Game Developers of Kiwi Farms

[ifxztykgdnfvmsdjhfbSD]

The best way to learn game dev is to spend about ten years reading programming language theory on the internet. Preferrably stuff by people who have written major languages, or game engines, or games, or have worked with such people, or at least interviewed them. Maybe write one or two toy programs, but nothing that actually does anything. Then come to the conclusion that programming is the intellectual equivalent of coal mining, and you'd rather not get lung cancer. Also, gamers and gamer adjecent communities are the absolute worst.

Fun fact: the first steam engine was a toy that spun in circles and accomplished nothing. The second batch was for pumping water out of coal mines so coal miners could mine more coal to run more steam engines. Some brainiac put some numbers together and said this could be called "work." Now steam engines run your computers, so you can make games, so people will buy new computers, so coal miners can wonder when their jobs will be fully replaced by AI robots (two more weeks). Nerds worry about nanotechnology turning everything into paperclips or gray goo at some point in the future, but the joke's on them, because that's the only thing that's been happening since at least the beginning of the industrial revolution.

In conclusion, your job as a game developer is to be a cheerleader for the clown world. You are driving the bleeding edge of progress forward. Don't worry too much about getting everything perfect. Revel in the complexity, the perversity, and the sheer insanity of it all. These things are not the problem: they are the entire point. You are not here to solve that problem. You are here to add to it. Just contribute something that keeps the steam engines going and the miners in business for another few minutes. One more piece of coal for the fire.

People think the worst side effect of coal mining is global warming. Ha! Hahahaha! Bwahahahahaha! If only they knew.

 

[TrainWreckWatcher]

Peeking in here to see what we have for developers as I kind of want to support some smaller devs that aren't faggots.
Good luck to those of you doing stuff.
I haven't a fuckin clue, but it seems like a lot of work.

 

[Hee]

Does anyone have any recommendations for an personal wiki/documentation manager? I like to document my solutions and personal workflows, and would like to organize them better for future me. Outside of a huge word document I have no idea.

 

[Whatevermancer]

Does anyone have any recommendations for an personal wiki/documentation manager? I like to document my solutions and personal workflows, and would like to organize them better for future me. Outside of a huge word document I have no idea.

I occasionally use tools that generate HTML files with documentation from comments. Doxygen for C++, TypeDoc for Typescript.

 

[my penis is on fire]

personal wiki/documentation manager

Even though it's a bit of a meme pushed by productivity hucksters, Obsidian is good for a personal wiki sorta thing because you can quickly make hyperlinks between notes. That said, I tried it myself and found that it was a lot slower than just smashing all of my notes into a word document, but it might be better for larger projects since word documents can't scale with the amount of info you'd need to keep track of.
Also, as a card-carrying Godotnigger I am legally required to shill the engine whenever possible and mention that it has a built-in method for writing documentation as code comments.

 

[my penis is on fire]

Currently making a flag system in 'odot. My current solution is just having every flag be a bool stored in an autoload scipt called Flags so it can be accessed by anything, setting a flag is done by running Flags.generic_flag = true and reading flag state is just if Flags.generic_flag:. However, this seems kinda... naive. The solution seems way too obvious but I'm not sure how to improve on it. Storing every flag in a {str:bool} dictionary would make it easier to make new flags in code, but I don't see where that would be necessary or faster than just typing var generic_flag2 := false into the Flags script. Hardcoding each flag is also surprisingly scalable in this case, because the #region keyword can be used to separate flags into easily readable and collapsible groups. Biggest possible issue I can think of is implementing this into a save system, which I don't fully know how to do (made a basic JSON save system for a small project a long time ago, but it was very annoying and I have no idea how to scale it for a bigger project). I'm not particularly concerned with performance since setting a bool isn't a costly operation, and with flags it's usually not done every frame. I want to try using setget so messing with flags could also trigger special behavior, but I don't know how to make multiple variables use the same setter function.
Thought of this because of a slapfight in the Pirate Software thread about Mald's flag system, where every flag is an int instead of a human-readable string.

 

[Gender: Xenomorph]

