Hacker News Reader

I pretty wholeheartedly disagree with this entire sentiment. For some people making a game engine isn't a monumental task, but implying that it's easy seems like an out-of-touch sentiment. There are many people who love making games but who aren't software devs that are enabled to make whatever they dream up via by the plug and play nature of game engines.

I'm not a game dev, but I had a lot of fun making an ECS system by following ideas in an article I found (and which I have now annoyingly lost).

It's a very educational exercise that any dev would benefit from, game dev or not.

Have you ever tried to “make your own game engine” such that you can opine on this from a place of experience?

General-purpose game engines like Unity and Godot are “plug-and-play” for only a small percentage of your game's development cycle—at some point, unless you're making an extremely trivial game, you're going to end up “fighting the engine” to make it do the thing you want it to do at some point or another—typically much more than once. If you weren't relying on someone else's underlying game engine substrate to build your game upon, then you would never encounter something like this. It would be entirely upon you to restructure your own underlying game engine substrate that you've built in order to build your game upon. You would know what each part of the machinery is doing, because you built it—you wouldn't have to guess and check and dive deep into documentation and forum threads and Discord channels just to try to figure out the optimal way to beat the engine into submission to do the thing you're trying to make it do.

Have you seen the Raylib examples[0], such as the “2D platformer camera” example [1] (playable from the examples webpage)? It's really not a lot of code at all to get a basic playable game going—then from there, you just make more structs, store struct instances in arrays, and loop through the arrays to do 99% of the things you want a “game engine” to do that aren't covered by Raylib library functions.

If you made a 2D platformer by starting from that example instead of using something like Unity or Godot, and do as I said above and wrap all Raylib library function calls in your own functions, then, in the absolute worst case, tomorrow you wake up and find out that Raylib has, for some reason, gone all “Our Machinery”[2] and deleted its public source repositories and informed you that you're legally obligated to delete all Raylib code on your machine. Not a problem—just switch to SDL or SFML or bgfx (for just the graphics) or something similar, spend a couple hours replacing the library function calls in your code, and you're good to go! You maintain complete ownership over the vast bulk of your game's code, because you wrote it yourself, except for a few library calls which can be easily replaced with something else. This is a much better situation to be in, compared to e.g. the Unity fiasco of last year!

> There are many people who love making games but who aren't software devs

This idea still baffles me—why do people try to make video games while abstaining from learning anything at all about software development? Like there's nothing wrong with using higher-level tools as a means of learning the very basics of the craft—that's how I started out, too. But wanting to learn a high-level tool and then stopping there and learning nothing more is like wanting to be an artist but never learning any art fundamentals and using an AI generator instead.[3] Video game development as a whole is extremely difficult, and a craft that should either be taken remotely seriously (especially if you wish to self-describe as a “game developer”!!), or taken extremely casually. If you want to take it extremely casually, then by all means continue to refrain from engaging with even baseline software development knowledge and principles. But if you want to take it seriously, because, for example, you wish to sell the software you've made to other people so they can run it on their computers, then really, making a “game engine” is the least of your concerns as a game developer. Actually figuring out the game's design is much more difficult and time-consuming!

[0] https://www.raylib.com/examples.html

[1] https://github.com/raysan5/raylib/blob/master/examples/core/...

[2] https://old.reddit.com/r/gamedev/comments/wd4qoh/our_machine...

[3] Surely we all agree that someone whose idea of “creating art” is “learning how to best write a prompt for an AI art generator”, self-describing as an “artist”, weakens the term and is offensive to those who put untold amounts of time and effort into truly learning their craft—why should game development be any different?

You seem to be very intent on insisting that anyone can make a game engine (which I mostly agree with). But, it’s not easy, even when you use a pre-existing framework like Raylib. I’ve used frameworks like Monogame, I’ve used bare metal C++ and OpenGL, I’ve used the HTML canvas and JavaScript, I’ve built physics engines and used physics engines like Box2D or Havok. What I’m trying to say is I’ve done a lot of game engine-y stuff at various levels of the stack.

