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

    - A M A T E U R   W A R S -

**********************************
AKA Nick's First Attempt To Code
         a NY "game...

Started: 24/5/98 (13:36)
   v1.0: 6/7/98 (21:55)
Finished: ???

NB: This is *NOT* my GDUK entry :-)

WRITTEN FOR PAL TVs (revenge! revenge!)
----------------------------------
Nick Ferguson, Edinburgh
6 July, 1998
nickf@saqnet.co.uk
http://www.netyaroze-europe.com/~rookie1
http://www.saqnet.co.uk/users/nickf
http://www.n64gazetta.com
----------------------------------
TIMELINE:

24/5/98
Initial goal - 2 sprites moving about
the screen in response to input from
both pads...
(DID IT - 23:30)!!!

25/5/98
Goal - set up collision detection
between the two sprites and improve
boundaries...
(DID IT - 11:30 29/5/98)!!!

29/5/98
Goal - add a pretty backdrop (a sprite!)
and change the player sprites to something
a bit cooler.
(DID IT at last - 16:30 31/5/98)!!!

1/6/98
Goal - add some animation to the ships.
Ideas: Gunfire? Rockets?
Direction changes - rotation vs animation?
(ADDED ship rotation for turns - 25/6/98)

(BIG 3 WEEK BREAK DUE TO UNIVERSITY WORK)

25/6/98
Goal - add bullets/laser fire to ships.
(and try to remember how Yaroze works after
3 weeks...)
(KIND OF DID IT eventually - 1/7/98)

2/7/98
Goal - rewriting program to be a bit more sensible,
coherent and generally more moral.
(MUCHO IMPROVED 3/7/98)

3/7/98
Goal - get lasers firing properly (ie not taking up huge amounts of space in
memory).
(WAHEY! LASERS AHOY 4/7/98)

4/7/98
Goal - add transparent energy bars to the top of the screen for each player sprite,
work out the collision detection to apply to the lasers on the ships and *maybe*
even get the lasers to decrement the counter...(whew!)
(DONE IT! 5/7/98)

5/7/98
Goal - add a scores counter and make a loop so that there is a Game Over screen and
the program can be looped...generally tidy it up and get v1.0 FINISHED!!!
(DONE IT! 6/7/98)

Goals for (much?) later:
add explosion animations to ships...
add decent homedone font for menu/announcements?
add titlescreen?
transparent lasers?
add laser recharge bar?
Or "superlaser" - to be fired only once per round?

KNOWN BUGS:

A single laser usually fires when a new round begins. Presumably
this is a hang-up from the last round, but if everything is reset
(which I *think* it is) then how does it happen???

THANKS TO:
Ira Rainey & Scott Campbell for their sprite tutorials and code
John Ward for his understandable-if-uncommented "Spacies" source
James Shaugnessy for the brill Gravitation Source
and
SCEE and Net Yaroze for estranging my girlfriend ;-/

SPECIAL THANKS TO MR FROSTY FOR HIS BUG-HUNTING EXPERTISE (!),
PEEKS AT THE SBF SOURCE, AND FCONTROL v1.5 CONTROLLER LIBRARY!
(Visit the omni-talented Mr F at the URL below:)
http://www.netyaroze-europe.com/~mrfrosty
*********************************/

/* HEADER FILES */

#include <libps.h>						// Hooray for LIBPS!
#include "fcont1_5.h"					// fcontrol v1.5 (from Mr Frosty)

#define SPRITE_CNT (MAX_LASERS*2+5)		// sprite count

#define SCREEN_W        320				// setup screen stuff. Dur.
#define SCREEN_H        240

#define player1Add      0x80090000      // memory address of player sprites
#define player2Add      0x80092000
#define laser1Add       0x800a7000      // memory add. of laser sprites
#define laser2Add       0x800a9000
#define BGAdd           0x80094000      // memory add. of background

#define ROTATE_UP (0)					// Rotation definitions
#define ROTATE_DOWN (0-ONE*180)
#define ROTATE_LEFT (0-ONE*90)
#define ROTATE_RIGHT (0+ONE*90)

#define OT_LENGTH 2						//Ordering Table length

/*GAME CONTROL DEFINITIONS */

// You can play about with these if you want :-)