Currently making a flag system in 'odot. My current solution is just having every flag be a bool stored in an autoload scipt called Flags so it can be accessed by anything, setting a flag is done by running Flags.generic_flag = true and reading flag state is just if Flags.generic_flag:. However, this seems kinda... naive. The solution seems way too obvious but I'm not sure how to improve on it. Storing every flag in a {str:bool} dictionary would make it easier to make new flags in code, but I don't see where that would be necessary or faster than just typing var generic_flag2 := false into the Flags script. Hardcoding each flag is also surprisingly scalable in this case, because the #region keyword can be used to separate flags into easily readable and collapsible groups. Biggest possible issue I can think of is implementing this into a save system, which I don't fully know how to do (made a basic JSON save system for a small project a long time ago, but it was very annoying and I have no idea how to scale it for a bigger project). I'm not particularly concerned with performance since setting a bool isn't a costly operation, and with flags it's usually not done every frame. I want to try using setget so messing with flags could also trigger special behavior, but I don't know how to make multiple variables use the same setter function.
Thought of this because of a slapfight in the Pirate Software thread about Mald's flag system, where every flag is an int instead of a human-readable string.

Please learn bitwise operations.

Have an enum:
BEAST
UNDEAD
ETHEREAL

Then you can use bitwise operations to store all data inside an int.

Spoiler: How it works

If the int is 1, the creature is a BEAST
A 2 is UNDEAD
3 is BEAST and UNDEAD
4 is ETHEREAL
5 is ETHEREAL BEAST
6 is ETHEREAL UNDEAD
7 is ETHEREAL UNDEAD BEAST

It's a lot more effective for storing and retrieving information. Might not work if you want to dynamically allocate flags (ie user content) but I don't think that is the case.

 

[my penis is on fire]

bitwise operations

Oh shit that's the system Cave Story uses to track equipped items. Each equippable item is stored as a different bit so the game can store every possible combination of items as an int. Like for example if you have the Booster 2.0 (32), Turbocharge (, and Map System (2) equipped then the game stores the items as 32 + 8 + 2 = 42 = 0b00101010

 

[Lance 45]

Never really looked into Godot. Sure there's a lot of nice gizmos for the engine and no retarded and illogical "object is pending kill" error when actually destroying an actor like there is in Unreal, but they falsely assume you already have at least an intermediate level of programming skills. Which is why no one really makes games with it beyond shilling the engine. Any up and coming game engine that will also teach people how to program from scratch will pretty much take the current crown in the game engine market.

I dont mean lazy "here's all the work done for you" teaching. I mean "this is how we create a functional inventory component and access it during gameplay and here are some dummy items. Now that everything is all set, we are ready to replace the placeholder assets with our actual assets. This is how you modify object properties. Lets try adding three different objects that have different effects when picked up. one with a debuff, one with a buff, and one that is just a normal item."

 

[Private Tag Reporter]

I would be more than happy to teach you, or you can find help in the programming thread, if you quit yer bitchin'

 

[Coolio55]

Never really looked into Godot. Sure there's a lot of nice gizmos for the engine and no retarded and illogical "object is pending kill" error when actually destroying an actor like there is in Unreal, but they falsely assume you already have at least an intermediate level of programming skills. Which is why no one really makes games with it beyond shilling the engine. Any up and coming game engine that will also teach people how to program from scratch will pretty much take the current crown in the game engine market.

I dont mean lazy "here's all the work done for you" teaching. I mean "this is how we create a functional inventory component and access it during gameplay and here are some dummy items. Now that everything is all set, we are ready to replace the placeholder assets with our actual assets. This is how you modify object properties. Lets try adding three different objects that have different effects when picked up. one with a debuff, one with a buff, and one that is just a normal item."

I swear that the docs had a big long series of tutorials and that there were plenty of official demo projects for you to download and edit. This was back in the early days though.
Also, Godot isn't ECS based so your component example doesn't fit.

 

[Judge Dredd]

Never really looked into Godot. Sure there's a lot of nice gizmos for the engine and no retarded and illogical "object is pending kill" error when actually destroying an actor like there is in Unreal, but they falsely assume you already have at least an intermediate level of programming skills.

No. It doesn't. There's the docs, and there's no shortage of beginner tier tutorials. GDQuest is the most famous. People swear by Brackeys. KidsCanCode is good too, despite the name. There's even at least two video series making vampire survivors from scratch in the engine. And then you have the visual node based thing that's like Unreal's blueprint mode. Never messed with that. It's when you get out of the beginner level that things quickly dry up.

Which is why no one really makes games with it beyond shilling the engine.