I’ve _also_ used Godot, Unity and Unreal. There’s a tremendous difference. I just started learning Godot a week ago and I already have the core game loop practically done in a new RPG. Sure I could’ve done the same thing using C++ and OpenGL (or Raylib or something), but I would be missing out on a lot of useful things that _just work_. Godot’s BBCode text labels are amazing and give my dialogue boxes a whole bunch of character out of the box. The tilemap editor allows me to just build my levels without having to build an editor first. The lighting system can add a ton of visual polish with very little effort on my part.

I’ve also dabbled in VR games with Unreal. And I’ve tried making some simple 3D games in Unity. Is this all possible without those engines? Yea. Would I have been able to experiment with the kinds of tech I got to play with if I made it all myself from scratch? I doubt it (not because I couldn’t do it, I just don’t have the time).

Another thing to consider is porting your game to different platforms! There’s a whole lot of variability in what kind of support you’ll get for that with something you made yourself or a framework like Raylib.

Anyways, from someone who has experienced both sides of the coin, you’ll end up fighting with the engine either way ;) There’s nothing wrong with using a general purpose engine.

Would you not say that learning how one could possibly make a game without using someone else's engine that does everything for you made you a better game developer, even if you end up choosing to use one?

That’s completely besides the point. I agree that working on an engine can be very fulfilling and round you out as a developer. But it’s not easy and I wouldn’t recommend that somebody who just wants to make a game go down that path. I’m pretty sure some of my favorite games like Hollow Knight would have never been made if they decided to just build the engine as well.

What is it specifically about Hollow Knight that makes you think it never would've been made without using someone else's engine? I didn't get too far into it myself but in terms of gameplay systems it seemed like a very standard 2D metroidvania platformer, except with a fantastic visual style.

Compare and contrast Salt & Sanctuary, which was uses FNA (which is a library, not an engine).

The fact that it’s a game that was developed by people that were self-proclaimed “non-coders”[0] using a plug n’ play game engine Stencyl (a no code engine) and then later switching to Unity. It seems to me the plug n’ play nature enabled them to gain traction with a prototype that led to the full fledged game.

This one quote on page 2 from the developers really hammers home this point:

> Those limitations aside, working in Stencyl has been fantastic. Ideas come together really easily and the tools are all intuitive. We definitely couldn't have come so far in such a short amount of time without it.

[0]: https://community.stencyl.com/index.php?topic=36539.0

Because the people writing the game did not have infinite time and budget, and spent their resources on making the game rather than the engine. That allowed them to a) finish the game at all, b) make a game of bigger scope and higher quality. Maybe (just maybe!) they could have finished a game when rolling their own. But it would not have been the Hollow Knight we know.

It's great that you're enthusiastic about writing your own engine. I'm kind of in the same boat: I'm opinionated on software engineering and architecture, and my opinions don't line up with any of the existing engines. So I roll my own. But it's not actually an efficient use of my time, and as a result I don't write as many games as I'd prefer to, and the projects often end up down-scoped from the original vision just to finish them. It's a suboptimal way to work, but it's the one I have to use since any time I try using an engine I give up in disgust and get nothing done.

What's not so great is that you're ignoring the very obvious upsides of using an engine, pretending it's only downsides, and pushing your personal preference on other people as the obviously correct way to do things. Your bafflement on why anyone would use an engine is showing a distinct lack of empathy. Not everyone thinks like you, or has your priorities. You want to write a toolset and demonstrate your mastery of that toolset; some others just want to make a game. And you have no business telling them that their goal is invalid and they should instead copy your priorities.

It's great that Hollow Knight got made, in short enough order at the time (2017) and it's great for them that they were able to port it to so many platforms with relative ease.

But the entire development team probably got a few gray hairs from the stress of last year's Unity debacle.

