// ----------------------------------------------
// - EXON  ( Ver 1.2 )          13th MARCH 1999 -
// -                                            -
// - Programmed by      :   Paul Flint (BEAKER) -
// - Time spent so far  :  2 Weeks ( 55 Hours ) -            
// - PSX Program Number :     First C Program ! -
// -                      ( I guess it shows. ) -
// ----------------------------------------------

// This program uses the excellent pad routines from Nelson Santos/ROGUE ( cheers! )

// ***** Thanks Must Go To ******

// Everyone who supplies source code on the Net Yaroze Site 
// ( I'd have been lost without it ! )

// Herbert Schildt for his book:- " Teach Yourself C "

// SCEE For sending me my bundle of joy so quickly

// ***** Special Thanks ******

// Scott Campbell for his help regarding TIM files and general support

// ************************************************************************************ 


// -----------------------------------------------
// Includes
// -----------------------------------------------
#include <__rts_info_t__.h>

#include <libps.h>
#include "rougepad.h"				// Include the rougepad.h header file

// -----------------------------------------------
// Defines
// -----------------------------------------------

// Total number of sprites
#define		SPRITE_CNT	(256)

// Screen size detail
#define		SCREEN_WIDTH	320
#define		SCREEN_HEIGHT	240

// Tim address' in Memory
#define		spriteAdd	0x801a0000
#define     spriteAdd2  0x80100000
#define     spriteAdd3  0x80110000
#define     spriteAdd4  0x80120000
#define     spriteAdd5  0x80130000
#define     spriteAdd6  0x80140000
#define     spriteAdd7  0x80150000
#define		spriteAdd8	0x80160000
#define     spriteAdd9  0x80170000
#define		spriteAdd10	0x80180000
#define     spriteAdd11 0x80190000
#define     spriteAdd12 0x801b0000
#define		spriteAdd13	0x801c0000
#define     spriteAdd14 0x801d0000

// Set ordering table length
#define OT_LENGTH	(4)

// -----------------------------------------------
// General Function Prototypes
// -----------------------------------------------
void InitSprite1 ();  // (open sequence pic)
void InitSprite2 ();  // (open sequence pic)
void InitSprite3 ();  // (open sequence pic)
void InitSprite4 ();  // (open sequence pic)
void InitSprite5 ();  // (open sequence pic)

void InitSprite6 ();  // Player 1 Sprite
void InitSprite7 ();  // Player 2 Sprite

void InitSprite8 ();  // Game Background left side   (coz I can't work out GsBG yet,)
void InitSprite9 ();  // Game Background right side  (sprites are used as background)

void InitSprite10 (); // Player 1's X
void InitSprite11 (); // Player 2's O

void InitSprite12 (); // Player 1's Winner Sprite
void InitSprite13 (); // Player 2's Winner Sprite
void InitSprite14 (); // Game was a Draw Sprite

void InitGrid();              // Clear all grid values to 0 ( no-one owns them )
							 
void DrawGrid();              // Draw all owned grid location
void GetGridNumberP1();       // used to determine which grid player 1 is at
void GetGridNumberP2();       // used to determine which grid player 2 is at
void DrawO(int number);   // Register grid location ownership to Player 2
void DrawX(int number);   // Register grid location ownership to Player 1

void delay(int num);      // delay function to pause program        (open sequence)
void FadeSprite4Out();    // fade sprite4 out to zero brightness    (open sequence)
void FadeSprite4In();     // fade sprite4 in to normal brightness   (open sequence)
void FlashSprite5();      // flash sprite5 on / off                 (open sequence)
 
void CheckP1Score();      // used to check player 1's score        
void CheckP2Score();      // used to check player 2's score

void DisplayWinner();       // check to see who won and display victory screen accordingly

// ------------------------------------
// Game Function Prototypes
// ------------------------------------
void opentitle();   // Run Title Sequence
void InitGame();    // Run Game

void SomePad1();    // Pad 1 reading function
void SomePad2();    // Pad 2 reading function

// -----------------------------------------------
// Initialise Structures
// -----------------------------------------------

// Ordering table 1 variables
GsOT			WorldOT[2];
GsOT_TAG		OTTags[2][1<<OT_LENGTH];
int				activeBuff;

// Primitive related vaiables
PACKET			GpuPacketArea[2][SPRITE_CNT*sizeof(GsSPRITE)];

// Sprite structure pointer
GsSPRITE		TestSprite;
GsSPRITE        TestSprite2;
GsSPRITE        TestSprite3;
GsSPRITE        TestSprite4;
GsSPRITE        TestSprite5;
GsSPRITE        TestSprite6;
GsSPRITE        TestSprite7;
GsSPRITE        TestSprite8;
GsSPRITE		TestSprite9;
GsSPRITE        TestSprite10;
GsSPRITE		TestSprite11;
GsSPRITE		TestSprite12;
GsSPRITE        TestSprite13;
GsSPRITE		TestSprite14;

// ------------------------------------
// Global settings
// ------------------------------------

int Quit = 0;       // counter (used in Open sequence)
int run;            // counter (used in InitGame() to run
int swap = 0;       // value to swap turns between P1 + P2  ( 0 + 1 )

int grid[240];      // Total grid locations  (These will be set to 0 to assign)
                    //                       (no-one ownership at game start. )
                    //                       (0 = Not owned  1= Player 1 owned)
                    //						 (2 = Player 2 owned              )
					// ****** IMPORTANT *******
					// The Grid Size is 20 x 12 (hence 240)

int gridnumber;

int P1screenx = 0;  // Used to calculate Player 1 Max / Min x Movement value
int P1screeny = 0;  // Used to calculate Player 1 Max / Min y Movement value

int P2screenx = 0;  // Used to calculate Player 2 Max / Min x Movement value
int P2screeny = 0;  // Used to calculate Player 2 Max / Min y Movement value

int p1score;
int p2score;

// ----------------------
// main()
// ----------------------

void main(void)
{

	int	i;
	
	PadInit();					// First initialize the joypads
	SetVideoMode (MODE_PAL);    // Set PAL screen mode

	// Initialise the drawing system
	GsInitGraph(SCREEN_WIDTH,SCREEN_HEIGHT,4,0,0);  // Set screen values
	GsDefDispBuff(0,0,0,SCREEN_HEIGHT);
	ResetGraph(0);
	
	// Initialise the 1st ordering table
	for (i=0;i<2;i++)
		{
		WorldOT[i].length = OT_LENGTH;
		WorldOT[i].org = OTTags[i];
		}
		
	// Initialise all the sprites
	InitSprite1();
    InitSprite2();
	InitSprite3();
	InitSprite4();
	InitSprite5();
	InitSprite6();
	InitSprite7();
	InitSprite8();
	InitSprite9();
	InitSprite10();
	InitSprite11();
	InitSprite12();
	InitSprite13();
	InitSprite14();
	
	InitGrid();   // Clear all grid locations to 0 ( un-owned)
	
	opentitle(); // run title sequence  (This leads to InitGame hence main() doesn't call it)
	
	
} // end of main()


///////////////////////////////////////////////////////////////////////////////////////////


//
// Sprite1 initialisation routine 
//