#define PLAYERSPEED 2		// controls the speed of the player ships (default=2)
#define LASERSPEED 5		// controls the speed of lasers 'n stuff (default=5)
#define LASER_GAP 10		// this is the gap between each laser fired (default=10)
#define MAX_LASERS 20		// the max number of lasers "fireable" (is that a word?) at a time (default=20)
#define PLAYER_LIFE 80		// the length of players' energy bars (default=80)
#define LASER_DAMAGE 5		// the damage done to energy bars by laser damage (default=5)

// I wouldn't change these...
#define TOP_WALL 13			// collision boundaries for the "arena"
#define BOTTOM_WALL 225
#define LEFT_WALL 15
#define RIGHT_WALL 305

/* PROTOTYPE FUNCTIONS */

void InitialiseGraphics(void);	// I-N-I-T-I-A-L-I-S-E.... G-R-A-P-H-I-C-S. Oh!
void InitialiseOTs(void);		// You can guess what this does, too.
void FSetPortBuffers(void);		// Setup pad reading routine (Courtesy of Mr Frosty)
void InitialisePlayers(void);	// Sets up those SEXY player sprites and THAT funky BG...
void InitialiseLasers(void);	// Set up the lasers (hidden under the ships)
void InitialiseLife(void);		// Set up players' energy bars
void ResetMovement(void);		// solves a "drift" problem/bug... (maybe an option later?)
void GameOverCheck(void);		// If game is over, prompts for and then restarts
void ReadPads(void);			// Reads. The. Pads. Using FCONTROL v1.5 (1.6 now available!!!)
void MoveShips(void);			// Moves. The. Ships. (Good names, huh?)
void RotateShips(void);			// Actually, this DOESN'T rotate the ships.
								// Oh, OK then, I'm lying. It does.
void MoveLasers(void);			// Hey, it's a secret :-)
void CheckLaserCollision(void);	// Try typing that in a hurry (checks laser collision)
int CheckLasers1(int num);		// Checks for laser collision between P1 lasers and P2
int CheckLasers2(int num);		// Checks for laser collision between P2 lasers and P1
void CountGap(void);			// Decrements the L1(or 2)_GAP each turn. Keeps lasers from
								// flying as a long line/solid mass! Doesn't really need to
								// be a seperate function, but I like my cheesy functions...
void PrintScores(void);			// Prints da scores


// Complex (ahem) collision detection functions, using the old "bounding box" method...
int CheckCollision(long P1x_minus, long P1y_minus, long P1x_plus, long P1y_plus, long P2x_minus, long P2y_minus, long P2x_plus, long P2y_plus);
int Check();

/* GLOBALS 'N STUFF */

GsOT            WorldOT[2];
GsOT_TAG        OTTags[2][1<<OT_LENGTH];
int             activeBuff;

PACKET          GpuPacketArea[2][SPRITE_CNT*1024];

GsSPRITE player1, player2, BG_left, BG_right, laser1[MAX_LASERS], laser2[MAX_LASERS];

GsBOXF P1_LIFE, P2_LIFE;

u_short SPAD1, SPAD2;

//short collide;   // for collision checks

int L1_LAUNCHED[MAX_LASERS];	// An array to hold laser status info...
int L2_LAUNCHED[MAX_LASERS];	// for each position in array, 0='home', 1='fired'

int L1_GAP = 0;		// keeps gaps between the lasers
int L2_GAP = 0;

int P1_up, P1_down, P1_left, P1_right, P1_fire, P1_hold, P1_rotate, P1_start;	// P1 movement/controls held here
int P2_up, P2_down, P2_left, P2_right, P2_fire, P2_hold, P2_rotate, P2_start; // P2 movement/controls held here
int P1_SCORE, P2_SCORE = 0;	// scores
int GAMEOVER = 0;	//controls whether Game Over or not in GameOverCheck...


/**************************************
        MAIN FUNCTION
**************************************/