There's already a bunch of games made in it. Endoparasitic, Dome Keeper, and Brotato are the most famous. A quick search says Buckshot Roulette and Cruelty Squad were made in it, but I'm not sure.

I mean "this is how we create a functional inventory component and access it during gameplay and here are some dummy items. Now that everything is all set, we are ready to replace the placeholder assets with our actual assets. This is how you modify object properties. Lets try adding three different objects that have different effects when picked up. one with a debuff, one with a buff, and one that is just a normal item."

So what you want is plug ins? I know Godot has a few, but I tend to avoid that stuff because you quickly run out of options if a plug in doesn't do what you want.

---

On a completely different note. I'm putting serious thought into homebrew. I'm torn between a few systems. GameBoy, Mega Drive, NES, Pico-8, or maybe going for home computer type machines such as Amiga, Commador 64, or it's clones like the Commander X16 and Mega 65.

They all have pros and cons. eg. I love GBStudio, but it's very limited if you don't use GameBoy Colour mode. The Mega Drive and NES have a lot of homebrew and romhacks, pointing to those possibly being easier to work on. And of course, home computer style computers run basic and have manuals that teach you to code and ins and outs of the hardware. Modern clones supposedly have quality of life improvements too.

Related to that, I considered modding Streets of Rage Remake, but the docs online are scattershot.

 

[ZMOT]

Does anyone have any recommendations for an personal wiki/documentation manager? I like to document my solutions and personal workflows, and would like to organize them better for future me. Outside of a huge word document I have no idea.

https://tiddlywiki.com/

https://joplinapp.org/

 

[Two by Four]

I am trying to learn C++ but tutorial hell is going to be the end of me, do any of you guys know any effective way to deal with it?

If you know other languages and need C++ specific advice, ignore this. Otherwise I have some general advice (which served me well getting started in the late 2000s but may be shithouse now).

tl;dr - Confidence and ability mostly comes naturally over time so just keep writing stuff, it doesn't really matter what as long as it gets you thinking. Look for inspiration in other people's code, and formal logic puzzles/programming competition exercises might help too.

Spoiler: oldfag advice

I found the "trick" to learning to code is less about knowing how to do any particular thing, and more about getting into the right style of thinking. Once you learn to flip your autismo switch things get a lot easier, but fuck if I know when exactly I got to that point. Perhaps I have always been autismo...

Find something you want to do and try to make it work. If you can't think of anything, look around online for university programming competitions, not to compete in but just to do their past exercises and read the scoring criteria; anything set up for high-schoolers is a great starting point. leetcode is another option but I don't have much experience with it.

I find traditional logic puzzles need a similar style of thinking that I use for coding. E.g. prisoners with hats, fox+hen+grain puzzle, etc. They're a nice way to practice without actually sitting down to write code.