It is now no longer 2016–17. We have now seen firsthand the quite possible perils of building your game on someone else's engine.

It's like how Twitter used to provide very open API access for people to use to build all sorts of third-party apps. Overnight there was a huge explosion of these apps, and it was great for Twitter because it meant more people had more ways to engage with the platform. But when, after Twitter bought all the third-party apps they cared about and kept increasingly clamping down on API access more and more before finally pulling the plug on third-party app support entirely, what did that mean for everyone who built their entire business around using someone else's platform? They got fucked, hard.

When you see this pattern recur time and time again, you start to think, maybe it's not such a great idea to build a business atop someone else's platform. Maybe you're better off in the long run if you have complete ownership over your code.

Imagine if Unity pulled the trigger on their bullshit last year and went through with it. What would the Hollow Knight developers have to do? Scramble to reimplement their game in a new, Unity-free codebase, on every platform it's been released on, just to prevent paying Unity more than they already do? It doesn't sound like an enviable position to be in.

You have to look at the bigger picture and consider nth-order effects if you're trying to make a business out of game development. If you're doing it as a hobby, then it's fine, who cares—if you wake up one day to find that the platform you've been using for your hobby projects now wants to charge you to use it or whatever, then it's a bummer, but not a big deal, because you haven't invested your business into the platform, you're just partaking in a hobby.

Out-of-hand accusations of “lacking empathy” and the like when it comes to subject matters like this are inane, vapid, and really quite untoward. We're talking about concrete things here like the technology used to make video games and its relation to treating game development as a business—not feelings, or inclusivity, or whatever it is you're responding to with this verbiage.

>That’s completely besides the point.

I think it's a worthwhile thing to consider instead of dismmiss.

>But it’s not easy and I wouldn’t recommend that somebody who just wants to make a game go down that path.

Nothing is easy in game development. You can focus on whatever sector you choose, but don't expect an easy ride. That's why my honest first step to "how do I become a game programmer" is to fire up a terminal and write a Hello World in C or C#. I always approached concepts bottom-up, personally.

>I’m pretty sure some of my favorite games like Hollow Knight would have never been made if they decided to just build the engine as well.

Well, it sure is helping with Silksong, that's for sure.

But as a fun fact: Hungry Knight was made in Flash. I'm sure the devs would have found a way if they were determined enough if they didn't choose Unity. It could have been done in Game Maker or Construct or even good ol' Monogame (I believe Celeste used that).

I didn’t dismiss the point. My next sentence that you left out of that quote addresses it ;)

I also learn concepts bottom up, but thank God everyone isn’t like me. I’m just glad prebuilt tools like the game engines we have today exist so we can have artists creating awesome games.

Heck, even half life likely wouldn’t exist if Carmack hadn’t written the Quake engine and shared it with the Valve developers![0] Think of all the amazing games that have since been released by Valve that might never have been unless they had the kickstart that they got.

[0]: https://en.m.wikipedia.org/wiki/GoldSrc#:~:text=GoldSrc%20(p....

The idea that people who use game engines are at all equivalent to AI art prompters is ridiculous. What you’re doing is being like a painter who says “real painters mix their own pigments”. It’s unnecessary gatekeeping.

I would call both gatekeeping. All forms of creation; using AI, CSP or paint to make art, or using ChatGPT, a game engine or no game engine to make games, are all valid, with different restrictions and advantages.

Sometimes gatekeeping is necessary. None of the AI driven "make a game with a prompt" projects I've seen posted here (which would be the AI equivalent of a "game engine") have been capable of making a game worth playing, despite technically being "games", so I'll have to disagree with you on at least that point for now.

You aren’t disagreeing with me.

I specifically said complaining about game devs who use engines is unnecessary gatekeeping. On the other hand, complaining about artists (or game devs!) who exclusively use AI seems like a valid use of gatekeeping to me.

Some gates need to be kept!

