Step 1: Choose Your Game Library

Unless you want to write your own library for all the dirty graphics/sound programming, you will
probably want to get a game library. There are many game libraries out there. but they all offer the
same base functionality (mostly...).
Features that any good library should have:
-Some system to load and play sound files
-Some system to load and display graphics
-At least some basic image manipulation (rotation, etc)
-Primitive drawing functions (circles, lines, rectangles, dots, etc)
-Functions to display text
-Multi-threading support
-Basic timer functions
Some game libraries include:
-Simple Fast Multi-Media Library (SFML): http://www.sfml-dev.org/
-Simple DirectMedia Layer (SDL): http://www.libsdl.org/
-Allegro: http://www.allegro.cc/
-OpenGL (GFX only, however, there are wrapper libs like AllegroGL): http://www.opengl.org/
-DirectX (Windows only): http://msdn.microsoft.com/en-us/directx/
-Irrlicht (3d lib): http://irrlicht.sourceforge.net/
Step 2: Define the Concept
All games start here, merely ideas in someone's head.
First, come up with an idea for a game. Once you have a simple idea, expand on it. For example, if it
is a board game, what is the objective/How do you win? What will the rules be like? etc. If your game
will have characters or a story, create them. Make sure you have a pretty well defined concept of what
your game will be when its finished. The more complex the game, the better you should plan it out in
the beginning so you don't have to worry about the game itself while your coding. Keep in mind that
your game WILL evolve as you create it.
Step 3: Plan Your Engine
Here, you will plan out the various components your game engine will need and how everything will fit
together. Depending on the complexity of your project, you may not need to do this step. This is also a
good time to test various parts of your engine that you have never implemented in the past, just to
make sure they work before you put them in the main project source. Also, you should begin to design
the structure of your classes here as well(if you are using OOP, which you should be). Keep in mind,
however, that there are pre-made engines out there, available for use in all kinds of
projects.
Step 4: Code Your Engine (if your making your own)
Now its time to actually start coding your engine. This doesn't necessarily mean the game itself, but
rather, core rendering, physics, file handling and the like, functions and classes that will be used to
construct your game. However, depending on the complexity of the game, the engine and game code
may be the same. Also, a more complex game will probably require a resource manager. A resource
manager does what it sounds like, it manages your resources (graphics, music, sounds, etc). It also
keeps your code clean and helps to avoid memory leaks. See an excellent resource manager below
by Xander314. Try to give your entire engine some kind of compact, easy interface for use as well.
That way, when you program your game, you don't have search through source to find functions

names and the like. An easy way of doing this would be OOP.
Like so:

1 //put related components into classes

2 class collisions {
3
bool check_col(obj1*, obj2*); //you should use a template for the
4 objects
5
void handle_col(obj1*, obj2*); //so you can test players, bullets, bots
6 with the same function
7
8
public:
9
void handle_all(); //handles EVERYTHING collision related
10
}Collision;
11
12 class rendering {
13
void bots();
14
void bullets();
15
void players();
16
17
public:
18
void draw_all(); //calls other functions for rendering
19
}Renderer;
20
21 //this allows collision management and rendering in your game loop to be as
simple as:
Renderer.draw_all();
Collision.handle_all();
Resource Manager by Xander314

