#include <nmgrfx.cpp>
#include "nib.dat"

const int MAXSHOTS = 25;
const int MAXAMMO  = 250;

// Bitmap holders:

bitmap snakecell(4,4);
int NUMPLYRS;

// OBJECTS:

struct coord
{
	float x,y;
	int direction;

	coord() {}
	coord(float xx,float yy)
	{
		x = xx; y = yy;
	}
};

struct shot
{
	float x,y,mx,my;
	int type;

	shot() {}
	shot(float xx,float yy,int t)
	{
		x = xx;
		y = yy;
		type = t;
	}

	void move()
	{
		x += mx;
		y += my;
	}
	void draw()
	{
		switch(type) // type is equivelent to which player part the shot is.
		{
			case 0: snakecell.setdata(snake1_body);
					break;
			case 1: snakecell.setdata(snake2_body);
					break;
			case 2: snakecell.setdata(snake3_body);
					break;
			case 3: snakecell.setdata(snake4_body);
					break;
		}
		snakecell.setx(x); snakecell.sety(y);
		snakecell.draw();
	}
};

struct snake
{
	float x,y;
	int length;
	int direction;
	int keyset;
	int ammo;
	int numshots;
	int shotdelay;
	int delaycount;
	int weapon;
	int alive;
	float speed;
	coord parts[250];
	shot  shots[MAXSHOTS];
	int   ammostore[MAXAMMO];

	snake () {}
	snake (float xx,float yy,int l,int d,float s)
	{
		x=xx;y=yy;speed=s;direction = d;length = l;
		ammo = 0; weapon = 1; numshots = 0; shotdelay = 50;
		delaycount = 0; alive = 1;
	}

	void draw(int p);
	void move();
	void fire();
	void ctrl();
	void updateshots();
	void addammo(int num,int t);
	int  getammo();
};

struct fatblob
{
	float x,y,movex,movey;
	int type;

	fatblob()
	{
		x = 0;
		y = 0;
		movex = 0;
		movey = 0;
		type = 1;
	}
	fatblob(float xx,float yy,float mmx, float mmy,int tt)
	{
		x = xx;
		y = yy;
		movex = mmx;
		movey = mmy;
		type = tt;
	}
	void draw()
	{
		switch(type)
		{

		}
	}
};

// END OBJECTS

// ARRAYS

snake players[4];

// PROTOTYPES
	void drawsnakes();
	int updatesnakes();
	int numalive();
// ==========

int lost;


int main()
{
	// gamesetup
	clrscr();
	cout << "Battle Snakes. BETA v.0.1" << endl <<
			"Nick Meyer. (c) 2002. Fractal Games." << endl;
	cout << endl << "How many players? "; cin >> NUMPLYRS;
	cout << endl << "Thankyou" << endl;

	// setupgraphics
	setmode(MODE13H);
	setupbuf();
	clrbuf();
	setupkbd();

	// setup players
	for (int n=0;n<NUMPLYRS;n++)
	{
		switch (n)
		{
			case 0:
				players[n] = snake(80,16,20,2,1);
				for (int m=0;m<players[n].length;m++)
				{
					players[n].parts[m] = coord(80-(m*4),16);
					players[n].parts[m].direction = players[n].direction;
				}
				break;
			case 1:
				players[n] = snake(300,80,20,3,1);
				for (m=0;m<players[n].length;m++)
				{
					players[n].parts[m] = coord(300,80-(m*4));
					players[n].parts[m].direction = players[n].direction;
				}
				break;
			case 2:
				players[n] = snake(240,184,20,4,1);
				for (m=0;m<players[n].length;m++)
				{
					players[n].parts[m] = coord(240+(m*4),184);
					players[n].parts[m].direction = players[n].direction;
				}
				break;
			case 3:
				players[n] = snake(20,120,20,1,1);
				for (m=0;m<players[n].length;m++)
				{
					players[n].parts[m] = coord(20,120+(m*4));
					players[n].parts[m].direction = players[n].direction;
				}
				break;
		}
		players[n].draw(n);
	}
	// /------------------------------/
	// /---- game loop ---------------/
	// /------------------------------/

	showbuf();

	while(!KeyEnter && !Spacebar && !KeyEnter) ; KeyEscape=0;
	lost = 0;

	while(!KeyEscape && numalive() > 1)
	{
		clrbuf();

		drawsnakes();
		lost = updatesnakes();
		if (lost)  { players[lost-1].alive = 0; lost = 0; }

		showbuf();
		delay(5);
	}
	KeyEscape = 0;

	// /------------------------------/
	// /------------------------------/
	// /------------------------------/

restorekbd();
disablebuf();
setmode(TEXTMODE);
clrscr();

if (!numalive) cout << "It was a tie!!!";
else
{
	for (int n=0;n<NUMPLYRS;n++)
	if (players[n].alive) break;
	cout << "Player " << n+1 << " Wins!!!";
}
getch();

return(0);
}

