An introduction to Game programming in C using the SDL graphics engine.

1. Workshop India
Wilson Wingston Sharon
wingston.sharon@gmail.com

2. • Why?
• Learning is not just about marks.
• Its about building something.
• You cannot learn C in 2 weeks.
• You can only learn C by writing programs.
• Without writing programs OF YOUR OWN and ON YOUR
OWN.
• We can only guide you – you have to put in some effort.

3. • In todays session file, you will see some files like this.
• Install all of them.
• Now see the Dev-Cpp folder?
• Copy everything in that to your
Dev-Cpp folder (C:/Dev-Cpp). Copy the folders *inside*
this one to the one in you C drive.

4. • In the /game folder, you will see a folder called
“SDL_Template(copy this folder)”
• Copy this folder to your own folder in your Exercise drive.
• After copying, rename the Folder to something like
“SDL_1”
• In the folder you will see sdl.dev, you will have to open
this file.
• You can open dev-cpp normally (if you need to enter
passwrd) and then use the file>>open project or file>> to
open this sdl.dev project file in your folder.

6. Code
For the
File that is currently
Open in the tab
Files that
Belong to the
Current
project

7. -lmingw32
-lSDLmain
-lSDL
-lSGE
• The above parameters
• Must be present in
• The linker tab
• Say OK
• Press Ctr-F11to build
• And then F9 to run the program.

8. • If it doesn’t work.
• Recheck your project options tab
• See if you installed everything in the folder?
• Does it complain about missing dll? See if all files in the
project folder conform to the folder image provided 3
slides before.

11. • Help your friends set it up
• Learning is a collaborative process. Se what mistakes
your friends have made. Check them. Help them.
• It makes you a better programmer by exposing you to the
mistakes that are possible in C.
• It’ll help you avoid silly mistakes if you help others by
correcting them.

12. • main.cpp
• this file contains the main() function
• This is called the entry point of the program.
• grapics.h
• This file contains some structures and function that I wrote.
• You might or might not use them as per requirement of the
program.
• The thing is well commented and documented.

13. The game itself
Here the logic that specifies how the game behaves to the user
Game Engine
SDL just gives as access to graphics card. SGE is our game engine.
SDL
Simple Direct Media Layer Provides a layer to access graphics card
Graphics Card on computer
Harware support for drawing stuff onto the screen

14. • make sure you have copied the Dev-Cpp folder i gave
you onto your Dev-Cpp installation.
• That links up all sort of libraries for SDL to function
• Otherwise you might get an error about missing SDL.h

15. • This must be a global object.
• Whatever we want SDL to display has to be written to this
screen.
•

19. screen = SDL_SetVideoMode(MX, MY, 32,
SDL_HWSURFACE|SDL_DOUBLEBUF);
The above line is important
• If you change MX and MY (in the beginning of
graphics.h) you change the size of screen
• If you add,
SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCR
EEN
• To the last argument of the function, the program goes
into full screen mode!

21. Update Draw
graphics game
models elements
Undraw
Get input
what is
from
not
user
required
Check
Game
logic

22. • Events are things that happen outside the game engine
that the game must be aware of.
• Eg: Keypresses
• SDL_pollevent(&event)
• Returns NULL when there are no events left to handle, so then
that while loops terminates and the game continues.
• The event object contains details about what happened and the
rest of the code handles it!

26. • Don’t touch the init() function.
• To add user interaction, code has to go in which function?
•?
• To add some more drawings, code has to go where?
•?

27. • Don’t touch the init() function.
• To add user interaction, code has to go in which function?
• The event managing while loop in the main() function.
• To add some more drawings, code has to go where?
• The render() function.
• Or another function between init() and the eventhandler()

28. • Here are codes for most functions and all
• The main.cpp and graphics.h need to *share* the same
global variable screen.
• This is done by the keyword extern; this specifies that
this is not a different variable, but a same one that is
declared in another file.

30. • The function _putpixel
draws a point at the MX/2
and MY/2 position.
• Modify the code to draw a
horizontal line.
• ______________________
__
• Across the screen.