If you meet someone at a party who self-describes as a carpenter, and you say, “oh that's awesome, I've been trying to add onto my deck by myself with no prior knowledge of carpentry and I'm running into trouble, can you give me some pointers?” and he replies, “oh I don't actually know anything at all about carpentry, I've never done carpentry before, I just design mass-produced wooden products in CAD software”, then you'd probably ask, “okay, well why do you self-describe as a carpenter, then?”

If the term used to describe a craftsman of a given craft grows to include people who don't actually know anything about said craft other than engaging with higher-level abstractions over core practices of said craft, then what value does the term continue to have?

The idea that “gatekeeping” is always a bad word (for ill-defined wishy-washy reasons) is asinine, and the sooner we recognize this, the better.

I didn’t say gatekeeping was always a bad word, in fact I think some gatekeeping is often justified when it comes to AI art.

As far as the carpenter stuff, I feel like your metaphor is once again going much too far. Someone can be a carpenter whether they buy their wood at home depot or grow the trees themselves… but it would be foolish to say that the person who buys the wood pre-grown is not a real carpenter.

We are talking about game developers, not engine developers. If someone wants to be a game dev, they have to have developed the game, but not the underlying engine. I don’t see how this is controversial.

It's only “controversial” because you're thinking in framing terms that don't necessarily reflect reality—“making a game” and “making a game engine” don't need to be distinct, disparate things.

When Ska Studios (a husband and wife) made Salt and Sanctuary, they just made a game using a library, and a framework that they've evolved over many years of using XNA and then later FNA (both libraries, not engines!), to make their games. They don't “do engine programming” and then “do game programming” as separate acts done by separate people of separate disciplines—they're one and the same!

The whole point I've been getting at in my posts here is that “game engine programming and game development are necessarily distinct, practically unrelated disciplines” is a false premise that people have recently come to believe, and one that I believe deserves significant pushback.

My carpenter metaphor was just fine, you're the one making it more convoluted—when has “carpenter” ever been defined to include “one who grows his own lumber” in its definition, at any point in human history? That was never the case—“carpentry” is the practice of crafting things out of wood, and a “carpenter” is one who engages in and has knowledge of the practice of “carpentry”.

Thus, one who uses CAD software to design products that a factory will mass-produce using wood as a material could be technically referred to as a “carpenter”, because “crafting things out of wood” is, in an abstract sense, what they are doing. But it's clearly disingenuous for such a person, who lacks any knowledge or experience in “traditional” “carpentry”, to self-describe as such, precisely because he lacks the domain knowledge and experience that is expected of someone of such a self-description.

But if an actual carpenter, with actual carpentry knowledge and experience, then goes on to design mass-produced wooden products with CAD software, and he self-describes as a “carpenter” when you meet him at a party, you may think his self-description is a bit odd given what he does for a living—but at least he will in fact be able to give you some pointers about building your deck—thus proving his self-description to be meaningful on some level.

Do you honestly think it is disingenuous for someone to call themselves a game developer if they didn’t write the engine as well?

Where did I ever say that?

I thought the last paragraph of my previous post made it pretty clear that I rather specifically don't think that.

Well again, this is the problem with how far you’ve stretched the carpentry comparison. You said it was disingenuous for the CAD user to call themselves a carpenter… and as far as I understand, the CAD user is your equivalent of a game dev who only uses engines.

If your argument is just that sometimes game devs can also make the engine at the same time as making the game, then yeah I agree with that… but I think your earlier posts were saying a lot more than that (such as implying that engine users aren’t really game developers and are basically equivalent to AI art prompters).

Also it’s a little funny you bring up the example of an XNA/FNA game, because that’s already a relatively high level framework, the kind of code those devs would use is really quite similar to using an engine, especially another C# engine like Unity.

If you use someone else's high-level game engine to make a game (metaphor: use CAD software to design mass-produced wooden products), but you could write a simple game yourself “from scratch (with libraries)” (you have carpentry experience), then you're a game developer (carpenter). If not, then you're not, you're a proficient tool-user, with no domain knowledge outside of how to use said tool.