void InitSprite1()
	{
	RECT		rect;								// Define RECT structure
	GsIMAGE	tim_data;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd+4),&tim_data);

	// Load the image into the frame buffer
	rect.x = tim_data.px;							// x pos in frame buffer
	rect.y = tim_data.py;							// y pos in frame buffer
	rect.w = tim_data.pw;							// width of image
	rect.h = tim_data.ph;							// height of image
	LoadImage(&rect, tim_data.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect.x = tim_data.cx;							// x pos in frame buffer
	rect.y = tim_data.cy;							// y pos in frame buffer
	rect.w = tim_data.cw;							// width of CLUT
	rect.h = tim_data.ch;							// height of CLUT
	LoadImage(&rect, tim_data.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite.x = ((SCREEN_WIDTH/2)-(tim_data.pw));		// sprite x axis position
	TestSprite.y = ((SCREEN_HEIGHT/2)-(tim_data.ph/2));// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite.w = (tim_data.pw*2);				// sprite width
	TestSprite.h = tim_data.ph;					// sprite height
	TestSprite.tpage = GetTPage(1,0, tim_data.px, tim_data.py);
	TestSprite.u = 0;								// Texture page offset x axis
	TestSprite.v = 0;								// Texture page offset y axis
	TestSprite.cx = tim_data.cx;					// CLUT x axis position
	TestSprite.cy = tim_data.cy;					// CLUT y axis position
	TestSprite.r = 128;								// Regular brightness
	TestSprite.g = 128;								// Regular brightness
	TestSprite.b = 128;								// Regular brightness
	TestSprite.mx = 0;								//
	TestSprite.my = 0;								//
	TestSprite.scalex = ONE;						// Defined as 4096
	TestSprite.scaley = ONE;						// Defined as 4096
	TestSprite.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}
	
	
//
// Sprite2 initialisation routine
//

void InitSprite2()
	{
	RECT		rect2;								// Define RECT structure
	GsIMAGE	tim_data2;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd2+4),&tim_data2);

	// Load the image into the frame buffer
	rect2.x = tim_data2.px;							// x pos in frame buffer
	rect2.y = tim_data2.py;							// y pos in frame buffer
	rect2.w = tim_data2.pw;							// width of image
	rect2.h = tim_data2.ph;							// height of image
	LoadImage(&rect2, tim_data2.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect2.x = tim_data2.cx;							// x pos in frame buffer
	rect2.y = tim_data2.cy;							// y pos in frame buffer
	rect2.w = tim_data2.cw;							// width of CLUT
	rect2.h = tim_data2.ch;							// height of CLUT
	LoadImage(&rect2, tim_data2.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite2.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite2.x = ((SCREEN_WIDTH/2)-(tim_data2.pw));		// sprite x axis position
	TestSprite2.y = ((SCREEN_HEIGHT/2)-(tim_data2.ph/2));// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite2.w = (tim_data2.pw*2);				// sprite width
	TestSprite2.h = tim_data2.ph;					// sprite height
	TestSprite2.tpage = GetTPage(1,0, tim_data2.px, tim_data2.py);
	TestSprite2.u = 0;									// Texture page offset x axis
	TestSprite2.v = 0;									// Texture page offset y axis
	TestSprite2.cx = tim_data2.cx;					// CLUT x axis position
	TestSprite2.cy = tim_data2.cy;					// CLUT y axis position
	TestSprite2.r = 128;								// Regular brightness
	TestSprite2.g = 128;								// Regular brightness
	TestSprite2.b = 128;								// Regular brightness
	TestSprite2.mx = 0;								//
	TestSprite2.my = 0;								//
	TestSprite2.scalex = ONE;						// Defined as 4096
	TestSprite2.scaley = ONE;						// Defined as 4096
	TestSprite2.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}


//
// Sprite3 initialisation routine
//

void InitSprite3()
	{
	RECT		rect3;								// Define RECT structure
	GsIMAGE	tim_data3;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd3+4),&tim_data3);

	// Load the image into the frame buffer
	rect3.x = tim_data3.px;							// x pos in frame buffer
	rect3.y = tim_data3.py;							// y pos in frame buffer
	rect3.w = tim_data3.pw;							// width of image
	rect3.h = tim_data3.ph;							// height of image
	LoadImage(&rect3, tim_data3.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect3.x = tim_data3.cx;							// x pos in frame buffer
	rect3.y = tim_data3.cy;							// y pos in frame buffer
	rect3.w = tim_data3.cw;							// width of CLUT
	rect3.h = tim_data3.ch;							// height of CLUT
	LoadImage(&rect3, tim_data3.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite3.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite3.x = ((SCREEN_WIDTH/2)-(tim_data3.pw)-50);		// sprite x axis position
	TestSprite3.y = ((SCREEN_HEIGHT/2)-(tim_data3.ph/2));// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite3.w = (tim_data3.pw*2);				// sprite width
	TestSprite3.h = tim_data3.ph;					// sprite height
	TestSprite3.tpage = GetTPage(1,0, tim_data3.px, tim_data3.py);
	TestSprite3.u = 0;									// Texture page offset x axis
	TestSprite3.v = 0;									// Texture page offset y axis
	TestSprite3.cx = tim_data3.cx;					// CLUT x axis position
	TestSprite3.cy = tim_data3.cy;					// CLUT y axis position
	TestSprite3.r = 128;								// Regular brightness
	TestSprite3.g = 128;								// Regular brightness
	TestSprite3.b = 128;								// Regular brightness
	TestSprite3.mx = 0;								//
	TestSprite3.my = 0;								//
	TestSprite3.scalex = ONE-1600;						// Defined as 4096
	TestSprite3.scaley = ONE-1600;						// Defined as 4096
	TestSprite3.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}
	
	
//
// Sprite4 initialisation routine
//

void InitSprite4()
	{
	RECT		rect4;								// Define RECT structure
	GsIMAGE	tim_data4;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd4+4),&tim_data4);

	// Load the image into the frame buffer
	rect4.x = tim_data4.px;							// x pos in frame buffer
	rect4.y = tim_data4.py;							// y pos in frame buffer
	rect4.w = tim_data4.pw;							// width of image
	rect4.h = tim_data4.ph;							// height of image
	LoadImage(&rect4, tim_data4.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect4.x = tim_data4.cx;							// x pos in frame buffer
	rect4.y = tim_data4.cy;							// y pos in frame buffer
	rect4.w = tim_data4.cw;							// width of CLUT
	rect4.h = tim_data4.ch;							// height of CLUT
	LoadImage(&rect4, tim_data4.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite4.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite4.x = ((SCREEN_WIDTH/2)-(tim_data4.pw));		// sprite x axis position
	TestSprite4.y = ((SCREEN_HEIGHT/2)-(tim_data4.ph/2));// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite4.w = (tim_data4.pw*2);				// sprite width
	TestSprite4.h = tim_data4.ph;					// sprite height
	TestSprite4.tpage = GetTPage(1,0, tim_data4.px, tim_data4.py);
	TestSprite4.u = 0;									// Texture page offset x axis
	TestSprite4.v = 0;									// Texture page offset y axis
	TestSprite4.cx = tim_data4.cx;					// CLUT x axis position
	TestSprite4.cy = tim_data4.cy;					// CLUT y axis position
	TestSprite4.r = 0;								// Zero brightness
	TestSprite4.g = 0;								// Zero brightness
	TestSprite4.b = 0;								// Zero brightness
	TestSprite4.mx = 0;								//
	TestSprite4.my = 0;								//
	TestSprite4.scalex = ONE;						// Defined as 4096
	TestSprite4.scaley = ONE;						// Defined as 4096
	TestSprite4.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}
	
	
//
// Sprite5 initialisation routine
//

void InitSprite5()
	{
	RECT		rect5;								// Define RECT structure
	GsIMAGE	tim_data5;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd5+4),&tim_data5);

	// Load the image into the frame buffer
	rect5.x = tim_data5.px;							// x pos in frame buffer
	rect5.y = tim_data5.py;							// y pos in frame buffer
	rect5.w = tim_data5.pw;							// width of image
	rect5.h = tim_data5.ph;							// height of image
	LoadImage(&rect5, tim_data5.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect5.x = tim_data5.cx;							// x pos in frame buffer
	rect5.y = tim_data5.cy;							// y pos in frame buffer
	rect5.w = tim_data5.cw;							// width of CLUT
	rect5.h = tim_data5.ch;							// height of CLUT
	LoadImage(&rect5, tim_data5.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite5.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite5.x = ((SCREEN_WIDTH/2)-(tim_data5.pw));		// sprite x axis position
	TestSprite5.y = ((SCREEN_HEIGHT/2)-(tim_data5.ph/2)+60);// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite5.w = (tim_data5.pw*2);				// sprite width
	TestSprite5.h = tim_data5.ph;					// sprite height
	TestSprite5.tpage = GetTPage(1,0, tim_data5.px, tim_data5.py);
	TestSprite5.u = 0;									// Texture page offset x axis
	TestSprite5.v = 0;									// Texture page offset y axis
	TestSprite5.cx = tim_data5.cx;					// CLUT x axis position
	TestSprite5.cy = tim_data5.cy;					// CLUT y axis position
	TestSprite5.r = 128;								// Regular brightness
	TestSprite5.g = 128;								// Regular brightness
	TestSprite5.b = 128;								// Regular brightness
	TestSprite5.mx = 0;								//
	TestSprite5.my = 0;								//
	TestSprite5.scalex = ONE;						// Defined as 4096
	TestSprite5.scaley = ONE;						// Defined as 4096
	TestSprite5.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}
	
	//
// Sprite6 initialisation routine
//

void InitSprite6()
	{
	RECT		rect6;								// Define RECT structure
	GsIMAGE	tim_data6;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd6+4),&tim_data6);

	// Load the image into the frame buffer
	rect6.x = tim_data6.px;							// x pos in frame buffer
	rect6.y = tim_data6.py;							// y pos in frame buffer
	rect6.w = tim_data6.pw;							// width of image
	rect6.h = tim_data6.ph;							// height of image
	LoadImage(&rect6, tim_data6.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect6.x = tim_data6.cx;							// x pos in frame buffer
	rect6.y = tim_data6.cy;							// y pos in frame buffer
	rect6.w = tim_data6.cw;							// width of CLUT
	rect6.h = tim_data6.ch;							// height of CLUT
	LoadImage(&rect6, tim_data6.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite6.attribute = 0x01000000;						// sprite attribute - 8 bit
//	TestSprite6.x = ((SCREEN_WIDTH/2)-(tim_data6.pw));		// sprite x axis position
//	TestSprite6.y = ((SCREEN_HEIGHT/2)-(tim_data6.ph/2));// sprite y axis position
	
	TestSprite6.x = 10;
	TestSprite6.y = 55;
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite6.w = (tim_data6.pw*2);				// sprite width
	TestSprite6.h = tim_data6.ph;					// sprite height
	TestSprite6.tpage = GetTPage(1,0, tim_data6.px, tim_data6.py);
	TestSprite6.u = 0;									// Texture page offset x axis
	TestSprite6.v = 0;									// Texture page offset y axis
	TestSprite6.cx = tim_data6.cx;					// CLUT x axis position
	TestSprite6.cy = tim_data6.cy;					// CLUT y axis position
	TestSprite6.r = 128;								// Regular brightness
	TestSprite6.g = 128;								// Regular brightness
	TestSprite6.b = 128;								// Regular brightness
	TestSprite6.mx = 0;								//
	TestSprite6.my = 0;								//
	TestSprite6.scalex = ONE;						// Defined as 4096
	TestSprite6.scaley = ONE;						// Defined as 4096
	TestSprite6.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}
	
	//
// Sprite7 initialisation routine
//

void InitSprite7()
	{
	RECT		rect7;								// Define RECT structure
	GsIMAGE	tim_data7;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd7+4),&tim_data7);

	// Load the image into the frame buffer
	rect7.x = tim_data7.px;							// x pos in frame buffer
	rect7.y = tim_data7.py;							// y pos in frame buffer
	rect7.w = tim_data7.pw;							// width of image
	rect7.h = tim_data7.ph;							// height of image
	LoadImage(&rect7, tim_data7.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect7.x = tim_data7.cx;							// x pos in frame buffer
	rect7.y = tim_data7.cy;							// y pos in frame buffer
	rect7.w = tim_data7.cw;							// width of CLUT
	rect7.h = tim_data7.ch;							// height of CLUT
	LoadImage(&rect7, tim_data7.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite7.attribute = 0x01000000;						// sprite attribute - 8 bit
//	TestSprite7.x = ((SCREEN_WIDTH/2)-(tim_data7.pw));		// sprite x axis position
//	TestSprite7.y = ((SCREEN_HEIGHT/2)-(tim_data7.ph/2));// sprite y axis position
	
	TestSprite7.x = 295;
	TestSprite7.y =	55;
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite7.w = (tim_data7.pw*2);				// sprite width
	TestSprite7.h = tim_data7.ph;					// sprite height
	TestSprite7.tpage = GetTPage(1,0, tim_data7.px, tim_data7.py);
	TestSprite7.u = 0;									// Texture page offset x axis
	TestSprite7.v = 0;									// Texture page offset y axis
	TestSprite7.cx = tim_data7.cx;					// CLUT x axis position
	TestSprite7.cy = tim_data7.cy;					// CLUT y axis position
	TestSprite7.r = 128;								// Regular brightness
	TestSprite7.g = 128;								// Regular brightness
	TestSprite7.b = 128;								// Regular brightness
	TestSprite7.mx = 0;								//
	TestSprite7.my = 0;								//
	TestSprite7.scalex = ONE;						// Defined as 4096
	TestSprite7.scaley = ONE;						// Defined as 4096
	TestSprite7.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}
	
//
// Sprite8 initialisation routine
//

void InitSprite8()
	{
	RECT		rect8;								// Define RECT structure
	GsIMAGE	tim_data8;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd8+4),&tim_data8);

	// Load the image into the frame buffer
	rect8.x = tim_data8.px;							// x pos in frame buffer
	rect8.y = tim_data8.py;							// y pos in frame buffer
	rect8.w = tim_data8.pw;							// width of image
	rect8.h = tim_data8.ph;							// height of image
	LoadImage(&rect8, tim_data8.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect8.x = tim_data8.cx;							// x pos in frame buffer
	rect8.y = tim_data8.cy;							// y pos in frame buffer
	rect8.w = tim_data8.cw;							// width of CLUT
	rect8.h = tim_data8.ch;							// height of CLUT
	LoadImage(&rect8, tim_data8.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite8.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite8.x = 0;		// sprite x axis position
	TestSprite8.y = 0;// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite8.w = (tim_data8.pw*2);				// sprite width
	TestSprite8.h = tim_data8.ph;					// sprite height
	TestSprite8.tpage = GetTPage(1,0, tim_data8.px, tim_data8.py);
	TestSprite8.u = 0;									// Texture page offset x axis
	TestSprite8.v = 0;									// Texture page offset y axis
	TestSprite8.cx = tim_data8.cx;					// CLUT x axis position
	TestSprite8.cy = tim_data8.cy;					// CLUT y axis position
	TestSprite8.r = 128;								// Regular brightness
	TestSprite8.g = 128;								// Regular brightness
	TestSprite8.b = 128;								// Regular brightness
	TestSprite8.mx = 0;								//
	TestSprite8.my = 0;								//
	TestSprite8.scalex = ONE;						// Defined as 4096
	TestSprite8.scaley = ONE;						// Defined as 4096
	TestSprite8.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}
	
//
// Sprite9 initialisation routine
//

void InitSprite9()
	{
	RECT		rect9;								// Define RECT structure
	GsIMAGE	tim_data9;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd9+4),&tim_data9);

	// Load the image into the frame buffer
	rect9.x = tim_data9.px;							// x pos in frame buffer
	rect9.y = tim_data9.py;							// y pos in frame buffer
	rect9.w = tim_data9.pw;							// width of image
	rect9.h = tim_data9.ph;							// height of image
	LoadImage(&rect9, tim_data9.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect9.x = tim_data9.cx;							// x pos in frame buffer
	rect9.y = tim_data9.cy;							// y pos in frame buffer
	rect9.w = tim_data9.cw;							// width of CLUT
	rect9.h = tim_data9.ch;							// height of CLUT
	LoadImage(&rect9, tim_data9.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite9.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite9.x = 160;		// sprite x axis position
	TestSprite9.y = 0;		// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite9.w = (tim_data9.pw*2);				// sprite width
	TestSprite9.h = tim_data9.ph;					// sprite height
	TestSprite9.tpage = GetTPage(1,0, tim_data9.px, tim_data9.py);
	TestSprite9.u = 0;									// Texture page offset x axis
	TestSprite9.v = 0;									// Texture page offset y axis
	TestSprite9.cx = tim_data9.cx;					// CLUT x axis position
	TestSprite9.cy = tim_data9.cy;					// CLUT y axis position
	TestSprite9.r = 128;								// Regular brightness
	TestSprite9.g = 128;								// Regular brightness
	TestSprite9.b = 128;								// Regular brightness
	TestSprite9.mx = 0;								//
	TestSprite9.my = 0;								//
	TestSprite9.scalex = ONE;						// Defined as 4096
	TestSprite9.scaley = ONE;						// Defined as 4096
	TestSprite9.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}
	
	
//
// Sprite10 initialisation routine
//

void InitSprite10()
	{
	RECT		rect10;								// Define RECT structure
	GsIMAGE	tim_data10;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd10+4),&tim_data10);

	// Load the image into the frame buffer
	rect10.x = tim_data10.px;							// x pos in frame buffer
	rect10.y = tim_data10.py;							// y pos in frame buffer
	rect10.w = tim_data10.pw;							// width of image
	rect10.h = tim_data10.ph;							// height of image
	LoadImage(&rect10, tim_data10.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect10.x = tim_data10.cx;							// x pos in frame buffer
	rect10.y = tim_data10.cy;							// y pos in frame buffer
	rect10.w = tim_data10.cw;							// width of CLUT
	rect10.h = tim_data10.ch;							// height of CLUT
	LoadImage(&rect10, tim_data10.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite10.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite10.x = 295;  //((SCREEN_WIDTH/2)-(tim_data10.pw));		// sprite x axis position
	TestSprite10.y = 55;   //((SCREEN_HEIGHT/2)-(tim_data10.ph/2));// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite10.w = (tim_data10.pw*2);				// sprite width
	TestSprite10.h = tim_data10.ph;					// sprite height
	TestSprite10.tpage = GetTPage(1,0, tim_data10.px, tim_data10.py);
	TestSprite10.u = 0;									// Texture page offset x axis
	TestSprite10.v = 0;									// Texture page offset y axis
	TestSprite10.cx = tim_data10.cx;					// CLUT x axis position
	TestSprite10.cy = tim_data10.cy;					// CLUT y axis position
	TestSprite10.r = 128;								// Regular brightness
	TestSprite10.g = 128;								// Regular brightness
	TestSprite10.b = 128;								// Regular brightness
	TestSprite10.mx = 0;								//
	TestSprite10.my = 0;								//
	TestSprite10.scalex = ONE;						// Defined as 4096
	TestSprite10.scaley = ONE;						// Defined as 4096
	TestSprite10.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}
	
	
//
// Sprite11 initialisation routine
//

void InitSprite11()
	{
	RECT		rect11;								// Define RECT structure
	GsIMAGE	tim_data11;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd11+4),&tim_data11);

	// Load the image into the frame buffer
	rect11.x = tim_data11.px;							// x pos in frame buffer
	rect11.y = tim_data11.py;							// y pos in frame buffer
	rect11.w = tim_data11.pw;							// width of image
	rect11.h = tim_data11.ph;							// height of image
	LoadImage(&rect11, tim_data11.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect11.x = tim_data11.cx;							// x pos in frame buffer
	rect11.y = tim_data11.cy;							// y pos in frame buffer
	rect11.w = tim_data11.cw;							// width of CLUT
	rect11.h = tim_data11.ch;							// height of CLUT
	LoadImage(&rect11, tim_data11.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite11.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite11.x = 10;   //((SCREEN_WIDTH/2)-(tim_data11.pw));		// sprite x axis position
	TestSprite11.y = 55;   //((SCREEN_HEIGHT/2)-(tim_data11.ph/2));// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite11.w = (tim_data11.pw*2);				// sprite width
	TestSprite11.h = tim_data11.ph;					// sprite height
	TestSprite11.tpage = GetTPage(1,0, tim_data11.px, tim_data11.py);
	TestSprite11.u = 0;									// Texture page offset x axis
	TestSprite11.v = 0;									// Texture page offset y axis
	TestSprite11.cx = tim_data11.cx;					// CLUT x axis position
	TestSprite11.cy = tim_data11.cy;					// CLUT y axis position
	TestSprite11.r = 128;								// Regular brightness
	TestSprite11.g = 128;								// Regular brightness
	TestSprite11.b = 128;								// Regular brightness
	TestSprite11.mx = 0;								//
	TestSprite11.my = 0;								//
	TestSprite11.scalex = ONE;						// Defined as 4096
	TestSprite11.scaley = ONE;						// Defined as 4096
	TestSprite11.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}

//
// Sprite12 initialisation routine 
//

void InitSprite12()
	{
	RECT		rect12;								// Define RECT structure
	GsIMAGE	tim_data12;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd12+4),&tim_data12);

	// Load the image into the frame buffer
	rect12.x = tim_data12.px;							// x pos in frame buffer
	rect12.y = tim_data12.py;							// y pos in frame buffer
	rect12.w = tim_data12.pw;							// width of image
	rect12.h = tim_data12.ph;							// height of image
	LoadImage(&rect12, tim_data12.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect12.x = tim_data12.cx;							// x pos in frame buffer
	rect12.y = tim_data12.cy;							// y pos in frame buffer
	rect12.w = tim_data12.cw;							// width of CLUT
	rect12.h = tim_data12.ch;							// height of CLUT
	LoadImage(&rect12, tim_data12.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite12.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite12.x = ((SCREEN_WIDTH/2)-(tim_data12.pw));		// sprite x axis position
	TestSprite12.y = ((SCREEN_HEIGHT/2)-(tim_data12.ph/2));// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite12.w = (tim_data12.pw*2);				// sprite width
	TestSprite12.h = tim_data12.ph;					// sprite height
	TestSprite12.tpage = GetTPage(1,0, tim_data12.px, tim_data12.py);
	TestSprite12.u = 0;								// Texture page offset x axis
	TestSprite12.v = 0;								// Texture page offset y axis
	TestSprite12.cx = tim_data12.cx;					// CLUT x axis position
	TestSprite12.cy = tim_data12.cy;					// CLUT y axis position
	TestSprite12.r = 128;								// Regular brightness
	TestSprite12.g = 128;								// Regular brightness
	TestSprite12.b = 128;								// Regular brightness
	TestSprite12.mx = 0;								//
	TestSprite12.my = 0;								//
	TestSprite12.scalex = ONE;						// Defined as 4096
	TestSprite12.scaley = ONE;						// Defined as 4096
	TestSprite12.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}	
	
//
// Sprite13 initialisation routine 
//

void InitSprite13()
	{
	RECT		rect13;								// Define RECT structure
	GsIMAGE	tim_data13;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd13+4),&tim_data13);

	// Load the image into the frame buffer
	rect13.x = tim_data13.px;							// x pos in frame buffer
	rect13.y = tim_data13.py;							// y pos in frame buffer
	rect13.w = tim_data13.pw;							// width of image
	rect13.h = tim_data13.ph;							// height of image
	LoadImage(&rect13, tim_data13.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect13.x = tim_data13.cx;							// x pos in frame buffer
	rect13.y = tim_data13.cy;							// y pos in frame buffer
	rect13.w = tim_data13.cw;							// width of CLUT
	rect13.h = tim_data13.ch;							// height of CLUT
	LoadImage(&rect13, tim_data13.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite13.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite13.x = ((SCREEN_WIDTH/2)-(tim_data13.pw));		// sprite x axis position
	TestSprite13.y = ((SCREEN_HEIGHT/2)-(tim_data13.ph/2));// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite13.w = (tim_data13.pw*2);				// sprite width
	TestSprite13.h = tim_data13.ph;					// sprite height
	TestSprite13.tpage = GetTPage(1,0, tim_data13.px, tim_data13.py);
	TestSprite13.u = 0;								// Texture page offset x axis
	TestSprite13.v = 0;								// Texture page offset y axis
	TestSprite13.cx = tim_data13.cx;					// CLUT x axis position
	TestSprite13.cy = tim_data13.cy;					// CLUT y axis position
	TestSprite13.r = 128;								// Regular brightness
	TestSprite13.g = 128;								// Regular brightness
	TestSprite13.b = 128;								// Regular brightness
	TestSprite13.mx = 0;								//
	TestSprite13.my = 0;								//
	TestSprite13.scalex = ONE;						// Defined as 4096
	TestSprite13.scaley = ONE;						// Defined as 4096
	TestSprite13.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}	
	
//
// Sprite14 initialisation routine 
//

void InitSprite14()
	{
	RECT		rect14;								// Define RECT structure
	GsIMAGE	tim_data14;							// Define GsIMAGE structure

	// Get the TIM file info - skip 4 bytes from start of file
	// to get to info we need
	GsGetTimInfo ((u_long *)(spriteAdd14+4),&tim_data14);

	// Load the image into the frame buffer
	rect14.x = tim_data14.px;							// x pos in frame buffer
	rect14.y = tim_data14.py;							// y pos in frame buffer
	rect14.w = tim_data14.pw;							// width of image
	rect14.h = tim_data14.ph;							// height of image
	LoadImage(&rect14, tim_data14.pixel);				// load data into frame buffer

	// Load the CLUT into the frame buffer
	rect14.x = tim_data14.cx;							// x pos in frame buffer
	rect14.y = tim_data14.cy;							// y pos in frame buffer
	rect14.w = tim_data14.cw;							// width of CLUT
	rect14.h = tim_data14.ch;							// height of CLUT
	LoadImage(&rect14, tim_data14.clut);				// load data into frame buffer

	// Initialise sprite structure
	TestSprite14.attribute = 0x01000000;						// sprite attribute - 8 bit
	TestSprite14.x = ((SCREEN_WIDTH/2)-(tim_data14.pw));		// sprite x axis position
	TestSprite14.y = ((SCREEN_HEIGHT/2)-(tim_data14.ph/2));// sprite y axis position
	
	// The width of an 8 bit sprite is half that of a 16 bit hence the *2
	TestSprite14.w = (tim_data14.pw*2);				// sprite width
	TestSprite14.h = tim_data14.ph;					// sprite height
	TestSprite14.tpage = GetTPage(1,0, tim_data14.px, tim_data14.py);
	TestSprite14.u = 0;								// Texture page offset x axis
	TestSprite14.v = 0;								// Texture page offset y axis
	TestSprite14.cx = tim_data14.cx;					// CLUT x axis position
	TestSprite14.cy = tim_data14.cy;					// CLUT y axis position
	TestSprite14.r = 128;								// Regular brightness
	TestSprite14.g = 128;								// Regular brightness
	TestSprite14.b = 128;								// Regular brightness
	TestSprite14.mx = 0;								//
	TestSprite14.my = 0;								//
	TestSprite14.scalex = ONE;						// Defined as 4096
	TestSprite14.scaley = ONE;						// Defined as 4096
	TestSprite14.rotate = 0;							// No rotation

	// Wait until LoadImage() has finished before returning
	DrawSync(0);
	}	
	

////////////////////////////////////////////////////////////////////////////////////////////

//
// delay() function (used in open sequence)
//

void delay(int num)  // num passed = delay time
{
int count = 0;

while(count!=num)    // run until delay time is reached
	{
	count++;
	}
}


///////////////////////////////////////////////////////////////////////////////////////////

// -----------------------------------------------------------
// void InitGrid()   (Clear all grid locations to 0 un-owned)
// -----------------------------------------------------------

void InitGrid()
{

int gcnt = 0;

while(gcnt != 239)
	{
	grid[gcnt] = 0;
	gcnt++;
	}
}// end of void InitGrid()

///////////////////////////////////////////////////////////////////////////////////////////

// ---------------------------------
// void DrawGrid()
// ---------------------------------

void DrawGrid()
{

int ddraw;  // used to increase grid position check by 1 
int xpos;   // defines x co-ordinate left to right
int ypos;   // defines y co-ordinate top to bottom (ie.     55 = top row             )
		    //									   (sprites are 15 x 15 pixels  so...)
			//									   (55+15 = 70 = 2nd row down        )

// Row 1 (of 12)
xpos = 10;  // first x co-ordinate 
ypos = 55;  // 1st row (top row) 
ddraw = 0;  // Check grids 0 - 19
while(ddraw != 20)
	{
	if(grid[ddraw] == 1)        // If Grid is owned by Player 1
		{
		TestSprite10.x = xpos;  // Place P1 X at xpos
		TestSprite10.y = ypos;  //               ypos
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)   // Else if Grid is owned by Player 2
		{
		TestSprite11.x = xpos;  // Place P2 O at xpos
		TestSprite11.y = ypos;  //               ypos
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15; 
	ddraw++;
	}

// Row 2 (of 12)

xpos = 10;
ypos = 70;   // 2nd row down
ddraw = 20;  // Check grids 20 - 40
while(ddraw != 40)
	{
	if(grid[ddraw] == 1)
		{
		TestSprite10.x = xpos;
		TestSprite10.y = ypos;
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)
		{
		TestSprite11.x = xpos;
		TestSprite11.y = ypos;
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15;
	ddraw++;
	}

// Row 3 (of 12)

xpos = 10;
ypos = 85;   // 3rd row down
ddraw = 40;  // Check grids 40 - 60
while(ddraw != 60)
	{
	if(grid[ddraw] == 1)
		{
		TestSprite10.x = xpos;
		TestSprite10.y = ypos;
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)
		{
		TestSprite11.x = xpos;
		TestSprite11.y = ypos;
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15;
	ddraw++;
	}

// Row 4 (of 12)

xpos = 10;
ypos = 100;   // 4th row down
ddraw = 60;  // Check grids 60 - 80
while(ddraw != 80)
	{
	if(grid[ddraw] == 1)
		{
		TestSprite10.x = xpos;
		TestSprite10.y = ypos;
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)
		{
		TestSprite11.x = xpos;
		TestSprite11.y = ypos;
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15;
	ddraw++;
	}

// Row 5 (of 12)

xpos = 10;
ypos = 115;   // 5th row down
ddraw = 80;  // Check grids 80 - 100
while(ddraw != 100)
	{
	if(grid[ddraw] == 1)
		{
		TestSprite10.x = xpos;
		TestSprite10.y = ypos;
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)
		{
		TestSprite11.x = xpos;
		TestSprite11.y = ypos;
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15;
	ddraw++;
	}

// Row 6 (of 12)

xpos = 10;
ypos = 130;   // 6th row down
ddraw = 100;  // Check grids 100 - 120
while(ddraw != 120)
	{
	if(grid[ddraw] == 1)
		{
		TestSprite10.x = xpos;
		TestSprite10.y = ypos;
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)
		{
		TestSprite11.x = xpos;
		TestSprite11.y = ypos;
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15;
	ddraw++;
	}

// Row 7 (of 12)
xpos = 10;  // first x co-ordinate 
ypos = 145;  // 7th row (top row) 
ddraw = 120;  // Check grids 120 - 140
while(ddraw != 140)
	{
	if(grid[ddraw] == 1)        // If Grid is owned by Player 1
		{
		TestSprite10.x = xpos;  // Place P1 X at xpos
		TestSprite10.y = ypos;  //               ypos
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)   // Else if Grid is owned by Player 2
		{
		TestSprite11.x = xpos;  // Place P2 O at xpos
		TestSprite11.y = ypos;  //               ypos
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15; 
	ddraw++;
	}

// Row 8 (of 12)

xpos = 10;
ypos = 160;   // 8th row down
ddraw = 140;  // Check grids 140 - 160
while(ddraw != 160)
	{
	if(grid[ddraw] == 1)
		{
		TestSprite10.x = xpos;
		TestSprite10.y = ypos;
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)
		{
		TestSprite11.x = xpos;
		TestSprite11.y = ypos;
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15;
	ddraw++;
	}

// Row 9 (of 12)

xpos = 10;
ypos = 175;   // 9th row down
ddraw = 160;  // Check grids 160 - 180
while(ddraw != 180)
	{
	if(grid[ddraw] == 1)
		{
		TestSprite10.x = xpos;
		TestSprite10.y = ypos;
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)
		{
		TestSprite11.x = xpos;
		TestSprite11.y = ypos;
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15;
	ddraw++;
	}

// Row 10 (of 12)

xpos = 10;
ypos = 190;   // 10th row down
ddraw = 180;  // Check grids 180 - 200
while(ddraw != 200)
	{
	if(grid[ddraw] == 1)
		{
		TestSprite10.x = xpos;
		TestSprite10.y = ypos;
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)
		{
		TestSprite11.x = xpos;
		TestSprite11.y = ypos;
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15;
	ddraw++;
	}

// Row 11 (of 12)

xpos = 10;
ypos = 205;   // 5th row down
ddraw = 200;  // Check grids 200 - 220
while(ddraw != 220)
	{
	if(grid[ddraw] == 1)
		{
		TestSprite10.x = xpos;
		TestSprite10.y = ypos;
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)
		{
		TestSprite11.x = xpos;
		TestSprite11.y = ypos;
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15;
	ddraw++;
	}

// Row 12 (of 12)

xpos = 10;
ypos = 220;   // 12th row down
ddraw = 220;  // Check grids 220 - 240
while(ddraw != 240)
	{
	if(grid[ddraw] == 1)
		{
		TestSprite10.x = xpos;
		TestSprite10.y = ypos;
		
		GsSortFastSprite(&TestSprite10, &WorldOT[activeBuff],2);
		}
	
	else if(grid[ddraw] == 2)
		{
		TestSprite11.x = xpos;
		TestSprite11.y = ypos;
		
		GsSortFastSprite(&TestSprite11, &WorldOT[activeBuff],2);
		}
		
	xpos=xpos+15;
	ddraw++;
	}

}// end of void DrawGrid()

/////////////////////////////////////////////////////////////////////////////////////////////

// ------------------------------------------
// void DrawO(int number)
// ------------------------------------------

void DrawO(int number)
{

if(grid[number] == 0)
	{
	grid[number] = 2;
	CheckP2Score();
	run++;
	swap = 0;
	}

}// end of void DrawO(int number)

////////////////////////////////////////////////////////////////////////////////////////////

// ---------------------------------
// void DrawX(int number)
// ---------------------------------

void DrawX(int number)
{

if(grid[number] == 0)
	{
	grid[number] = 1;
	CheckP1Score();
	run++;
	swap = 1;
	}

}// end of void DrawX(int number)

/////////////////////////////////////////////////////////////////////////////////////////////

// ---------------------------
// Opening Sequence
// ---------------------------

void opentitle()
{

while (Quit != 2)
	{	
		
		// Find out which buffer is being used
		activeBuff = GsGetActiveBuff();

		// Packet area
		GsSetWorkBase((PACKET *)GpuPacketArea[activeBuff]);

		// Clear the ordering table
		GsClearOt(0,0,&WorldOT[activeBuff]);
		
  		// Register sprite into ordering table
		// Uses GsSortFastSprite for speed - no rotation/scaling needed
		GsSortFastSprite(&TestSprite,&WorldOT[activeBuff],0);
		
		// Wait for all drawing to finish
		DrawSync(0);

		// Wait for vertical blank interrupt
		VSync(0);

		// Switch display buffer & offscreen buffer
		GsSwapDispBuff();

		// Sort the ordering table
		GsSortClear(0,0,0,&WorldOT[activeBuff]);

		// Draw the objects registered in the Ordering table
		GsDrawOt(&WorldOT[activeBuff]);	
		
		Quit++;
		
	}	

// clear sprite1 and draw sprite2
	
	delay(4000000);    // call to delay function to pause program
					   // so last image is held on screen for a moment
	Quit=0;
	
	while (Quit != 2)
	{	
		// Find out which buffer is being used
		activeBuff = GsGetActiveBuff();

		// Packet area
		GsSetWorkBase((PACKET *)GpuPacketArea[activeBuff]);

		// Clear the ordering table
		GsClearOt(0,0,&WorldOT[activeBuff]);
		
  		// Register sprite into ordering table
		// Uses GsSortFastSprite for speed - no rotation/scaling needed
		GsSortFastSprite(&TestSprite2,&WorldOT[activeBuff],0);
		
		// Wait for all drawing to finish
		DrawSync(0);

		// Wait for vertical blank interrupt
		VSync(0);

		// Switch display buffer & offscreen buffer
		GsSwapDispBuff();

		// Sort the ordering table
		GsSortClear(0,0,0,&WorldOT[activeBuff]);

		// Draw the objects registered in the Ordering table
		GsDrawOt(&WorldOT[activeBuff]);	
		
		Quit++;
		
	}	


	// clear sprite2 and draw sprite3
	
	delay(4000000);    // call to delay function to pause program
					   // so last image is held on screen for a moment
	Quit=0;
	
	while (Quit != 40)
	{	
		
		TestSprite3.scalex=TestSprite3.scaley+=100;  // scale sprite 3 up
		if (TestSprite3.scaley>8096) TestSprite3.scaley=TestSprite3.scalex=8096;
		
		// Find out which buffer is being used
		activeBuff = GsGetActiveBuff();

		// Packet area
		GsSetWorkBase((PACKET *)GpuPacketArea[activeBuff]);

		// Clear the ordering table
		GsClearOt(0,0,&WorldOT[activeBuff]);
		
  		// Register sprite into ordering table
		// Uses GsSortFastSprite for speed - no rotation/scaling needed
		GsSortSprite(&TestSprite3,&WorldOT[activeBuff],0);
		
		// Wait for all drawing to finish
		DrawSync(0);

		// Wait for vertical blank interrupt
		VSync(0);

		// Switch display buffer & offscreen buffer
		GsSwapDispBuff();

		// Sort the ordering table
		GsSortClear(0,0,0,&WorldOT[activeBuff]);

		// Draw the objects registered in the Ordering table
		GsDrawOt(&WorldOT[activeBuff]);	
		
		delay(2000);
		
		Quit++;
		
	}	

	delay(2000000);    // call to delay function to pause program
					   // so last image is held on screen for a moment
	Quit=0;
	
	while (Quit != 80)
	{	
		
		TestSprite3.x+=5; // scroll sprite 3 right
		
		// Find out which buffer is being used
		activeBuff = GsGetActiveBuff();

		// Packet area
		GsSetWorkBase((PACKET *)GpuPacketArea[activeBuff]);

		// Clear the ordering table
		GsClearOt(0,0,&WorldOT[activeBuff]);
		
  		// Register sprite into ordering table
		// Uses GsSortFastSprite for speed - no rotation/scaling needed
		GsSortSprite(&TestSprite3,&WorldOT[activeBuff],0);
		
		// Wait for all drawing to finish
		DrawSync(0);

		// Wait for vertical blank interrupt
		VSync(0);

		// Switch display buffer & offscreen buffer
		GsSwapDispBuff();

		// Sort the ordering table
		GsSortClear(0,0,0,&WorldOT[activeBuff]);

		// Draw the objects registered in the Ordering table
		GsDrawOt(&WorldOT[activeBuff]);	
		
		delay(2000);
		
		Quit++;
		
	}	
	
	FadeSprite4In();
	
	Quit=0;
	
	while(Quit!=1)
	{
	FlashSprite5();
	}
	
	FadeSprite4Out();
	
	delay(2000);
	
	InitGame();   // Call to start game
				
} // end of opentitle()


//////////////////////////////////////////////////////////////////////////////////////////

// -------------------------------------
// void FadeSprite4Out()
// -------------------------------------

void FadeSprite4Out()
{

int fade = 0;

while(fade!= 128)
	{
	
	TestSprite4.r--;								
	TestSprite4.g--;
	TestSprite4.b--;								
	
	// Find out which buffer is being used
		activeBuff = GsGetActiveBuff();
	
	// Clear the ordering table
		GsClearOt(0,0,&WorldOT[activeBuff]);
		
  	// Register sprite into ordering table
	// Uses GsSortFastSprite for speed - no rotation/scaling needed
		GsSortFastSprite(&TestSprite4,&WorldOT[activeBuff],0);
	
	// Wait for all drawing to finish
		DrawSync(0);

	// Wait for vertical blank interrupt
		VSync(0);
		
	// Switch display buffer & offscreen buffer
		GsSwapDispBuff();

		// Sort the ordering table
	GsSortClear(0,0,0,&WorldOT[activeBuff]);
	
	// Draw the objects registered in the Ordering table
		GsDrawOt(&WorldOT[activeBuff]);	
	
	fade++;
	}
	
}// end of FadeSprite4Out()

/////////////////////////////////////////////////////////////////////////////////////////////

// -------------------------------------
// void FadeSprite4In()
// -------------------------------------

void FadeSprite4In()
{

int fade = 0;

while(fade!= 128)
	{
	
	TestSprite4.r++;								
	TestSprite4.g++;
	TestSprite4.b++;								
	
	// Find out which buffer is being used
		activeBuff = GsGetActiveBuff();
	
	// Clear the ordering table
		GsClearOt(0,0,&WorldOT[activeBuff]);
		
  	// Register sprite into ordering table
	// Uses GsSortFastSprite for speed - no rotation/scaling needed
		GsSortFastSprite(&TestSprite4,&WorldOT[activeBuff],0);
	
	// Wait for all drawing to finish
		DrawSync(0);

	// Wait for vertical blank interrupt
		VSync(0);
		
	// Switch display buffer & offscreen buffer
		GsSwapDispBuff();

		// Sort the ordering table
	GsSortClear(0,0,0,&WorldOT[activeBuff]);
	
	// Draw the objects registered in the Ordering table
		GsDrawOt(&WorldOT[activeBuff]);	
	
	fade++;
	}
	
}// end of FadeSprite4In()

////////////////////////////////////////////////////////////////////////////////////////////

// --------------------
// void FlashSprite5()
// --------------------

void FlashSprite5()
{

int flash = 0;

while(flash != 32 && Quit !=1)
	{
	
	TestSprite5.r--;								
	TestSprite5.g--;
	TestSprite5.b--;								
	TestSprite5.r--;								
	TestSprite5.g--;
	TestSprite5.b--;	
	
	Pad1 = PadRead(1);		// Read in input data from Pad 1 
  //Pad2 = PadRead(2);		// Read in input data from Pad 1
	
	if  (Pad1 & PADSTART)   // if user pressed START on Pad1
		{
		flash=32;
		Quit=1;		
		} 
	
	// Find out which buffer is being used
		activeBuff = GsGetActiveBuff();
	
	// Clear the ordering table
		GsClearOt(0,0,&WorldOT[activeBuff]);
		
  	// Register sprite into ordering table
	// Uses GsSortFastSprite for speed - no rotation/scaling needed
	   GsSortFastSprite(&TestSprite4,&WorldOT[activeBuff],0);
	   GsSortFastSprite(&TestSprite5,&WorldOT[activeBuff],0);
	
	// Wait for all drawing to finish
		DrawSync(0);

	// Wait for vertical blank interrupt
		VSync(0);
		
	// Switch display buffer & offscreen buffer
		GsSwapDispBuff();

		// Sort the ordering table
	GsSortClear(0,0,0,&WorldOT[activeBuff]);
	
	// Draw the objects registered in the Ordering table
		GsDrawOt(&WorldOT[activeBuff]);	
	
	flash++;
	}
	
	flash = 0;
	
	while(flash != 32 && Quit !=1)
	{
	
	TestSprite5.r++;								
	TestSprite5.g++;
	TestSprite5.b++;								
	TestSprite5.r++;								
	TestSprite5.g++;
	TestSprite5.b++;
	
	Pad1 = PadRead(1);		// Read in input data from Pad 1 
  //Pad2 = PadRead(2);		// Read in input data from Pad 2
	
	if  (Pad1 & PADSTART)   // if user pressed START on Pad1
		{
		flash=32;
		Quit=1;		
		} 
	
	// Find out which buffer is being used
		activeBuff = GsGetActiveBuff();
	
	// Clear the ordering table
		GsClearOt(0,0,&WorldOT[activeBuff]);
		
  	// Register sprite into ordering table
	// Uses GsSortFastSprite for speed - no rotation/scaling needed
	   GsSortFastSprite(&TestSprite4,&WorldOT[activeBuff],0);
	   GsSortFastSprite(&TestSprite5,&WorldOT[activeBuff],0);
	
	// Wait for all drawing to finish
		DrawSync(0);

	// Wait for vertical blank interrupt
		VSync(0);
		
	// Switch display buffer & offscreen buffer
		GsSwapDispBuff();

		// Sort the ordering table
	GsSortClear(0,0,0,&WorldOT[activeBuff]);
	
	// Draw the objects registered in the Ordering table
		GsDrawOt(&WorldOT[activeBuff]);	
	
	flash++;
	}
	
}// end of FlashSprite5()

////////////////////////////////////////////////////////////////////////////////////////

// ----------------------------
// void SomePad1()
// ----------------------------

void SomePad1()
{
			
			if	(Pad1 & PADSTART && Pad1 & PADSELECT)
				{
					run=240;
				}
			
			
			if  (Pad1 & PADRIGHT)
				{
					if(P1screenx != 19)
						{
						TestSprite6.x+=15;
						P1screenx++;
						delay(80000);
						}
				} 
			if  (Pad1 & PADLEFT)
				{
					if(P1screenx != 0)
						{
						TestSprite6.x-=15;
						P1screenx--;
						delay(80000);
						}	
				} 		
			if  (Pad1 & PADDOWN)
				{
					if(P1screeny != 11)
						{
						TestSprite6.y+=15;
						P1screeny++;
						delay(80000);
						}
				} 
			if  (Pad1 & PADUP)
				{
					if(P1screeny != 0)
						{
						TestSprite6.y-=15;
						P1screeny--;
						delay(80000);
						}
				} 


			//  Place an X at current position and swap control to P1
			if (Pad1 & PADX)
				{
				GetGridNumberP1();
				DrawX(gridnumber);
				}
}// end of void SomePad1()

////////////////////////////////////////////////////////////////////////////////////////////

// ----------------------------
// void SomePad2()
// ----------------------------

void SomePad2()
{
			
			if  (Pad2 & PADRIGHT)
				{
					if(P2screenx != 0)
						{
						TestSprite7.x+=15;
						P2screenx--;
						delay(80000);
						}
				} 
			if  (Pad2 & PADLEFT)
				{
					if(P2screenx != 19)
						{
						TestSprite7.x-=15;
						P2screenx++;
						delay(80000);
						}	
				} 		
			if  (Pad2 & PADDOWN)
				{
					if(P2screeny != 11)
						{
						TestSprite7.y+=15;
						P2screeny++;
						delay(80000);
						}
				} 
			if  (Pad2 & PADUP)
				{
					if(P2screeny != 0)
						{
						TestSprite7.y-=15;
						P2screeny--;
						delay(80000);
						}
				} 


			// Place an O at current position and swap control to P1
			if (Pad2 & PADX)
				{
				GetGridNumberP2();
				DrawO(gridnumber);	
				}
}// end of void SomePad2()


////////////////////////////////////////////////////////////////////////////////////////////

// --------------------------------------
// void InitGame()
// --------------------------------------

void InitGame()
{

run = 0;
p1score = 0;
p2score = 0;

while(run != 240)
	{	
	
	// Find out which buffer is being used
			activeBuff = GsGetActiveBuff();
	
//**********************************************************************
//     FOR ANYONE WHO HAS VISITED MY WEBSITE, THIS NEXT LINE OF
//    CODE WAS ORIGINALLY MISSING WHICH CAUSED THE GAME TO CRASH
//    FOR NO APPARENT REASON. (REMOVE IT AND SEE WHAT HAPPENS !)
//    I DISCOVERED THIS BY CALLING InitGame() BEFORE OpenTitle()
//      FROM main() AND THE GAME SCREEN DIDN'T DISPLAY AT ALL. 
	
	// Packet area (VERY IMPORTANT !!)
	
	GsSetWorkBase((PACKET *)GpuPacketArea[activeBuff]);

//**********************************************************************
	
	// Clear the ordering table
			GsClearOt(0,0,&WorldOT[activeBuff]);
	
	if(swap == 0)
		{
		Pad1 = PadRead(1);		// Read in input data from Pad 1 
	
		if (Pad1 != 0)          // if a key on pad 1 has been pressed...
			{
				SomePad1();  
			}
  		
	   	GsSortSprite(&TestSprite6,&WorldOT[activeBuff],1);
   		}

	if(swap == 1)
		{
		Pad2 = PadRead(2);		// Read in input data from Pad 2 
	
		if (Pad2 != 0)          // if a key on pad 2 has been pressed...
			{
				SomePad2();  
			}
	   		
	    GsSortSprite(&TestSprite7,&WorldOT[activeBuff],1);
   		}

	GsSortFastSprite(&TestSprite8,&WorldOT[activeBuff],3);
	GsSortFastSprite(&TestSprite9,&WorldOT[activeBuff],3);
	
	DrawGrid();
   	
   	// Wait for all drawing to finish
		DrawSync(0);

	// Wait for vertical blank interrupt
		VSync(0);
	
	// Switch display buffer & offscreen buffer
		GsSwapDispBuff();

	// Sort the ordering table
		GsSortClear(0,0,0,&WorldOT[activeBuff]);
		
	// Draw the objects registered in the Ordering table
		GsDrawOt(&WorldOT[activeBuff]);	
	
	/* Load basic font pattern in frame buffer */
	FntLoad(960, 256);	
	/* Font display location setting */
	FntOpen(5, 0, 320, 240, 0, 1024);	
	
	FntPrint("P1: %d\n\n",p1score);
	FntPrint("P2: %d",p2score);
	FntFlush(-1);
	
	}

DisplayWinner();
	
}// end of InitGame()


////////////////////////////////////////////////////////////////////////////////////

// ---------------------------------
// void GetGridNumberP1()
// ---------------------------------

void GetGridNumberP1()
{

// Row 1 (of 12)

if(TestSprite6.x == 10 && TestSprite6.y == 55)
	{
	gridnumber = 0;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 55)
	{
	gridnumber = 1;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 55)
	{
	gridnumber = 2;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 55)
	{
	gridnumber = 3;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 55)
	{
	gridnumber = 4;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 55)
	{
	gridnumber = 5;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 55)
	{
	gridnumber = 6;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 55)
	{
	gridnumber = 7;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 55)
	{
	gridnumber = 8;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 55)
	{
	gridnumber = 9;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 55)
	{
	gridnumber = 10;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 55)
	{
	gridnumber = 11;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 55)
	{
	gridnumber = 12;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 55)
	{
	gridnumber = 13;
	}	
if(TestSprite6.x == 220 && TestSprite6.y == 55)
	{
	gridnumber = 14;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 55)
	{
	gridnumber = 15;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 55)
	{
	gridnumber = 16;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 55)
	{
	gridnumber = 17;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 55)
	{
	gridnumber = 18;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 55)
	{
	gridnumber = 19;
	}

// Row 2 (of 12)

if(TestSprite6.x == 10 && TestSprite6.y == 70)
	{
	gridnumber = 20;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 70)
	{
	gridnumber = 21;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 70)
	{
	gridnumber = 22;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 70)
	{
	gridnumber = 23;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 70)
	{
	gridnumber = 24;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 70)
	{
	gridnumber = 25;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 70)
	{
	gridnumber = 26;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 70)
	{
	gridnumber = 27;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 70)
	{
	gridnumber = 28;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 70)
	{
	gridnumber = 29;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 70)
	{
	gridnumber = 30;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 70)
	{
	gridnumber = 31;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 70)
	{
	gridnumber = 32;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 70)
	{
	gridnumber = 33;
	}	
if(TestSprite6.x == 220 && TestSprite6.y == 70)
	{
	gridnumber = 34;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 70)
	{
	gridnumber = 35;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 70)
	{
	gridnumber = 36;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 70)
	{
	gridnumber = 37;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 70)
	{
	gridnumber = 38;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 70)
	{
	gridnumber = 39;
	}

// Row 3 (of 12)


if(TestSprite6.x == 10 && TestSprite6.y == 85)
	{
	gridnumber = 40;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 85)
	{
	gridnumber = 41;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 85)
	{
	gridnumber = 42;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 85)
	{
	gridnumber = 43;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 85)
	{
	gridnumber = 44;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 85)
	{
	gridnumber = 45;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 85)
	{
	gridnumber = 46;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 85)
	{
	gridnumber = 47;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 85)
	{
	gridnumber = 48;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 85)
	{
	gridnumber = 49;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 85)
	{
	gridnumber = 50;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 85)
	{
	gridnumber = 51;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 85)
	{
	gridnumber = 52;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 85)
	{
	gridnumber = 53;
	}	
if(TestSprite6.x == 220 && TestSprite6.y == 85)
	{
	gridnumber = 54;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 85)
	{
	gridnumber = 55;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 85)
	{
	gridnumber = 56;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 85)
	{
	gridnumber = 57;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 85)
	{
	gridnumber = 58;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 85)
	{
	gridnumber = 59;
	}

// Row 4 (of 12)

if(TestSprite6.x == 10 && TestSprite6.y == 100)
	{
	gridnumber = 60;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 100)
	{
	gridnumber = 61;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 100)
	{
	gridnumber = 62;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 100)
	{
	gridnumber = 63;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 100)
	{
	gridnumber = 64;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 100)
	{
	gridnumber = 65;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 100)
	{
	gridnumber = 66;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 100)
	{
	gridnumber = 67;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 100)
	{
	gridnumber = 68;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 100)
	{
	gridnumber = 69;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 100)
	{
	gridnumber = 70;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 100)
	{
	gridnumber = 71;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 100)
	{
	gridnumber = 72;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 100)
	{
	gridnumber = 73;
	}		
if(TestSprite6.x == 220 && TestSprite6.y == 100)
	{
	gridnumber = 74;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 100)
	{
	gridnumber = 75;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 100)
	{
	gridnumber = 76;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 100)
	{
	gridnumber = 77;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 100)
	{
	gridnumber = 78;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 100)
	{
	gridnumber = 79;
	}

// Row 5 (of 12)

if(TestSprite6.x == 10 && TestSprite6.y == 115)
	{
	gridnumber = 80;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 115)
	{
	gridnumber = 81;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 115)
	{
	gridnumber = 82;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 115)
	{
	gridnumber = 83;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 115)
	{
	gridnumber = 84;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 115)
	{
	gridnumber = 85;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 115)
	{
	gridnumber = 86;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 115)
	{
	gridnumber = 87;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 115)
	{
	gridnumber = 88;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 115)
	{
	gridnumber = 89;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 115)
	{
	gridnumber = 90;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 115)
	{
	gridnumber = 91;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 115)
	{
	gridnumber = 92;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 115)
	{
	gridnumber = 93;
	}		
if(TestSprite6.x == 220 && TestSprite6.y == 115)
	{
	gridnumber = 94;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 115)
	{
	gridnumber = 95;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 115)
	{
	gridnumber = 96;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 115)
	{
	gridnumber = 97;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 115)
	{
	gridnumber = 98;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 115)
	{
	gridnumber = 99;
	}

// Row 6 (of 12)

if(TestSprite6.x == 10 && TestSprite6.y == 130)
	{
	gridnumber = 100;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 130)
	{
	gridnumber = 101;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 130)
	{
	gridnumber = 102;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 130)
	{
	gridnumber = 103;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 130)
	{
	gridnumber = 104;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 130)
	{
	gridnumber = 105;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 130)
	{
	gridnumber = 106;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 130)
	{
	gridnumber = 107;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 130)
	{
	gridnumber = 108;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 130)
	{
	gridnumber = 109;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 130)
	{
	gridnumber = 110;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 130)
	{
	gridnumber = 111;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 130)
	{
	gridnumber = 112;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 130)
	{
	gridnumber = 113;
	}		
if(TestSprite6.x == 220 && TestSprite6.y == 130)
	{
	gridnumber = 114;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 130)
	{
	gridnumber = 115;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 130)
	{
	gridnumber = 116;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 130)
	{
	gridnumber = 117;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 130)
	{
	gridnumber = 118;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 130)
	{
	gridnumber = 119;
	}

// Row 7 (of 12)  **********************************
                

if(TestSprite6.x == 10 && TestSprite6.y == 145)
	{
	gridnumber = 120;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 145)
	{
	gridnumber = 121;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 145)
	{
	gridnumber = 122;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 145)
	{
	gridnumber = 123;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 145)
	{
	gridnumber = 124;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 145)
	{
	gridnumber = 125;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 145)
	{
	gridnumber = 126;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 145)
	{
	gridnumber = 127;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 145)
	{
	gridnumber = 128;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 145)
	{
	gridnumber = 129;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 145)
	{
	gridnumber = 130;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 145)
	{
	gridnumber = 131;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 145)
	{
	gridnumber = 132;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 145)
	{
	gridnumber = 133;
	}	
if(TestSprite6.x == 220 && TestSprite6.y == 145)
	{
	gridnumber = 134;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 145)
	{
	gridnumber = 135;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 145)
	{
	gridnumber = 136;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 145)
	{
	gridnumber = 137;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 145)
	{
	gridnumber = 138;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 145)
	{
	gridnumber = 139;
	}

// Row 8 (of 12)

if(TestSprite6.x == 10 && TestSprite6.y == 160)
	{
	gridnumber = 140;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 160)
	{
	gridnumber = 141;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 160)
	{
	gridnumber = 142;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 160)
	{
	gridnumber = 143;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 160)
	{
	gridnumber = 144;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 160)
	{
	gridnumber = 145;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 160)
	{
	gridnumber = 146;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 160)
	{
	gridnumber = 147;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 160)
	{
	gridnumber = 148;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 160)
	{
	gridnumber = 149;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 160)
	{
	gridnumber = 150;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 160)
	{
	gridnumber = 151;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 160)
	{
	gridnumber = 152;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 160)
	{
	gridnumber = 153;
	}	
if(TestSprite6.x == 220 && TestSprite6.y == 160)
	{
	gridnumber = 154;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 160)
	{
	gridnumber = 155;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 160)
	{
	gridnumber = 156;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 160)
	{
	gridnumber = 157;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 160)
	{
	gridnumber = 158;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 160)
	{
	gridnumber = 159;
	}

// Row 9 (of 12)


if(TestSprite6.x == 10 && TestSprite6.y == 175)
	{
	gridnumber = 160;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 175)
	{
	gridnumber = 161;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 175)
	{
	gridnumber = 162;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 175)
	{
	gridnumber = 163;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 175)
	{
	gridnumber = 164;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 175)
	{
	gridnumber = 165;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 175)
	{
	gridnumber = 166;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 175)
	{
	gridnumber = 167;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 175)
	{
	gridnumber = 168;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 175)
	{
	gridnumber = 169;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 175)
	{
	gridnumber = 170;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 175)
	{
	gridnumber = 171;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 175)
	{
	gridnumber = 172;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 175)
	{
	gridnumber = 173;
	}	
if(TestSprite6.x == 220 && TestSprite6.y == 175)
	{
	gridnumber = 174;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 175)
	{
	gridnumber = 175;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 175)
	{
	gridnumber = 176;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 175)
	{
	gridnumber = 177;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 175)
	{
	gridnumber = 178;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 175)
	{
	gridnumber = 179;
	}

// Row 10 (of 12)

if(TestSprite6.x == 10 && TestSprite6.y == 190)
	{
	gridnumber = 180;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 190)
	{
	gridnumber = 181;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 190)
	{
	gridnumber = 182;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 190)
	{
	gridnumber = 183;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 190)
	{
	gridnumber = 184;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 190)
	{
	gridnumber = 185;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 190)
	{
	gridnumber = 186;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 190)
	{
	gridnumber = 187;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 190)
	{
	gridnumber = 188;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 190)
	{
	gridnumber = 189;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 190)
	{
	gridnumber = 190;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 190)
	{
	gridnumber = 191;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 190)
	{
	gridnumber = 192;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 190)
	{
	gridnumber = 193;
	}		
if(TestSprite6.x == 220 && TestSprite6.y == 190)
	{
	gridnumber = 194;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 190)
	{
	gridnumber = 195;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 190)
	{
	gridnumber = 196;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 190)
	{
	gridnumber = 197;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 190)
	{
	gridnumber = 198;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 190)
	{
	gridnumber = 199;
	}

// Row 11 (of 12)

if(TestSprite6.x == 10 && TestSprite6.y == 205)
	{
	gridnumber = 200;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 205)
	{
	gridnumber = 201;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 205)
	{
	gridnumber = 202;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 205)
	{
	gridnumber = 203;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 205)
	{
	gridnumber = 204;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 205)
	{
	gridnumber = 205;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 205)
	{
	gridnumber = 206;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 205)
	{
	gridnumber = 207;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 205)
	{
	gridnumber = 208;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 205)
	{
	gridnumber = 209;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 205)
	{
	gridnumber = 210;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 205)
	{
	gridnumber = 211;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 205)
	{
	gridnumber = 212;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 205)
	{
	gridnumber = 213;
	}		
if(TestSprite6.x == 220 && TestSprite6.y == 205)
	{
	gridnumber = 214;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 205)
	{
	gridnumber = 215;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 205)
	{
	gridnumber = 216;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 205)
	{
	gridnumber = 217;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 205)
	{
	gridnumber = 218;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 205)
	{
	gridnumber = 219;
	}

// Row 12 (of 12)

if(TestSprite6.x == 10 && TestSprite6.y == 220)
	{
	gridnumber = 220;
	}
if(TestSprite6.x == 25 && TestSprite6.y == 220)
	{
	gridnumber = 221;
	}
if(TestSprite6.x == 40 && TestSprite6.y == 220)
	{
	gridnumber = 222;
	}
if(TestSprite6.x == 55 && TestSprite6.y == 220)
	{
	gridnumber = 223;
	}
if(TestSprite6.x == 70 && TestSprite6.y == 220)
	{
	gridnumber = 224;
	}
if(TestSprite6.x == 85 && TestSprite6.y == 220)
	{
	gridnumber = 225;
	}
if(TestSprite6.x == 100 && TestSprite6.y == 220)
	{
	gridnumber = 226;
	}	
if(TestSprite6.x == 115 && TestSprite6.y == 220)
	{
	gridnumber = 227;
	}
if(TestSprite6.x == 130 && TestSprite6.y == 220)
	{
	gridnumber = 228;
	}
if(TestSprite6.x == 145 && TestSprite6.y == 220)
	{
	gridnumber = 229;
	}
if(TestSprite6.x == 160 && TestSprite6.y == 220)
	{
	gridnumber = 230;
	}
if(TestSprite6.x == 175 && TestSprite6.y == 220)
	{
	gridnumber = 231;
	}
if(TestSprite6.x == 190 && TestSprite6.y == 220)
	{
	gridnumber = 232;
	}
if(TestSprite6.x == 205 && TestSprite6.y == 220)
	{
	gridnumber = 233;
	}		
if(TestSprite6.x == 220 && TestSprite6.y == 220)
	{
	gridnumber = 234;
	}
if(TestSprite6.x == 235 && TestSprite6.y == 220)
	{
	gridnumber = 235;
	}
if(TestSprite6.x == 250 && TestSprite6.y == 220)
	{
	gridnumber = 236;
	}
if(TestSprite6.x == 265 && TestSprite6.y == 220)
	{
	gridnumber = 237;
	}
if(TestSprite6.x == 280 && TestSprite6.y == 220)
	{
	gridnumber = 238;
	}
if(TestSprite6.x == 295 && TestSprite6.y == 220)
	{
	gridnumber = 239;
	}

}// end of void GetGridNumberP1()

////////////////////////////////////////////////////////////////////////////////////

// ---------------------------------
// void GetGridNumberP2()
// ---------------------------------

void GetGridNumberP2()
{

if(TestSprite7.x == 10 && TestSprite7.y == 55)
	{
	gridnumber = 0;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 55)
	{
	gridnumber = 1;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 55)
	{
	gridnumber = 2;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 55)
	{
	gridnumber = 3;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 55)
	{
	gridnumber = 4;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 55)
	{
	gridnumber = 5;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 55)
	{
	gridnumber = 6;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 55)
	{
	gridnumber = 7;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 55)
	{
	gridnumber = 8;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 55)
	{
	gridnumber = 9;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 55)
	{
	gridnumber = 10;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 55)
	{
	gridnumber = 11;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 55)
	{
	gridnumber = 12;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 55)
	{
	gridnumber = 13;
	}		
if(TestSprite7.x == 220 && TestSprite7.y == 55)
	{
	gridnumber = 14;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 55)
	{
	gridnumber = 15;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 55)
	{
	gridnumber = 16;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 55)
	{
	gridnumber = 17;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 55)
	{
	gridnumber = 18;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 55)
	{
	gridnumber = 19;
	}
	
// Row 2 (of 12)
if(TestSprite7.x == 10 && TestSprite7.y == 70)
	{
	gridnumber = 20;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 70)
	{
	gridnumber = 21;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 70)
	{
	gridnumber = 22;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 70)
	{
	gridnumber = 23;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 70)
	{
	gridnumber = 24;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 70)
	{
	gridnumber = 25;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 70)
	{
	gridnumber = 26;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 70)
	{
	gridnumber = 27;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 70)
	{
	gridnumber = 28;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 70)
	{
	gridnumber = 29;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 70)
	{
	gridnumber = 30;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 70)
	{
	gridnumber = 31;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 70)
	{
	gridnumber = 32;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 70)
	{
	gridnumber = 33;
	}		
if(TestSprite7.x == 220 && TestSprite7.y == 70)
	{
	gridnumber = 34;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 70)
	{
	gridnumber = 35;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 70)
	{
	gridnumber = 36;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 70)
	{
	gridnumber = 37;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 70)
	{
	gridnumber = 38;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 70)
	{
	gridnumber = 39;
	}

// Row 3 (of 12)

if(TestSprite7.x == 10 && TestSprite7.y == 85)
	{
	gridnumber = 40;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 85)
	{
	gridnumber = 41;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 85)
	{
	gridnumber = 42;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 85)
	{
	gridnumber = 43;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 85)
	{
	gridnumber = 44;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 85)
	{
	gridnumber = 45;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 85)
	{
	gridnumber = 46;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 85)
	{
	gridnumber = 47;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 85)
	{
	gridnumber = 48;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 85)
	{
	gridnumber = 49;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 85)
	{
	gridnumber = 50;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 85)
	{
	gridnumber = 51;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 85)
	{
	gridnumber = 52;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 85)
	{
	gridnumber = 53;
	}		
if(TestSprite7.x == 220 && TestSprite7.y == 85)
	{
	gridnumber = 54;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 85)
	{
	gridnumber = 55;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 85)
	{
	gridnumber = 56;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 85)
	{
	gridnumber = 57;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 85)
	{
	gridnumber = 58;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 85)
	{
	gridnumber = 59;
	}

// Row 4 (of 12)

if(TestSprite7.x == 10 && TestSprite7.y == 100)
	{
	gridnumber = 60;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 100)
	{
	gridnumber = 61;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 100)
	{
	gridnumber = 62;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 100)
	{
	gridnumber = 63;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 100)
	{
	gridnumber = 64;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 100)
	{
	gridnumber = 65;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 100)
	{
	gridnumber = 66;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 100)
	{
	gridnumber = 67;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 100)
	{
	gridnumber = 68;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 100)
	{
	gridnumber = 69;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 100)
	{
	gridnumber = 70;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 100)
	{
	gridnumber = 71;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 100)
	{
	gridnumber = 72;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 100)
	{
	gridnumber = 73;
	}		
if(TestSprite7.x == 220 && TestSprite7.y == 100)
	{
	gridnumber = 74;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 100)
	{
	gridnumber = 75;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 100)
	{
	gridnumber = 76;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 100)
	{
	gridnumber = 77;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 100)
	{
	gridnumber = 78;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 100)
	{
	gridnumber = 79;
	}

// Row 5 (of 12)

if(TestSprite7.x == 10 && TestSprite7.y == 115)
	{
	gridnumber = 80;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 115)
	{
	gridnumber = 81;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 115)
	{
	gridnumber = 82;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 115)
	{
	gridnumber = 83;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 115)
	{
	gridnumber = 84;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 115)
	{
	gridnumber = 85;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 115)
	{
	gridnumber = 86;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 115)
	{
	gridnumber = 87;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 115)
	{
	gridnumber = 88;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 115)
	{
	gridnumber = 89;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 115)
	{
	gridnumber = 90;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 115)
	{
	gridnumber = 91;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 115)
	{
	gridnumber = 92;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 115)
	{
	gridnumber = 93;
	}		
if(TestSprite7.x == 220 && TestSprite7.y == 115)
	{
	gridnumber = 94;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 115)
	{
	gridnumber = 95;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 115)
	{
	gridnumber = 96;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 115)
	{
	gridnumber = 97;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 115)
	{
	gridnumber = 98;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 115)
	{
	gridnumber = 99;
	}

// Row 6 (of 12)

if(TestSprite7.x == 10 && TestSprite7.y == 130)
	{
	gridnumber = 100;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 130)
	{
	gridnumber = 101;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 130)
	{
	gridnumber = 102;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 130)
	{
	gridnumber = 103;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 130)
	{
	gridnumber = 104;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 130)
	{
	gridnumber = 105;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 130)
	{
	gridnumber = 106;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 130)
	{
	gridnumber = 107;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 130)
	{
	gridnumber = 108;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 130)
	{
	gridnumber = 109;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 130)
	{
	gridnumber = 110;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 130)
	{
	gridnumber = 111;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 130)
	{
	gridnumber = 112;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 130)
	{
	gridnumber = 113;
	}		
if(TestSprite7.x == 220 && TestSprite7.y == 130)
	{
	gridnumber = 114;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 130)
	{
	gridnumber = 115;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 130)
	{
	gridnumber = 116;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 130)
	{
	gridnumber = 117;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 130)
	{
	gridnumber = 118;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 130)
	{
	gridnumber = 119;
	}

// Row 7 (of 12)


if(TestSprite7.x == 10 && TestSprite7.y == 145)
	{
	gridnumber = 120;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 145)
	{
	gridnumber = 121;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 145)
	{
	gridnumber = 122;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 145)
	{
	gridnumber = 123;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 145)
	{
	gridnumber = 124;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 145)
	{
	gridnumber = 125;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 145)
	{
	gridnumber = 126;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 145)
	{
	gridnumber = 127;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 145)
	{
	gridnumber = 128;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 145)
	{
	gridnumber = 129;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 145)
	{
	gridnumber = 130;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 145)
	{
	gridnumber = 131;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 145)
	{
	gridnumber = 132;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 145)
	{
	gridnumber = 133;
	}	
if(TestSprite7.x == 220 && TestSprite7.y == 145)
	{
	gridnumber = 134;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 145)
	{
	gridnumber = 135;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 145)
	{
	gridnumber = 136;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 145)
	{
	gridnumber = 137;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 145)
	{
	gridnumber = 138;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 145)
	{
	gridnumber = 139;
	}

// Row 8 (of 12)

if(TestSprite7.x == 10 && TestSprite7.y == 160)
	{
	gridnumber = 140;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 160)
	{
	gridnumber = 141;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 160)
	{
	gridnumber = 142;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 160)
	{
	gridnumber = 143;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 160)
	{
	gridnumber = 144;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 160)
	{
	gridnumber = 145;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 160)
	{
	gridnumber = 146;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 160)
	{
	gridnumber = 147;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 160)
	{
	gridnumber = 148;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 160)
	{
	gridnumber = 149;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 160)
	{
	gridnumber = 150;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 160)
	{
	gridnumber = 151;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 160)
	{
	gridnumber = 152;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 160)
	{
	gridnumber = 153;
	}	
if(TestSprite7.x == 220 && TestSprite7.y == 160)
	{
	gridnumber = 154;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 160)
	{
	gridnumber = 155;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 160)
	{
	gridnumber = 156;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 160)
	{
	gridnumber = 157;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 160)
	{
	gridnumber = 158;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 160)
	{
	gridnumber = 159;
	}

// Row 9 (of 12)


if(TestSprite7.x == 10 && TestSprite7.y == 175)
	{
	gridnumber = 160;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 175)
	{
	gridnumber = 161;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 175)
	{
	gridnumber = 162;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 175)
	{
	gridnumber = 163;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 175)
	{
	gridnumber = 164;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 175)
	{
	gridnumber = 165;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 175)
	{
	gridnumber = 166;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 175)
	{
	gridnumber = 167;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 175)
	{
	gridnumber = 168;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 175)
	{
	gridnumber = 169;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 175)
	{
	gridnumber = 170;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 175)
	{
	gridnumber = 171;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 175)
	{
	gridnumber = 172;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 175)
	{
	gridnumber = 173;
	}	
if(TestSprite7.x == 220 && TestSprite7.y == 175)
	{
	gridnumber = 174;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 175)
	{
	gridnumber = 175;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 175)
	{
	gridnumber = 176;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 175)
	{
	gridnumber = 177;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 175)
	{
	gridnumber = 178;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 175)
	{
	gridnumber = 179;
	}

// Row 10 (of 12)

if(TestSprite7.x == 10 && TestSprite7.y == 190)
	{
	gridnumber = 180;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 190)
	{
	gridnumber = 181;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 190)
	{
	gridnumber = 182;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 190)
	{
	gridnumber = 183;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 190)
	{
	gridnumber = 184;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 190)
	{
	gridnumber = 185;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 190)
	{
	gridnumber = 186;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 190)
	{
	gridnumber = 187;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 190)
	{
	gridnumber = 188;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 190)
	{
	gridnumber = 189;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 190)
	{
	gridnumber = 190;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 190)
	{
	gridnumber = 191;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 190)
	{
	gridnumber = 192;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 190)
	{
	gridnumber = 193;
	}		
if(TestSprite7.x == 220 && TestSprite7.y == 190)
	{
	gridnumber = 194;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 190)
	{
	gridnumber = 195;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 190)
	{
	gridnumber = 196;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 190)
	{
	gridnumber = 197;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 190)
	{
	gridnumber = 198;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 190)
	{
	gridnumber = 199;
	}

// Row 11 (of 12)

if(TestSprite7.x == 10 && TestSprite7.y == 205)
	{
	gridnumber = 200;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 205)
	{
	gridnumber = 201;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 205)
	{
	gridnumber = 202;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 205)
	{
	gridnumber = 203;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 205)
	{
	gridnumber = 204;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 205)
	{
	gridnumber = 205;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 205)
	{
	gridnumber = 206;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 205)
	{
	gridnumber = 207;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 205)
	{
	gridnumber = 208;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 205)
	{
	gridnumber = 209;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 205)
	{
	gridnumber = 210;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 205)
	{
	gridnumber = 211;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 205)
	{
	gridnumber = 212;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 205)
	{
	gridnumber = 213;
	}		
if(TestSprite7.x == 220 && TestSprite7.y == 205)
	{
	gridnumber = 214;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 205)
	{
	gridnumber = 215;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 205)
	{
	gridnumber = 216;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 205)
	{
	gridnumber = 217;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 205)
	{
	gridnumber = 218;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 205)
	{
	gridnumber = 219;
	}

// Row 12 (of 12)

if(TestSprite7.x == 10 && TestSprite7.y == 220)
	{
	gridnumber = 220;
	}
if(TestSprite7.x == 25 && TestSprite7.y == 220)
	{
	gridnumber = 221;
	}
if(TestSprite7.x == 40 && TestSprite7.y == 220)
	{
	gridnumber = 222;
	}
if(TestSprite7.x == 55 && TestSprite7.y == 220)
	{
	gridnumber = 223;
	}
if(TestSprite7.x == 70 && TestSprite7.y == 220)
	{
	gridnumber = 224;
	}
if(TestSprite7.x == 85 && TestSprite7.y == 220)
	{
	gridnumber = 225;
	}
if(TestSprite7.x == 100 && TestSprite7.y == 220)
	{
	gridnumber = 226;
	}	
if(TestSprite7.x == 115 && TestSprite7.y == 220)
	{
	gridnumber = 227;
	}
if(TestSprite7.x == 130 && TestSprite7.y == 220)
	{
	gridnumber = 228;
	}
if(TestSprite7.x == 145 && TestSprite7.y == 220)
	{
	gridnumber = 229;
	}
if(TestSprite7.x == 160 && TestSprite7.y == 220)
	{
	gridnumber = 230;
	}
if(TestSprite7.x == 175 && TestSprite7.y == 220)
	{
	gridnumber = 231;
	}
if(TestSprite7.x == 190 && TestSprite7.y == 220)
	{
	gridnumber = 232;
	}
if(TestSprite7.x == 205 && TestSprite7.y == 220)
	{
	gridnumber = 233;
	}		
if(TestSprite7.x == 220 && TestSprite7.y == 220)
	{
	gridnumber = 234;
	}
if(TestSprite7.x == 235 && TestSprite7.y == 220)
	{
	gridnumber = 235;
	}
if(TestSprite7.x == 250 && TestSprite7.y == 220)
	{
	gridnumber = 236;
	}
if(TestSprite7.x == 265 && TestSprite7.y == 220)
	{
	gridnumber = 237;
	}
if(TestSprite7.x == 280 && TestSprite7.y == 220)
	{
	gridnumber = 238;
	}
if(TestSprite7.x == 295 && TestSprite7.y == 220)
	{
	gridnumber = 239;
	}


}// end of void GetGridNumberP2()

///////////////////////////////////////////////////////////////////////////////////////

// ----------------------------------
// void CheckP1Score()
// ----------------------------------

void CheckP1Score()
{
int oldnumber; // used to store player's current move
int check;     // loop counter

oldnumber = gridnumber; // save player's current move

// check right of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber++;
	if(grid[gridnumber] == 1)
		{
		p1score++;
		}
	else
		{
		check++;
		}
	}

// check left of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber--;
	if(grid[gridnumber] == 1)
		{
		p1score++;
		}
	else
		{
		check++;
		}
	}

// check above playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber-20;
	if(grid[gridnumber] == 1)
		{
		p1score++;
		}
	else
		{
		check++;
		}
	}

// check below playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber+20;
	if(grid[gridnumber] == 1)
		{
		p1score++;
		}
	else
		{
		check++;
		}
	}

// check diogonal up left of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber-21;
	if(grid[gridnumber] == 1)
		{
		p1score++;
		}
	else
		{
		check++;
		}
	}
	
// check diogonal up right of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber-19;
	if(grid[gridnumber] == 1)
		{
		p1score++;
		}
	else
		{
		check++;
		}
	}

// check diogonal down left of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber+19;
	if(grid[gridnumber] == 1)
		{
		p1score++;
		}
	else
		{
		check++;
		}
	}
	
// check diogonal down right of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber+21;
	if(grid[gridnumber] == 1)
		{
		p1score++;
		}
	else
		{
		check++;
		}
	}

}// end of void CheckP1Score()

////////////////////////////////////////////////////////////////////////////////////////

// ----------------------------------
// void CheckP2Score()
// ----------------------------------

void CheckP2Score()
{
int oldnumber; // used to store player's current move
int check;     // loop counter

oldnumber = gridnumber; // save player's current move

// check right of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber++;
	if(grid[gridnumber] == 2)
		{
		p2score++;
		}
	else
		{
		check++;
		}
	}

// check left of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber--;
	if(grid[gridnumber] == 2)
		{
		p2score++;
		}
	else
		{
		check++;
		}
	}

// check above playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber-20;
	if(grid[gridnumber] == 2)
		{
		p2score++;
		}
	else
		{
		check++;
		}
	}

// check below playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber+20;
	if(grid[gridnumber] == 2)
		{
		p2score++;
		}
	else
		{
		check++;
		}
	}

// check diogonal up left of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber-21;
	if(grid[gridnumber] == 2)
		{
		p2score++;
		}
	else
		{
		check++;
		}
	}
	
