Sorry your browser is not supported!

c:\program files\the game creators\dark gdk\include\darksdkcamera.h(16) : fatal error C1083: Cannot open include file: 'd3dx9.h': No such file or directory

/*#################################################################################
#####     ######   ####   #####  #####       #############  ####    #######    ####
#####  ### ###  ##  ###    ####  ####  ###### ###########  ###  ###  ####  ###  ###
#####  ### ##  ####  ##  #  ###  ###  ##################  ###  #####  ##  #####  ##
#####     ###  ####  ##  ##  ##  ##  ########################  #####  ##   ###  ###
#####  ######  ####  ##  ###  #  ##  ###        #############  #####  ###       ###
#####  #######  ##  ###  ####    ###  ####   ## ##############  ###  #########  ###
#####  ########   #####  #####   ####      #### ###############     #####     #####
###################################################################################
##############>>>>>GAME DESIGNED AND PROGRAMMED BY KRISACZ<<<<<####################
####################################2009###########################################
#################################################################################*/

#include "DarkGDK.h"


//===== PLAYERS AND CPU CLASS =====
class cPlayer
{
public:
	//=== CLASS FUNCTIONS ===
	void MoveLeft();
	void MoveRight();
	void DrawPlayer();
	void MakePlayer();
	void Update();

	//=== CLASS CONSTRUCTOR ===
	cPlayer(int Xpos_c, int Ypos_c, int KeyL_c, int KeyR_c, int Spd_c, int SpriteID_c, DWORD Colour_c);
	
	//=== CLASS VARIABLES ===
	int   Xpos;	
	int   Ypos;
	int   KeyL;
	int   KeyR;
	int   Spd;
	int	  SpriteID;
	DWORD Colour;
};

//===== CREATING 3 CLASS OBJECTS =====
cPlayer Player1	(350, 575, 203, 205, 6, 2, dbRGB(0,255,0));
cPlayer Player2	(350,   5,  30,  32, 3, 3, dbRGB(0,0,255));
cPlayer CPU		(350,   5,   0,   0, 3, 3, dbRGB(255,0,0));

//===== FUNCTION DECLARATIONS (A-Z) =====
void BallControll(bool Start);
void CPU_AI();
void CrazyBall();
void MakeBall();
void MakeSparks(int Xpos, int Ypos);
void MenuControl();
int	 MM(int minv, int maxv);
bool P1_Ball_Collision(int Player1_ID, int Ball_ID);
bool P2CPU_Ball_Collision(int P2CPU_ID, int Ball_ID);
void ShowScores();
void Winner();

//===== GAME CONTROLL ENUM =====
enum cGameState {MENU, GAME1P_SETUP, GAME1P, GAME2P_SETUP, GAME2P, GAME_END, EXIT};
cGameState GAME_STATE = MENU;

//===== OTHER =====
bool StartGame = false;
float BallSpeed = 5.0f;
int Player1Score = 0;
int Player2Score = 0;
int GameMode = 0;


//================================================================================================
//===== DARK GDK MAIN LOOP =======================================================================
//================================================================================================
void DarkGDK ( void )
{
	//===== SCREEN SETTINGS =====
	dbSyncOn   ( );
	dbSyncRate ( 60 );
	dbSetDisplayMode(800, 600, 32);
	//dbSetWindowLayout(0, 0, 0);
	//dbMaximizeWindow();
	dbRandomize(dbTimer());
	dbDisableEscapeKey();
	
	while ( LoopGDK ( ) )
	{
		switch	(GAME_STATE)
		{			
		case MENU:
			//DRAWING AND CONTROLING MENU
			MenuControl();
		break;

		case GAME1P_SETUP:
			//PLAYER 1 SETTINGS
			Player1.MakePlayer();			
			Player1.Xpos = 350;
			Player1.DrawPlayer();
			Player1Score = 0;
			dbScaleSprite(Player1.SpriteID, 100);
			//CPU SETIINGS
			CPU.MakePlayer();
			CPU.Xpos = 350;
			CPU.DrawPlayer();
			Player2Score = 0;
			dbScaleSprite(CPU.SpriteID, 100);
			//BALL SETTINGS
			MakeBall();	
			dbSprite(1, 397, 297, 1);			
			BallSpeed = 5.0f;			
			//CHANGE GAME MODE
			GAME_STATE = GAME1P;
		break;

		case GAME1P:	
			//CLEARING SCREEN
			dbCLS(dbRGB(0,0,0));			
			//UPDATE PLAYER 1
			Player1.Update();
			//UPDATE CPU
			CPU.Update();
			CPU_AI();
			//UPDATE BALL
			BallControll(StartGame);
			CrazyBall();
			//DRAW SCORES
			ShowScores();			
			//EXTRA CONTROLS
			if((dbKeyState(28))&&(StartGame==false))	{StartGame=true;}
			if((Player1Score == 5)||(Player2Score == 5))	{GameMode = GAME1P; GAME_STATE = GAME_END;}
			if(dbKeyState(1)){	for(int S=1; S<=3; S++){dbHideSprite(S);}	GAME_STATE = MENU;}
		break;

		case GAME2P_SETUP:
			//PLAYER 1 SETTINGS
			Player1.MakePlayer();
			Player1.Xpos = 350;
			Player1.DrawPlayer();
			Player1Score = 0;
			dbScaleSprite(Player1.SpriteID, 100);
			//PLAYER 2 SETTINGS
			Player2.MakePlayer();
			Player2.Xpos = 350;
			Player2.DrawPlayer();						
			Player2Score = 0;
			dbScaleSprite(Player2.SpriteID, 100);
			//BALL SETTINGS
			MakeBall();
			dbSprite(1, 397, 297, 1);			
			BallSpeed = 5.0f;
			//CHANGE GAME MODE			
			GAME_STATE = GAME2P;
		break;

		case GAME2P:
			//CLEARING SCREEN
			dbCLS(dbRGB(0,0,0));			
			//UPDATE PLAYER 1
			Player1.Update();
			//UPDATE PLAYER 2
			Player2.Update();
			//UPDATE BALL
			BallControll(StartGame);			
			CrazyBall();
			//DRAW SCORES
			ShowScores();
			//EXTRA CONTROLS
			if((dbKeyState(28))&&(StartGame==false))	{StartGame=true;}
			if((Player1Score == 5)||(Player2Score == 5))	{GameMode = GAME2P; GAME_STATE = GAME_END;}
			if(dbKeyState(1)){	for(int S=1; S<=3; S++){dbHideSprite(S);}	GAME_STATE = MENU;}
		break;

		case GAME_END:
			//WHEN 1 OF PLAYERS SCORE 5...
			Winner();
		break;

		case EXIT:
			return;
		break;
		}

		dbSync ( );
	}

	// return back to windows
	return;
}
//================================================================================================
//===== END OF DARK GDK MAIN LOOP ================================================================
//================================================================================================

//===========================
//===== CLASS FUNCTIONS =====
//===========================

//===== MOVING PLAYER LEFT =====
void cPlayer::MoveLeft()
{
	if( (dbKeyState(KeyL))&&(Xpos-Spd>0) )
	{
		Xpos-=	Spd;
	}			
}

//===== MOVING PLAYER RIGHT =====
void cPlayer::MoveRight()
{
	if( (dbKeyState(KeyR)) &&(Xpos+Spd+dbSpriteWidth(SpriteID)<800) )
	{
		Xpos+=	Spd;
	}			
}

//===== MAKING PLAYERS/CPU SPRITE =====
void cPlayer::MakePlayer()
{
	dbCreateBitmap(SpriteID, 100, 20);
	dbSetCurrentBitmap(SpriteID);
	dbInk(Colour,Colour);
	dbBox(0,0,99,19);
	dbInk(Colour-50,Colour-50);
	dbBox(4,4,94,14);
	dbInk(dbRGB(255,255,255),dbRGB(255,255,255));
	dbLine(0,0,4,4);
	dbLine(94,14,99,19);
	dbLine(0,19,4,14);
	dbLine(94,4,99,0);
	dbGetImage(SpriteID,0,0,99,19);
	dbDeleteBitmap(SpriteID);
	dbSetCurrentBitmap(0);
	dbShowSprite(SpriteID);
}

//===== DRAWING PLAYER ON SCREEN =====
void cPlayer::DrawPlayer()
{	
	dbSprite(SpriteID, Xpos, Ypos, SpriteID);
}

//===== ALL IN ONE - DRAWING AND MOVING PLAYER/CPU ON SCREEN =====
void cPlayer::Update()
{
	DrawPlayer();
	MoveLeft();
	MoveRight();
}


//===== CONSTRUCTOR =====
cPlayer::cPlayer(int Xpos_c, int Ypos_c, int KeyL_c, int KeyR_c, int Spd_c, int SpriteID_c, DWORD Colour_c)
{
	Xpos     = Xpos_c;
	Ypos     = Ypos_c;
	KeyL     = KeyL_c;
	KeyR     = KeyR_c;
	Spd		 = Spd_c;
	SpriteID = SpriteID_c;
	Colour   = Colour_c;		
}

//===========================
//===== OTHER FUNCTIONS =====
//===========================

//===== CONTROLING BALL ON SCREEN =====
void BallControll(bool Start)
{
	if(Start)
	{
		enum eBallState { START, MOVE, BOUNCE_WALL, BOUNCE_PLAYER, SCORE1, SCORE2};
		static eBallState BALL_STATE = START;
		
		//ball starting to move
		if(BALL_STATE == START)
		{
			if(MM(0,1))
			{
				dbRotateSprite(1, MM(-45,45));			
			}
			else
			{
				dbRotateSprite(1, MM(135,225));			
			}			
			BALL_STATE = MOVE;
		}
		//ball is moving
		if(BALL_STATE == MOVE)
		{
			dbMoveSprite(1,BallSpeed);

			if(dbSpriteX(1)>795)			{BALL_STATE = BOUNCE_WALL;}
			if(dbSpriteX(1)<5)				{BALL_STATE = BOUNCE_WALL;}
			if(dbSpriteY(1)>=600)			{BALL_STATE = SCORE2;}
			if(dbSpriteY(1)<=0)				{BALL_STATE = SCORE1;}
			if(P1_Ball_Collision(2,1))		{BALL_STATE = BOUNCE_PLAYER;}
			if(P2CPU_Ball_Collision(3,1))	{BALL_STATE = BOUNCE_PLAYER;}
		}
		//ball bouncing of wall
		if(BALL_STATE == BOUNCE_WALL)
		{
			dbRotateSprite(1, dbWrapValue(dbSpriteAngle(1)*-1));
			BALL_STATE = MOVE;
		}
		//ball bouncing of player/cpu
		if(BALL_STATE == BOUNCE_PLAYER)
		{
			dbPlaySound(1);
			
			dbRotateSprite(1, dbWrapValue( (dbSpriteAngle(1)*-1))+MM(-10,10));
			BallSpeed *= -1; 
			MakeSparks(dbSpriteX(1), dbSpriteY(1));
			
			if(dbSpriteY(1)>400)
			{
				if(dbSpriteScaleX(2)> 30){dbScaleSprite( 2, (dbSpriteScaleX(2)*0.95f) );}
			}
			else
			{
				if(dbSpriteScaleX(3)> 30){dbScaleSprite( 3, (dbSpriteScaleX(3)*0.95f) );}
			}

			BALL_STATE = MOVE;
		}
		//Player 1 - score
		if(BALL_STATE == SCORE1)
		{
			dbSprite(1, 397, 297, 1);
			Player1Score += 1;
			StartGame = false;
			dbScaleSprite( 3, (dbSpriteScaleX(3)*1.50f));
			if(dbSpriteScaleX(3)> 100) {dbScaleSprite( 3, 100);}
			BallSpeed = 5.0f;
			BALL_STATE = START;
		}
		//Player 2 or CPU - score
		if(BALL_STATE == SCORE2)
		{
			dbSprite(1, 397, 297, 1);
			Player2Score += 1;
			StartGame = false;
			dbScaleSprite( 2, (dbSpriteScaleX(2)*1.50f));
			if(dbSpriteScaleX(2)> 100) {dbScaleSprite( 2, 100);}
			BallSpeed = 5.0f;
			BALL_STATE = START;
		}

	}
}

//===== AI :-) =====
void CPU_AI()
{
	if(dbSpriteX(1)>CPU.Xpos+dbSpriteWidth(CPU.SpriteID)/2)
	{
		if( CPU.Xpos+dbSpriteWidth(CPU.SpriteID)+CPU.Spd < 800)
		{
			if(MM(1,10)<10)
			{
				CPU.Xpos += CPU.Spd;
			}			
		}		
	}
	
	if(dbSpriteX(1)<CPU.Xpos+dbSpriteWidth(CPU.SpriteID)/2)
	{
		if(CPU.Xpos-CPU.Spd > 0)
		{
			if(MM(1,10)<10)
			{
				CPU.Xpos -= CPU.Spd;
			}			
		}		
	}
}

//===== CRAZY BALL =====
void CrazyBall()
{
	//timer, angle and crazy ball! :-)
	static int StartTimer = dbTimer();
		   int NowTimer	  = dbTimer();

   if( NowTimer >= StartTimer+5000)
   {
		StartTimer = dbTimer();
		dbRotateSprite(1, MM(0,360));
		BallSpeed *= 1.1f;
   }
	
   //change ball color acording to time left
   float TMod = ((StartTimer+5000) - NowTimer)/50;
   dbSetSpriteDiffuse(1,255*((100-TMod)/100),255*(TMod/100),255*(TMod/100));
}

//===== MAKING BALL =====
void MakeBall()
{
	dbCreateBitmap(1,6,6);
	dbSetCurrentBitmap(1);
	dbInk(dbRGB(255,255,255),dbRGB(255,255,255));
	dbBox(0,0,5,5);
	dbGetImage(1,0,0,5,5);
	dbDeleteBitmap(1);
	dbSetCurrentBitmap(0);
	dbOffsetSprite(1, dbSpriteWidth(1)/2, dbSpriteHeight(1)/2);
	dbShowSprite(1);
}

