What Should Be in a 2D Game Engine?

Question

Ok, so I ended up writing my own game engine based on top of XNA, and I am just wondering what else I need to make a complete engine.

This is what's in the engine:

• Physics (Farseer Physics)
• Particle Engine (Mercury Project)
• 2D Cameras
• Input Handling
• Screen Management (Menus, Pause Screen, etc.)
• Sprite ( Animation, Sprite Sheets)
• And XNA stuff like Sound.

Am I missing anything that might be crucial to a game engine?

Answer 1

3d Acceleration should be in a 2D engine.

Using the 3d hardware that most people have these days is the best way to get amazing performance for your 2D games...

Answer 2

A couple ideas:

• Artificial intelligence (perhaps just simple AI utilities, like pathfinding algorithms)
• Saving all or part of the game state (for suspending and restarting at a later time or saving high scores).

Answer 3

A few more things:

• Path finding - very useful for AI
• AI - possibly - depends on how generic you want the engine to be.
• High scores
• Replays - makes high scores much more interesting, as you can actually watch them.

Answer 4

• Animation framework so that you can say: take this sprite, move it in this direction, folowing this path using this speed, acceleration and such
• Basic GUI system. Don't implement a whole Windows, but basic things like a pointer and a button, and such - keep it basic
• Debugging component for displaying FPS, numbers of sprites and such

Also a good thing is to make some games, and then you will quicky see what things you repeat doing for each game, and then look into how to can get that into the engine.

Answer 5

A theme or market for your engine. If you're doing anything beyond basic your basic graphics engine, you'll want to concentrate on a market for your engine, like RPG, strategy, puzzle, platformer, action, or FPS (ok, not FPS).

This will help you point yourself in the direction you need to go in order to make further enhancements to the engine without asking us. An engine like say, the Unreal Engine, can do multiple things, but what it tends to do best is what it's made for, FPS games. Likewise, you should tailor your engine so that it suits a particular field of interest, and therefore is picked up for that type of gameplay.

You can make it general to a point, but realize the more generalized your engine is, the harder it is to program, both time wise and skill wise. Other programmers are also less likely to pick up a general engine (unless that's all there is) if a more specific platform is available. Or to just write their own since modifying a generalized engine is about as hard as creating your own.

Answer 6

A tile repeat tool. Something that allows the user to add/create a tile, and manipulate the edges for a smooth repeath pattern.

Answer 7

It depends on the game, but another thing often needed is a good networking framework.

Many modern games, including 2D games, seem to have some form of networking in place.

Answer 8

I think that you covered the general requirements of a 2D engine. The only thing I would miss in that list would be:

• GUI Library

Also to make development processes easier:

• Script Engine (LUA, C#Script, ...)
• Dynamically Refreshed Assets (see Nick Gravelyn's Blog Entry)

You might also add another layer on top of XNA's existing stuff:

• A quite bareboned Network/Lobby implementation
• More abstract handling of multiple controllers (DropIn/DropOut during gaming sessions, like see Resident Evil 5 Coop) - maybe event-based

Finally you might add some "ready2use" shaders. Maybe get some inspiration from the discontinued FaceWound (from the "Garry's Mod" developer).

Answer 9

Good collision detection is very helpful. If you implement it efficiently, it really reduces the time required for every frame. Besides that, in my engine (for Pygame) I have a method of separating the main screen into a number of subscreens, which I find useful.

Answer 10

Depending on the target game type, include Navigation Graph(s) with node and edge annotations. (Good for many games, but not so much for the token side scrollers that are made with 2D graphics engines)

• A component to generate them (via a flood fill algorithm).
• Be sure to include all of the major path finding/planning algorithms (A*/Dijkstra/etc.) to traverse those graphs.

The pitfall of this is that you will have to define what a 'map' is for the engine, which might limit users of the engine.

Related things:

• Location based triggers (player enters an invisible circle and something happens - queue cutscene, start ambush, etc.). I would say provide a base class for the trigger and implement some basic ones to show how it's done (ie. weapon pickups etc.)
• Some game engines implement networking (though this is kind of part of the 'xna stuff')

Answer 11

The most useful thing to include above all else would be tools to easily use your engine. Maybe use your engine to create the tools. I'm sure you would find a lot of flaws that way.

Answer 12

Simple pixelperfect collision detection. NOT Farseer Physics. Simple drawing routines like drawline, drawcircle etc.

Answer 13

Um. This list is an "internals" list. To make great engine is to make great "external" list. Look at UE3 for example -- it is here because of great tools. You need tools for world creation, to create optimal packages of resources (it should be in internal list too ;-)), for collision object specification etc. Plus, to add to Organiccat answer you should decide on tech level. You can go for simple sprites or you can want fancy effects (so shaders are needed, and with this you need infrastructure)

Answer 14

You're approaching it in an upside-down manner.

What should be in your engine is the following:

All the code that turned out to be common between your first and your second game.

First, write a game. Don't write an engine, because, as you have found out, you don't know what it should contain, or how it should be designed. Write a game instead.

Once you have that game, write another game. Then, when you have done that, examine the second game's code. How much of it was reused from the first game?

Anything that was reused should then be refactored out into a separate project. That project is now your game engine.

Answer 15

A physics engine that can do a half-way decent boob wave motion, like in that DOA basketball game.