> Also it’s a little funny you bring up the example of an XNA/FNA game, because that’s already a relatively high level framework, the kind of code those devs would use is really quite similar to using an engine, especially another C# engine like Unity.

This is untrue and you know it. XNA/FNA does not have a GUI editor, a scene graph, a physics engine, an entity/component system, and many other things that Unity et al. have. When you use XNA/FNA(/MonoGame), you have to figure out how to structure your game logic yourself. The structure you think in terms of is by and large something that you've written yourself, as opposed to with something like Unity, where a complete structure is provided for you, and you learn to think in terms of the primitives it exposes to you (GameObjects, Components, Prefabs, Scenes).

Ok I think we’ve come to the root of the problem. You don’t realize how much software development people who use engines still have to do! Just because there are things like GameObjects and Components does not mean you don’t have to think about the game logic or structure. There are tons of ways to approach things, those are still just a relatively low level framework.

And just so you don’t think I’m making stuff up, I wrote a framework for Unity that acts much like XNA or some other 2D scene graph. It’s 100% code based and essentially doesn’t use Unity at all except as a publishing tool. It’s called Futile and it was used in popular games like Rain World and Mini Metro, as well as many of my own games.

However, I also have made games “the Unity way”, with GameObjects and Components etc. These two different approaches to making games are not nearly as different as you claim. I still have to think a lot about game architecture and system design even when using all of Unity’s built-in foundational stuff.

Yes, I do realize how much work people need to do to make games within arbitrary frameworks provided by game engines, and alluded to such in previous posts.

XNA never had a scene graph though, I don't know where you got that idea from. XNA and its descendants give you a basic game loop, and then it's entirely up to you how you structure your game logic from there.

There's nothing wrong with using someone else's structural backbone, like the library you made that you mentioned -- but everyone who wants to self-describe as a “game developer” should try to do this themselves, without such a thing, at least once.

Video games are computer applications, and computer applications consist of data, and functions that operate on said data. When you learn to think in these terms, stuff that seemed complicated before becomes very simple to reason about, and also very easy to write code for. Sometimes, a more generalized scene graph-type system is the best fit for what you're trying to do. Oftentimes though, it's not, and you're unwittingly contorting your thinking about the problem space to fit the shape of the predefined structure you've chosen to use.