1 /*
2 ResourceManagerB.hpp - Generic template resource manager
3
4 (C) Alexander Thorne (SFML Coder) 2011
5 http://sfmlcoder.wordpress.com/
6
7 Manages loading and unloading of a resource type specified by a
8 template argument.
9
10 ****************************************************************/
11
12 #include <map>
13 #include <string>
14 #include <exception>
15
16 typedef const std::string URI;
17
18 // exceptions
19 namespace Exceptions {
20
21
// thrown if user requests a resource URI not present in the
22 manager's list
23
class URINotFound : public std::runtime_error
24
{
25
public:
26
URINotFound(const std::string& Message = "The specified
27

28 URI was not found in the resource index.")

29
: runtime_error(Message) { }
30
};
31
32
// thrown if a resource allocation fails
33
class BadResourceAllocation : public std::runtime_error {
34
public:
35
BadResourceAllocation(const std::string& Message = "Failed
36 to allocate memory for resource.")
37
: runtime_error(Message) {}
38
};
39 }
40
41 template <class Resource> class ResourceManagerB {
42
typedef std::pair<URI, Resource*> ResourcePair;
43
typedef std::map<URI, Resource*> ResourceList;
44
45
// the list of the manager's resources
46
ResourceList Resources;
47 public:
48
~ResourceManagerB() { UnloadAll(); }
49
50
// Load a resource with the specified URI
51
// the URI could represent, e.g, a filename
52
URI& Load(URI& Uri);
53
// unload a resource with the specified URI
54
void Unload(URI& Uri);
55
// unload all resources
56
void UnloadAll();
57
58
// get a pointer to a resource
59
Resource* GetPtr(URI& Uri);
60
// get a reference to a resource
61
Resource& Get(URI& Uri);
62 };
63
64 template <class Resource>
65 URI& ResourceManagerB<Resource>::Load(URI& Uri)
66 {
67
// check if resource URI is already in list
68
// and if it is, we do no more
69
if (Resources.find(Uri) == Resources.end())
70
{
71
// try to allocate the resource
72
// NB: if the Resource template argument does not have a
73
// constructor accepting a const std::std::string, then
74 this
75
// line will cause a compiler error
76
Resource* temp = new (std::nothrow) Resource(Uri);
77
// check if the resource failed to be allocated
78
// std::nothrow means that if allocation failed
79
// temp will be 0
80
if (!temp)
81
throw Exceptions::BadResourceAllocation();
82
// add the resource and it's URI to the manager's list
83
Resources.insert(ResourcePair(Uri, temp));

84
}
85
return Uri;
86 }
87
88 template <class Resource>
89 void ResourceManagerB<Resource>::Unload(URI& Uri)
90 {
91
// try to find the specified URI in the list
92
ResourceList::const_iterator itr = Resources.find(Uri);
93
// if it is found...
94
if (itr != Resources.end())
95
{
96
// ... deallocate it
97
delete itr->second;
98
// then remove it from the list
99
Resources.erase(Uri);
100
}
101 }
102
103 template <class Resource>
104 void ResourceManagerB<Resource>::UnloadAll()
105 {
106
// iterate through every element of the resource list
107
ResourceList::iterator itr;
108
for (itr = Resources.begin(); itr != Resources.end(); itr++)
109
// delete each resource
110
delete itr->second;
111
// finally, clear the list
112
Resources.clear();
113 }
114
115 template <class Resource>
116 Resource* ResourceManagerB<Resource>::GetPtr(URI& Uri)
117 {
118
// find the specified URI in the list
119
ResourceList::const_iterator itr;
120
// if it is there...
121
if ((itr = Resources.find(Uri)) != Resources.end())
122
// ... return a pointer to the corresponding resource
123
return itr->second;
124
// ... else return 0
125
return 0;
126 }
127
128 template <class Resource>
129 Resource& ResourceManagerB<Resource>::Get(URI& Uri)
130 {
131
// get a pointer to the resource
132
Resource* temp = GetPtr(Uri);
133
// if the resource was found...
134
if (temp)
135
// ... dereference the pointer to return a reference
136
// to the resource
137
return *temp;
else
// ... else throw an exception to notify the caller that

// the resource was not found

throw Exceptions::URINotFound();
}
Last edited on Jun 2, 2011 at 3:49pm
May 17, 2011 at 3:37am
ModShop (993)

Step 5: Graphics/Sounds
Based on your game concept, start creating your graphics and sound effects/music. As you get further
into development, you will probably need to create more GFX and SFX and possibly discard unneeded
ones. This step may continue through the entire process of development.
Step 6: Code Your Game
Once you have your engine complete and working, you can start to code your actual game. This
involves anything specific such as rules, story, etc. Your main game loop will be here as well. This is
the loop that runs over and over and updates everything in your game. See example below. If you
made your engine right, this should be easier than coding your engine, and more fun! This will
probably be where you add your sounds as well. Once this stage is complete, you should have a
working copy of your game. Make sure you get it just how you want it!
Game Loop:

1 //your loop will probaly be very different from this, especially for board
2 games
3 //but this is the basic structure
4
5 while (!Game.lost()) //or whatever your condition is (esc key not pressed,
6 etc)
7{
8
Game.handle_input(); //get user input
9
10
AI.update_bots(); //let your bots move
11
12
Collision.handle_col(); //check for collisions
13
14
Game.check_win(); //see if the player won or lost
15
16
Renderer.draw_all(); //draw everything
17
18
Game.sleep(); //pause so your game doesn't run too fast
//your game lib of choice will have a function for this
}
Step 7: Optimize
Just because your game works, doesn't mean its finished. Besides adding in last minute details, there
will probably be optimizations that you can put in your code. This involves memory usage (try not to
use global variables, check for memory leaks, etc) as well as speed (make sure your code isn't too
slow or overly demanding on the CPU for whatever its doing). General debugging can also be grouped
here too.
Step 8: Package and Distribute
Now that your game is finished, you need to package it and then distribute it as you wish. For
packaging, try to keep it organized and put the final product into a single file (installer package, zip

file, etc). This makes distribution MUCH easier.

Tips:
I've learned many things about making games, some things the hard way. Here are some things that
you should do:
First, stay organized! You should have a good organizational system for everything; your code, your
graphics, your sound effects, etc. I would suggest putting code into different files based on what it
does. i.e, collision detection/resolution code in one file, resource management in another, AI in its own
file, etc. This way, if you need to track down a bug, it will be MUCH easier to find various functions,
and possibly, the bug itself. Keeping the structure of your code organized can help as well (i.e. have
classes for various purposes; rendering, AI, collision detection, etc. Rather than hundreds of void
some_func()'s all over).
Also, try to keep your code clean and efficient. Reuse variables where you can, minimize use of global
variables, check for memory leaks, don't load all of your graphics/sounds at once, etc.
Some starting tips from chrisname:
chrisname wrote:

You don't need to work that hard. What you need to do, is go through a programming tutorial (the
one on this website for example). Don't do too much in a day, or you will get bored and unmotivated.
Don't set a goal based on time, that doesn't work. You'll forget alot of what you learn if you stop
halfway through a lesson. Work through the tutorial on this website
( http://cplusplus.com/doc/tutorial/ ). Aim to get through two lessons a day. Don't stop partway
through a lesson (unless it's for a short break, that's a good idea) and don't do too much in one go, or
you simply won't remember it. I recommend reading and copying out each example (not copy and
paste; type it yourself, this will help you to understand what you are doing), compiling it, seeing what
it does when you run it and modifying things to see what changes. I also recommend you look at
other people's code (one of the things that has helped me is to take other people's broken code and
try to fix it, although don't get too hung up on this because it is hard to read other people's code
when you first start out). When you are reading, try to rephrase things: "If you can't explain it simply,
you don't understand it well enough." (Albert Einstein).
Once you've gone through this tutorial, and maybe some others (I read about three different tutorials
because it was useful to have things said in a different way - I find having something explained in two
different ways is useful for understanding and remembering it), you could read through the tutorials
for SFML (http://sfml-dev.org/tutorials/1.6/ ). Learning SFML will teach you to make 2D games. I'd
also recommend learning SDL ( http://lazyfoo.net/SDL_tutorials/index.php ) because lots of games
use it and you will most probably come across it eventually.
After that, you should get into OpenGL programming if you want to make 3D games. SFML makes this
very easy, and the SFML tutorial includes a tutorial for using OpenGL. For OpenGL, perhaps someone
here can recommend you a book or tutorial.

Throughout all this you should remember that it is important to pace yourself. Don't try to absorb too
much at once or you'll forget lots of it. And don't stay up until 3am when you have an exam the day
after next...

There are many other things that can be done to make development easier and your game more
efficient, but, these are the biggies.
__________________________________________________________________________

That's my 2 cents on game development and the general process. If you feel that I am wrong
somewhere, or missed something, please let me know.