If your goal is to make a game in a reasonable amount of time, I kind of disagree with this advice. Implementing an ECS system before anything else is a good way to find yourself spending time yak-shaving instead of actually building your game, and for most 2d games, YAGNI (at least not right away).
My personal advice would be program some of the major game systems and objects you want for your game first, they'll probably take you longer than expected but at least you'll have something that actually resembles game play and not just a framework for building a game. If you get to the point where you need ECS for performance or organizational reasons you'll probably have a good idea of how you want it to work by then instead of guessing at how you'll use it.
For example, I've got game with a core game loop that's been finished for probably a year now, but I've still got a ways to go with everything else before I'm finished with the rest of it.
Fast forward 25 years later, I have installed Unity, Unreal and some other OpenSource game development environments, and I just cannot find heads or tails. I've followed some Udemy courses, but for me, the current "game development" process feels more of a "graphic designer" process than a programming process. I would love to make games, but it seems that the current "tools" are more tailored to artists type rather than programmer types.
And there is a bit of a difference between game, and game engine. Unity is really for creating games itself, where most part is not engine work. Like most developers, we like to do engine work though, not graphics.
If you want some fun, find a lower-level engine which just implements some parts (e.g. while Phaser.js is a big game engine, still need to do a lot of coding by hand). Alternatively, use weird things. ASCII, HTML Checkboxes, voxel graphics, svg, in rust...
Seconded. Coding a roguelike in C and the amount of flexibility it gives even with no help from the language itself is crazy. It's really amazing how many concepts that were really hard to abstract become easy. Want a rock to move around and cast fireball? Give it the Actor and Spellcaster components. Do it dynamically at runtime. Now you can make a spell that makes rocks into wizards (.. if only, dynamic effects are more complicated than that, but it's a good showcase of the possibilities)
Basically, entities consist of components. Components should ideally just be data (a struct). Systems work on components (data), they are the code / functions. A system only cares about it's component (but for all entities, which have this component).
A entity "player" consists of the components like "texture", "input". A "monster" entity has components "texture", and "ai". The graphic processing done by the texture system doesnt care how the changes in x/y position is happening (via AI statemachine, or keyboard input).
Player and Monster should shoot too, so attach a "weapon" component to it. But then it's also possible to also create an entity with components "texture:door" and "portal" (portal system will teleport you to something, e.g. next level). No one stops you to attach the "ai" component too, making the door move around. And "weapon", which makes the door shoot too (then maybe call the entity something else, like portaling-monster).
As the components are just data stored outside your code, e.g. in files or a DB, you can change them at will. And load it, without recompiling or even restarting your game! This allows a large amount of creativity and innovation, without refactoring your code all the time.
I like to connect my systems with a message bus, where they send messages to each other. Messages change components, data, of entities. These may generate more messages. E.g. player clicking left mouse button creates a message, which gets handled by input system. This creates a message for the weapon system, reducing ammo count by one, and change its texture (-index) to like "shootingstance:1", and creating a new entity "bullet" with the source x/y and destination angle.
The advantage of this is that this requires less code, permits very good separation of concerns and is very transferrable even between engines. Unity, for example, uses something similar where components and systems are in the same class together. For self-coded games, there's several libraries too.
There's lots of great example code in the docs and within the repo itself, for what it's worth!
The entity itself can be literally just an int id. To make a new entity, request a new id. Since everything about an entity is contained in what components it has, you don't need more information.
Components: they're just data. You can model them as structs:
struct c_actor {
int entity_id;
// action to execute once enough energy is accrued
struct action *action;
// Angband style energy level, to take a turn must be >=100 (ACTOR_ENERGY_TO_ACT)
int energy;
// amount of energy gained per game tick
int energy_gain_per_tick;
};
I hope the comments explain. This is all the component is, data. You can have a helper function which stores it in some data structure where you keep each entity's components, indexed by id.Systems. They're just function which operate on entities which have their component.
int s_actor_do_acts(struct component_systems *c_systems)
{
// loop through your tracked entities
for (for (int i = 0; i < ACTOR_ENTITIES_NUM; i++) {
...
int *energy = &c_systems->actors[entity_id].energy;
if ((*energy) < ACTOR_ENERGY_TO_ACT) {
goto add_energy;
}
(*energy) -= ACTOR_ENERGY_TO_ACT;
...
// actually do action
if (c_actor.action != NULL) {
switch(c_actor.action->action_type) {
case ACTION_WALK:
action_walk_do((struct a_walk*)c_actor.action, &c_systems->positions[entity_id], c_systems->lmap);
break;
...
You call the system function in the main game loop.Note: something a bit "unorthodox" here is the fact that the Actor system here also directly gets a handle on the position component. Others prefer event systems, where instead you would fire off an event. My RL is single-threaded (I can definitely wring enough CPU perfomance without needing to overcomplicate), so I've opted to just pass handles around and have each system call each other directly via passing handles. In this example, the Walk action would call into the position system's function via the handle passed. This greatly simplifies code, and allows me to do partial updates of the game state outside the main loop.
edit: Also, in case you're wondering how the data about what each entity is stored (since that seemed to be the crux of your questions). You can have a data file:
... many other components ..
[components.actor]
energy_gain_per_tick = 20
[components.fov]
radius = 10
...
Then you read this in and dynamically build an entity: toml_table_t *actor = toml_table_in(comp, "actor");
if (actor) {
toml_datum_t energy_gain_per_tick = toml_int_in(actor, "energy_gain_per_tick");
if (!energy_gain_per_tick.ok) {
UNT_ERROR("energy_gain_per_tick not defined for actor");
return -1;
}
struct c_actor c_actor = {
.entity_id = entity_id,
.energy = 0,
.energy_gain_per_tick = energy_gain_per_tick.u.i,
.action = NULL
};
c_actor_add(c_systems, c_actor);
s_actor_track_entity(entity_id);
}
I hope the real code is readable enough to serve as pseudo code alternative.One advantage is you can generate semi-randomized entities, and dynamically change their components at runtime. You can't do that with OOP.
Even more, in networked games it can be used to roll-back actions you did (e.g. because someone with a 100ms ping shot you 50ms before launching a rocket, to roll-back rocket-launching animation). Or in the simulations of the behaviour of the other players (peeking around the wall).
I once had a goal of working on a beat 'em up engine for fun. I wrote one version on Mac and then later thought to write it in javascript. Like many other projects I've done, I got it to a working state and moved on. :) Take a look here if you're curious: https://www.ussherpress.com/yokosukajs/
It's not "true" game development, i.e. using modern 3d engines, but it did cover the core issues to think about, and I was learning to write more fp-like code at the time, so it helped me learn functional programming a bit.
So, to echo other people's comments, there are transferable skills in game dev.
Except that changing direction quickly left/right feels kinda bad. Seems you wait for the animation to finish before checking for new key presses, not buffering the last pressed key.
For some background, I have a state machine for the animations and I've set up some to be interruptible starting on certain animations, and in this case, I the "turn around" animation has to play out completely before I allow new directions from the "director". (I call the characters on the screen "actors" and the source of directions "directors", which can be a human or AI.) Anyway, the fun was in coming up with the engine, of course. :)
And of course, what often gets forgotten: Make sure it is fun, somehow. In my opinion, nobody can "make" a good game. Can just pump out a lot of games, and hope one is good. Be it EA, or King Digital Entertainment.
The most important thing i learned was that implementing your game as classes (with inheritance and all that) is futile. Use ECS (Entity-Component-System), its awesome.
Even a simple MVP takes like months or years to develop. During studying how Disney designed animations (the 12 principles, like anticipation, staging..) i realized just how deep you need to go into non-coding things like animations, music, graphics, UI, and more.
Shout out to the r/roguelikedev community though, they are awesome. People coding on their rougelikes for 12 years seems to be not extraordinary.