One example of this is how Game Maker (in the old versions—I don't know much about the newer GameMaker Studio) is structured. You define “Objects”, and each Object has, in addition to many other properties, “Events”, each of which can have one or more “Actions”. You also define “Rooms” (scenes), with a 2D GUI editor that lets you place instances of Objects within the Room. The first Room in the Room list is where your gameplay begins.

When you first start using Game Maker, you make a Room for each level in your game, you define Objects, and you place instances of Objects in your Rooms. You define logic with Events within Objects -- init stuff goes in the “Create” event, and update stuff goes in the “Step” event. You drag and drop Actions into Events in your Objects to define gameplay logic.

This is all well and good, but eventually you grow out of using any Action except “Execute code”, which lets you type GML code in an integrated editor. Eventually, you learn that it's a good idea to keep your “controller” logic in a single instance of a single Object—separate from your player character Object—called “objController” by convention. You put a single instance of objController at (0,0) in your first Room, and mark the “Persistent” checkbox in objController so it persists across Room transitions.

At this point, you're “fighting the engine”. The engine does not provide a first-class means of defining “controller logic”, so your only means of doing something like this is as I described above: defining an entire Object type—which contains tons of properties and functionality that you'll never use for this Object—just to allow you to define some code that gets run every frame. As an advanced Game Maker user, you get used to it, but you wish that this common pattern was given first-class support, so you didn't feel like you were “fighting the engine” to do something so obviously common.

As you become an even more advanced Game Maker user, depending on the type of game you're making, you might end up eschewing most if not all of the structural features of the engine, just so it “gets out of your way” and lets you write the code you want to write to make the game you want to make. You might end up as I did—having only a single Room, containing only a single objController instance, and then handling everything else yourself from there.

When I reached this point as a teen, had Raylib or XNA existed and had somebody shown it to me, I would've said, holy crap, this is exactly what I'm looking for. (XNA did come about shortly thereafter, and it's where I ended up going after outgrowing Game Maker.) I just want to draw sprites and text and simple geometric shapes to the screen, and I don't really care about learning low-level graphics stuff to learn how to do that myself, so if you can handle that for me, that's great—but I can handle managing all of the game's data in structs and arrays myself just fine though.

But apparently this is not the case for many modern game engine users. They learn to “think in terms of” whatever primitives the engine provides them with, and then decide that that's good enough, they don't need to learn anything else. They're already thinking in Scenes/Prefabs/GameObjects/Components—why stop now?

I firmly believe this is huge mistake, because it's such a self-limiting way of thinking about game development, and it causes you to become entrenched in your limited way of thinking about gameplay logic. But before last year's Unity debacle, my views were very unpopular, because, what's wrong with just using Unity, man? Well, now we know: it's not a great idea to invest one's entire way of thinking about game development and one's entire business prospects so heavily in someone else's platform, when they can decide to fuck you at any point in time, causing you to suddenly realize how dependent you were on said platform.

Some of the upvotes I've been getting in this thread are somewhat encouraging—maybe people are starting to come around to my way of thinking? (Not that I have a monopoly on such thinking, by any means, of course.) But many of the comments are incredibly discouraging—people really like to tie their entire identity to the specific-engine-specific way of thinking about game design and development, apparently, even when pitfalls of doing so are clearly outlined, and it's blatantly demonstrated how easy it is to begin to think outside of that box.

I think you’re getting consumed with HOW the game is made rather than WHAT is actually getting made. There are tons of super creative and unique games being made with engines like Unity all the time (or even with Game Maker, for example check out my cousin’s game Fight Knight).

The idea that the constraints of an engine are some big problem is absurd. Constraints are a good thing, they breed creativity. There’s a reason every game jam has a theme and a tight time limit, yet result in some of the most unique game concepts.

I completely agree that constraints can breed creativity—but so can trying to do things a different way than you're used to. If you've only ever made games with very generalized data structures organizing your game logic for you in some predefined way, then PICO-8 can give you the best of both worlds!

There's plenty of games made with Unity and other engines that I enjoy—I'm currently playing a Godot game and it's great.

But if nobody pushes back on the current status quo rhetoric, then many people will a.) continue to have extremely incorrect misconceptions about what necessarily constitutes a “game engine”, and how difficult it is to make one, b.) not be encouraged to try to learn something new that has more general applicability outside of the domain of their preferred tool, and c.) continue to find themselves in situations like Unity developers did last year, or like what some Godot developers are experiencing right now—feeling trapped, with no immediately-viable path forward.