// check diogonal up right of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber-19;
	if(grid[gridnumber] == 2)
		{
		p2score++;
		}
	else
		{
		check++;
		}
	}

// check diogonal down left of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber+19;
	if(grid[gridnumber] == 2)
		{
		p2score++;
		}
	else
		{
		check++;
		}
	}
	
// check diogonal down right of playermarker
check = 0;
gridnumber = oldnumber; // reset marker position to player's current move
while(check == 0)
	{
	gridnumber = gridnumber+21;
	if(grid[gridnumber] == 2)
		{
		p2score++;
		}
	else
		{
		check++;
		}
	}


}// end of void CheckP2Score()

////////////////////////////////////////////////////////////////////////////////////////
		
		
//----------------------------
// void DisplayWinner()
//----------------------------

void DisplayWinner()
{
int endgame = 0;

while(endgame != 2)
	{
	
		// Find out which buffer is being used
		activeBuff = GsGetActiveBuff();

		// Packet area
		GsSetWorkBase((PACKET *)GpuPacketArea[activeBuff]);

		// Clear the ordering table
		GsClearOt(0,0,&WorldOT[activeBuff]);
  		
  		GsSortFastSprite(&TestSprite8,&WorldOT[activeBuff],3);
		GsSortFastSprite(&TestSprite9,&WorldOT[activeBuff],3);
	
		DrawGrid();
  		
  		// Register winning sprite into ordering table
		// Uses GsSortFastSprite for speed - no rotation/scaling needed
		if(p1score > p2score)
			{
			GsSortFastSprite(&TestSprite12,&WorldOT[activeBuff],0);
			}
		else if(p1score < p2score)
			{
			GsSortFastSprite(&TestSprite13,&WorldOT[activeBuff],0);
			}
		else
			{
			GsSortFastSprite(&TestSprite14,&WorldOT[activeBuff],0);
			}
			
		// Wait for all drawing to finish
		DrawSync(0);

		// Wait for vertical blank interrupt
		VSync(0);

		// Switch display buffer & offscreen buffer
		GsSwapDispBuff();

		// Sort the ordering table
		GsSortClear(0,0,0,&WorldOT[activeBuff]);

		// Draw the objects registered in the Ordering table
		GsDrawOt(&WorldOT[activeBuff]);	
		
		// Load basic font pattern in frame buffer 
		FntLoad(960, 256);	
		// Font display location setting 
		FntOpen(5, 0, 320, 240, 0, 1024);	
	
		FntPrint("P1: %d\n\n",p1score);
		FntPrint("P2: %d",p2score);
		FntFlush(-1);
	
		endgame++;
		
		}

}// end of DisplayWinner()

////////////////////////////////////////////////////////////////////////////////////////

void CheckWinner()
{

//**********************************
//***   Nothing here yet. Will   ***
//***   eventually display win   ***
//***   lose or draw screens     ***
//**********************************
}// end of void CheckWinner()

////////////////////////////////////////////////////////////////////////////////////////