question

Skip to main content
 Page pathMy home /
Game Programming with C++ 2014 /
 /
Exercise - Creating Space Invaders Part 3

Introduction and Objective

The goal of this tutorial is to introduce you to making use of functions and structures within the context of a C++ program.  Functions are used to break our program down in to more manageable sections, a function can be used to neatly wrap up a section of code that can then be used to perform a specific task.

Structures are used to break our application down into more manageable components, not just a slap-dash collection of variables, structures are our first steps along the road to Object Oriented Programming (OOP).

This tutorial assumes that you have completed and fully implemented the features outlined in the previous Space Invaders tutorials.



Process



Ok so now that we have a simple version of space invaders coded up, where we can navigate from a menu screen into our gameplay state and back again, we can now begin to implement some functions to get our game playing a little bit more like a game and looking less like a few space invaders screen grabs.

First let's add some functions to our program that will allow us to break it down into the two major sections that have so far, processing the main menu state, and processing the game state.

To do this let's add some function declarations above our main function, we have to make sure we declare our functions before we attempt to call them. If we don't typically the compiler will tell us that we're trying to invoke or call a method that it hasn't been notified of, this is a good example of a compile time error.

So let's add the following code just above out main() function.
void UpdateMainMenu();
void UpdateGameState();


All we have done here is make a function declaration, this is akin to telling C++ that we are going to use some functions that have the above syntax somewhere later on in our program.

We're now going to flesh these functions out so that the code that was in out switch statement inside our main function now resides in these two functions, we are also going to alter our main functions switch statement to call these two functions, which one will depend upon which state we are currently in.

UpdateMainMenu()
void UpdateMainMenu()
{
	DrawSprite(iArcadeMarquee);
	DrawString( pkInsertCoins,	iScreenWidth * 0.37f,	iScreenHeight * 0.5f , 0.75f);
	DrawString( pkCredits,	iScreenWidth * 0.25f,	iScreenHeight * 0.4f , 0.7f);

}


Note: I have a variable called iArcadeMarquee which is simple just a sprite I have drawn on my menu to make it look more like the original arcade you can find a large version of the Arcade game's marquee here.

UpdateGame()
void UpdateGameState()
{
	//\==================================================================================
	//\ Player movement handling code
	//\==================================================================================
	if( IsKeyDown( 'A' ) )
	{
		fPlayerX -= 2.f;
		if( fPlayerX < (fPlayerWidth*.5f) )
		{
			fPlayerX = (fPlayerWidth*.5f);
		}
	}

	if( IsKeyDown( 'D' ) )
	{
		fPlayerX += 2.f;
		if( fPlayerX > (iScreenWidth - (fPlayerWidth*.5f)) )
		{
			fPlayerX = iScreenWidth - (fPlayerWidth*.5f);
		}
	}
	MoveSprite( iPlayerCannon, fPlayerX, fPlayerY );
	DrawSprite( iPlayerCannon );

	for( int i = 0; i < 15; ++i )
	{
		DrawSprite(alienShips[i]);
	}

	DrawLine( 0, 40, iScreenWidth, 40, SColour( 0x00, 0xFC, 0x00, 0xFF ));

	SetFont( pInvadersFont );
	DrawString( pkScore1,	iScreenWidth * 0.025f,	iScreenHeight - 2 );
	DrawString( pkHiScore,	iScreenWidth * 0.425f,	iScreenHeight - 2 );
	DrawString( pkScore2,	iScreenWidth * 0.8f,	iScreenHeight - 2 );
	DrawString( pkCredit,	iScreenWidth * 0.7f,	38 );


}


main( int argc, char* argv[] )
unsigned int iArcadeMarquee;
//Player global variables
unsigned int iPlayerCannon ;
float fPlayerX;
float fPlayerY;;
float fPlayerWidth = 64.f;
float fPlayerHeight = 32.f;
unsigned int alienShips[15];