//===== MAKING SPARKS =====
void MakeSparks(int Xpos, int Ypos)
{
	int OldYP1 = dbSpriteY(2);
	int OldYP2 = dbSpriteY(3);
	int ActYP1 = OldYP1;
	int ActYP2 = OldYP2;

	for (int NoOfSp=1; NoOfSp<=20; NoOfSp++)
	{		
		if(Ypos>400)
		{	
			dbInk( dbRGB(255,255,0), dbRGB(255,255,0));
			dbLine(Xpos,Ypos, Xpos+MM(-30,30), Ypos-MM(10,25));
			dbSprite(2, dbSpriteX(2), ActYP1, 2);
			ActYP1 += 1;
		}
		else
		{
			dbInk( dbRGB(255,255,0), dbRGB(255,255,0));
			dbLine(Xpos,Ypos, Xpos+MM(-30,30), Ypos+MM(10,25));
			dbSprite(3, dbSpriteX(3), ActYP2, 3);
			ActYP2 -= 1;
		}		
	}

	dbSprite(2, dbSpriteX(2), OldYP1, 2);
	dbSprite(3, dbSpriteX(3), OldYP2, 3);
}

//===== DRAWING AND CONTROLING MAIN MENU =====
void MenuControl()
{	
	static int MENU_STATE = 3;
	static bool KeyPressed = false;

	dbCLS(dbRGB(0,0,0));
	
	//DRAWING TITLE
	dbSetTextFont("Arial");
	dbSetTextToBold ();
	dbSetTextSize(80);
	dbInk(dbRGB(0,0,255),dbRGB(0,0,255));
	dbCenterText(400, 75, "PONG '09");
	dbInk(dbRGB(0,0,150),dbRGB(0,0,150));
	dbCenterText(403, 78, "PONG '09");

	//DRAWING MENU BOXES
	dbInk(dbRGB(0, 100, 0),dbRGB(0, 100, 0));
	dbBox(250-5, 200-5, 550-5, 275-5);	// 200x150 px
	dbBox(250-5, 325-5, 550-5, 400-5);	// 200x150 px
	dbBox(250-5, 450-5, 550-5, 525-5);	// 200x150 px
	dbInk(dbRGB(0, 200, 0),dbRGB(0, 200, 0));
	dbBox(250, 200, 550, 275);	// 200x150 px
	dbBox(250, 325, 550, 400);	// 200x150 px
	dbBox(250, 450, 550, 525);	// 200x150 px
	
	//DRAWING CHOSEN MENU BOX
	switch(MENU_STATE)
	{
	case 3:
		dbInk(dbRGB(200, 0, 0),dbRGB(200, 0, 0));
		dbBox(250, 200, 550, 275);	// 200x150 px	
	break;
	case 2:
		dbInk(dbRGB(200, 0, 0),dbRGB(200, 0, 0));
		dbBox(250, 325, 550, 400);	// 200x150 px
	break;
	case 1:
		dbInk(dbRGB(200, 0, 0),dbRGB(200, 0, 0));
		dbBox(250, 450, 550, 525);	// 200x150 px
	break;
	}

	//INSERT TEXT ON MENU BOXES
	dbInk(dbRGB(255, 255, 255),dbRGB(255, 255, 255));
	dbSetTextSize(25);	
	dbCenterText(400, 225, "START GAME - 1 PLAYER");
	dbCenterText(400, 350, "START GAME - 2 PLAYERS");
	dbCenterText(400, 475, "EXIT GAME");

	//CONTROLING MENU
	if( (dbKeyState(200))&&(KeyPressed == false) )
	{
		MENU_STATE += 1;
		KeyPressed = true;
	}
	if( (dbKeyState(208))&&(KeyPressed == false) )
	{
		MENU_STATE -= 1;
		KeyPressed = true;
	}
	if(MENU_STATE > 3) {MENU_STATE = 1;}
	if(MENU_STATE < 1) {MENU_STATE = 3;}
	if( (dbKeyState(200)==0)&&(dbKeyState(208)==0) ) {KeyPressed = false;}

	//CHOOSING...
	if(dbKeyState(28))
	{
		if(MENU_STATE == 3){GAME_STATE = GAME1P_SETUP;}
		if(MENU_STATE == 2){GAME_STATE = GAME2P_SETUP;}
		if(MENU_STATE == 1){GAME_STATE = EXIT;}
	}
}

//===== RANDOMIZE NUMBER FROM GIVEN RANGE - MIN-MAX =====
int MM(int minv, int maxv)
{	
	int result;
	int no_of_results = maxv - minv; 
	
	result = dbRND(no_of_results) + minv;
	return result;
}

//===== PLAYER1 <--> BALL COLLISION =====
bool P1_Ball_Collision(int Player1_ID, int Ball_ID)
{
	if(dbSpriteX(Ball_ID)>=dbSpriteX(Player1_ID))
	{
		if(dbSpriteX(Ball_ID)<=dbSpriteX(Player1_ID)+dbSpriteWidth(Player1_ID))
		{
			if(dbSpriteY(Ball_ID) >= dbSpriteY(Player1_ID))
			{
				return true;
			}
		}
	}

	return false;
}

//===== PLAYER2/CPU <--> BALL COLLISION =====
bool P2CPU_Ball_Collision(int P2CPU_ID, int Ball_ID)
{
	if(dbSpriteX(Ball_ID)>=dbSpriteX(P2CPU_ID))
	{
		if(dbSpriteX(Ball_ID)<=dbSpriteX(P2CPU_ID)+dbSpriteWidth(P2CPU_ID))
		{
			if(dbSpriteY(Ball_ID) <= dbSpriteY(P2CPU_ID)+dbSpriteHeight(P2CPU_ID))
			{
				return true;
			}
		}
	}

	return false;
}

//===== SHOWING SCORES =====
void ShowScores()
{	
	dbSetTextSize(20);
	dbInk(Player1.Colour,Player1.Colour);
	dbCenterText(10, 575, dbStr(Player1Score));	

	if(GAME_STATE == GAME1P)	{dbInk(CPU.Colour,CPU.Colour);}
	if(GAME_STATE == GAME2P)	{dbInk(Player2.Colour,Player2.Colour);}
	dbCenterText(10, 10, dbStr(Player2Score));
	
}

//===== WINNER =====
void Winner()
{
	dbCLS(dbRGB(0,0,0));
	int WinnerNo = 0;
	
	if(GameMode == 2)
	{
		if(Player1Score == 5){ WinnerNo = 1;}
		if(Player2Score == 5){ WinnerNo = 2;}
	}
	else
	{
		if(Player1Score == 5){ WinnerNo = 3;}
		if(Player2Score == 5){ WinnerNo = 4;}
	}

	dbSetTextSize(100);
	dbInk(dbRGB( MM(0,255),MM(0,255),MM(0,255) ), dbRGB( MM(0,255),MM(0,255),MM(0,255) ));

	if(WinnerNo == 1) {dbCenterText(400,230, "YOU WON!!!");}
	if(WinnerNo == 2) {dbCenterText(400,230, "YOU LOST!!!");}
	if(WinnerNo == 3) {dbCenterText(400,230, "Player 1 WON!!!");}
	if(WinnerNo == 4) {dbCenterText(400,230, "Player 2 WON!!!");}

	if(dbKeyState(28))
	{		
		dbHideSprite(1);
		dbHideSprite(2);
		dbHideSprite(3);
		GAME_STATE = MENU;
	}	
}

//===== SHOWING SCORES =====
void ShowScores()
{	
        static bool SetFont = true;
        if(SetFont){dbSetTextSize(20); SetFont = false;}

	dbInk(Player1.Colour,Player1.Colour);
	dbText(15, 575, dbStr(Player1Score));	
        if(GAME_STATE == GAME1P){dbInk(CPU.Colour,CPU.Colour);}
	if(GAME_STATE == GAME2P)	{dbInk(Player2.Colour,Player2.Colour);}
	dbText(15, 10, dbStr(Player2Score));
	
}

///////////////////////////////////////////////////////////////////////////
//                                  NewPong                              //
//                          Author:  Lilith Calbridge                    //
//                              Release: .000015                         //
//                           Release Date: 05/29/09                      //
///////////////////////////////////////////////////////////////////////////

#include "DarkGDK.h"
#include "balldata.h"
#include "paddle.h"
const int bitTemp = 1;
int temp;

// screen related data
const int screenWidth = 800;
const int screenHeight = 600;

int lastPointTo = 1;	// 1 = computer, 2 = player

class Pong
{	// base class for the sprite-based classes
protected:
	int sprite;	// maintains the sprite number for the object
	int image;	// maintains the image number for the object
	int Width;	// the width of the sprite
	int Height;	// the height of the sprite
	int X;		// the integer x position of the sprite
	int Y;		// the integer y position of the sprite

public:
	Pong (){}	// default constructor, does nothing

	Pong (int *gsize, DWORD *gdata)	// constructor with image input
	{
		Pong();						// calls the default constructor
		GenGraphic (gsize, gdata);	// gets the image data from two arrays
	}

	~Pong ()	// the destructor
	{	// gets rid of the sprite and image
		if (dbSpriteExist(sprite))  dbDeleteSprite(sprite);
		if (dbImageExist(image))  dbDeleteImage(image);
	}
protected:

	void GenGraphic (int *sizes, DWORD *imgData)
	{	// pulls the pizels in from an array and feeds them to the bitmap
		Width = sizes[0];	// get the width and height from the array
		Height = sizes[1];
		dbCreateBitmap (bitTemp, Width, Height);	// use a temporary bitmap
		dbSetCurrentBitmap (bitTemp);				// draw to the temporary bitmap
		int index = 0;								// this is the counter into imgData
		for (int i = 0; i < Height; i++) {			// scan the rows
			for (int j = 0; j < Width; j++){		// scan the columns
				dbInk (imgData[index++], 0x00);		// use the array to set the ink color
				dbDot(j, i);						// and place it in the bitmap
			}
		}
		dbGetImage(image, 0, 0, Width, Height, 1);	// make an image from the bitmap
		dbSprite (sprite, 20, 20, image);			// associate the image with the sprite
		dbDeleteBitmap (bitTemp);					// recycle the bitmap
	}

public:
	int GetX(){return X;}							// feeds the x position to the caller
	int GetY(){return Y;}							// feeds the y position to the caller
	int GetWidth() {return Width;}					// same for width
	int GetHeight() {return Height;}				// and height

	int StruckAt (int yPos) {	// returns a value based on where the paddle was struck
		if (yPos > ( Y - Height/2) && yPos < ( Y + Height/2)) {
			return ( (Y + Height/2) - yPos);	// indicates where on the paddle the ball hit
		}
		return -1;									// indicates that the paddle was not struck
	}
};

class Player : public Pong							// derives from the Pong class
{
private:
 static const int Image = 1;						// forces the player to be identified as image
static const int Sprite = 1;						// and sprite number 1.  updated in constructors
      int MinY;										// highest position the paddle can get
      int MaxY;										// lowest position the paddle can get
      int MaxDisp;									// used to keep the speed of the paddle down
      int Score;									// the player's score.

public:
	  Player () {  // default constructor
		image = Image;								// sets the local image number
		sprite = Sprite;							// same for the sprite
		Width = 20;									// these are really useless but I do them
		Height = 80;								// anyway to make sure they're initialized
		MinY = Height/2;							
		MaxY = screenHeight - Height/2;
		X = screenHeight - Width/2;
		Y = screenHeight;
		MaxDisp = 10;								// set the maximum number of pixels player can move
													// in each cycle
		Score = 0;									// always start the game at zero
	  }

	  Player (int *sizes, DWORD *imagedata)
	  {	// constructor that creates image data
		image = Image;								// some repeats of the default constructor
		sprite = Sprite;
		GenGraphic (sizes, imagedata);				// read in the image data
		MinY = Height/2;							// image data sets the sizes so now we
		MaxY = screenHeight - Height/2;				// need to set the dependent variables
		X = screenHeight - Width/2;
		Y = screenHeight/2;
		MaxDisp = 10;
		Score = 0;
		dbSprite (sprite, X, Y, image);				// position on the right side, half way down (or up)
	  }

	  void Init ()
	{
		dbOffsetSprite (sprite, Width/2, Height/2);
		MinY = Height/2;	// 
		MaxY = screenHeight - Height/2;
		X = screenWidth - Width/2;
		Y = 0;
		Score = 0;
	}

	void Set()
	{	// calculates where the paddle should be based on the mouse's Y postion
		// the displacement speed is limited by the paddleMaxDisp value so the
		// player can't just zoom to a position

		int spriteY = dbSpriteY(sprite);	// find where the sprite is
		int mouseY = dbMouseY();				// find where the mouse is

		if (abs(spriteY - mouseY) <= MaxDisp) {	// if sprite is within the displacement
			Y = mouseY;							// range just put it where the mouse is
		} else if (mouseY > Y) {					// if mouse is below the paddles position
			Y += MaxDisp;							// displace by the maximum in that direction
		} else Y -= MaxDisp;							// otherwise displace in the other direction

		if (Y < MinY) Y = MinY;	// make sure the paddle position isn't too high
		if (Y > MaxY) Y = MaxY;	// or too low
		dbSprite (sprite, X, Y, image);	// position the sprite
		dbPositionMouse(X, Y);
	}
	
	int GetScore ()
	{
		return Score;
	}

	int IncrementScore () {
		return Score++;
	}
};


class Computer : public Pong
{
private:
static const int Image = 2;
static const int Sprite = 2;
	int maxDisp;	// maximum displacement
	int Score;

public:
	Computer ()
	{	// defaults set just so the program has something to work with
		image = Image;
		sprite = Sprite;
		Width = 20;
		Height = 80;
		X = Width/2;
		Y = screenHeight/2;
		X = Width/2;
		Y = Height/2;
		maxDisp = 7;
	}