In this past year, I've built my own “engine” that runs a networked open-world game that loads world chunks in and out of memory as players move around the world—but unlike other games like this that I've seen, certain types of NPCs can also freely move around the world, even when there's no players nearby. This was not trivial, but it would've been at least an order of magnitude more difficult, and much less performant (even though I haven't done any optimization work on it yet!) if I was using someone else's engine, shoehorning my approach to solving the problems that this design I wanted to make presents, into said engine's way of doing things—instead of just defining structs and functions that do what I want them to do and writing the whole system myself. It wasn't trivial, but it was MUCH easier than I would've imagined before trying it myself, given that I'm using a library for rendering, and another for network sockets.

So constraints can certainly breed creativity, but if these constraints are left unchallenged for long enough, then you're just limiting your potential for what you can do.

It'll vary for now, but AI isn't quite in that league. It's in the same theory space where I'm sure you CAN make a decently enjoyable NFT game. BUt the concept is unproven as of now and if we're being honest: the scene is full of a lot of grifters.

That isn't' a dismisal nor comparison of AI to other tools. But we don't live in a vacuum, sadly. curent cultural and political issues will affect the reputation of the tools in question.

I program daily

At night I don't want to slog away implementing Foo and extending Bar

Unity is already a lot of programming to do any simple game mechanic, and you still have animation, modeling, art, lighting, shaders, sound...

I can't wait for AI to get to a point where I can tell it to "get look and feel from X game, mechanics from Y MOBA, multiplayer server" and get code good enough for an MVP

Games are for playing, code is an unfortunate side effect

> Games are for playing, code is an unfortunate side effect

Boo, hiss!

(I respect your opinion, though :)

> But wanting to learn a high-level tool and then stopping there and learning nothing more is like wanting to be an artist but never learning any art fundamentals and using an AI generator instead

It's more like an artist never learning the chemistry that makes pigments and watercolor work.

Sorry, comparing scripting in Unity/Godot and prompting in Stable Diffusion is just ridiculous.

People like designing and making games, so they design and make games… Making the engine (or underlying framework, whatever) is just not necessary for that goal.

There are relatively few game designs (especially with indie scope!) where a custom engine is truly necessary.

For the tinker/hacker types, there are plenty of things to do at a “lower level” within the engine itself (note: I don’t necessarily mean modifying the source code). There are all kinds of different ways to structure things within the confines of the engine, and lots of other ways of building frameworks and GUI tools within the engine too.

I think it's also easy to conflate game development as one big thing. 100 people could say that they want to make games and all mean 100 very different things. I think for some people, like you mentioned, they ostensibly want to "make games" but also just like to tinker of engine-flavored tech, and that's totally okay.

Absolutely agree! It's totally doable, but it does require some desire/ability to dig under the hood little. I think a lot of people conflate the game engine with a game editor, and don't realise how simple an engine can be if it only contains the features needed for one game. I've shipped several games with my home made engine, and it was the best technical decision I ever made! No more relying on someone else to fix bugs!

The editor is part of it but I think the complete lack of where to even begin structuring one's game code in absence of some kind of formalized scene graph is a huge part of it as well. Scene graph editors make seeing “what exists in the game world right now” very visually apparent and easy to understand: “well, there's this root Node, and within that there's these different Nodes, and some of them have child Nodes which represent…” and so on and so forth. I recently replied to someone on X [0] who was starting from the Raylib 2D platformer example and asked, earnestly, “so I have this constant array of five rectangles representing platforms… how do I go from this to ‘defining my game's world’”?

It's just data. In its most basic form, a game world can be represented as just arrays of instances of structs, and then you loop over those arrays and call a function on each element to simulate the “entity” that struct instance represents, and then again to render it onto the screen. Sure, you eventually might want to do something more complex than that if the need arises, but most people would be surprised at just how far you can go doing only the simplest possible thing.

[0] https://x.com/rezich/status/1841889141505851680

everyone will have a different engine. Some people will want to properly learn music theory and chord progressions and proper maintenance of a guitar. Others just want to learn 4 chords and use it to sing to their favorite pop song. Both are valid.

That's ultimately what one crowd wants. They want to deal wth minimum or no code, move around assets in a scene, and try to recreate a level in their head. General purpose engines abstracted the need to learn the code, which was never of interest to most people that just want to make a little game.

My only reservation is knowing when to pick the right tool for the right job. I wouldn't throw Photoshop at someone who just wanted to add some filter on a few pictures if some free phone app (probably a built-in one) worked for them. Likewise, I sure wouldn't tell someone who wanted to make a quick pixel art platformer to download Unreal Engine. Even Unity is a bit overkill. Flash used to be that "iMovie" of 2d games, and we never truly filled in that void when it died.

What? It's the opposite. Everyone and their dog is building their own game engine. Convincing people to actually make games with their engines is the hard part.