void main()
{
        int y; //required for looping stuff

        InitialiseGraphics();
        InitialiseOTs();
        FSetPortBuffers();        
        InitialisePlayers();
        InitialiseLife();
        InitialiseLasers();

        while(!(FSPadRead(PORT_ONE) & SPADselect))
        {
                activeBuff = GsGetActiveBuff();

                GsSetWorkBase((PACKET *)GpuPacketArea[activeBuff]);

                GsClearOt(0,0,&WorldOT[activeBuff]);
                
                GsSortBoxFill(&P1_LIFE,&WorldOT[activeBuff],0);	// display P1 energy bar
                GsSortBoxFill(&P2_LIFE,&WorldOT[activeBuff],0);	// display P2 energy bar
                GsSortSprite(&player1,&WorldOT[activeBuff],0);	//Player sprites
                GsSortSprite(&player2,&WorldOT[activeBuff],0);
                for(y=0;y<MAX_LASERS;y++)	// Initialise MAX_LASERS no. of lasers for P1
                	GsSortSprite(&laser1[y],&WorldOT[activeBuff],0);
                for(y=0;y<MAX_LASERS;y++)	// Ditto for P2!
                	GsSortSprite(&laser2[y],&WorldOT[activeBuff],0);
                GsSortFastSprite(&BG_left,&WorldOT[activeBuff],1);	// Left and right half of BG
                GsSortFastSprite(&BG_right,&WorldOT[activeBuff],1);

                DrawSync(0);

                VSync(0);

                GsSwapDispBuff();

                GsSortClear(0,0,0,&WorldOT[activeBuff]);

                GsDrawOt(&WorldOT[activeBuff]);

				// FntPrint stuff was ORIGINALLY here (in case of a problem)			

				ResetMovement();
				if(!GAMEOVER)	//only runs if game has not been "won" yet
				{
				ReadPads();				
				RotateShips();
				MoveShips();
				MoveLasers();
				CheckLaserCollision();
				}
				if(GAMEOVER==2) GameOverCheck();

// This next cycle runs twice! GAMEOVER must equal 2 for
// GameOverCheck to run (gets the energy bars totally clear
// before pausing)

				if((P1_LIFE.w==0)||(P2_LIFE.w==0))	// If someone's energy runs out
				{									                	
                	if(P1_LIFE.w==0)	//if P1 has lost...
                	{
                	FntLoad(960, 256);
                	FntOpen( 10, 10, 320, 256, 0, 1024);
                	FntPrint("GAME OVER\n\n");
                	FntPrint("PLAYER 1 LOSES\n");
                	FntFlush(-1);
                	P2_SCORE++;		//P2's score is incremented (this happens twice each Game over)
                	}
                	else
                	{
                	FntLoad(960, 256);
                	FntOpen((280-PLAYER_LIFE), 10, 320, 256, 0, 1024);
                	FntPrint("GAME OVER\n\n");
                	FntPrint("PLAYER 2 LOSES\n");
                	FntFlush(-1); 
                	P1_SCORE++;		//P1's score is incrememnted (this happens twice each GameOver)
                	}

                	GAMEOVER++;					// Gameover incremented (this too happens twice)
				}

				CountGap();						// Sorts out the gap between lasers (see MoveLasers)

				if(!GAMEOVER) PrintScores();	// otherwise the P1 or P2 lost message is shown
        }

        ResetGraph(3);
}

/**************************************
        INITIALISE STUFF
**************************************/

void InitialiseGraphics()
{
        SetVideoMode(MODE_NTSC);
        GsInitGraph(SCREEN_W, SCREEN_H, GsOFSGPU, 0, 0);
        GsDefDispBuff(0,0,0,SCREEN_H);
}

void InitialiseOTs()
{
        int i;

        for(i=0;i<2;i++)
        {
                WorldOT[i].length = OT_LENGTH;
                WorldOT[i].org = OTTags[i];
        }
}

void InitialiseText()
{
        FntLoad(960, 256);
        FntOpen( 150, 120, 320, 256, 0, 1024);
}