int main( int argc, char* argv[] )
{
	//\ Lets initialise the AIE Framework and give the window it creates an appropriate title
	Initialise( iScreenWidth, iScreenHeight, false, "Space Invaders" );
	SetBackgroundColour( SColour( 0x00, 0x00, 0x00, 0xFF ) );
	AddFont( pInvadersFont );

	iArcadeMarquee = CreateSprite( "./images/Space-Invaders-Marquee.png", iScreenWidth, iScreenHeight, true );
	MoveSprite( iArcadeMarquee, iScreenWidth * 0.5f, iScreenHeight * 0.5f );
	//\Now lets create the sprite for our players cannon. That's right in space invaders we control a cannon
	//\So lets create that with an appropriate variable name and move it to a suitable location (say the middle of our screen)
	iPlayerCannon = CreateSprite( "./images/cannon.png", fPlayerWidth, fPlayerHeight, true );
	fPlayerX =  iScreenWidth * 0.5f;
	fPlayerY =  80.f;
	MoveSprite( iPlayerCannon, fPlayerX, fPlayerY );

	float fEnemyX = iScreenWidth * 0.2f;
	float fEnemyY = iScreenHeight * 0.7f;
	for( int i = 0; i < 15; ++i )
	{
		alienShips[i] = CreateSprite( "./images/invaders/invaders_1_00.png",  fPlayerWidth, fPlayerHeight, true );
		MoveSprite( alienShips[i], fEnemyX, fEnemyY );
		fEnemyX += 0.12 * iScreenWidth;
		if( fEnemyX > iScreenWidth * 0.8f)
		{
				fEnemyX = iScreenWidth * 0.2f;;
				fEnemyY -= 0.08 * iScreenHeight;
		}

	}

	GameStates eCurrentState = eMAIN_MENU;
	do
	{
		ClearScreen();
		float fDeltaT = GetDeltaTime();
		switch (eCurrentState )
		{
		case eMAIN_MENU:
			UpdateMainMenu();
			if( IsKeyDown( KEY_ENTER ) )
			{
				eCurrentState = eGAMEPLAY;
			}
			break;
		case eGAMEPLAY:
			UpdateGameState();
			if( IsKeyDown( KEY_ESCAPE ) )
			{
				eCurrentState = eMAIN_MENU;
			}
			break;
		default:
			break;
		}
	} while ( FrameworkUpdate() == false );

	DestroySprite(iPlayerCannon);
	DestroySprite(iArcadeMarquee);
	Shutdown();

	return 0;
}



Now if we build an run our Space Invaders game we should get a few errors about variables not being declared etc. Visual Studio should identify these with a red underline in the text editor.  We need to go through and declare these variables outside of out main() function. I've already done this in the above code. So if you had copied that then built you would have seen that nothing has changed with the running of the game, however our code is now broken up into three functions main(), updateMainMenu(), and updateGame().

Alright so that that we have this in place lets keep on going down this track of adding functions, lets add a function in to create our Space Invader Aliens, Dont forget to add in the function declaration before the main() function, and don't forget that you need to call this function in order to create your enemies.

void CreateEnemies()
{
	float fEnemyX = iScreenWidth * 0.2f;
	float fEnemyY = iScreenHeight * 0.7f;
	for( int i = 0; i < 15; ++i )
	{
		alienShips[i] = CreateSprite( "./images/invaders/invaders_1_00.png",  fPlayerWidth, fPlayerHeight, true );
		MoveSprite( alienShips[i], fEnemyX, fEnemyY );
		fEnemyX += 0.12 * iScreenWidth;
		if( fEnemyX > iScreenWidth * 0.8f)
		{
				fEnemyX = iScreenWidth * 0.2f;;
				fEnemyY -= 0.08 * iScreenHeight;
		}
	}
}


Ok so now that we have some functions in place now might be a good time to look at implementing a few structures as you'll have no doubt noticed we've got a lot of variables floating around now for player X Position, and Y Position along with all the variables that are going towards making our Enemies and placing them around the screen, a lot of these are now global too. Global is bad, well it's bad in the sense of breaking Object Orientation rules. But apparently as far as online tutorials for OpenGL go global everything is perfectly normal, go figure.

Add the following structure to our main.cpp so that we can create and update our players cannon a little bit easier. Remember less global variables is better.
struct PlayerCannon
{
	unsigned int iSpriteID;
	float fWidth;
	float fHeight;
	float x;
	float y;
};

PlayerCannon player;


What we've done here is wrap our Player Cannon up as a type of small object.  As we can see our Players Cannon has an attribute called spriteID, an attribute for it's X and Y positions.  There are also some variables associated with our Cannon that will control it's movement. Just underneath our struct we have declared a variable of type 'PlayerCannon' called player that's right we've just created our first user defined type.

Now that we have created this structure let's use it in our code an replace the code we had that previously.
//\Now lets create the sprite for our players cannon. That's right in space invaders we control a cannon
//\So lets create that with an appropriate variable name and move it to a suitable location (say the middle of our screen)
player.fHeight = 32.f;
player.fWidth = 64.f;
player.iSpriteID = CreateSprite( "./images/cannon.png", player.fWidth, player.fHeight, true );
player.x =  iScreenWidth * 0.5f;
player.y =  80.f;


Note: I've not shown how to replace the code in the UpdateGameState() function to use this structure, as from the above that should be fairly common sense.