	Computer (int *sizes, DWORD *imagedata)
	{
		image = Image;
		sprite = Sprite;
		GenGraphic(sizes, imagedata);
		X = Width/2;
		Y = screenHeight/2;
		X = Width/2;
		Y = Height/2;
		maxDisp = 7;
	}
	void Init()
	{
		dbOffsetSprite (sprite, Width/2, Height/2);
		X = Width/2;
		Y = screenHeight/2;
		X = Width/2;
		Y = screenHeight/2;  // initial setting halfway down screen
		Score = 0;
	}

	void Set(int ballY)
	{	// this function needs to know the Y position of the ball in order to 
		// work its AI "magic"

		if (ballY < Y) {	// ball is above the paddle
			if (abs(ballY - Y) < maxDisp) Y = ballY;
			else Y -= maxDisp;
		} else {
			if (abs(ballY - Y) < maxDisp) Y = ballY;
			else Y += maxDisp;
		}
		if (Y < Height/2) Y = Height/2;
		if (Y > screenHeight - Height/2) Y = screenHeight - Height/2;
		dbSprite (sprite, X, Y, image);
	}

	int GetScore ()
	{
		return Score;
	}

	int IncrementScore () {
		return Score++;
	}
};

class Ball : public Pong
{
static	const int Sprite = 3;
static	const int Image = 3;
	int Radius;
	float Velocity;	// the speed of the ball
	float InitVelocity;	// starting speed
	float XVector;	// the speed in the X direction
	float YVector;	// the speed in the Y direction
	float XLoc;		// ball X postiion
	float YLoc;		// ball Y position
	float Angle;	// direction ball is traveling
	int	  bounceCount;
	bool movingRight;
	bool  Active;

public:
	Ball (){	// default constructor
		sprite = Sprite;
		image = Image;
		InitVelocity = Velocity = 10.0f;
		Angle = 0.11f;
		XVector = cos(Angle)* Velocity;
		YVector = sin(Angle)* Velocity;
		XLoc = (float) screenWidth/2;
		YLoc = (float) screenHeight/2;
		Radius = Width/2;
		dbOffsetSprite (sprite, Radius, Radius);
		movingRight = true;
		Active = true;
	}

	Ball (int *sizes, DWORD *imagedata)
	{
		sprite = Sprite;
		image = Image;
		InitVelocity = Velocity = 10.0f;
		Angle = 0.11f;
		XVector = cos(Angle * 0.0175f)* Velocity;
		YVector = sin(Angle * 0.0175f)* Velocity;
		GenGraphic (sizes, imagedata);
		Radius = Width/2;
		dbOffsetSprite (sprite, Radius, Radius);
		XLoc = (float) screenWidth/2;
		YLoc = (float) screenHeight/2;
		X = (int) (XLoc + 0.5f);
		Y = (int) (YLoc + 0.5f);
		dbSprite (sprite, X, Y, image);
		movingRight = true;
		Active = false;
	}

	void Init (int lastScorer)		
	{	// set the initial conditions on the ball
		Velocity = InitVelocity;
		bounceCount = 0;
		Angle = (float) (dbRND(90) - 45);	// get a random angle between 45 degrees and - 45
		movingRight = true;					// initially send towards player

		XVector = cos(Angle * 0.0175f)* Velocity;	// calculate the X and Y velocity components
		YVector = sin(Angle * 0.0175f)* Velocity;

		if (lastScorer == 2) {		// last score to player	
			XVector = -XVector;		// if the player scored last we reverse the direction so the
			movingRight = false;	// computer receives the serve
		}

		XLoc = (float) screenWidth/2;	// position the ball 
		YLoc = (float) screenHeight/2;	// using float values
		X = (int) (XLoc + 0.5f);		// use integer values 
		Y = (int) (YLoc + 0.5f);		// for the on-screen position 
		dbSprite (sprite, X, Y, image); // position the sprite
		Active = false;					// set for initially
	}

	bool SetActive (bool tf)
	{
		return (Active = tf);
	}

	bool IsMovingRight (void)
	{
		return movingRight;
	}

	void Update ()
	{
		if (!Active) return;
		if ( Y >= screenHeight - Radius) YVector = - YVector;	// bounce off bottom
		if ( Y <= 0) YVector = - YVector;						// bounce off top

		XLoc += XVector;
		YLoc += YVector;
		X = (int) (XLoc + .5);
		Y = (int) (YLoc + .5);
		dbSprite (sprite, X, Y, image);

	}
	int Collision (Pong &paddle)
	{
		int hitAt;

		if (movingRight) {	// check against the player's paddle
			if (X < screenWidth - paddle.GetWidth() - Radius) return -1;	// not near the paddle
			if (X > screenWidth) return -2;	// if beyond the screen it's past the paddle

			// if we got here it means we're in contact with the paddle (we hope)
			// this section checks to see if the ball hit the paddle on the right (player)
			// if not, it returns -1.  if it did hit the paddle it determines where on the paddle
			// it struck and calculates a deflection angle.  The upper half deflects the ball upward
			// the lower half deflects downward.  the further from the center the steeper the
			// deflection.
			if ((hitAt = paddle.StruckAt(Y)) == -1) 
				return -1;	// no contact, otherwise
			Angle = ((float)((float) hitAt)/(float) paddle.GetHeight()) * 120.0f - 60.0f;
			if (++bounceCount % 6) Velocity += 0.1f;
			XVector = -Velocity * cos (Angle * 0.0175f);
			YVector = -Velocity * sin (Angle * 0.0175f);
			movingRight = false;
			return 0;
		}

		// if the ball is moving left the code should drop down to here
		if (X > paddle.GetWidth() + Radius) return -1;	// not near the paddle
		if (X < 0) return -2;	// if beyond the screen it's past the paddle

		if ((hitAt = paddle.StruckAt(Y)) == -1) return -1;	// no contact, otherwise
		Angle = ((float)((int) hitAt)/(float) paddle.GetHeight()) * 120.0f - 60.0f;
		if (++bounceCount % 6) Velocity += 0.1f;
		XVector = Velocity * cos (Angle * 0.0175f);
		YVector = -Velocity * sin (Angle * 0.0175f);
		movingRight = true;
		return 0;
	}

};

////////////////////////////////////////////////////////////
// the main entry point for the application is this function
////////////////////////////////////////////////////////////

void DarkGDK ( void )
{
	char strScores [50];	// large enough string to hold the scores
	bool replay = true;		// flag for player to start new game

	dbSetDisplayMode(screenWidth, screenHeight, 32);
//	dbSetWindowOff();

	dbSyncOn   ( );
	dbSyncRate ( 60 );

	dbRandomize(dbTimer());

	dbDisableEscapeKey ( );
	dbHideMouse();

	// create the components and 
	Player player(paddlesizes, paddleimgData);
	Computer comp (paddlesizes, paddleimgData);
	Ball ball (ballsizes, ballimgData);

	dbSetCurrentBitmap(0);	

	while (replay){
		lastPointTo = 1;

		player.Init();
		comp.Init();
		ball.Init(lastPointTo);


		// now we come to our main loop, we call LoopGDK so some internal
		// work can be carried out by the GDK
		while ( LoopGDK ( ) && (comp.GetScore() != 6) && (player.GetScore() != 6))
		{

			if ( dbEscapeKey ( )){
				replay = false;
				break;
			}

			if ( dbSpaceKey () ) ball.SetActive (true);

	
			dbCLS(0xffffffff);		// clear the screen
		
			// draw a vertical line in the center of the screen
			dbInk (0xff000000, 0xff000000);
			dbLine (screenWidth/2, 0, screenWidth/2, screenHeight);

			// print the scores to the screen
			sprintf (strScores, "%d          %d", comp.GetScore(), player.GetScore());
			dbInk (0xff00ff00, 0x00000000);				// using green ink
			dbSetTextFont ("Arial");					// it's a nice font
			dbSetTextSize (36);							// that can grow to 36 points
			dbCenterText (screenWidth/2, 20, strScores);// print the scores centered near the top

			player.Set();								// update all the components
			comp.Set(ball.GetY());						// computer needs the ball's vertical position
			ball.Update();								// move the ball

			if (ball.IsMovingRight()) {					// if the ball is moving right
				switch (ball.Collision(player)){		// check for collision with player's paddle
					case -1: break;						// not near the paddle
					case -2: comp.IncrementScore();		// out of bounds player side
							 lastPointTo = 1;
							 ball.Init(lastPointTo);
							 break;
				}
			} else {
				switch (ball.Collision(comp)) {
					case -1: break;						// not near the paddle
					case -2: player.IncrementScore();	// out of bounds computer side
							 lastPointTo = 2;
							 ball.Init(lastPointTo);
							 break;
				}
			}

			dbSync ( );
		}

		if (!replay) break;	// player pressed escape during play

		// someone won the game
		
		dbSetCurrentBitmap(0);
		dbCLS (0x80ffffff);
		
		// print the scores for posterity
		sprintf (strScores, "%d          %d", comp.GetScore(), player.GetScore());
		dbInk (0xff00ff00, 0x00000000);
		dbSetTextFont ("Arial");
		dbSetTextSize (36);
		dbCenterText (screenWidth/2, 20, strScores);
		
		if (player.GetScore() == 6) {
			dbCenterText (screenWidth/2, screenHeight/2 - 60, "Congratulations!!!  You've won!!");
		} else {
			dbCenterText (screenWidth/2, screenHeight/2 - 60, "Sorry! You lost");
		}
		dbCenterText (screenWidth/2, screenHeight/2 + 40, "Play again?");
		dbCenterText (screenWidth/2, screenHeight/2 + 80, "Enter to continue, Space to quit");
		dbSync();
		while (true) {	// await input 
			if (dbReturnKey()) {
				replay = true;
				break;
			}
			if (dbSpaceKey()) {
				replay = false;
				break;
			}
		}
		if (replay) continue;
	}
	return;
}

 
int ballsizes [] = {20, 20};

DWORD ballimgData [] = {

	0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff1c0101, 0Xff580404, 0Xff940606, 
	0Xffb60707, 0Xffbc0606, 0Xffb60303, 0Xffad0101, 0Xff6d0101, 0Xff380000, 0Xff120000, 0Xff000000, 
	0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 
	0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff580404, 0Xffa30d0d, 0Xffd01919, 0Xffd31e1e, 
	0Xffce1d1d, 0Xffcb1818, 0Xffc60f0f, 0Xffc00808, 0Xffb80303, 0Xffaf0000, 0Xff7d0000, 0Xff390000, 
	0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 
	0Xff000000, 0Xff000000, 0Xff0e0101, 0Xff780909, 0Xffda2424, 0Xffdc3a3a, 0Xffde4c4c, 0Xffdc4e4e, 
	0Xffd64646, 0Xffcf3939, 0Xffc72626, 0Xffc01818, 0Xffb90b0b, 0Xffb30404, 0Xffaa0101, 0Xff9e0000, 
	0Xff4f0000, 0Xff090000, 0Xff000000, 0Xff000000, 
	0Xff000000, 0Xff000000, 0Xff6f0909, 0Xffd12323, 0Xffe24d4d, 0Xffe96969, 0Xffed7979, 0Xffea7878, 
	0Xffe06969, 0Xffd65656, 0Xffc93b3b, 0Xffc12828, 0Xffb81414, 0Xffb20909, 0Xffa90202, 0Xffa10000, 
	0Xff8b0000, 0Xff4c0000, 0Xff000000, 0Xff000000, 
	0Xff000000, 0Xff4d0303, 0Xffd92424, 0Xffe14d4d, 0Xfff17e7e, 0Xfffb9898, 0Xffffa4a4, 0Xfffba1a1, 
	0Xffee8d8d, 0Xffdf7373, 0Xffcd5151, 0Xffc13737, 0Xffb71e1e, 0Xffb11010, 0Xffa80505, 0Xffa00101, 
	0Xff940000, 0Xff830000, 0Xff2c0000, 0Xff000000, 
	0Xff1c0101, 0Xffa60d0d, 0Xffdc3a3a, 0Xffe86868, 0Xfffc9898, 0Xffffacac, 0Xffffb3b3, 0Xffffb0b0, 
	0Xfff69e9e, 0Xffe48282, 0Xffce5c5c, 0Xffc14040, 0Xffb52323, 0Xffaf1313, 0Xffa60707, 0Xff9e0303, 
	0Xff920000, 0Xff850000, 0Xff520000, 0Xff0c0000, 
	0Xff4f0303, 0Xffcd1919, 0Xffde4c4c, 0Xffec7979, 0Xfffea5a5, 0Xffffb3b3, 0Xffffb9b9, 0Xffffb5b5, 
	0Xfff6a3a3, 0Xffe38686, 0Xffcd6060, 0Xffbf4444, 0Xffb22626, 0Xffab1616, 0Xffa20808, 0Xff9b0303, 
	0Xff8f0000, 0Xff820000, 0Xff660000, 0Xff1b0000, 
	0Xff8e0606, 0Xffd31e1e, 0Xffdc4f4f, 0Xffea7979, 0Xfffca2a2, 0Xffffb0b0, 0Xffffb5b5, 0Xfffeb1b1, 
	0Xffef9b9b, 0Xffdd7f7f, 0Xffc85b5b, 0Xffbb4040, 0Xffaf2525, 0Xffa81515, 0Xff9f0808, 0Xff970303, 
	0Xff8b0000, 0Xff7f0000, 0Xff670000, 0Xff360000, 
	0Xffb80707, 0Xffce1d1d, 0Xffd64646, 0Xffe06969, 0Xffee8d8d, 0Xfff69e9e, 0Xfff6a2a2, 0Xffef9b9b, 
	0Xffdf8585, 0Xffd06d6d, 0Xffc04e4e, 0Xffb43737, 0Xffaa1f1f, 0Xffa31212, 0Xff9a0808, 0Xff920303, 
	0Xff860000, 0Xff790000, 0Xff620000, 0Xff4f0000, 
	0Xffc30505, 0Xffcb1717, 0Xffcf3939, 0Xffd55656, 0Xffdf7373, 0Xffe48181, 0Xffe38686, 0Xffdd8080, 
	0Xffd06d6d, 0Xffc55a5a, 0Xffb84040, 0Xffae2d2d, 0Xffa41a1a, 0Xff9e0e0e, 0Xff950606, 0Xff8d0202, 
	0Xff800000, 0Xff730000, 0Xff5e0000, 0Xff4f0000, 
	0Xffc20303, 0Xffc60f0f, 0Xffc72727, 0Xffc93b3b, 0Xffcd5151, 0Xffce5c5c, 0Xffcd6060, 0Xffc85b5b, 
	0Xffc04e4e, 0Xffb84040, 0Xffad2d2d, 0Xffa71f1f, 0Xff9e1212, 0Xff980a0a, 0Xff8f0303, 0Xff850101, 
	0Xff780000, 0Xff690000, 0Xff590000, 0Xff550000, 
	0Xffaf0101, 0Xffc00909, 0Xffc01919, 0Xffc12727, 0Xffc13737, 0Xffc14040, 0Xffbf4444, 0Xffbb4040, 
	0Xffb43737, 0Xffae2d2d, 0Xffa71f1f, 0Xffa11515, 0Xff980b0b, 0Xff920606, 0Xff890202, 0Xff7f0000, 
	0Xff700000, 0Xff5f0000, 0Xff590000, 0Xff520000, 
	0Xff7b0000, 0Xffb70303, 0Xffb90b0b, 0Xffb81414, 0Xffb71e1e, 0Xffb52323, 0Xffb22626, 0Xffaf2525, 
	0Xffaa2020, 0Xffa41a1a, 0Xff9e1111, 0Xff980b0b, 0Xff900606, 0Xff8a0303, 0Xff800101, 0Xff750000, 
	0Xff630000, 0Xff5a0000, 0Xff590000, 0Xff3d0000, 
	0Xff440000, 0Xffac0101, 0Xffb30404, 0Xffb20909, 0Xffb11010, 0Xffaf1313, 0Xffab1616, 0Xffa81515, 
	0Xffa31212, 0Xff9e0e0e, 0Xff980a0a, 0Xff920606, 0Xff8a0303, 0Xff820101, 0Xff760000, 0Xff6a0000, 
	0Xff5b0000, 0Xff590000, 0Xff570000, 0Xff230000, 
	0Xff130000, 0Xff7d0000, 0Xffaa0101, 0Xffa90202, 0Xffa80505, 0Xffa60707, 0Xffa20808, 0Xff9f0808, 
	0Xff9a0808, 0Xff950606, 0Xff8f0303, 0Xff890202, 0Xff800101, 0Xff760000, 0Xff680000, 0Xff5c0000, 
	0Xff590000, 0Xff590000, 0Xff470000, 0Xff0e0000, 
	0Xff000000, 0Xff390000, 0Xff9c0000, 0Xffa10000, 0Xffa00101, 0Xff9e0303, 0Xff9b0303, 0Xff970303, 
	0Xff920303, 0Xff8d0202, 0Xff850101, 0Xff7f0000, 0Xff750000, 0Xff6a0000, 0Xff5c0000, 0Xff590000, 
	0Xff590000, 0Xff590000, 0Xff260000, 0Xff000000, 
	0Xff000000, 0Xff000000, 0Xff510000, 0Xff8b0000, 0Xff940000, 0Xff920000, 0Xff8f0000, 0Xff8b0000, 
	0Xff860000, 0Xff800000, 0Xff780000, 0Xff700000, 0Xff640000, 0Xff5b0000, 0Xff590000, 0Xff590000, 
	0Xff550000, 0Xff310000, 0Xff000000, 0Xff000000, 
	0Xff000000, 0Xff000000, 0Xff090000, 0Xff4d0000, 0Xff830000, 0Xff850000, 0Xff820000, 0Xff7f0000, 
	0Xff790000, 0Xff730000, 0Xff690000, 0Xff5f0000, 0Xff5a0000, 0Xff590000, 0Xff590000, 0Xff570000, 
	0Xff350000, 0Xff060000, 0Xff000000, 0Xff000000, 
	0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff2c0000, 0Xff520000, 0Xff660000, 0Xff670000, 
	0Xff630000, 0Xff5d0000, 0Xff590000, 0Xff590000, 0Xff590000, 0Xff560000, 0Xff450000, 0Xff200000, 
	0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 
	0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff0a0000, 0Xff230000, 0Xff410000, 
	0Xff4f0000, 0Xff540000, 0Xff590000, 0Xff520000, 0Xff390000, 0Xff220000, 0Xff0c0000, 0Xff000000, 
	0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000
};  

  
int paddlesizes [] = {26, 94};