void InitialisePlayers()
{
        RECT rect;
        GsIMAGE timData, timData2, timData3;

        // Setup PLAYER1

        GsGetTimInfo((u_long*)(player1Add+4),&timData);

        rect.x=timData.px;
        rect.y=timData.py;
        rect.w=timData.pw;
        rect.h=timData.ph;
        LoadImage(&rect, timData.pixel);

        rect.x=timData.cx;
        rect.y=timData.cy;
        rect.w=timData.cw;
        rect.h=timData.ch;
        LoadImage(&rect, timData.clut);

        player1.attribute = (1<<24);
        player1.x = (SCREEN_W/4);
        player1.y = (SCREEN_H/2);
        player1.w = (timData.pw*2);
        player1.h = (timData.ph);
        player1.tpage = GetTPage(1,0,timData.px,timData.py);
        player1.u = 0;
        player1.v = 0;
        player1.cx = timData.cx;
        player1.cy = timData.cy;
        player1.r = 128;
        player1.g = 128;
        player1.b = 128;
        player1.mx = player1.w/2;
        player1.my = player1.h/2;
        player1.scalex = ONE;
        player1.scaley = ONE;
        player1.rotate = 0;

        // Setup PLAYER2

        GsGetTimInfo((u_long*)(player2Add+4),&timData2);

        rect.x=timData2.px;
        rect.y=timData2.py;
        rect.w=timData2.pw;
        rect.h=timData2.ph;
        LoadImage(&rect, timData2.pixel);

        rect.x=timData2.cx;
        rect.y=timData2.cy;
        rect.w=timData2.cw;
        rect.h=timData2.ch;
        LoadImage(&rect, timData2.clut);

        player2.attribute = (1<<24);
        player2.x = 240;
        player2.y = (SCREEN_H/2);
        player2.w = (timData2.pw*2);
        player2.h = (timData2.ph);
        player2.tpage = GetTPage(1,0,timData2.px,timData2.py);
        player2.u = 0;
        player2.v = 0;
        player2.cx = timData2.cx;
        player2.cy = timData2.cy;
        player2.r = 128;
        player2.g = 128;
        player2.b = 128;
        player2.mx = player2.w/2;
        player2.my = player2.h/2;
        player2.scalex = ONE;
        player2.scaley = ONE;
        player2.rotate = 0;

        //Setup Background (need to setup 2 sprites)

        GsGetTimInfo((u_long *)(BGAdd+4),&timData3);

        rect.x = 320;           //hard code the TIM position
        rect.y = 0;             //ditto
        rect.w = timData3.pw;
        rect.h = timData3.ph;
        LoadImage(&rect, timData3.pixel);

        rect.x=timData3.cx;
        rect.y=timData3.cy;
        rect.w=timData3.cw;
        rect.h=timData3.ch;
        LoadImage(&rect, timData3.clut);


        // Initialise Sprite Structure!

		// First half of the BG sprite (sprites can only be 256x256)
        BG_left.attribute = (1<<24);	// middling 8-bitter
        BG_left.x = 0;
        BG_left.y = 0;
        BG_left.w = timData3.pw;
        BG_left.h = timData3.ph;
        BG_left.tpage = GetTPage(1,0,320,0);
        BG_left.u = 0;
        BG_left.v = 0;
        BG_left.r = 128;
        BG_left.g = 128;
        BG_left.b = 128;
        BG_left.mx = 0;
        BG_left.my = 0;
        BG_left.scalex = ONE;
        BG_left.scaley = ONE;
        BG_left.rotate = 0;
        BG_left.cx = timData3.cx;
        BG_left.cy = timData3.cy;

		// other half of the BG sprite
        BG_right.attribute = (1<<24);
        BG_right.x = 160;
        BG_right.y = 0;
        BG_right.w = timData3.pw;
        BG_right.h = timData3.ph;
        BG_right.tpage = GetTPage(1,0,400,0);
        BG_right.u = 32;
        BG_right.v = 0;
        BG_right.r = 128;
        BG_right.g = 128;
        BG_right.b = 128;
        BG_right.mx = 0;
        BG_right.my = 0;
        BG_right.scalex = ONE;
        BG_right.scaley = ONE;
        BG_right.rotate = 0;
        BG_right.cx = timData3.cx;
        BG_right.cy = timData3.cy;

        DrawSync(0);
}
   