We should also perhaps add a function or two into our Player Cannon structure so that we don't just access these variables directly (We'll learn more about why this is bad in an upcoming lesson on classes soon.). That's right structures can also have functions, which they can make use of to conduct operations on their attributes (or variables).  So lets get our cannon structure and add the following functions.
struct PlayerCannon
{

	unsigned int iSpriteID;

	float fWidth;
	float fHeight;
	void SetSize( float a_fWidth, float a_fHeight )
	{
		fWidth = a_fWidth;
		fHeight = a_fHeight;
	}

	float x;
	float y;
	void SetPosition( float a_x, float a_y )
	{
		x = a_x;
		y = a_y;
	}

	unsigned int iMoveLeftKey;
	unsigned int iMoveRightKey;
	void SetMovementKeys( unsigned int a_moveLeft, unsigned int a_moveRight )
	{
		iMoveLeftKey = a_moveLeft;
		iMoveRightKey = a_moveRight;
	}
};


To access these functions we can make use of the dot operator on our PlayerCannon variable player, for example to set our width and height we could do the following.
player.SetSize( 64.f, 32.f );
player.SetMovementKeys( 'A', 'D' );


Cool so now we've got a structure in place for our player cannon, we've got a few functions in place for setting up our movement keys, etcetera.  What we could do now is set up our player cannon so that it knows how to move itself (to an extent) and ensure that it remains within the screens bounds.

So let's modify our Player Cannon structure a little bit more. Add the following into our PlayerCannon structure.
unsigned int iLeftMovementExtreme;
unsigned int iRightMovementExtreme;
void SetMovementExtremes( unsigned int a_leftExtreme, unsigned int a_RightExtreme )
{
	iLeftMovementExtreme = a_leftExtreme;
	iRightMovementExtreme = a_RightExtreme;
}

void Move( float a_fTimeStep, float a_fSpeed )
{
	if( IsKeyDown( iMoveLeftKey ) )
	{
		x -= a_fTimeStep * a_fSpeed;
		if( x < (iLeftMovementExtreme + fWidth*.5f) )
		{
			x = (iLeftMovementExtreme + fWidth*.5f);
		}
	}
	if( IsKeyDown( iMoveRightKey ) )
	{
		x -= a_fTimeStep * a_fSpeed;
		if( x > (iRightMovementExtreme - fWidth*.5f) )
		{
			x = (iRightMovementExtreme - fWidth*.5f);
		}
	}
	MoveSprite( iSpriteID, x, y );
}


Ok so we should now have a version of our Space Invaders game that has some functions and a player structure in place of all the global player variables that we previously had.  Go ahead and insert these functions in the location we previously had our player movement code, do not forget to set your movement Extreme values.

If you are paying attention you will notice that there is a float parameter passed into our Move function called a_fDeltaTime this is the change in time per frame of our game. This is passed in from our main function, so I have also gone ahead an modified our UpdateGameState() function to accept a float parameter so it's declaration and implementation now have the following function signature UpdateGameState( float a_fDeltaTime ).  Inside the main() function I am calling an AIE framework function to get the number of seconds that have passed since the last frame. Add the following line just inside the start of our do/while loop in our main() function
float fDeltaT = GetDeltaTime();


What this means is that our movement code is now no longer limited by the speed of the CPU that our code is running on and will instead move appropriately over a consistent time frame.

We should go ahead and create a structure for our Alien Enemies, and add some functionality to make is similar to our player cannon structure, although our move function would want to behave a bit differently.

If we look at the game of Space Invaders our enemies should behave in a very identifiable pattern, they move left until the left most unit encounters the edge of the screen or play area, then they all move towards the planet a few pixels then proceed to move right until the rightmost unit encounters the edge of the play area, then they move forward a few more pixels.  This pattern then repeats.

We should be able to manipulate our Enemy Move function to replicate this behaviour, although there are some considerations that we will need to think about. Our Enemies progress towards the player as a whole, once one enemy encounters the edge of the playing field they should all move in a unified direction forwards then swap to the opposite left/right direction.

We can use our Enemy move function to return a boolean value, so that when one enemy crosses the bounds for the playing field our main update loop is notified of this and can then set the appropriate move direction that our enemies should undertake on their next update. Perhaps the following function will help you understand how to implement the Move functionality in your Enemy class.
struct Enemy
{
    bool Move( float a_fDeltaTime, int a_Direction )
    {
        if( a_Direction == eLeft )
        {
           //Move Left
           if( /*Moved too far Left*/ )
           {
              return true;
           }
        }
        if( a_Direction == eRight )
        {
           //Move Right
           if( /*Moved too far Right*/ )
           {
              return true;
           }
        }
        if( a_Direction == eDown )
        {
           //Move towards the planet
        }
    }
};