// NON-CLASS FUNCTIONS:

void drawsnakes()
{
	for (int n=0;n<NUMPLYRS;n++) if (players[n].alive) players[n].draw(n);
}
int numalive()
{
	int num = 0;
	for (int n=0;n<NUMPLYRS;n++) if (players[n].alive) num++;
	return num;
}
int updatesnakes()
{
	for (int n=0;n<NUMPLYRS;n++)
	{
		if (!players[n].alive) continue;
		// loop through all snakes
		for (int os=0;os<NUMPLYRS;os++)
		{
			if (n==os) continue;
			// loop through all snake 'os's parts
			for (int p=0;p<players[os].length;p++)
			{
				// distance formula
				if ( ((players[os].parts[p].x-players[n].parts[0].x)*(players[os].parts[p].x-players[n].parts[0].x)
					+ (players[os].parts[p].y-players[n].parts[0].y)*(players[os].parts[p].y-players[n].parts[0].y))
					< 16.0)
					// decrease snake size
				{
					if (p==0)
					{
						players[n].alive = 0;
						players[os].alive = 0;
						break;
					}
					players[n].addammo(players[os].length-p,os);
					players[os].length = p;
				}
				// loop through all snake 'n's shots
				for (int s=0;s<players[n].numshots;s++)
				{
					// distance formula
					if ( ((players[os].parts[p].x-players[n].shots[s].x)*(players[os].parts[p].x-players[n].shots[s].x)
						+ (players[os].parts[p].y-players[n].shots[s].y)*(players[os].parts[p].y-players[n].shots[s].y))
						< 16.0)
						// decrease snake size
					{
						if (p==0) players[os].alive = 0;
						players[n].addammo(players[os].length-p,os);
						players[os].length = p;
					}
				// loop through all snake 'n's shots

				}
			}
		}

		// check key strokes
		switch(n)
		{
		case 0:
			if      (KeyW) { if (players[n].parts[0].direction != 3) players[n].parts[0].direction = 1; else return 1; }
			else if (KeyD) { if (players[n].parts[0].direction != 4) players[n].parts[0].direction = 2; else return 1; }
			else if (KeyS) { if (players[n].parts[0].direction != 1) players[n].parts[0].direction = 3; else return 1; }
			else if (KeyA) { if (players[n].parts[0].direction != 2) players[n].parts[0].direction = 4; else return 1; }
			if (KeyF) players[n].fire();
			break;
		case 1:
			if 		(CursorUp) 	  { if (players[n].parts[0].direction != 3) players[n].parts[0].direction = 1; else return 2; }
			else if (CursorRight) { if (players[n].parts[0].direction != 4) players[n].parts[0].direction = 2; else return 2; }
			else if (CursorDown)  { if (players[n].parts[0].direction != 1) players[n].parts[0].direction = 3; else return 2; }
			else if (CursorLeft)  { if (players[n].parts[0].direction != 2) players[n].parts[0].direction = 4; else return 2; }
			if (KeyRCtrl) players[n].fire();
			break;
		case 2:
			if 		(Key3)     { if (players[n].parts[0].direction != 3) players[n].parts[0].direction = 1; else return 3; }
			else if (KeyEnter) { if (players[n].parts[0].direction != 4) players[n].parts[0].direction = 2; else return 3; }
			else if (KeyDel)   { if (players[n].parts[0].direction != 1) players[n].parts[0].direction = 3; else return 3; }
			else if (Key0)     { if (players[n].parts[0].direction != 2) players[n].parts[0].direction = 4; else return 3; }
			if (Key1) players[n].fire();
			break;
		case 3:
			if 		(KeyI) { if (players[n].parts[0].direction != 3) players[n].parts[0].direction = 1; else return 4; }
			else if (KeyL) { if (players[n].parts[0].direction != 4) players[n].parts[0].direction = 2; else return 4; }
			else if (KeyK) { if (players[n].parts[0].direction != 1) players[n].parts[0].direction = 3; else return 4; }
			else if (KeyJ) { if (players[n].parts[0].direction != 2) players[n].parts[0].direction = 4; else return 4; }
			if (KeyP) players[n].fire();
			break;
		}
		players[n].move();
		players[n].updateshots();
	}
	return (0);
}

// END NON-CLASS FUNCTIONS


// CLASS FUNCTIONS