void InitialiseLasers()
{
        RECT rect;
        GsIMAGE timData;
        // Using a pointer to initialise the lasers purely to get
        // used to them and not let them scare the shit out of me :-)
        GsSPRITE *sp;
        int i;			//for loops


        // Setup LASER1

        GsGetTimInfo((u_long*)(laser1Add+4),&timData);

        rect.x=timData.px;
        rect.y=timData.py;
        rect.w=timData.pw;
        rect.h=timData.ph;
        LoadImage(&rect, timData.pixel);

        rect.x=timData.cx;
        rect.y=timData.cy;
        rect.w=timData.cw;
        rect.h=timData.ch;
        LoadImage(&rect, timData.clut);

	for(sp=laser1,i=0;i<MAX_LASERS;i++,sp++)
		{
        sp->attribute = (1<<24);
        sp->x = player1.x;
        sp->y = player1.y;
        sp->w = (timData.pw*4);
        sp->h = (timData.ph);
        sp->tpage = GetTPage(0,0,timData.px,timData.py);
        sp->u = 0;
        sp->v = 0;
        sp->cx = timData.cx;
        sp->cy = timData.cy;
        sp->r = 128;
        sp->g = 128;
        sp->b = 128;
        sp->mx = sp->w/2;
        sp->my = sp->h/2;
        sp->scalex = ONE;
        sp->scaley = ONE;
        sp->rotate = player1.rotate;
		}
		
        // Setup LASER2

        GsGetTimInfo((u_long*)(laser2Add+4),&timData);

        rect.x=timData.px;
        rect.y=timData.py;
        rect.w=timData.pw;
        rect.h=timData.ph;
        LoadImage(&rect, timData.pixel);

        rect.x=timData.cx;
        rect.y=timData.cy;
        rect.w=timData.cw;
        rect.h=timData.ch;
        LoadImage(&rect, timData.clut);

	for(sp=laser2,i=0;i<MAX_LASERS;i++,sp++)
		{
        sp->attribute = (1<<24);
        sp->x = player2.x;
        sp->y = player2.y;
        sp->w = (timData.pw*4);
        sp->h = (timData.ph);
        sp->tpage = GetTPage(0,0,timData.px,timData.py);
        sp->u = 0;
        sp->v = 0;
        sp->cx = timData.cx;
        sp->cy = timData.cy;
        sp->r = 128;
        sp->g = 128;
        sp->b = 128;
        sp->mx = sp->w/2;
        sp->my = sp->h/2;
        sp->scalex = ONE;
        sp->scaley = ONE;
        sp->rotate = player2.rotate;
		}
        DrawSync(0);
}

void InitialiseLife()
{
	P1_LIFE.attribute = (1<<30);
	P1_LIFE.x = 10;
	P1_LIFE.y = 10;
	P1_LIFE.w = PLAYER_LIFE;
	P1_LIFE.h = 10;
	P1_LIFE.r = 0;
	P1_LIFE.g = 180;
	P1_LIFE.b = 20;
	
	P2_LIFE.attribute = (1<<30);
	P2_LIFE.x = 310-PLAYER_LIFE;
	P2_LIFE.y = 10;
	P2_LIFE.w = PLAYER_LIFE;
	P2_LIFE.h = 10;
	P2_LIFE.r = 0;
	P2_LIFE.g = 180;
	P2_LIFE.b = 20;
}

/***********************
     MAIN FUNCTIONS
***********************/

void ReadPads()		//reads both pad inputs, and defines control variables as true or false depending...
{
	SPAD1 = FSPadRead(PORT_ONE);
	SPAD2 = FSPadRead(PORT_TWO);

    if(SPAD1)
    {
		if(SPAD1 & SPADleft)		
		P1_left=1;
		if(!(SPAD1 & SPADleft))
		P1_left=0;
        
        if(SPAD1 & SPADright)
        P1_right=1;
        else
        P1_right=0;

        if(SPAD1 & SPADup)
        P1_up=1;
        else
        P1_up=0;

        if(SPAD1 & SPADdown)
        P1_down=1;
        else
        P1_down=0;

        if(SPAD1 & SPADsq)
        P1_hold=1;
        else
        P1_hold=0;

		if(SPAD1 & SPADci)
		P1_rotate=1;
		else
		P1_rotate=0;

        if(SPAD1 & SPADcr)
        P1_fire=1;
        else
        P1_fire=0;

        if(SPAD1 & SPADstart)
        P1_start=1;
        else
        P1_start=0;
	}
            
if(SPAD2)
    {
		if(SPAD2 & SPADleft)		
		P2_left=1;
		else
		P2_left=0;
        
        if(SPAD2 & SPADright)
        P2_right=1;
        else
        P2_right=0;

        if(SPAD2 & SPADup)
        P2_up=1;
        else
        P2_up=0;

        if(SPAD2 & SPADdown)
        P2_down=1;
        else
        P2_down=0;

        if(SPAD2 & SPADsq)
        P2_hold=1;
        else
        P2_hold=0;

        if(SPAD2 & SPADci)
        P2_rotate=1;
        else
        P2_rotate=0;

        if(SPAD2 & SPADcr)
        P2_fire=1;
        else
        P2_fire=0;

        if(SPAD2 & SPADstart)
        P2_start=1;
        else
        P2_start=0;
	}
}