32. • That for loop starts from i =0
• Till MX in steps of 1
• And the putpixel function
draws a pixel at every point.
• Can you change it to vertical?

33. • What to do when considering to move a point.
• What all is required to define a point?
• X
• Y
• Colour.
• Keyboard handling is done on the event loop.
Position
Keyboard is
Screen is Point is
press is updated
cleared drawn
checked for the
point

34. • Keyboard presses is update as a
struct in graphics.h called move.
• Each point will have an associated
move variable.
• If kLR is -1/1 the point will have to
move Left/Right.
• And so on.

36. • It is the while(SDL_Pollevent(&event))
• For every loop, the event structure will have the details of
what happens, we want to see onky keyboard events.
• These are events of event.type ==
• SDL_KEYDOWN
• SDL_KEYUP
• Etc..
• Using a switch case we can write what code to happen
when each event is fired.

38. • Code comes at the level of the last
one.
• Case SDL_KEYUP:
• What to dowhen the key has been
released?
Set the move variable m1 kUD or KLR
to 0. Signifying no movement.

39. • cls(0) fills the screen with
black;
• Updates point p1 with m1 for
which direction to move the
point
• Putpixel to draw the point.

40. • Render() runs infinitely,
• Checks if point p1 has moved by using the m1variable
• If moved, update the point’s x & y
• Then clear the screen and draws the point.
• When keyboard is pressed
• The eventloop() in main now enters the loop
• A switch case is done on the event type to determine if it’s a keypress
or a release.
• When the keypress is detected the m1 variable is adjusted
• When the keyrelease is detected the m1 variable is set to 0 so not
movement happens.
• Compile 2.Movment folder code.
• Again: follow dev-cpp rules for opening projects and compiling them.

41. • We have the point p1 that we can move
around with the keyboard.
• Lets draw a line between p1 and MX/2,
MY/2.
• That is a line from p1 to the center.
• Line function:
• sge_Line(*screen,x1,y1,x2,y2,color);
• sge_AALine(…) is line with anti-aliasing

44. • I want the other points to move by using the
• W - UP
• S - DOWN
• A - LEFT
• D – Right
• Point 2 is handled by m2.
• Using switch case do the update of m2
• And update p2 with m2
• I want the line to move by both points.
• One point moves by arrow keys
• The other moves by wasd keys.

45. • The SGE SDL library provides some basic primitives for
drawing.
• Drawing in this case is mathematical drawing.
• The basic shapes that are provided are:
• Points
• Lines
• Circle
• Rectangle
• Ellipse
• Polygons

48. • Try to think of creative shapes and things that you can
draw with these functions.
• You can also make interesting mathematical loop
shapes.
• If you don’t do the cls(0) whatever the loop draws wont
be erased in the next iteration!.
• Try and do some more hoola!

49. • SDL printing things on the screen means
you need a font!
• The font file is *something*.ttf
• These sort of fonts can be opened by SDL
and drawn onto the screen.
• First we need to make a global font *
variable.

50. • We need to initialise the font
• We have cour.ttf right now.
• sge_TTF_Init() initialises the font
engine.
• sge_TTF_openFont(font, size)
returns the font object that should
be global pointer of the same,

53. • Get text to appear one by one on the screen.
• Get text to scroll around the screen.
• Can you get keyboard input using the event loop ?
• Do only numbers

54. • First we create a struct circle. (same like point except
with radius too).

57. • Same
KEYUP/KEYDOW
N movement code
to move m1 and
m2.
• Adjust this code
and get the second
circle moving too.

58. • Instead of moving the second circle use the below
random functions
• int sge_Random(int min, int max)
Returns a random integer between (and including) min
and max.
void sge_Randomize(void)
Seed the random number generator with a number from
the system clock. Should be called once before the first
use of sge_Random.

59. • Move the second circle randomly.
• When the first circle is touching the second circle, a
counter should start in the corner.
• As long as the two circles are touching, counter must
keep incrementing and the second circle keeps moves
faster and faster.
• When the first circle leaves, the counter goes to 0 and
stays there.