DWORD paddleimgData [] = {	
0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff0f0f0f, 0Xff272727, 0Xff404040, 0Xff424242, 0Xff434343, 0Xff444444, 0Xff2a2a2a, 	
0Xff111111, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 
0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff070707, 0Xff414141, 	
0Xff848484, 0Xffafafaf, 0Xffbababa, 0Xffc0c0c0, 0Xffc4c4c4, 0Xffc7c7c7, 0Xffcacaca, 0Xffcccccc, 	
0Xffc8c8c8, 0Xff9e9e9e, 0Xff646464, 0Xff080808, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff464646, 0Xff959595, 0Xffa9a9a9, 	
0Xffb1b1b1, 0Xffb7b7b7, 0Xffbdbdbd, 0Xffc2c2c2, 0Xffc6c6c6, 0Xffcacaca, 0Xffcdcdcd, 0Xffd0d0d0, 	
0Xffd2d2d2, 0Xffd3d3d3, 0Xffd5d5d5, 0Xffc8c8c8, 0Xff5e5e5e, 0Xff000000, 0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 0Xff000000, 0Xff0b0b0b, 0Xff686868, 0Xff979797, 0Xffa1a1a1, 0Xffa9a9a9, 	
0Xffb0b0b0, 0Xffb6b6b6, 0Xffbcbcbc, 0Xffc1c1c1, 0Xffc5c5c5, 0Xffc9c9c9, 0Xffcccccc, 0Xffcfcfcf, 	
0Xffd2d2d2, 0Xffd4d4d4, 0Xffd6d6d6, 0Xffd7d7d7, 0Xffd7d7d7, 0Xff9a9a9a, 0Xff161616, 0Xff000000, 	
0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 0Xff0c0c0c, 0Xff6a6a6a, 0Xff8a8a8a, 0Xff969696, 0Xff9f9f9f, 0Xffa6a6a6, 	
0Xffadadad, 0Xffb3b3b3, 0Xffb9b9b9, 0Xffbebebe, 0Xffc2c2c2, 0Xffc7c7c7, 0Xffcacaca, 0Xffcdcdcd, 	
0Xffd0d0d0, 0Xffd3d3d3, 0Xffd5d5d5, 0Xffd7d7d7, 0Xffd8d8d8, 0Xffd8d8d8, 0Xffb8b8b8, 0Xff191919, 	
0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff020202, 0Xff484848, 0Xff767676, 0Xff858585, 0Xff909090, 0Xff999999, 0Xffa1a1a1, 	
0Xffa8a8a8, 0Xffaeaeae, 0Xffb4b4b4, 0Xffb9b9b9, 0Xffbebebe, 0Xffc2c2c2, 0Xffc6c6c6, 0Xffc9c9c9, 	
0Xffcecece, 0Xffd2d2d2, 0Xffd2d2d2, 0Xffd5d5d5, 0Xffd6d6d6, 0Xffd7d7d7, 0Xffd7d7d7, 0Xff9b9b9b, 	
0Xff030303, 0Xff000000, 	
0Xff000000, 0Xff232323, 0Xff5c5c5c, 0Xff6e6e6e, 0Xff7d7d7d, 0Xff888888, 0Xff929292, 0Xff9a9a9a, 	
0Xffa1a1a1, 0Xffa8a8a8, 0Xffaeaeae, 0Xffb3b3b3, 0Xffb8b8b8, 0Xffbdbdbd, 0Xffc1c1c1, 0Xffc4c4c4, 	
0Xffd5d5d5, 0Xffefefef, 0Xffd0d0d0, 0Xffd1d1d1, 0Xffd3d3d3, 0Xffd4d4d4, 0Xffd4d4d4, 0Xffd3d3d3, 	
0Xff4f4f4f, 0Xff000000, 	
0Xff000000, 0Xff4a4a4a, 0Xff595959, 0Xff616161, 0Xff717171, 0Xff7e7e7e, 0Xff888888, 0Xff919191, 	
0Xff999797, 0Xffa29a9a, 0Xffaa9c9c, 0Xffaaa0a0, 0Xffb1a2a2, 0Xffb6a6a6, 0Xffb6abab, 0Xffbcb3b3, 	
0Xffbfbaba, 0Xffc4c2c2, 0Xffc8c8c8, 0Xffcbcbcb, 0Xffcdcdcd, 0Xffcfcfcf, 0Xffd0d0d0, 0Xffd0d0d0, 	
0Xffa7a7a7, 0Xff000000, 	
0Xff090909, 0Xff575757, 0Xff595959, 0Xff595959, 0Xff656565, 0Xff757575, 0Xff986f6f, 0Xffcd2e2e, 	
0Xffb54141, 0Xffa24a4a, 0Xffa94747, 0Xff984d4d, 0Xffb04646, 0Xffa84949, 0Xffae4747, 0Xffad4a4a, 	
0Xffa94a4a, 0Xffc33f3f, 0Xffd73434, 0Xffd0abab, 0Xffc8c8c8, 0Xffc9c9c9, 0Xffcacaca, 0Xffcbcbcb, 	
0Xffc7c7c7, 0Xff161616, 	
0Xff191818, 0Xff735454, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xff9e6969, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xfffe0202, 0Xfff80909, 0Xfff40a0a, 0Xfff60a0a, 0Xfff70909, 0Xfffa0707, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a6a6, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc5c4c4, 	
0Xffa78585, 0Xff2c2b2b, 	
0Xff191010, 0Xff774e4e, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a7a7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc5c3c3, 	
0Xff824e4e, 0Xff150b0b, 	
0Xff000000, 0Xff0e0b0b, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa16464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a5a5, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff0d0b0b, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a6a6, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa06666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd4a4a4, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a5a5, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa06363, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd4a1a1, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa16161, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa06565, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa06565, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd4a2a2, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa06464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a4a4, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xff9e6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xff9f6464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa16363, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd4a0a0, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa06666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd4a2a2, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xff9e6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49e9e, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa06464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49e9e, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa16464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49e9e, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa06464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49f9f, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd4a2a2, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xff9e6666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a5a5, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa16565, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a5a5, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa06666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49f9f, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xff9e6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a2a2, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc7c7c7, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa06666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd4a1a1, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff747474, 0Xffa06666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a5a5, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xffa06464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a5a5, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xffa06464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9f6666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd1a8a8, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9e6969, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a2a2, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xffa06767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a2a2, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9f6666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49d9d, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a4a4, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9d6a6a, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49d9d, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9e6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49c9c, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a4a4, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9e6969, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a5a5, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49c9c, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xffa16363, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49c9c, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9d6a6a, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a2a2, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a2a2, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xffa06464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49e9e, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xffa16363, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9e6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49e9e, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xffa06666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xffa06464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a4a4, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9e6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49d9d, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a4a4, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9e6969, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a4a4, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff636363, 0Xff737373, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a4a4, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xffa16464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49e9e, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xffa06767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd2a5a5, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9e6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a5a5, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xffa06666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd2a5a5, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a4a4, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd1a8a8, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xffa06363, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a5a5, 0Xffc7c7c7, 0Xffc8c8c8, 0Xffc8c8c8, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xffa06464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a5a5, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9e6969, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xffa06666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd4a1a1, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd2a5a5, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a6a6, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xffa06666, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd49b9b, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xffa06464, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a2a2, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd2a6a6, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a3a3, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xffa16363, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd39f9f, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd2a5a5, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff000000, 0Xff050505, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6868, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd2a7a7, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c6c6, 	
0Xff070707, 0Xff000000, 	
0Xff0e0b0b, 0Xff654343, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a0a0, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c4c4, 	
0Xffa07e7e, 0Xff171414, 	
0Xff1e1b1b, 0Xff7b5252, 0Xff595959, 0Xff595959, 0Xff626262, 0Xff737373, 0Xff9f6767, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffff0000, 	
0Xffff0000, 0Xffff0000, 0Xffff0000, 0Xffd3a0a0, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc7c7c7, 0Xffc6c4c4, 	
0Xffc7a2a2, 0Xff3f3a3a, 	
0Xff0d0d0d, 0Xff595959, 0Xff595959, 0Xff595959, 0Xff616161, 0Xff737373, 0Xff9d6b6b, 0Xffef3434, 	
0Xffe35656, 0Xffdd6a6a, 0Xffd87d7d, 0Xffda8181, 0Xffd58989, 0Xffd18d8d, 0Xffd38989, 0Xffd67474, 	
0Xffd85c5c, 0Xffdf4343, 0Xffec2525, 0Xffd1a1a1, 0Xffc6c6c6, 0Xffc7c7c7, 0Xffc6c6c6, 0Xffc3c3c3, 	
0Xffbab9b9, 0Xff161616, 	
0Xff010101, 0Xff4e4e4e, 0Xff595959, 0Xff595959, 0Xff5a5a5a, 0Xff686868, 0Xff7a7878, 0Xff8c8686, 	
0Xff9a8f8f, 0Xffa49595, 0Xffab9b9b, 0Xffb19f9f, 0Xffb6a2a2, 0Xffbaa5a5, 0Xffbda8a8, 0Xffbcafaf, 	
0Xffbdb3b3, 0Xffc3b2b2, 0Xffc0baba, 0Xffc1bfbf, 0Xffc1c1c1, 0Xffc0c0c0, 0Xffbebebe, 0Xffb9b9b9, 	
0Xff969696, 0Xff020202, 	
0Xff000000, 0Xff2c2c2c, 0Xff595959, 0Xff595959, 0Xff595959, 0Xff5b5b5b, 0Xff676767, 0Xff767676, 	
0Xff828282, 0Xff8c8c8c, 0Xff949494, 0Xff9b9b9b, 0Xffa1a1a1, 0Xffa6a6a6, 0Xffababab, 0Xffaeaeae, 	
0Xffb2b2b2, 0Xffb4b4b4, 0Xffb6b6b6, 0Xffb7b7b7, 0Xffb7b7b7, 0Xffb5b5b5, 0Xffb2b2b2, 0Xffaaaaaa, 	
0Xff464646, 0Xff000000, 	
0Xff000000, 0Xff040404, 0Xff4c4c4c, 0Xff595959, 0Xff595959, 0Xff595959, 0Xff5a5a5a, 0Xff636363, 	
0Xff717171, 0Xff7d7d7d, 0Xff868686, 0Xff8e8e8e, 0Xff959595, 0Xff9a9a9a, 0Xff9f9f9f, 0Xffa3a3a3, 	
0Xffa6a6a6, 0Xffa8a8a8, 0Xffaaaaaa, 0Xffababab, 0Xffaaaaaa, 0Xffa8a8a8, 0Xffa2a2a2, 0Xff797979, 	
0Xff040404, 0Xff000000, 	
0Xff000000, 0Xff000000, 0Xff111111, 0Xff545454, 0Xff595959, 0Xff595959, 0Xff595959, 0Xff595959, 	
0Xff5d5d5d, 0Xff696969, 0Xff747474, 0Xff7d7d7d, 0Xff858585, 0Xff8b8b8b, 0Xff909090, 0Xff949494, 	
0Xff989898, 0Xff9a9a9a, 0Xff9b9b9b, 0Xff9c9c9c, 0Xff9a9a9a, 0Xff959595, 0Xff828282, 0Xff131313, 	
0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 0Xff000000, 0Xff131313, 0Xff4c4c4c, 0Xff595959, 0Xff595959, 0Xff595959, 	
0Xff595959, 0Xff5a5a5a, 0Xff5f5f5f, 0Xff686868, 0Xff717171, 0Xff787878, 0Xff7e7e7e, 0Xff828282, 	
0Xff868686, 0Xff888888, 0Xff898989, 0Xff878787, 0Xff828282, 0Xff676767, 0Xff181818, 0Xff000000, 	
0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff060606, 0Xff393939, 0Xff595959, 0Xff595959, 	
0Xff595959, 0Xff595959, 0Xff595959, 0Xff595959, 0Xff5b5b5b, 0Xff606060, 0Xff656565, 0Xff6a6a6a, 	
0Xff6e6e6e, 0Xff6f6f6f, 0Xff6d6d6d, 0Xff666666, 0Xff404040, 0Xff060606, 0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff101010, 0Xff373737, 	
0Xff525252, 0Xff595959, 0Xff595959, 0Xff595959, 0Xff595959, 0Xff595959, 0Xff595959, 0Xff595959, 	
0Xff595959, 0Xff515151, 0Xff333333, 0Xff0f0f0f, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 	
0Xff030303, 0Xff161616, 0Xff232323, 0Xff2f2f2f, 0Xff2f2f2f, 0Xff2f2f2f, 0Xff2f2f2f, 0Xff272727, 	
0Xff111111, 0Xff030303, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 0Xff000000, 	
0Xff000000, 0Xff000000};

   
NewPong