void MoveShips()
{
	
	int player_x = player1.x;	// Backup original X Y stuff just in case...
	int player_y = player1.y;

	if(P1_up) player1.y-= PLAYERSPEED;
	if(player1.y < TOP_WALL) player1.y = TOP_WALL;

	if(P1_down) player1.y+= PLAYERSPEED;
	if(player1.y > BOTTOM_WALL) player1.y = BOTTOM_WALL;

	if(P1_left) player1.x-= PLAYERSPEED;
	if(player1.x < LEFT_WALL) player1.x = LEFT_WALL;

	if(P1_right) player1.x+= PLAYERSPEED;
	if(player1.x > RIGHT_WALL) player1.x = RIGHT_WALL;

	if((Check())||(P1_rotate))	// move back to original position if a collision with player2 occurs
								// or if the "rotate" button is held down.
	{
		player1.x = player_x;
		player1.y = player_y;
	}

	// SAME THING FOR PLAYER 2, basically.

	player_x = player2.x;
	player_y = player2.y;
	
	if(P2_up!=0) player2.y-= PLAYERSPEED;
	if(player2.y < TOP_WALL) player2.y = TOP_WALL;

	if(P2_down!=0) player2.y+= PLAYERSPEED;
	if(player2.y > BOTTOM_WALL) player2.y = BOTTOM_WALL;

	if(P2_left!=0) player2.x-= PLAYERSPEED;
	if(player2.x < LEFT_WALL) player2.x = LEFT_WALL;

	if(P2_right!=0) player2.x+= PLAYERSPEED;
	if(player2.x > RIGHT_WALL) player2.x = RIGHT_WALL;

	if((Check())||(P2_rotate))
	{
		player2.x = player_x;
		player2.y = player_y;
	}
}

void RotateShips()
{
	// rotate Player 1 using EZ-understand DEFINEs
	if((P1_up) && (!P1_hold)) player1.rotate = ROTATE_UP;

	if((P1_down) && (!P1_hold)) player1.rotate = ROTATE_DOWN;

	if((P1_left) && (!P1_hold)) player1.rotate = ROTATE_LEFT;

	if((P1_right) && (!P1_hold)) player1.rotate = ROTATE_RIGHT;

	// rotate Player 2 as above
	if((P2_up) && (!P2_hold)) player2.rotate = ROTATE_UP;	

	if((P2_down) && (!P2_hold)) player2.rotate = ROTATE_DOWN;

	if((P2_left) && (!P2_hold)) player2.rotate = ROTATE_LEFT;

	if((P2_right) && (!P2_hold)) player2.rotate = ROTATE_RIGHT;
}