I also enjoy watching videos about old-school game programming where devs were squeezing as much as humanly possible out of the hardware, GameHut is a great channel for this (EDIT: Just realised he's split his content up and all the best code stuff is on this channel). It's fun stuff and also might give you some confidence to experiment a little with "hacky" solutions.

Edit to add a personal inspiration:

Then you can use bitwise operations to store all data inside an int.

The highest value use of bitwise fuckery is making people who don't know what it is think you have a huge brain.

 

[Lukie]

Found a very cool dithering fractal shader. The developer has put the shader on github too.

 

[Battlefield42]

 

[Verdun_Salient]

Are there any good books for a beginners to read so they can learn to code for hobby? I find videos difficult to follow along with compared to a physical book

 

[schzo]

Are there any good books for a beginners to read so they can learn to code for hobby? I find videos difficult to follow along with compared to a physical book

Can't help you by suggesting books, but if you dislike videos, have you tried online text-only courses? They're usually accompanied by exercises too.

The "learn to code" meme was huge up until the bubble popped, so just google that and you'll find plenty. W3Schools, Codecademy, freeCodeCamp are a few popular examples.

 

[my penis is on fire]

Made a thingy that draws a Bézier curve (the green line with arrows) which approximates a circular arc.

Some credit to Philip Todd of Saltire Software, who derived the formula to find the distances of the control points from the start and end points in this video.

Spoiler: CVDE

extends Node2D

# setup
@onready var path_2d: Path2D = $Path2D
@onready var debug_circle: CollisionShape2D = $DebugCircle
@onready var start_pt: Sprite2D = $StartPoint
@onready var end_pt: Sprite2D = $EndPoint
@onready var slider: HSlider = $HSlider
@onready var angle_label: Label = $AngleLabel
var path_curve: Curve2D
var ctrl_pts: Array[Vector2] = [Vector2.ZERO, Vector2.ZERO]

func _ready() -> void:
    path_curve = path_2d.curve
    update_everything()

## Given a start and end point and angle in radians, returns the two control point
## locations needed to create a cubic bezier curve that approximates a circular arc
## of that degree. These control points are in the local coordinate systems of the
## start and end points respectively.
## Only behaves properly for 0 < degree <= 180.
func circle_spline(start:Vector2, end:Vector2, degree:float = PI) -> Array[Vector2]:
    var invert := false
    if start.y > end.y: invert = true
    # Find origin of circle that makes this arc
    var start2end: Vector2 = end - start # chord between start and end
    var midpoint: Vector2 = Vector2((start.x + end.x) / 2, (start.y + end.y) / 2)
    var dist: float = start2end.length() # Chord length
    var radius: float = dist / (2 * sin(degree / 2)) # get circle radius
    var phi: float = atan(-1 / (start2end.y / start2end.x)) # angle of perpendicular bisector of chord
    var ctr_dist: float = sqrt((radius ** 2.0) - ((dist / 2) ** 2.0)) # dist from chord to origin
    var origin: Vector2 = Vector2(midpoint.x + ctr_dist*cos(phi), midpoint.y + ctr_dist*sin(phi)) # coords of circle origin
    
    if invert: # Prevents circle from flipping when start is below end
        var move_by: Vector2 = midpoint - origin
        origin += move_by * 2
    
    update_debug_circle(origin, radius) # circle visual
    
    # get control points for bezier curve
    var start_ctrl: Vector2
    var end_ctrl: Vector2
    start_ctrl = (origin - start).rotated(PI/2).normalized() * todds_formula(degree, radius)
    # ORIGINAL CODE, TO HELP DE-OBFUSCATE THE ABOVE LINE
    #start_ctrl = origin - start # vector from start to origin
    #start_ctrl = start_ctrl.rotated(PI/2) # rot90 since it's tangent to circle
    #start_ctrl = start_ctrl.normalized() # set to unit length
    #start_ctrl *= todds_formula(degree, radius) # multiply by Todd's Formula to get required length
    end_ctrl = (origin - end).rotated(-PI/2).normalized() * todds_formula(degree, radius)
    return [start_ctrl, end_ctrl]

## This formula was derived by Philip Todd from Saltire Software in this video:
## https://www.youtube.com/watch?v=fUn1lUWPUWs
## Returns the necessary distance of the control point away from the start/endpoint.
func todds_formula(theta:float, r:float) -> float:
    var a: float
    a = (4 / (3 * sqrt(sin(theta / 2)**2))) + ((4 * sin(theta)) / (3 * (cos(theta) - 1))) # Todd's Formula
    a *= r # By some miracle, this scales linearly with radius.
    return a

func update_everything() -> void:
    ctrl_pts = circle_spline(start_pt.position, end_pt.position, deg_to_rad(slider.value))
    path_curve.set_point_position(0, start_pt.position)
    path_curve.set_point_position(1, end_pt.position)
    path_curve.set_point_out(0, ctrl_pts[0])
    path_curve.set_point_in(1, ctrl_pts[1])
    angle_label.text = "Arc angle: " + str(slider.value) + "°"

func update_debug_circle(origin:Vector2, radius:float) -> void:
    debug_circle.position = origin
    debug_circle.shape.radius = radius

func _on_start_point_pos_changed() -> void:
    update_everything()

func _on_h_slider_value_changed(value: float) -> void:
    update_everything()

 

[Gingervitis]

Looking to get into hobbyist gamedev, experimenting with RPG Maker MZ atm. I have a pitch for the first real game I want to make (that I actually show people), but I want to pitch it to people first. The issue is, whenever I try to explain what the game’s mechanics would be (think Madou Monogatari expanded to a whole JRPG, except I don’t mention Madou Monogatari), everyone says it’s a terrible idea. I know the idea is good- otherwise, Puyo Puyo wouldn’t exist- so it’s obvious I’m not doing a good job explaining it. Any thoughts on how you guys explain game mechanics to other people, without using other games as a reference?