Okay, so the name isn’t clever.  It came about because my initial
 solution got corrupted somehow and I had to copy the code into a
 new solution.  At least I didn’t call it UltraPong.


This is a basic game with little frills.  The computer plays the 
paddle on the left and the player controls the paddle on the 
right.  The player’s paddle is controlled by the mouse using 
vertical movement.  In order to allow for some degree difficulty 
the player’s movement is constricted to a maximum speed.  The AI 
for the computer controlled left paddle is fairly simplistic.  It 
tracks the vertical position of the ball.  However, its speed is 
a bit less than that of the player’s paddle so the player has a 
chance to beat it.


At the beginning of each round the ball is positioned in the 
center of the screen.  Pressing the space bar launches the ball, 
which is always served to the player the first round of a set. 
 Thereafter the ball is served to the competitor who lost the 
last point.  When the ball passes a paddle and goes out of bounds 
the point goes to the opposing contender.  A game is six points.  
The program then allows you to chose whether to play again or to 
quit.  


The one feature is that the angle of deflection is determined by 
the position on the paddle where the ball is struck.  If struck 
on the upper half the ball deflects upward.  If struck on the 
lower half the ball is directed downward.  The further from the 
center of the paddle the greater the angle.  This gives the 
player a bit of control over where the ball goes.  The computer’s 
paddle provides the same type of deflection but the current AI 
doesn’t attempt to do anything clever with it.  Where on the 
paddle the ball strikes depends on whether the paddle can catch 
up with the ball and how far behind it lags.


The Inner Workins 

The player, computer and ball are class objects of the Player, 
Computer and Ball classes respectively.  They are all derived 
from the Pong class.  The Pong class carries the common elements 
that the child classes will need, including their position on the 
screen, the size of the graphic, the associated sprite number and 
image number.  Among the member functions are the public 
interfaces to provide the private data to the rest of the 
program.  


The StruckAt function tests to see if an integer value passed to 
it, usually representing the vertical position of the ball  falls 
along it’s height.  If not the function returns a -1 to indicate 
it was not struck or the pixel position from the bottom of the 
sprite where it was hit.  This could be used for certain types of 
collision detection but is used in this application to determine 
the degree of deflection.


The other function in the Pong class is GenGraphic.  Its purpose 
is to read data from two arrays to create the image to be used.  
The first array had only two elements that define the width and 
height of the graphic and the second array is composed of DWORDs 
that contain the pixel information.  This information is read in 
and drawn to a temporary bitmap which is then copied to an 
image.  The source of the image data derives from a utility 
program that generates the array from an image read into the 
program.


The Computer and Player classes take care of positioning 
themselves using the Set function.  However, this function 
differs for each class.  The Player class uses the function to 
input the mouse’s Y value and moves the paddle in the right 
direction.  However, the paddle can only move a certain number if
 pixels with each cycle.  The Computer class’ Set function tracks
 the vertical position of the ball, which has to be passed to it, 
and tries to match the position.  But its movement is slower than 
the player’s paddle to help offset its advantage in response 
time.  Both classes also have Init function that reset their 
values at the beginning of each round.


The Ball class is the most involved of the three active classes.  
The Ball class uses floating point numbers to track its velocity, 
position and displacement in the x and y directions in order to 
keep its movement consistent.  When an angle is determined 
separate x and y components to the speed are determined in order 
to keep the ball’s diagonal velocity the same regardless of the 
angle it’s traveling at.  Floating point is used in order to 
avoid any problems that the calculations might introduce if 
incremental values are used.  The angle is maintained in degrees 
but a multiplier is used to pass it to the trig functions as 
radians.


The Ball class does the collision detection for the program.  It 
maintains a flag that indicates whether it’s moving right or left 
so the program can have it check for collision with the player’s 
paddle or the computer’s paddle.  The collision routine is passed 
a reference to either the Computer object or the Player object 
but they’re passed as a Pong reference to use the StruckAt 
routine.  If there is no collision it passes back a -1,  If there 
is a collision it updates its internal data to indicate its new 
direction, calculates a new angle and sets the x and y velocity 
components.  If the ball passes beyond the paddle it returns a -2 
to let the program know it needs to update the scores and reset 
the ball.


All three classes have Init functions to reset them where 
needed.  The Computer and Player objects only have to be 
initialized at the beginning of the set whereas the Ball object 
needs to be reset after each point is earned.



At the beginning of a round the program loops and updates all 
three objects.  However, the Ball object has been set to an 
inactive state so won’t move itself until the program tells it to
 start moving.  Each loop through the program tests to see if the 
space bar has been pressed. If so, the ball is told to activate 
itself and it can now move when told to update itself.  Otherwise 
the player can move his/her paddle while the computer’s paddle is 
stuck tracking the unmoving ball.  


Once the movement has begun each cycle the program checks to see 
if the ball is moving right, at which point it checks for 
collision with the player’s paddle, or left, where it will check 
for collision with the computer’s paddle.  The only result it 
really needs to react to is if the ball passed out of bounds.  
Otherwise it takes care of its own needs during the collision 
routine itself.  If it receives a -2 result it updates the 
appropriate score and resets the ball to the center of the play 
field where it waits for the space bar to be pressed again.


When either opponent reaches a score of six the game is over and 
a congratulatory message or a consolement message is displayed 
with the options to press Enter to play a new game or the space 
bar to quit.

string Image[][]=
{
{"255255255","255255255","255255255","255255255","255255255"},
{"255255255","255255255","255255255","255255255","255255255"},
{"255255255","255255255","255255255","255255255","255255255"},
{"255255255","255255255","255255255","255255255","255255255"},
{"255255255","255255255","255255255","255255255","255255255"}
};

Krisacz: A job well done, I especially enjoyed the ball randomly adjusting its angle every 5 sec! Very nice!

Make turn-based game, 2D or 3D, it's entirely up to you what type, it can be anything: strategic, economic, tactical, puzzle, action etc.

By turn-based I mean game where progress is measured in turns, even if single turn is limited by e.g. time, action points or actions (walk, attack, use item etc).

I thing that's could be a bigger project so time limit is 14 days - till 14th of June (including).

Examples: Worms, Civilization, UFO: Enemy Unknown, Jagged Alliance etc.

Obviously no one expect from you to make huge and complicated game, just get idea and try to realized it the best way you can.

So summarize:

Target: Turn-based game
Bonus points - A: Game play (in first place, graphic doesn't matter)
Bonus points - B: 2 player mode (co-op or/and against)
Good luck every one!

  

#include "DarkGDK.h"
 
#define WHITE 0xffffffff
#define BLACK 0xff000000
#define RED 0xffff0000
#define GREEN 0xff00ff00
#define BLUE 0xff0000ff
#define NADA 0x00000000
#define PURPLE 0xffff00ff
#define CYAN 0xff00ffff
#define YELLOW 0xffffff00
 
struct coords {
 int x;
 int y;
 
 coords ()
 {
  x = y = 0;
 }
 
 coords (int xp, int yp)
 {
  x = xp;
  y = yp;
 }
 
 bool operator== (const coords &a)
 {
  return (x == a.x && y == a.y);
 }
 
 bool operator!= (const coords &a)
 {
  return (x != a.x || y != a.y);
 }
 
};
 
class Grid {
 
private:
 int x;   // horizontal position
 int y;   // vertical postion
 int width;  // may be only part of screen
 int height;
 int across;  // number of rectangles across
 int down;  // number of rectangles down
 int vSpacing;
 int hSpacing;
 DWORD foreground;
 DWORD background;
 
public:
 
 Grid ()   // default constructor
 {
  width  = dbScreenWidth();
  height = dbScreenHeight();
  across = 10;   // we need some number
  down   = 10;   // and 10 is kinda round
  vSpacing = height / down;
  hSpacing = width / across;
  foreground = BLACK; // foreground = black
  background = WHITE; // background = white
 }
 
 Grid (int w, int h, int a, int d)
 {
  width  = w;  // construct with the data provided.
  height = h;
  across = a;
  down   = d;
  vSpacing = height / down;
  hSpacing = width / across;
 }
 
void Locate (int X, int Y)
  {
   x = X;
   y = Y;
  }
 
coords GetLocation ()
{
 return coords (x, y);
}
 
coords GetDimensions ()
{
 return coords (across, down);
}
 
coords GetSpacing ()
{
 return coords (hSpacing, vSpacing);
}
void Color (DWORD f, DWORD b)
  {
   foreground = f;
   background = b;
  }
 
void Draw ()
  {
   dbInk (foreground, background);
 
   for (int i = 0; i <= across; i++) {
    dbLine ((x + i) * hSpacing, y, (x + i) * hSpacing, y + height);
   }
   for (int i = 0; i <= down; i++ ) {
    dbLine (x, (y + i) * vSpacing, x + width, (y + i) * vSpacing);
   }
  }
 
coords ClickedGrid()
{
 static bool mouseClicked = false;
 
 if (dbMouseClick () == 0 && mouseClicked == false) return coords (-1, -1);
 
 if (dbMouseClick () == 1) {
  mouseClicked = true;
  return coords (-1, -1);
 }
 if (dbMouseClick () == 0 && mouseClicked == true) {
  mouseClicked = false;
 }
 int xMouse = dbMouseX();
 int yMouse = dbMouseY();
 
 // first test returns negative if cursor is outside the grid
 if (xMouse < x || xMouse > x + width || yMouse < y || yMouse > y + height) return coords (-1, -1);
 return coords (xMouse / hSpacing, yMouse / vSpacing);
}
coords Pixels (coords grd)
{
 return coords (grd.x * hSpacing + x, grd.y * vSpacing + y);
}
};
 
class Electrode
{
private:
 
 // this section pertains to the robot
 int xGrid;  // horizontal position on the grid
 int yGrid;  // vertical   position on the grid
 int sprite; // advancing sprite
 
 // this section pertains to the grid
static int GridX; // pixel location of the upper left corner
static int GridY;
static int vSpacing; // vertical and horizonal spacing
static int hSpacing;
static int numAcross; // number of blocks across and down
static int numDown;
static int image;
protected:
static int nextsprite;
static std::vector<Electrode> electrodeVec;
static std::vector<Electrode>::iterator it;
static  Grid *gridPtr;
public:
 
 
 Electrode ()  // default c'tor
 {
   do {
		xGrid = dbRnd(numAcross - 5);
		yGrid = dbRnd(numDown - 5);
		xGrid += numAcross/2;
		yGrid += numDown/2;
		xGrid -= (numAcross - 5)/2;
		yGrid -= (numDown - 5)/2;
	} while (xGrid == 20 && yGrid == 20);  //this prevents an electrode from being dropped on the human's starting point
  sprite = nextsprite++;
  if (sprite == 100) {
   ConstructElectrode ();
  }
  electrodeVec.push_back(*this);
  Draw();
 }
 
 Electrode (int x, int y)
 {
   xGrid = x;
  yGrid = y;
  sprite = nextsprite++;
  if (sprite == 100) {
   ConstructElectrode ();
  }
  electrodeVec.push_back(*this);
  Draw();
 }
 
 static void Clear ()
 {
  for (it = electrodeVec.begin();it < electrodeVec.end(); ++it) {
   if ( dbSpriteExist ((*it).sprite)) dbDeleteSprite((*it).sprite);
  }
  nextsprite = 100;
  electrodeVec.clear();
  if (dbImageExist(image)) dbDeleteImage(image);
 }
 
 ~Electrode ()
 {
 }
 
void ConstructElectrode ()
{
 // make electrode
 dbCreateBitmap (1, 30, 30);
 dbSetCurrentBitmap (1);
 dbInk (BLACK, NADA);
 dbCircle (15, 15, 13);
 dbInk (BLUE, NADA);
 dbCircle (15, 15, 11);
 dbInk (RED, NADA);
 dbCircle (15, 15, 9);
 dbInk (GREEN, NADA);
 dbCircle (15, 15, 7);
 dbInk (PURPLE, NADA);
 dbCircle (15, 15, 5);
 dbInk (CYAN, NADA);
 dbCircle(15, 15, 3);
 dbInk (YELLOW, NADA);
 dbCircle(15, 15, 1);
 dbInk (WHITE, NADA);
 dbLine (15, 2, 15, 29);
 dbInk (WHITE, NADA);
 dbLine (2, 15, 29, 15);
 dbGetImage (image, 0, 0, 29, 29);
 dbDeleteBitmap (1);
}
 
 
static void Bind (Grid *grid)
{
 gridPtr = grid;
 GridX = gridPtr->GetLocation().x;
 GridY = gridPtr->GetLocation().y;
 vSpacing = gridPtr->GetSpacing().y;
 hSpacing = gridPtr->GetSpacing().x;
 numAcross = gridPtr->GetDimensions().x;
 numDown = gridPtr->GetDimensions().y;
}
 
static void GenElectrode ()
{
 electrodeVec.push_back(Electrode());
}
 
void Put (int x, int y)
{
 xGrid = x;
 yGrid = y;
}
 
coords Where ()
{
 return coords (xGrid, yGrid);
}
 
 
void Draw ()
{
 dbSprite (sprite, xGrid * hSpacing + GridX, yGrid * vSpacing + GridX, image);
}
 
static bool FoundAt(int x, int y)
{
 for (it = electrodeVec.begin(); it < electrodeVec.end(); ++it) {
  if ((*it).xGrid == x && (*it).yGrid == y) return true;
 }
 return false;
 
}
 
}; 
 
int Electrode::nextsprite = 100;
std::vector<Electrode> Electrode::electrodeVec;
int Electrode::GridX; // pixel location of the upper left corner
int Electrode::GridY;
int Electrode::vSpacing; // vertical and horizonal spacing
int Electrode::hSpacing;
int Electrode::numAcross; // number of blocks across and down
int Electrode::numDown;
int Electrode::image = 4;
std::vector<Electrode>::iterator Electrode::it;
Grid* Electrode::gridPtr;
 
class Block
{
private:
 
 // this section pertains to the block
 int xGrid;  // horizontal position on the grid
 int yGrid;  // vertical   position on the grid
 int sprite; // advancing sprite
 
 // this section pertains to the grid
static int GridX; // pixel location of the upper left corner
static int GridY;
static int vSpacing; // vertical and horizonal spacing
static int hSpacing;
static int numAcross; // number of blocks across and down
static int numDown;
static int image;
static std::vector<Block>::iterator it;
protected:
static int nextsprite;
static std::vector<Block> blockVec;
static  Grid *gridPtr;
public:
 
 
 Block ()  // default c'tor
 {
   do {
		xGrid = dbRnd(numAcross - 5);
		yGrid = dbRnd(numDown - 5);
		xGrid += numAcross/2;
		yGrid += numDown/2;
		xGrid -= (numAcross - 5)/2;
		yGrid -= (numDown - 5)/2;
	} while (xGrid == 20 && yGrid == 20);  //this prevents a block from being dropped on the human's starting point

  sprite = nextsprite++;
  if (sprite == 1000) {
   BuildBlock ();
  }
  blockVec.push_back(*this);
  Draw();
 }
 
 Block (int x, int y)
 {
   xGrid = x;
  yGrid = y;
  sprite = nextsprite++;
  image = 5;
  if (sprite == 1000) {
   BuildBlock ();
  }
  blockVec.push_back(*this);
  Draw();
 }
 
 ~Block ()
 {
 }
 
 static void Clear ()
 {
  for (it = blockVec.begin();it < blockVec.end(); ++it) {
   if ( dbSpriteExist ((*it).sprite)) dbDeleteSprite((*it).sprite);
  }
  nextsprite = 1000;
  blockVec.clear();
  if (dbImageExist(image)) dbDeleteImage(image);
 }
 
void BuildBlock ()
{
 // make block
 dbCreateBitmap (1, 30, 30);
 dbSetCurrentBitmap (1);
 dbInk (BLACK, NADA);
 dbBox (0, 0, 29, 29);
 dbInk (BLUE, NADA);
 dbBox (2, 2, 27, 27);
 dbInk (RED, NADA);
 dbBox (4, 4, 25, 25);
 dbInk (GREEN, NADA);
 dbBox (6, 6, 23, 23);
 dbInk (PURPLE, NADA);
 dbBox (8, 8, 21, 21);
 dbInk (CYAN, NADA);
 dbBox (10, 10, 19, 19);
 dbInk (YELLOW, NADA);
 dbBox (12, 12, 17, 17);
 dbInk (WHITE, NADA);
 dbLine (0, 0, 29, 29);
 dbLine (29, 0, 0, 29);
 dbGetImage (image, 0, 0, 29, 29);
 dbDeleteBitmap (1);
}
 
 
static void Bind (Grid *grid)
{
 gridPtr = grid;
 GridX = gridPtr->GetLocation().x;
 GridY = gridPtr->GetLocation().y;
 vSpacing = gridPtr->GetSpacing().y;
 hSpacing = gridPtr->GetSpacing().x;
 numAcross = gridPtr->GetDimensions().x;
 numDown = gridPtr->GetDimensions().y;
}
 
static void GenBlock ()
{
 blockVec.push_back(Block());
}
 
void Put (int x, int y)
{
 xGrid = x;
 yGrid = y;
}
 
coords Where ()
{
 return coords (xGrid, yGrid);
}
 
 
void Draw ()
{
 dbSprite (sprite, xGrid * hSpacing + GridX, yGrid * vSpacing + GridX, image);
}
 
static bool FoundAt(int x, int y)
{
 for (it = blockVec.begin(); it < blockVec.end(); ++it) {
  if ((*it).xGrid == x && (*it).yGrid == y) return true;
 }
 return false;
}
 

};
 
int Block::nextsprite = 1000;
std::vector<Block> Block::blockVec;
int Block::GridX; // pixel location of the upper left corner
int Block::GridY;
int Block::vSpacing; // vertical and horizonal spacing
int Block::hSpacing;
int Block::numAcross; // number of blocks across and down
int Block::numDown;
int Block::image = 5;
std::vector<Block>::iterator Block::it;
Grid* Block::gridPtr;
 
class Robot
{
private:
 
 // this section pertains to the robot
 int xGrid;  // horizontal position on the grid
 int yGrid;  // vertical   position on the grid
 int sprite; // advancing sprite
 bool alive;
 

 // this section pertains to the grid
static int GridX; // pixel location of the upper left corner
static int GridY;
static int vSpacing; // vertical and horizonal spacing
static int hSpacing;
static int numAcross; // number of blocks across and down
static int numDown;
static int image;
static std::vector<Robot>::iterator it;
static Grid *gridPtr;
 
protected:
static int nextsprite;
static std::vector<Robot> robotVec;
static  Grid &grid;
public:
 
 
 Robot ()  // default c'tor
 {
    do {
		xGrid = dbRnd(numAcross - 5);
		yGrid = dbRnd(numDown - 5);
		xGrid += numAcross/2;
		yGrid += numDown/2;
		xGrid -= (numAcross - 5)/2;
		yGrid -= (numDown - 5)/2;
	} while (abs(xGrid - 10) < 6 || abs(yGrid - 10) < 6);  //this prevents a robot from being dropped within 6
	                                                       // units of the human's starting point

	alive = true;
	sprite = nextsprite++;
	if (sprite == 10) {
	BuildRobot ();
  }
  robotVec.push_back(*this);
  Draw();
 }
 
 Robot (int x, int y)
 {
 
  xGrid = x;
  yGrid = y;
  alive = true;
  sprite = nextsprite++;
  if (sprite == 10) {
   BuildRobot ();
  }
  robotVec.push_back(*this);
  Draw();
 }
 
 ~Robot ()
 {	// didn't put a destructor here.  use clear instead when finished with the robots
 }
 
  static void Clear ()
 {
  for (it = robotVec.begin();it < robotVec.end(); ++it) {
   if ( dbSpriteExist ((*it).sprite)) dbDeleteSprite((*it).sprite);
  }

  nextsprite = 10;
  robotVec.clear();
  if (dbImageExist(image)) dbDeleteImage(image);
 }
void BuildRobot ()
{
 dbCreateBitmap(1, 30, 30);
 dbSetCurrentBitmap (1);
 dbInk (RED, NADA);
 dbBox(10, 0, 19, 7);   // the head
 dbBox( 8, 8, 21, 18);   // the body
 dbBox( 8, 19, 12, 27);   // both legs
 dbBox( 17, 19, 21, 27);
 dbBox( 4, 10, 26, 12);   // both arms
 dbInk (BLACK, NADA);
 dbLine(12, 5, 17, 5);   // a little slash for the mouth
 dbDot (12, 12);     // and some buttons for his belly
 dbDot (17, 12);
 dbDot (12, 15);
 dbDot (17, 15);
 dbDot (12, 3);     // and a couple of cute eyes
 dbDot (17, 3);
 dbGetImage(image, 0, 0, 29, 29);
 dbDeleteBitmap(1);
}
 
static void Bind (Grid *grid)
{
 gridPtr = grid;
 GridX = gridPtr->GetLocation().x;
 GridY = gridPtr->GetLocation().y;
 vSpacing = gridPtr->GetSpacing().y;
 hSpacing = gridPtr->GetSpacing().x;
 numAcross = gridPtr->GetDimensions().x;
 numDown = gridPtr->GetDimensions().y;
}
 
static void Update (coords loc)
{
 std::vector<Robot>::iterator ds;
 // first we move all of the robots toward the human
 // TrackHuman will also eliminate any 'bots that run into an electrode
 // or stop any 'bots that run into a block
 for (it = robotVec.begin(); it < robotVec.end(); ++it) it->TrackHuman(loc);
 
 // then we check to see if any of the 'bots killed each other
 for (it = robotVec.begin(); it < (robotVec.end() - 1); ++it) { // track through all but the last 'bot
  for (ds = (it + 1); ds < robotVec.end(); ++ds) {   // against all the remaining 'bots
   if  ( (*ds).xGrid == (*it).xGrid && (*ds).yGrid == (*it).yGrid) { // collision?
    if (!(*ds).alive || !(*it).alive) continue;  // make sure both 'bots are alive 
    (*ds).Kill();          // otherwise destory them both
    (*it).Kill();
   }
  }
 }
}
 
static void GenBot ()
{
 int holdX; 
 int holdY;
 
 while (true) {
  holdX = dbRnd(numAcross - 1);
  holdY = dbRnd(numDown - 1);
  if (Electrode::FoundAt(holdX, holdY)) continue;
  if (Block::FoundAt(holdX, holdY)) continue;
  break;
 }
 
 Robot(holdX, holdY);
}
 
void Put (int x, int y)
{
 xGrid = x;
 yGrid = y;
}
 
coords Where ()
{
 return coords (xGrid, yGrid);
}
 
void Draw ()
{
 if (!alive) return;
 dbSprite (sprite, xGrid * hSpacing + GridX, yGrid * vSpacing + GridX, image);
}
 
bool TrackHuman (coords humanLoc)
{
 int holdX = xGrid; // hold these in case we hit a block
 int holdY = yGrid;
 
 if (xGrid != humanLoc.x) xGrid > humanLoc.x ? xGrid-- : xGrid++;
 if (yGrid != humanLoc.y) yGrid > humanLoc.y ? yGrid-- : yGrid++;
 if (Electrode::FoundAt(xGrid, yGrid)) {
  Kill();
  return false;
 }
 if (Block::FoundAt(xGrid, yGrid)) {
  xGrid = holdX;
  yGrid = holdY;
 }
 Draw();
 return true;  // temporary until I add some more code
}
 
void Kill ()
{
 alive = false;
 dbHideSprite(sprite);
}
 
static bool FoundAt(int x, int y)
{
 for (it = robotVec.begin(); it < robotVec.end(); ++it) {
  if ((*it).alive && (*it).xGrid == x && (*it).yGrid == y) return true;
 }
 return false;
}
};
 
int Robot::nextsprite = 10;
std::vector<Robot> Robot::robotVec;
int Robot::GridX; // pixel location of the upper left corner
int Robot::GridY;
int Robot::vSpacing; // vertical and horizonal spacing
int Robot::hSpacing;
int Robot::numAcross; // number of blocks across and down
int Robot::numDown;
int Robot::image=2;
std::vector<Robot>::iterator Robot::it;
Grid * Robot::gridPtr; 
 
class Human 
{
private:
 int xGrid;
 int yGrid;
 int sprite;
 int image;
 bool alive;
 
void MakeHuman ()
{
 dbCreateBitmap (1, 30, 30);
 dbSetCurrentBitmap (1);
 dbInk (GREEN, NADA);
 dbCircle(15, 4, 3);  // head
 dbCircle(15, 4, 2);
 dbLine(15, 4, 15, 17); // torso, very skinny
 dbLine (7, 10, 22, 10);
 dbLine (15, 17, 10, 29);// one leg 
 dbLine (15, 17, 19, 29);// other leg
 dbGetImage(1, 0, 0, 29, 29);
 dbDeleteBitmap(1);
}
public:
 
 Human ()
 {
  xGrid = 10;
  yGrid = 10;
  image = 1;
  sprite = 1;
  MakeHuman ();
  alive = true;
  dbSprite (sprite, 0, 0, image);
 }
 
 Human (int x, int y)
 {
  xGrid = x;
  yGrid = y;
  image = 1;
  sprite = 1;
  MakeHuman ();
  alive = true;
  dbSprite (sprite, 0, 0, image);
 }
 
void Put (coords gridloc)
{
 xGrid = gridloc.x;
 yGrid = gridloc.y;
}
 
coords Where ()
{
 return coords (xGrid, yGrid);
}
 
void Draw (coords location)
{
 dbSprite (sprite, location.x, location.y, image);
}
 
void Kill()
{
 alive = false;
}
 
void Revive ()
{
 alive = true;
}
 
bool Alive ()
{
 return alive;
}
 
};
 
class BotFactory
{
 
 int modFactor;
 int counter;
 
public:
 BotFactory ()
 {
  counter = 0;
  modFactor = 3;
 }
 
 void Update ()
 { // determines if it's time to release another robot
	if (modFactor == 0) modFactor = 1;		// this is a real hack
	if (++counter % modFactor == 0) Robot::GenBot() ;
  
	// these lines allow the production to go faster after 50 and 100 turns 
	if (counter >50 && counter < 100) modFactor--;
	if (counter > 100 && modFactor != 1) modFactor--;
 }
 void Restart()
 {
	 counter = 0;
	 modFactor = 3;
 }
};
 
// the main entry point for the application is this function
 
void DarkGDK ( void )
{
 
 coords clickety; // holds grid co-ordinates when a square is clicked
 int turns;
 char turnString [40];
 
 dbSetDisplayMode(800, 600, 32);
 
 dbSyncOn   ( );
 dbSyncRate ( 60 );
 
 dbDisableEscapeKey ( );
 
 dbRandomize ( dbTimer ( ) );
 
 Grid grid (600, 600, 20, 20); // set the size and number of rectangles in the grid
 grid.Locate (0, 0);   // and place it in the upper left corner
 
 Robot::Bind(&grid);   // allow robots to know whhat the grid is all about
 Electrode::Bind(&grid);  // same for electrodes
 Block::Bind(&grid);   // and the blocks
 Human human;
 BotFactory factory;
 bool replay = true;
 
 do {
	// now we generate a number of blocks, electrodes and robots.
	for (int i = 0; i < 10; i++) Block::GenBlock();
	for (int i = 0; i < 10; i++) Electrode::GenElectrode();
	for (int i = 0; i < 5; i++) Robot::GenBot();
 
	// place the human and draw him/her
	human.Revive();							// make sure he's alive
	human.Put(coords (10, 10));				// put him in the middle of the screen
	human.Draw(grid.Pixels(human.Where()));
	factory.Restart();
	turns = 0;
 
	// now begins the turn taking
	while ( LoopGDK ( ) && human.Alive())
	{
 
		if ( dbEscapeKey ( ) )   break;
 
		dbCLS(WHITE);  // clear the screen
		grid.Draw();  // draw the grid
		sprintf (turnString, "Turn number: %d", turns);
		dbInk (0xff00ff00, 0x00000000);    // using green ink
		dbSetTextFont ("Arial");     // it's a nice font
		dbSetTextSize (24);
		dbCenterText (700, 25, turnString);

		clickety = grid.ClickedGrid(); // see if grid is clicked 
		if (clickety.x != -1) {   // non-negative indicates valid grid block clicked
			turns++;
			// if grid is clicked make sure it's within one square of the human
			if (abs (clickety.x - human.Where().x) <= 1 && abs (clickety.y - human.Where().y) <= 1) {
				// check to see if the human ran into an electrode
				if (Electrode::FoundAt(clickety.x, clickety.y)) human.Kill();
					// if he ran into a block
					if (Block::FoundAt(clickety.x, clickety.y)) {
					clickety.x = human.Where().x; // put him/her back where he/she was
					clickety.y = human.Where().y;
				}
				human.Put(clickety);      // move human to where the click says
				human.Draw(grid.Pixels(human.Where())); // grid.pixels returs the upper left corner
				// of the grid block in pixels
				Robot::Update(human.Where());    // move the robots to intercept the human
				if (Robot::FoundAt(human.Where().x, human.Where().y)) 
					human.Kill();
			}
				factory.Update();
		}
		dbSync ( );
	}
	dbHideAllSprites();
	dbInk (WHITE, NADA);
	dbBox (200, 200, 600, 420);
	dbInk (0xff00ff00, 0x00000000); // using green ink
	dbSetTextFont ("Arial");   // it's a nice font
	dbSetTextSize (36);    // that can grow to 36 points
	sprintf (turnString, "%d Turns", turns);
	dbCenterText (400, 230, "You survived for");
	dbCenterText (400, 280, turnString);
	dbCenterText (400, 330, "Enter to continue");
	dbCenterText (400, 380, "ESCape to exit");

	dbSync();

	do {
		 if (dbEscapeKey() == 1) {
			replay = false;
			break;
		 }
		 if (dbReturnKey() == 1) break;
	} while (true);
	Robot::Clear();
	Electrode::Clear();
	Block::Clear();
	dbShowAllSprites();
 }while (replay == true);
 return;
}

Lilith for Robots

===== 1st =====
Lilith - Robots
Gameplay - 7 pts (14pts)
Graphic - 5 pts
Sounds/Music - 0 pts
Bonus - 0 pts
Total: 19 pts

===== 2nd =====
Mireben - Dice Poker
Gameplay - 6 pts (12pts)
Graphic - 4 pts
Sounds/Music - 0 pts
Bonus - 0 pts
Total: 16 pts

/***************************************************************
***** Name: Hangman ********************************************
***** Made to be entered in the Dark GDK Coding Challenges *****
***** Forum Name = Bran flakes91093 ****************************
****************************************************************/

#include "DarkGDK.h"
#include "Globstruct.h"
#include <iostream>
#include <string>
#include <vector>
#include <fstream> // For reading from files
#include <stdio.h> // For the exit(int exitcode) function
#include <ctype.h> // For isalpha() (to check if a char is a letter or not)
using namespace std;

#define TARGET_FILE "WordList.txt"

enum GameState {
	GS_INIT, // Initialize
	GS_GIP, // Game in progress
	GS_WIN, // Guessed word correctly
	GS_HANGED // The man was hanged
} gs(GS_INIT);

vector<string> words(0); // List of words
string current = ""; // Current word
string guessed = ""; // Guessed letters
string wrong = ""; // Wrong letters
int limbs = 0; // The current number of limbs on the screen
//int score = 0; // Score

//Prototypes
void Game(); // Switches the gamestate
void Initialize(); // Initializes
void PopulateWordList(); // Clears word list and then repopulates it from the file
string GetRandomWord(); // Returns a random word from the word list
char* RemoveNonAlpha(char str[]); // Removes all non-alpha characters except spaces
char* RemoveSpaces(char str[]); // Removes all spaces
void Restart(); // Resets everything
char* Lowercase(char* str); // Makes every letter lowercase
bool Contains(string str, char c); // Returns true if the string contains the char
void DrawLimbs(); // Draws the limbs
void DrawGallows(); // Draws the gallows

// the main entry point for the application is this function
void DarkGDK ( void )
{
	// turn on sync rate and set maximum rate to 60 fps
	dbSyncOn   ( );
	dbSyncRate ( 0 );

	Initialize();

	// our main loop
	while ( LoopGDK ( ) )
	{
		dbCLS();
		Game();
		dbSync();
	}

	// return back to windows
	return;
}

void Initialize() {
	PopulateWordList();
	dbSetTextSize(26);
	dbSetTextFont("Verdana");
	dbSetWindowTitle("Hangman by Bran flakes91093");
}

void Game() {
	string mask = ""; // For printing underscores and the word
	switch(gs) {
		case GS_INIT:
			Initialize();
			current = GetRandomWord();
			gs = GS_GIP;
			break;
		case GS_GIP: 
			{
				DrawGallows();
				DrawLimbs();
				dbInk(0xFFFFFF, dbRGB(0, 0, 0));
				for(int i = 0; i < current.size(); i++)
					mask.append(" _"); // Fill the string with underscores
				char* tinput = dbGetEntry(); // Get input
				if(tinput) {
					RemoveSpaces(tinput); // Remove Spaces
					Lowercase(tinput); // Change input to lowercase
					if(isalpha(*tinput) && !Contains(guessed, *tinput)) { // If char is a letter and has not been guessed
						guessed += *tinput; // Add letter to guessed list
						if(!Contains(current, *tinput)) { // Letter is wrong
							wrong += *tinput; // Add letter to wrong list
							limbs++; // Add a limb
						}
					}
					delete[] tinput;
					dbClearEntryBuffer();
				}
				for(int i = 0; i < guessed.size(); i++)
					for(int p = 0; p < current.size(); p++)
						if(current[p] == guessed[i])
							mask[(p * 2) + 1] = guessed[i]; // Replace underscore with the corresponding guessed letter
				dbCenterText(dbScreenWidth() / 2, dbScreenHeight() / 2, (char*)mask.c_str());
				dbText(0, 0, "Guessed Wrong: ");
				dbText(0, 20, (char*)wrong.c_str());
				if(limbs > 5) // Has all limbs
					gs = GS_HANGED;
				if(!Contains(mask, '_')) // No underscores in word (all right letters guessed)
					gs = GS_WIN;
				break;
			}
		case GS_WIN:
			if(limbs != 6)
				limbs = 6;
			DrawLimbs();
			dbSetTextSize(14);
			dbText(145, 200, "^"); // Draw happy Eyes
			dbText(155, 200, "^");
			dbSetTextSize(26);
			dbInk(0x33FF00, dbRGB(0, 0, 0));
			dbCenterText(dbScreenWidth() / 2, 0, "You Win!");
			dbCenterText(dbScreenWidth() / 2, dbTextHeight("Game"), "Press the space bar to play again or ESC to quit.");
			dbText(170, 170, "Woohoo!!!");
			if(dbSpaceKey()) {
				//score += (current.size() * 50) - (wrong.size() * 5);
				Restart();
				gs = GS_GIP;
			}
			break;
		case GS_HANGED:
			dbInk(0x8C1717, dbRGB(0, 0, 0));
			dbLine(147, 208, 153, 202); // Draw x's as eyes
			dbLine(153, 208, 147, 202);
			dbLine(155, 208, 163, 202);
			dbLine(163, 208, 155, 202);
			DrawGallows();
			DrawLimbs();
			dbCenterText(dbScreenWidth() / 2, 0, "Game over! He was hanged. . .");
			dbCenterText(dbScreenWidth() / 2, dbTextHeight("Game"), "Press the space bar to play again or ESC to quit.");
			dbText(170, 170, "Agh!");
			if(dbSpaceKey()) {
				//score -= current.size() * 10;
				Restart();
				gs = GS_GIP;
			}
			break;
	}
}

void PopulateWordList() {
	words.clear();
	ifstream inf;
	inf.open(TARGET_FILE, ifstream::in);
	if(!inf.is_open()) {
		string msg = "The file: <";
		msg.append(dbGetDir());
		msg.append("\\");
		msg.append(TARGET_FILE);
		msg.append("> could not be opened for reading. ");
		MessageBoxA(g_pGlob->hWnd, msg.c_str(), TEXT("Error"), MB_OK);
		exit(1);
	}
	while(!inf.eof()) {
		char temp[32];
		inf.getline(temp, sizeof(temp)); // Retrieve the next word
		RemoveNonAlpha(temp);
		RemoveSpaces(temp);
		Lowercase(temp);
		if(strlen(temp) > 5 && strlen(temp) < 11)
			words.push_back((string)temp);
	}
	inf.close();
}

string GetRandomWord() {
	if(words.size() > 0) {
		srand(timeGetTime());
		unsigned short word = 0;
		word = rand() % words.size();
		string str = words[word];
		words.erase(words.begin() + word);
		return str;
	}
	else {
		MessageBoxA(g_pGlob->hWnd, TEXT("Out of words"), TEXT("Error"), MB_OK);
		exit(2);
	}
	return "<ERROR>";
}

char* RemoveSpaces(char str[]) {
	for(int i = 0; i < strlen(str); i++)
		if(str[i] == ' ') {
			for(int p = i; p < strlen(str); p++)
				str[p] = str[p + 1];
			i--;
		}
	return str;
}

char* RemoveNonAlpha(char str[]) {
	for(int i = 0; i < strlen(str); i++)
		if(isalpha(str[i]) == 0 && str[i] != ' ') {
			for(int p = i; p < strlen(str); p++)
				str[p] = str[p + 1];
			i--;
		}
	return str;
}
void Restart() {
	current = GetRandomWord(); // Retrieve a new word from the list
	guessed = ""; // No guessed letters yet
	wrong = ""; // No wrong letters yet
	dbClearEntryBuffer();
	limbs = 0; // No limbs should be drawn to the screen
}

char* Lowercase(char* str) {
	for(int i = 0; i < strlen(str); i++)
		if(str[i] >= 0x41 && str[i] <= 0x5A)
			str[i] = str[i] + 0x20;
	return str;
}

bool Contains(string str, char c) { // Returns true if the string contains the char
	for(int i = 0; i < str.size(); i++)
		if(str[i] == c)
			return true;
	return false;
}

void DrawGallows() {
	dbInk(0x5C4033, dbRGB(0, 0, 0));
	dbLine(22, 411, 230, 411); // Floor
	dbLine(53, 411, 53, 161); // Vertical Post
	dbLine(53, 161, 156, 161); // Horizontal Post
	dbEllipse(155, 196, 22, 35); // Noose
}

void DrawLimbs() {
	dbInk(0x8C1717, dbRGB(0, 0, 0));
	switch(limbs) {
		case 6: // Right Leg
			dbLine(155, 300, 165, 330);
		case 5: // Left Leg
			dbLine(155, 300, 145, 330);
		case 4: // Right Arm
			dbLine(155, 235, 180, 269);
		case 3: // Left Arm
			dbLine(155, 235, 130, 269);
		case 2: // Body
			dbLine(155, 221, 155, 300);
		case 1: // Head
			dbCircle(155, 209, 12);
			break;
	}
}

#pragma once

void MakeGrid (int Xpos, int Ypos);
void SetupGrid (bool comp);
void Choose (void);
void CheckForWinner (void);
void FindBox (int g_Xpos, int g_Ypos);
void ShowSetup (void);
void ShowAttempts (void);
void HighlightBox (int g_Xpos, int g_Ypos, int Xpos, int Ypos);

#include "DarkGDK.h"
#include "main.h"

//1.player/comp 2.3.x/y
bool Grid [2][10][10] = {};
bool Attempts [2][10][10] = {};
int ships = 0;
int selection [1] = {};
int timesave = 0;
int input[3] = {};
int gridpos[2] = {};
int grid_s = 0;
int turns[2] = {};
int HitCount[2] = {};

enum  eMode {eSetupGrid, eSetupCompGrid, ePlay, eGameOver};
eMode g_eGameMode = eSetupGrid;

void DarkGDK ( void )
{
	dbSyncOn   ( );
	dbSyncRate ( 60 );
	dbRandomize (dbTimer());
	
	// our main loop
	while ( LoopGDK ( ) )
	{
		dbCLS();
		//make player grid
		MakeGrid (20,20);
		//make guessing grid
		MakeGrid (200,20);

		switch ( g_eGameMode )
		{
			case eSetupGrid:
				SetupGrid (false);
				ShowSetup (); break;
			case eSetupCompGrid:
				SetupGrid (true);
				ShowSetup (); break;
			case ePlay:
				ShowSetup ();
				ShowAttempts ();
				Choose (); 
				CheckForWinner(); break;
			case eGameOver:
				ShowSetup();
				ShowAttempts(); 
				CheckForWinner(); break;
		}
		// update the screen
		dbSync ( );
	}

	// return back to windows
	return;
}

void MakeGrid (int Xpos, int Ypos)
{
	dbInk (dbRGB(255,255,255),dbRGB(0,0,0));
	for (int x = Xpos/10; x < Xpos/10 + 10; x++)
	{
		for (int y = Ypos/10; y < Ypos/10 + 10; y++)
			dbBox( 10*x + 1, 10*y + 1, 10*x + 9, 10*y + 9);
	}
}

void SetupGrid (bool comp)
{
	if (comp)
	{
		dbText (0,0, "Setting up opposing ships");
		input[0] = dbRnd(100) + 200;
		input[1] = dbRnd(100) + 20;
		input[2] = dbRnd(3);
		gridpos[0] = 200;
		gridpos[1] = 20;
		grid_s = 1;
	}
	else
	{
		dbText (0,0, "Place your ships on the left grid. RightClick to rotate");
		input[0] = dbMouseX();
		input[1] = dbMouseY();
		input[2] = dbMouseClick();
		gridpos[0] = 20;
		gridpos[1] = 20;
		grid_s = 0;
	}
	dbInk (dbRGB(100,100,100), dbRGB(0,0,0));
	if (ships < 4)
		{
			switch (input[2])
			{
				case 2:
					dbBox (input[0], input[1], input[0] + 8, input[1] + 18);
					break;
				case 0:
					dbBox (input[0], input[1], input[0] + 18, input[1] + 8);
					break;
				case 1:
					if (dbTimer() - timesave > 5000)
					{
						timesave = dbTimer();
						FindBox (gridpos[0], gridpos[1]);
						if ( selection [0] < 9 && selection [0] >= 0 && selection [1] <= 9 && selection [1] >= 0  )
						{
							if ( Grid [grid_s] [selection [0]][selection[1]] == false && Grid [grid_s] [selection [0] + 1][selection[1]] == false )
							{
								Grid [grid_s] [selection [0]][selection[1]] = true;
								Grid [grid_s] [selection [0] + 1][selection[1]] = true;
								ships++;
							}
						}
					}
					break;
				case 3:
					if (dbTimer() - timesave > 5000)
					{
						timesave = dbTimer();
						FindBox (gridpos[0], gridpos[1]);
						if ( selection [1] < 9 && selection [1] >= 0 && selection [0] <= 9 && selection [0] >= 0  )
						{
							if ( Grid [grid_s] [selection [0]][selection[1]] == false && Grid [grid_s] [selection [0]][selection[1] + 1] == false)
							{
								Grid [grid_s] [selection [0]][selection[1]] = true;
								Grid [grid_s] [selection [0]][selection[1] + 1] = true;
								ships++;
							}
						}
					}
					break;
			}
		}
	if ( ships > 3 && ships < 7 )
		{
			switch (input[2])
			{
				case 2:
					dbBox (input[0], input[1], input[0] + 8, input[1] + 28);
					break;
				case 0:
					dbBox (input[0], input[1], input[0] + 28, input[1] + 8);
					break;
				case 1:
					if (dbTimer() - timesave > 5000)
					{
						timesave = dbTimer();
						FindBox (gridpos[0], gridpos[1]);
						if ( selection [0] < 8 && selection [0] >= 0 && selection [1] <= 9 && selection [1] >= 0  )
						{
							if ( Grid [grid_s] [selection [0]][selection[1]] == false && Grid [grid_s] [selection [0] + 1][selection[1]] == false && Grid [grid_s] [selection [0] + 2][selection[1]] == false)
							{
								Grid [grid_s] [selection [0]][selection[1]] = true;
								Grid [grid_s] [selection [0] + 1][selection[1]] = true;
								Grid [grid_s] [selection [0] + 2][selection[1]] = true;
								ships++;
							}
						}
					}
					break;
				case 3:
					if (dbTimer() - timesave > 5000)
					{
						timesave = dbTimer();
						FindBox (gridpos[0], gridpos[1]);
						if ( selection [1] < 8 && selection [1] >= 0 && selection [0] <= 9 && selection [0] >= 0  )
						{
							if ( Grid [grid_s] [selection [0]][selection[1]] == false && Grid [grid_s] [selection [0]][selection[1] + 1] == false && Grid [grid_s] [selection [0]][selection[1] + 2] == false)
							{
								Grid [grid_s] [selection [0]][selection[1]] = true;
								Grid [grid_s] [selection [0]][selection[1] + 1] = true;
								Grid [grid_s] [selection [0]][selection[1] + 2] = true;
								ships++;
							}
						}
					}
					break;
			}
		}
	if ( ships > 6 && ships < 9 )
		{
			switch (input[2])
			{
				case 2:
					dbBox (input[0], input[1], input[0] + 8, input[1] + 38);
					break;
				case 0:
					dbBox (input[0], input[1], input[0] + 38, input[1] + 8);
					break;
				case 1:
					if (dbTimer() - timesave > 5000)
					{
						timesave = dbTimer();
						FindBox (gridpos[0], gridpos[1]);
						if ( selection [0] < 7 && selection [0] >= 0  && selection [1] <= 9 && selection [1] >= 0  )
						{
							if ( Grid [grid_s] [selection [0]][selection[1]] == false && Grid [grid_s] [selection [0] + 1][selection[1]] == false && Grid [grid_s] [selection [0] + 2][selection[1]] == false && Grid [grid_s] [selection [0] + 3][selection[1]] == false)
							{
								Grid [grid_s] [selection [0]][selection[1]] = true;
								Grid [grid_s] [selection [0] + 1][selection[1]] = true;
								Grid [grid_s] [selection [0] + 2][selection[1]] = true;
								Grid [grid_s] [selection [0] + 3][selection[1]] = true;
								ships++;
							}
						}
					}
					break;
				case 3:
					if (dbTimer() - timesave > 5000)
					{
						timesave = dbTimer();
						FindBox (gridpos[0], gridpos[1]);
						if ( selection [1] < 7 && selection [1] >= 0  && selection [0] <= 9 && selection [0] >= 0  )
						{
							if ( Grid [grid_s] [selection [0]][selection[1]] == false && Grid [grid_s] [selection [0]][selection[1] + 1] == false && Grid [grid_s] [selection [0]][selection[1] + 2] == false && Grid [grid_s] [selection [0]][selection[1] + 3] == false)
							{
								Grid [grid_s] [selection [0]][selection[1]] = true;
								Grid [grid_s] [selection [0]][selection[1] + 1] = true;
								Grid [grid_s] [selection [0]][selection[1] + 2] = true;
								Grid [grid_s] [selection [0]][selection[1] + 3] = true;
								ships++;
							}
						}
					}
					break;
			}
		}
	if ( ships == 9 )
		{
			switch (input[2])
			{
				case 2:
					dbBox (input[0], input[1], input[0] + 8, input[1] + 48);
					break;
				case 0:
					dbBox (input[0], input[1], input[0] + 48, input[1] + 8);
					break;
				case 1:
					if (dbTimer() - timesave > 5000)
					{
						timesave = dbTimer();
						FindBox (gridpos[0], gridpos[1]);
						if ( selection [0] < 6 && selection [0] >= 0  && selection [1] <= 9 && selection [1] >= 0  )
						{
							if ( Grid [grid_s] [selection [0]][selection[1]] == false && Grid [grid_s] [selection [0] + 1][selection[1]] == false && Grid [grid_s] [selection [0] + 2][selection[1]] == false && Grid [grid_s] [selection [0] + 3][selection[1]] == false && Grid [grid_s] [selection [0] + 4][selection[1]] == false)
							{
								Grid [grid_s] [selection [0]][selection[1]] = true;
								Grid [grid_s] [selection [0] + 1][selection[1]] = true;
								Grid [grid_s] [selection [0] + 2][selection[1]] = true;
								Grid [grid_s] [selection [0] + 3][selection[1]] = true;
								Grid [grid_s] [selection [0] + 4][selection[1]] = true;
								ships++;
							}
						}
					}
					break;
				case 3:
					if (dbTimer() - timesave > 5000)
					{
						timesave = dbTimer();
						FindBox (gridpos[0], gridpos[1]);
						if ( selection [1] < 6 && selection [1] >= 0 && selection [0] <= 9 && selection [0] >= 0  )
						{
							if ( Grid [grid_s] [selection [0]][selection[1]] == false && Grid [grid_s] [selection [0]][selection[1] + 1] == false && Grid [grid_s] [selection [0]][selection[1] + 2] == false && Grid [grid_s] [selection [0]][selection[1] + 3] == false && Grid [grid_s] [selection [0]][selection[1] + 4] == false)
							{
								Grid [grid_s] [selection [0]][selection[1]] = true;
								Grid [grid_s] [selection [0]][selection[1] + 1] = true;
								Grid [grid_s] [selection [0]][selection[1] + 2] = true;
								Grid [grid_s] [selection [0]][selection[1] + 3] = true;
								Grid [grid_s] [selection [0]][selection[1] + 4] = true;
								ships++;
							}
						}
					}
					break;
			}
		}
	if (ships == 10)
	{
		if (comp)
			g_eGameMode = ePlay;
		else
		{
			ships = 0;
			g_eGameMode = eSetupCompGrid;
		}
	}
}
void ShowSetup (void)
{
	//I don't know how to pass colours between functions. What data type is it?
	dbInk(dbRGB(100,100,100), dbRGB(0,0,0));
	for (int x = 0; x < 10; x++)
	{
		for (int y = 0; y < 10; y++)
		{
			if (Grid [0][x][y] == true)
				HighlightBox(20,20,x,y);
		}
	}
}

void Choose (void)
{
	input[0] = dbMouseX();
	input[1] = dbMouseY();
	dbInk (dbRGB(255,255,255), dbRGB(0,0,0));
	dbText (0,0, "Pick a space on the right grid to attack");
	if(dbMouseClick()==1 && turns[0] == turns[1])
	{
		FindBox(200,20);
		if(selection [0] <= 9 && selection [0] >= 0 && selection [1] <= 9 && selection [1] >= 0 && Attempts [0][selection [0]][selection [1]] == false )
			{
				Attempts [0][selection [0]][selection [1]] = true;
				turns [0]++;
			}
	}
	if (turns[1] < turns[0])
	{
		selection [0] = dbRnd(9);
		selection [1] = dbRnd(9);
		if (Attempts [1][selection [0]][selection [1]] == false)
		{
			Attempts [1][selection [0]][selection [1]] = true;
			turns [1]++;
		}
	}
}

void CheckForWinner (void)
{
	dbInk (dbRGB(255,255,255),dbRGB(0,0,0));
	if (HitCount[0] == 30)
	{
		dbText(0,0, "Well done. You win!");
		g_eGameMode = eGameOver;
	}
	if (HitCount[1] == 30)
	{
		dbText(0,0, "Well done. You win!");
		g_eGameMode = eGameOver;
	}
}

void FindBox (int g_Xpos, int g_Ypos)
{
	selection [0] = (input[0] - g_Xpos) / 10;
	selection [1] = (input[1] - g_Ypos) / 10;
}

void HighlightBox (int g_Xpos, int g_Ypos, int Xpos, int Ypos)
{
	dbBox( g_Xpos + 10*Xpos + 1, g_Ypos + 10*Ypos + 1, g_Xpos + 10*Xpos + 9, g_Ypos + 10*Ypos + 9);
}
void ShowAttempts (void)
{
	HitCount[0] = 0;
	HitCount[1] = 0;
	for (int x = 0; x < 10; x++)
	{
		for (int y = 0; y < 10; y++)
		{
			if (Attempts [0][x][y] == true)
			{
				if (Attempts [0][x][y] == true && Grid [1][x][y] == true)
				{
					dbInk(dbRGB(255,0,0), dbRGB(0,0,0));
					HitCount[0]++;
				}
				else
					dbInk(dbRGB(0,0,255), dbRGB(0,0,0));
				HighlightBox(200,20,x,y);
			}
			if (Attempts [1][x][y] == true)
			{
				if (Attempts [1][x][y] == true && Grid [0][x][y] == true)
				{
					dbInk(dbRGB(255,0,0), dbRGB(0,0,0));
					HitCount[1]++;
				}
				else
					dbInk(dbRGB(0,0,255), dbRGB(0,0,0));
				HighlightBox(20,20,x,y);
			}
		}
	}
}