void MoveLasers()		// "Home" lasers are kept under the player ship, "Fired" lasers 
						// travel on their own in the direction they were fired
{
	int i=0;

	if((P1_fire) && (L1_GAP==0))	// i.e if P1 fire is pressed and the laser gap is OK
	{
		i=0;

		while(L1_LAUNCHED[i]) i++;	// skims through array to find next "home" laser

		L1_LAUNCHED[i]=1;			// sets the laser as "fired"
		L1_GAP = LASER_GAP;			// sets the laser gap to maximum
	}

	for(i=0;i<MAX_LASERS;i++)		// scans through each laser's L1_LAUNCH[?] info	
	{
		if(L1_LAUNCHED[i])			// if the laser status is "fired"
		{
			if(laser1[i].rotate==ROTATE_UP)	//ie direction is tied to rotation of ship
			{
				laser1[i].y -= LASERSPEED;	// move in desired direction by LASERSPEED amount
				if(laser1[i].y <= -10)		// ie if out of bounds
				{
				laser1[i].x = player1.x;	//reset to under player ship
				laser1[i].y = player1.y;
				laser1[i].rotate = player1.rotate;
				L1_LAUNCHED[i] = 0;			// reset L1_LAUNCH status to "Home" (ie '0')
				}
			}

			if(laser1[i].rotate==ROTATE_DOWN)	// same sort of thing as above
			{
				laser1[i].y += LASERSPEED;
				if(laser1[i].y >= 250)
				{
				laser1[i].x = player1.x;
				laser1[i].y = player1.y;
				laser1[i].rotate = player1.rotate;
				L1_LAUNCHED[i] = 0;
				}
			}

			if(laser1[i].rotate==ROTATE_LEFT)	// same sort of thing as above
			{
				laser1[i].x -= LASERSPEED;
				if(laser1[i].x <= -10)
				{
				laser1[i].x = player1.x;
				laser1[i].y = player1.y;
				laser1[i].rotate = player1.rotate;
				L1_LAUNCHED[i] = 0;
				}
			}

			if(laser1[i].rotate==ROTATE_RIGHT)	// same sort of thing as above
			{
				laser1[i].x += LASERSPEED;
				if(laser1[i].x >= 330)
				{
				laser1[i].x = player1.x;
				laser1[i].y = player1.y;
				laser1[i].rotate = player1.rotate;
				L1_LAUNCHED[i] = 0;
				}
			}		
		}	
		
		else									// if L1_LAUNCHED is 0 ie laser is "Home"
												// it is kept under the ship
		{
			laser1[i].x = player1.x;
			laser1[i].y = player1.y;
			laser1[i].rotate = player1.rotate;
		}
	}


	// EXACTLY THE SAME THING AS ABOVE GOES FOR PLAYER 2

	if((P2_fire) && (L2_GAP==0))
	{
		i=0;

		while(L2_LAUNCHED[i]) i++;

		L2_LAUNCHED[i]=1;
		L2_GAP = LASER_GAP;
	}

	for(i=0;i<MAX_LASERS;i++)
	{
		if(L2_LAUNCHED[i])
		{
			if(laser2[i].rotate==ROTATE_UP)
			{
				laser2[i].y -= LASERSPEED;
				if(laser2[i].y <= -10)
				{
				laser2[i].x = player2.x;
				laser2[i].y = player2.y;
				laser2[i].rotate = player2.rotate;
				L2_LAUNCHED[i] = 0;
				}
			}

			if(laser2[i].rotate==ROTATE_DOWN)
			{
				laser2[i].y += LASERSPEED;
				if(laser2[i].y >= 250)
				{
				laser2[i].x = player2.x;
				laser2[i].y = player2.y;
				laser2[i].rotate = player2.rotate;
				L2_LAUNCHED[i] = 0;
				}
			}

			if(laser2[i].rotate==ROTATE_LEFT)
			{
				laser2[i].x -= LASERSPEED;
				if(laser2[i].x <= -10)
				{
				laser2[i].x = player2.x;
				laser2[i].y = player2.y;
				laser2[i].rotate = player2.rotate;
				L2_LAUNCHED[i] = 0;
				}
			}

			if(laser2[i].rotate==ROTATE_RIGHT)
			{
				laser2[i].x += LASERSPEED;
				if(laser2[i].x >= 330)
				{
				laser2[i].x = player2.x;
				laser2[i].y = player2.y;
				laser2[i].rotate = player2.rotate;
				L2_LAUNCHED[i] = 0;
				}
			}		
		}	
		
		else
		{
			laser2[i].x = player2.x;
			laser2[i].y = player2.y;
			laser2[i].rotate = player2.rotate;
		}
	}

}

void CountGap()
{
	L1_GAP--;	//reduce laser gap distance by 1 (needs to be 0 for next laser)
	
	if(L1_GAP<0) L1_GAP=0;

	L2_GAP--;	//reduce laser gap distance by 1 (needs to be 0 for next laser)
	
	if(L2_GAP<0) L2_GAP=0;
}	

// Bounding Box method ahoy!
int CheckCollision(long P1x_minus, long P1y_minus, long P1x_plus, long P1y_plus, long P2x_minus, long P2y_minus, long P2x_plus, long P2y_plus)
{
   if((P2x_minus <= P1x_plus) & (P2x_plus >= P1x_minus)
      &
      (P2y_minus <= P1y_plus) & (P2y_plus >= P1y_minus))

      return(1);
      else return(0);
}