void snake:: fire()
{
	if (ammo > 0 && numshots<MAXSHOTS && delaycount >= shotdelay)
	{
		switch (weapon)
		{
		case 1:
			numshots++;
			shots[numshots-1].x = parts[0].x;
			shots[numshots-1].y = parts[0].y;
			switch (parts[0].direction)
			{
				case 1:
					shots[numshots-1].mx = 0;
					shots[numshots-1].my = -2;
					shots[numshots-1].type = getammo();
					break;
				case 2:
					shots[numshots-1].mx = 2;
					shots[numshots-1].my = 0;
					shots[numshots-1].type = getammo();
					break;
				case 3:
					shots[numshots-1].mx = 0;
					shots[numshots-1].my = 2;
					shots[numshots-1].type = getammo();
					break;
				case 4:
					shots[numshots-1].mx = -2;
					shots[numshots-1].my = 0;
					shots[numshots-1].type = getammo();
					break;
			}
		}
		delaycount = 0;
	}
}
void snake:: updateshots()
{
	for (int n=0;n<numshots;n++)
	{
		if (shots[n].x < 2 || shots[n].x > 318 ||
			shots[n].y < 2 || shots[n].y > 198)
		{
			for (int m=n;m<numshots-1;m++) shots[m] = shots[m+1];
			numshots--;
		}
		shots[n].move();
		shots[n].draw();
	}
	delaycount++;
}
void snake:: addammo(int num,int t)
{
	for (int n=ammo;n<ammo+num;n++) ammostore[n] = t;
	ammo += num;
}
int snake:: getammo()
{
	int t = ammostore[0];
	for (int n=0;n<ammo-1;n++) ammostore[n]=ammostore[n+1];
	ammo--;
	return t;
}
void snake:: move()
{
		for (int m=0;m<length;m++)
		{
			switch(parts[m].direction)
			{
				case 1:
					parts[m].y -= speed; break;
				case 2:
					parts[m].x += speed; break;
				case 3:
					parts[m].y += speed; break;
				case 4:
					parts[m].x -= speed; break;
			}
			if (parts[m].x<0) parts[m].x+=320;
				else if (parts[m].x>316) parts[m].x-=320;
			if (parts[m].y<0) parts[m].y+=200;
				else if (parts[m].y>196) parts[m].y-=200;
		}

		for (m=length-1;m>0;m--)
		{
			switch (parts[m].direction)
			{
				case 1:
				case 3:
					if (parts[m].y == parts[m-1].y) parts[m].direction = parts[m-1].direction;
				case 2:
				case 4:
					if (parts[m].x == parts[m-1].x) parts[m].direction = parts[m-1].direction;
			}
		}
}
void snake:: draw(int p)
{
	for (int n=0;n<length;n++)
	{
		snakecell.setx(parts[n].x);
		snakecell.sety(parts[n].y);
		if (!n)
		{
			switch (p)
			{
			case 0:
				switch (parts[n].direction)
				{
					case 1:
					{
						snakecell.setdata(snake1_head_up);
						break;
					}
					case 2:
					{
						snakecell.setdata(snake1_head_right);
						break;
					}
					case 3:
					{
						snakecell.setdata(snake1_head_down);
						break;
					}
					case 4:
					{
						snakecell.setdata(snake1_head_left);
						break;
					}
				}
				break;
			case 1:
				switch (parts[n].direction)
				{
					case 1:
					{
						snakecell.setdata(snake2_head_up);
						break;
					}
					case 2:
					{
						snakecell.setdata(snake2_head_right);
						break;
					}
					case 3:
					{
						snakecell.setdata(snake2_head_down);
						break;
					}
					case 4:
					{
						snakecell.setdata(snake2_head_left);
						break;
					}
				}
				break;
			case 2:
				switch (parts[n].direction)
				{
					case 1:
					{
						snakecell.setdata(snake3_head_up);
						break;
					}
					case 2:
					{
						snakecell.setdata(snake3_head_right);
						break;
					}
					case 3:
					{
						snakecell.setdata(snake3_head_down);
						break;
					}
					case 4:
					{
						snakecell.setdata(snake3_head_left);
						break;
					}
				}
				break;
			case 3:
				switch (parts[n].direction)
				{
					case 1:
					{
						snakecell.setdata(snake4_head_up);
						break;
					}
					case 2:
					{
						snakecell.setdata(snake4_head_right);
						break;
					}
					case 3:
					{
						snakecell.setdata(snake4_head_down);
						break;
					}
					case 4:
					{
						snakecell.setdata(snake4_head_left);
						break;
					}
				}
				break;
			}
		}
		else
		switch (p)
		{
			case 0: snakecell.setdata(snake1_body); break;
			case 1: snakecell.setdata(snake2_body); break;
			case 2: snakecell.setdata(snake3_body); break;
			case 3: snakecell.setdata(snake4_body); break;
		}

		snakecell.draw();
	}
}

// END CLASS FUNCTIONS