// for checking the inter-player collision...
int Check()
{
                return(CheckCollision((player1.x)-((player1.w/2)-3),
                (player1.y)-((player1.h/2)-3),
                (player1.x)+((player1.w/2)-3),
                (player1.y)+((player1.h/2)-3),
                (player2.x)-((player2.w/2)-3),
                (player2.y)-((player2.h/2)-3),
                (player2.x)+((player2.w/2)-3),
                (player2.y)+((player2.h/2)-3)
                ));
}

void ResetMovement()	//solves drifting weirdness (remove this function from main() to see what I mean)
{
	P1_up = 0;
	P1_down = 0;
	P1_left = 0;
	P1_right = 0;
	P1_fire = 0;
	P1_start = 0;

	P2_up = 0;
	P2_down = 0;
	P2_left = 0;
	P2_right = 0;
	P2_fire = 0;
	P1_start = 0;
}

void CheckLaserCollision()
{
	int i;

	for(i=0;i<MAX_LASERS;i++)
	{
		if(CheckLasers1(i))	//if P1's laser hits P2
		{
			P2_LIFE.w -= LASER_DAMAGE;
			if(P2_LIFE.w > PLAYER_LIFE) P2_LIFE.w = 0;
			laser1[i].x = player1.x;
			laser1[i].y = player1.y;
			laser1[i].rotate = player1.rotate;
			L1_LAUNCHED[i] = 0;
		}

		if(CheckLasers2(i))	//if P2's laser hits P1
		{
			P1_LIFE.w -= LASER_DAMAGE;
			if(P1_LIFE.w > PLAYER_LIFE) P1_LIFE.w = 0;
			laser2[i].x = player2.x;
			laser2[i].y = player2.y;
			laser2[i].rotate = player2.rotate;
			L2_LAUNCHED[i] = 0;
		}			
	}
}

int CheckLasers1(int num)
{
                return(CheckCollision(laser1[num].x-((laser1[num].w/2)-2),
                laser1[num].y-((laser1[num].h/2)-4),
                laser1[num].x+((laser1[num].w/2)-2),
                laser1[num].y+((laser1[num].h/2)-4),
                player2.x-((player2.w/2)-3),
                player2.y-((player2.h/2)-3),
                player2.x+((player2.w/2)-3),
                player2.y+((player2.h/2)-3)
                ));
}

int CheckLasers2(int num)
{
                return(CheckCollision(laser2[num].x-((laser2[num].w/2)-2),
                laser2[num].y-((laser2[num].h/2)-4),
                laser2[num].x+((laser2[num].w/2)-2),
                laser2[num].y+((laser2[num].h/2)-4),
                player1.x-((player1.w/2)-3),
                player1.y-((player1.h/2)-3),
                player1.x+((player1.w/2)-3),
                player1.y+((player1.h/2)-3)
                ));
}


void GameOverCheck()	//handles Game Over stuff
{
		while(!((P1_start)||(P2_start))) //pause until P1 or P2 hits start
		{
		ReadPads();
		}
		GAMEOVER=0;				// the game is no longer "over"
        InitialisePlayers();	//re-initialise sprites, boxes and movement.
        InitialiseLife();
        InitialiseLasers();
        ResetMovement();
        L1_GAP = LASER_GAP;
        L2_GAP = LASER_GAP;
}

void PrintScores()	
{

        FntLoad(960, 256);
        FntOpen( 15, 227, 320, 256, 0, 1024);
        FntPrint("P1 SCORE: %d              P2 SCORE: %d",(P1_SCORE/2),(P2_SCORE/2));	//easier just to print on one long line
// Note that the P1_SCORE etc must be divided by two. This is because the scores are incremented by one
// TWICE after a win (ie they go up by 2). This is fixable in a more elegant way, but I'm getting tired :-)
        FntFlush(-1);
}

/****************************************
 I HOPE YOU LEARNT SOMETHING FROM THIS!
      (KEEP UP THE GOOD WORK...)

         NICK F WILL RETURN WITH

   - C H E M I C A L   W A R F A R E -

(It's not big. It's not clever. Just fun.)

         (DUE SEPTEMBER 1998)       
*****************************************/