#include <nmgrfx.cpp>

// game properties ===================

int playto;
int maxballs;

//===OBJECTS==========================

struct paddle
{
	float top,side;
	int length;
	int state;
	int fcount;
	int shotdelay;
	int delaycount;
	int powerups;
	int dgradedelay;
	int updelay;
	float Yspeed;
	float Xspeed;
	float MAXspeed;
	float accel;
};
struct player
{
	int lives;
	float score;
	paddle mypaddle;
};
struct ball
{
	float x;
	float y;
	float movex;
	float movey;

	void draw();
};
struct shot
{
	float x;
	float y;
	float basey;
	float movex;
	float movey;
	int frame;

	void draw(int type,int frame,int d);
};

int numballs;
int numHshots;
int numCshots;

ball balls[150];
shot h_shots[250];
shot c_shots[250];

int key;int lose = 0;

//===========PROTOTYPES===============

void keypress();

void checkballs (ball balls[],int &numballs,player &human,player &comp,shot h_shots[],shot c_shots[],int &numHshots,int &numCshots);
void moveballs  (ball balls[],int numballs);
void drawballs  (ball balls[],int numballs);
void drawpaddles(paddle &paddle1,paddle &paddle2);
void drawshots  (shot h_shots[],shot c_shots[],int numHshots,int numCshots,player human,player comp);
void moveshots  (shot h_shots[],shot c_shots[],int numHshots,int numCshots,paddle humanpad,paddle comppad);
void updateshots (shot h_shots[],shot c_shots[],int &numHshots,int &numCshots,player &human,player &comp);

void hshoot     (shot h_shots[],int &numHshots,paddle &paddle);
void cshoot     (shot c_shots[],int &numCshots,paddle &paddle);

//==============MAIN==================

int main()
{
	// setup game
	clrscr();
	cout << "Blast Pong v2.01. Game Setup." << endl << endl;
	cout << "Controls for Left Paddle: " << endl
		 << "Left.......a" << endl
		 << "Right......d" << endl
		 << "Up.........w" << endl
		 << "Down.......s" << endl
		 << "Upgrade....Spacebar" << endl
		 << "Controls for Right Paddle: " << endl
		 << "Use Arrow Keys to Move" << endl
		 << "Upgrade....Enter" << endl
		 << "YOU MUST PAY 5 PNTS PER UPGRADE." << endl << endl;
	cout << "1 or 2 Players: "; int plyrs; cin >> plyrs;
	cout << endl << "Play to: "; cin >> playto;
	cout << endl << "Max balls on screen: "; cin >> maxballs;
	//setup graphics
	setmode(MODE13H);
	setupbuf();
	clrbuf(); cleardevice();
	setupkbd();
	randomize();
	player human, comp;
	human.score = 0; comp.score = 0;

	// play game!!!

		human.mypaddle.top        = 85;
		human.mypaddle.side       = 10;
		human.mypaddle.length     = 30;
		human.mypaddle.fcount     =  0;
		human.mypaddle.state      =  0;
		human.mypaddle.shotdelay  = 25;
		human.mypaddle.delaycount = 25;
		human.mypaddle.Xspeed     =  0;
		human.mypaddle.Yspeed     =  0;
		human.mypaddle.MAXspeed   =  2;
		human.mypaddle.accel      = .15;

		human.mypaddle.powerups   =  1;

		human.mypaddle.updelay    =  0;
		human.mypaddle.dgradedelay=  0;
		comp .mypaddle.dgradedelay=  0;
		comp .mypaddle.updelay    =  0;

		comp .mypaddle.powerups   =  1;

		comp .mypaddle.state      =  0;
		comp .mypaddle.fcount     =  0;
		comp .mypaddle.top        = 85;
		comp .mypaddle.side       = 310;
		comp .mypaddle.length     = 30;
		comp .mypaddle.shotdelay  = 25;
		comp .mypaddle.delaycount = 25;
		comp .mypaddle.Xspeed     =  0;
		comp .mypaddle.Yspeed     =  0;
		comp .mypaddle.MAXspeed   =  2;
		comp .mypaddle.accel      = .15;

		for (int n=0;n<5;n++)
		{
		balls[n].x = 0;
		balls[n].y = 0;
		balls[n].movex = 0;
		balls[n].movey = 0;
		}

		numballs = 1;
		int rand; if (random(2)) rand = 1; else rand = -1;
		balls[0].x = 160;
		balls[0].y = 100;
		balls[0].movex = rand;
		balls[0].movey = 1;

		lose = 0;

		for (n=0;n<150;n++)
		{
		h_shots[n].x = 0;
		h_shots[n].y = 0;
		h_shots[n].movex = 0;
		h_shots[n].movey = 0;
		h_shots[n].frame=1;
		c_shots[n].x = 0;
		c_shots[n].y = 0;
		c_shots[n].movex = 0;
		c_shots[n].movey = 0;
		c_shots[n].frame = 1;
		}
		numHshots = 0;
		numCshots = 0;

		int Hrow = 5;
		int Crow = 5;

		// game loop

		while (!KeyEscape && human.mypaddle.length>0 && comp.mypaddle.length>0 && human.score<playto && comp.score<playto)
		{
			clrbuf();
			// draw points
			for (n=0;n<human.score;n++)
				{
				Hrow = 5*(1+(n/20));
				if (!(n%10)) putbigpixel((n%20)*5,Hrow,LIGHTBLUE); else putbigpixel((n%20)*5,Hrow,PURPLE);
				}
			for (n=0;n<comp .score;n++)
				{
				Crow = 5*(1+(n/20));
				if (!(n%10)) putbigpixel(315-((n%20)*5),Crow,RED); else putbigpixel(315-((n%20)*5),Crow,ORANGE);
				}
			updateshots(h_shots,c_shots,numHshots,numCshots,human,comp);
			checkballs(balls,numballs,human,comp,h_shots,c_shots,numHshots,numCshots);
			// movement for 1st player
			if (KeyW && (human.mypaddle.Yspeed >  -human.mypaddle.MAXspeed))   human.mypaddle.Yspeed-=human.mypaddle.accel;
			if (KeyS && (human.mypaddle.Yspeed <   human.mypaddle.MAXspeed)) human.mypaddle.Yspeed+=human.mypaddle.accel;
			if (KeyA && (human.mypaddle.Xspeed >  -human.mypaddle.MAXspeed))  human.mypaddle.Xspeed-=human.mypaddle.accel;
			if (KeyD && (human.mypaddle.Xspeed <   human.mypaddle.MAXspeed))human.mypaddle.Xspeed+=human.mypaddle.accel;
			if (!(KeyW || KeyS)) human.mypaddle.Yspeed *= .8;
			if (!(KeyA || KeyD)) human.mypaddle.Xspeed *= .8;
			// movement for 2nd player
			if (plyrs==2)
			{
			if (CursorUp   && (comp.mypaddle.Yspeed > -comp.mypaddle.MAXspeed)) comp.mypaddle.Yspeed-=comp.mypaddle.accel;
			if (CursorDown && (comp.mypaddle.Yspeed <  comp.mypaddle.MAXspeed)) comp.mypaddle.Yspeed+=comp.mypaddle.accel;
			if (CursorLeft && (comp.mypaddle.Xspeed > -comp.mypaddle.MAXspeed)) comp.mypaddle.Xspeed-=comp.mypaddle.accel;
			if (CursorRight&& (comp.mypaddle.Xspeed <  comp.mypaddle.MAXspeed)) comp.mypaddle.Xspeed+=comp.mypaddle.accel;
			if (!(CursorUp || CursorDown))    comp.mypaddle.Yspeed *= .8;
			if (!(CursorLeft || CursorRight)) comp.mypaddle.Xspeed *= .8;
			}
			// upgrading for both players
			if (Spacebar && human.score>4 && human.mypaddle.updelay>100 && human.mypaddle.powerups<6)
			{
				human.score-=5;
				human.mypaddle.powerups++;
				human.mypaddle.updelay=0;
				human.mypaddle.dgradedelay=0;
			}
			if (KeyEnter && comp .score>4 && comp. mypaddle.updelay>100 && comp.mypaddle.powerups<6)
			{
				comp .score-=5;
				comp .mypaddle.powerups++;
				comp .mypaddle.updelay=0;
				comp .mypaddle.dgradedelay=0;
			}
			// shooting for both players
			hshoot(h_shots,numHshots,human.mypaddle);
			cshoot(c_shots,numCshots,comp .mypaddle);
			// AI
			if (plyrs==1)
			{
				ball focus = balls[0];
				for (int n=1;n<numballs;n++) if (((comp.mypaddle.side-balls[n].x)/fabs(balls[n].movex)) < ((comp.mypaddle.side-focus.x)/fabs(focus.movex))) focus = balls[n];
				if (focus.x < 160 && comp.mypaddle.side > 162 ) comp.mypaddle.side-=2;
				if (focus.x >= comp.mypaddle.side-3 && comp.mypaddle.side < 317) comp.mypaddle.side+=2;
				if ((focus.y < comp.mypaddle.top+comp.mypaddle.length/2) && comp.mypaddle.top > 2) comp.mypaddle.top-=3;
				if ((focus.y > comp.mypaddle.top+comp.mypaddle.length/2) && comp.mypaddle.top+comp.mypaddle.length < 197) comp.mypaddle.top+=3;

				if (comp.score > 4 && comp.score-3>human.score && comp.mypaddle.updelay>100 && comp.mypaddle.powerups<6)
				{
				comp .score-=5;
				comp .mypaddle.powerups++;
				comp .mypaddle.updelay=0;
				}

				if (comp.mypaddle.Xspeed>0) comp.mypaddle.Xspeed*=.8;
			}
			// MOVE PADDLES
			if (human.mypaddle.top+human.mypaddle.Yspeed > 2)                        human.mypaddle.top  += human.mypaddle.Yspeed;
			else { human.mypaddle.top = 2; human.mypaddle.Yspeed = 0; }
			if (human.mypaddle.top+human.mypaddle.length+human.mypaddle.Yspeed <197) human.mypaddle.top  += human.mypaddle.Yspeed;
			else { human.mypaddle.top = 197-human.mypaddle.length; human.mypaddle.Yspeed = 0; }

			if (human.mypaddle.side+human.mypaddle.Xspeed>2 )                        human.mypaddle.side += human.mypaddle.Xspeed;
			else { human.mypaddle.side = 4; human.mypaddle.Xspeed = 0; }
			if (human.mypaddle.side+human.mypaddle.Xspeed<317)                       human.mypaddle.side += human.mypaddle.Xspeed;
			else { human.mypaddle.side = 317; human.mypaddle.Xspeed = 0; }

			if (comp .mypaddle.top+comp.mypaddle.Yspeed  >2)                         comp .mypaddle.top  += comp .mypaddle.Yspeed;
			else { comp.mypaddle.top = 2; comp.mypaddle.Yspeed = 0; }
			if (comp. mypaddle.top+comp .mypaddle.length+comp.mypaddle.Yspeed<197)   comp .mypaddle.top  += comp .mypaddle.Yspeed;
			else { comp.mypaddle.top = 197 - comp.mypaddle.length;comp.mypaddle.Yspeed = 0; }

			if (comp .mypaddle.side+comp.mypaddle.Xspeed >2)                         comp .mypaddle.side += comp .mypaddle.Xspeed;
			else { comp.mypaddle.side = 4;comp.mypaddle.Xspeed = 0; }
			if (comp. mypaddle.side+comp.mypaddle.Xspeed <317)                       comp .mypaddle.side += comp .mypaddle.Xspeed;
			else { comp.mypaddle.side = 317; comp.mypaddle.Xspeed = 0; }

			//run action
			moveballs(balls,numballs);
			moveshots(h_shots,c_shots,numHshots,numCshots,human.mypaddle,comp.mypaddle);
			drawballs(balls,numballs);
			drawpaddles(human.mypaddle,comp.mypaddle);
			drawshots(h_shots,c_shots,numHshots,numCshots,human,comp);
			//update things
			if (human.mypaddle.updelay<101) human.mypaddle.updelay++;
			if (comp .mypaddle.updelay<101) comp .mypaddle.updelay++;
			//display action
			showbuf();
			delay(15);
			nosound();

		} //end game loop
disablebuf();
setmode(TEXTMODE);
clrscr();
if (human.mypaddle.length<=0) cout << "Right player Wins by Sharpshooting!";
else if (comp.mypaddle.length<=0) cout << "Left player Wins by Sharpshooting!";
else
{
	if (human.score > comp.score) cout << "Left player Wins " << human.score << " to " << comp.score;
	else if (human.score < comp.score) cout << "Right player Wins " << comp.score << " to " << human.score;
	else cout << "Draw!!!";
}
while (!KeyEscape && !KeyEnter) ;
restorekbd();
clrscr();
return (0);
}

//=========================================================================//
//=======================FUNCTIONS=========================================//
//=========================================================================//

void checkballs(ball balls[],int &numballs,player &human,player &comp,shot h_shots[],shot c_shots[],int &numHshots,int &numCshots)
{
	for (int n=0;n<numballs;n++)
	{
// player lost?
			if (balls[n].x < 2)
			{
				comp.score++;
				if (numballs > 1)
				{
					for (int m=n;m<numballs-1;m++) balls[m] = balls[m+1];
					numballs--;
				}
				else if (numballs<=1)
				{
					balls[0].x = 160.;
					balls[0].y = 100.;
					balls[0].movex = 1.0;
					balls[0].movey = 1.0;
				}
			}
			if (balls[n].x > 317)
			{
				human.score++;
				if (numballs > 1)
				{
					for (int m=n;m<numballs-1;m++) balls[m] = balls[m+1];
					numballs--;
				}
				else if (numballs <= 1)
				{
					balls[0].x = 160.;
					balls[0].y = 100.;
					balls[0].movex = 1.0;
					balls[0].movey = 1.0;
				}
			}
// ball being shot?
				for (int m=0;m<numHshots;m++)
				{
					if (numballs < maxballs)
					{
						if ( (fabs(balls[n].x-h_shots[m].x) <= 4) && (fabs(balls[n].y-h_shots[m].y) <= 4))
						{
							numballs++;
							balls[n].movex += h_shots[m].movex * .75;
							balls[numballs-1].x = h_shots[m].x;
							balls[numballs-1].y = h_shots[m].y;
							balls[numballs-1].movex = h_shots[m].movex / 2.0;
							balls[numballs-1].movey = h_shots[m].movey+.5;
							for (int s=m;s<numHshots-1;s++) h_shots[s] = h_shots[s+1];
							numHshots--;
						}
					}
				}
				for (    m=0;m<numCshots;m++)
				{
					if (numballs<maxballs)
					{
						if ( (fabs(balls[n].x-c_shots[m].x) <= 4) && (fabs(balls[n].y-c_shots[m].y) <= 4))
						{
							numballs++;
							balls[n].movex += c_shots[m].movex * .75;
							balls[numballs-1].x = c_shots[m].x;
							balls[numballs-1].y = c_shots[m].y;
							balls[numballs-1].movex = c_shots[m].movex / 2.0;
							balls[numballs-1].movey = c_shots[m].movey+.5;
							for (int s=m;s<numCshots-1;s++) c_shots[s] = c_shots[s+1];
							numCshots--;
						}
					}
				}
			// hitting top or bottom?
			if (balls[n].y < 5)
			{
				balls[n].movey *= -1;
				balls[n].y += 5;
			}
			if (balls[n].y > 195)
			{
				balls[n].movey *= -1;
				balls[n].y -= 5;
			}

			// HUMAN PADDLE BOUNCE
			if (balls[n].x >= human.mypaddle.side-4 && balls[n].x <= human.mypaddle.side+4)
			{
				// top part
				if (balls[n].y >= human.mypaddle.top &&
					balls[n].y <= human.mypaddle.top + human.mypaddle.length/3)
					{
					if (fabs(balls[n].movex) >= 3.0)
					{
						human.mypaddle.Xspeed += -fabs(balls[n].movex);
						balls[n].movex *= -1;
					}
					else {
						balls[n].movex *= -1;
						balls[n].movex += human.mypaddle.Xspeed;
						human.mypaddle.Xspeed += -fabs(balls[n].movex);
						}
					balls[n].movey += -.25;
					balls[n].x += 8+fabs(human.mypaddle.Xspeed)*2;
					sound(300);
					}
				// middle part
				if (balls[n].y > human.mypaddle.top + human.mypaddle.length/3 &&
					balls[n].y < human.mypaddle.top + human.mypaddle.length*.6667)
					{
					if (fabs(balls[n].movex) >= 3.0)
					{
						human.mypaddle.Xspeed += -fabs(balls[n].movex);
						balls[n].movex *= -1.0;
					}
					else {
						balls[n].movex *= -1;
						balls[n].movex += (human.mypaddle.Xspeed);
						human.mypaddle.Xspeed += -fabs(balls[n].movex);
						}
					balls[n].x += 8+fabs(human.mypaddle.Xspeed)*2;
					sound(300);
					}
				// bottom part
				if (balls[n].y >= human.mypaddle.top + human.mypaddle.length*.6667 &&
					balls[n].y <= human.mypaddle.top + human.mypaddle.length)
					{
					if (fabs(balls[n].movex) >= 3.0)
					{
						human.mypaddle.Xspeed += -fabs(balls[n].movex);
						balls[n].movex *= -1.0;
					}
					else {
						balls[n].movex *= -1;
						balls[n].movex += (human.mypaddle.Xspeed);
						human.mypaddle.Xspeed += -fabs(balls[n].movex);
						}
					balls[n].movey += .25;
					balls[n].x += 8+fabs(human.mypaddle.Xspeed)*2;
					sound(300);
					}
			}
			// COMPUTER PADDLE BOUNCE
			if (balls[n].x <= comp.mypaddle.side+4  && balls[n].x >= comp.mypaddle.side-4)
			{
				// top part
				if (balls[n].y >= comp.mypaddle.top &&
					balls[n].y <= comp.mypaddle.top + comp.mypaddle.length/5)
					{
					if (fabs(balls[n].movex) >= 3.0)
					{
						comp.mypaddle.Xspeed += fabs(balls[n].movex);
						balls[n].movex *= -1.0;
					}
					else {
						balls[n].movex *= -1;
						balls[n].movex += (comp.mypaddle.Xspeed);
						comp.mypaddle.Xspeed += fabs(balls[n].movex);
						}
					balls[n].movey += -.25;
					balls[n].x -= 8+fabs(comp.mypaddle.Xspeed)*2;
					sound(300);
					}
				// middle part
				if (balls[n].y > comp.mypaddle.top + comp.mypaddle.length/5 &&
					balls[n].y < comp.mypaddle.top + comp.mypaddle.length*.8)
					{
					if (fabs(balls[n].movex) >= 3.0)
					{
						comp.mypaddle.Xspeed += fabs(balls[n].movex);
						balls[n].movex *= -1.0;
					}
					else {
						balls[n].movex *= -1;
						balls[n].movex += (comp.mypaddle.Xspeed);
						comp.mypaddle.Xspeed += fabs(balls[n].movex);
						}
					balls[n].x -= 8+fabs(comp.mypaddle.Xspeed)*2;
					sound(300);
					}
				// bottom part
				if (balls[n].y >= comp.mypaddle.top + comp.mypaddle.length*.8 &&
					balls[n].y <= comp.mypaddle.top + comp.mypaddle.length)
					{
					if (fabs(balls[n].movex) >= 3.0)
					{
						comp.mypaddle.Xspeed += fabs(balls[n].movex);
						balls[n].movex *= -1.0;
					}
					else {
						balls[n].movex *= -1;
						balls[n].movex += (comp.mypaddle.Xspeed);
						comp.mypaddle.Xspeed += fabs(balls[n].movex);
						}
					balls[n].movey += .25;
					balls[n].x -= 8+fabs(comp.mypaddle.Xspeed)*2;
					sound(300);
					}
			}
	} // end for loop
}

void moveballs(ball balls[],int numballs)
{
	// MOVE BALL
	for (int n=0;n<numballs;n++)
	{
		balls[n].x += balls[n].movex;
		balls[n].y += balls[n].movey;
	}
}

void drawballs(ball balls[],int numballs)
{
	for (int n=0;n<numballs;n++) balls[n].draw();
}
void ball::draw()
{
	//     [*] [*]
	//  [*][@] [*][*]
	//  [*][@] [*][*]
	//     [*] [*]

	for (int n=-1;n<2;n++)
	{
		putpixel(x+n,y-2,PURPLE);
		putpixel(x+n,y-1,PURPLE);
		putpixel(x+n,y+1,PURPLE);
		putpixel(x+n,y  ,PURPLE);
	}
	putpixel(x-2,y-1,PURPLE);
	putpixel(x-2,y  ,PURPLE);
	putpixel(x+2,y-1,PURPLE);
	putpixel(x+2,y  ,PURPLE);
	putpixel(x-1,y-1,WHITE);
	putpixel(x-1,y  ,WHITE);
}

void drawpaddles(paddle &paddle1,paddle &paddle2)
{
	// DRAW PADDLES
	if (paddle1.fcount > 4)
	{
		paddle1.state = 0;
		paddle1.fcount= 0;
	}
	if (paddle2.fcount > 4)
	{
		paddle2.state = 0;
		paddle2.fcount= 0;
	}
	if (!paddle1.state) vert(paddle1.side,paddle1.top,paddle1.top+paddle1.length,3,BLUE);
	else {
		 vert(paddle1.side,paddle1.top,paddle1.top+paddle1.length,3,RED);
		 paddle1.fcount++;
		 }
	if (!paddle2.state)	vert(paddle2.side,paddle2.top,paddle2.top+paddle2.length,3,YELLOW);
	else {
		 vert(paddle2.side,paddle2.top,paddle2.top+paddle2.length,3,RED);
		 paddle2.fcount++;
		 }
}

void hshoot(shot h_shots[],int &numHshots,paddle &paddle)
{
	if ( paddle.delaycount >= paddle.shotdelay)
	{
		switch (paddle.powerups)
		{
		case 1 :
			numHshots++;
			h_shots[numHshots-1].x = paddle.side+2;
			h_shots[numHshots-1].y = paddle.top + paddle.length / 2;
			h_shots[numHshots-1].movex = 3;
			h_shots[numHshots-1].movey = 0;
			break;
		case 2 :
			numHshots+=2;
			h_shots[numHshots-2].x     = paddle.side+2;
			h_shots[numHshots-2].y     = paddle.top +1;
			h_shots[numHshots-2].movex = 3;
			h_shots[numHshots-2].movey = 0;
			h_shots[numHshots-1].x     = paddle.side+2;
			h_shots[numHshots-1].y     = paddle.top + paddle.length - 2;
			h_shots[numHshots-1].movex = 3;
			h_shots[numHshots-1].movey = 0;
			break;
		case 3 :
			numHshots+=3;
			h_shots[numHshots-3].x     = paddle.side+2;
			h_shots[numHshots-3].y     = paddle.top+2;
			h_shots[numHshots-3].movex = 3;
			h_shots[numHshots-3].movey = -.75;
			h_shots[numHshots-2].x     = paddle.side+2;
			h_shots[numHshots-2].y     = paddle.top+paddle.length/2;
			h_shots[numHshots-2].movex = 3;
			h_shots[numHshots-2].movey = 0;
			h_shots[numHshots-1].x     = paddle.side+2;
			h_shots[numHshots-1].y     = paddle.top+paddle.length-2;
			h_shots[numHshots-1].movex = 3;
			h_shots[numHshots-1].movey = .75;
			break;
		case 4 :
			numHshots+=5;
			int spc = paddle.length/5;
			for (int n=0;n<5;n++)
			{
				h_shots[numHshots-n-1].x = paddle.side+2;
				h_shots[numHshots-n-1].movex = 3;
				h_shots[numHshots-n-1].movey = 0;
				h_shots[numHshots-n-1].y = paddle.top+n*spc;
			}
			break;
		case 5 :
			numHshots+=7;
			for (n=0;n<7;n++)
			{
				h_shots[numHshots-n-1].x = paddle.side-2;
				h_shots[numHshots-n-1].movex = -1.5;
				h_shots[numHshots-n-1].movey = .35*(n-3);
				h_shots[numHshots-n-1].y = paddle.top+paddle.length/2+(n-3)*3;
			}
			break;
		case 6 :
			paddle.shotdelay=10;
			numHshots+=4;
			for (n=0;n<4;n++)
			{
				h_shots[numHshots-n-1].x = paddle.side+3;
				h_shots[numHshots-n-1].movex = random(3)+1;
				h_shots[numHshots-n-1].basey = paddle.top + n*(paddle.length/4);
				h_shots[numHshots-n-1].frame = 1;
			}
			break;
		}
		paddle.delaycount = 0;
	}
	else paddle.delaycount++;
}

void cshoot(shot c_shots[],int &numCshots,paddle &paddle)
{
	if ( paddle.delaycount >= paddle.shotdelay)
	{
	   switch (paddle.powerups)
	   {
	   case 1 :
			numCshots++;
			c_shots[numCshots-1].x = paddle.side-2;
			c_shots[numCshots-1].y = paddle.top + paddle.length / 2;
			c_shots[numCshots-1].movex = -3;
			c_shots[numCshots-1].movey = 0;
			break;
	   case 2 :
			numCshots+=2;
			c_shots[numCshots-2].x     = paddle.side+2;
			c_shots[numCshots-2].y     = paddle.top +1;
			c_shots[numCshots-2].movex = -3;
			c_shots[numCshots-2].movey = 0;
			c_shots[numCshots-1].x     = paddle.side+2;
			c_shots[numCshots-1].y     = paddle.top + paddle.length - 2;
			c_shots[numCshots-1].movex = -3;
			c_shots[numCshots-1].movey = 0;
			break;
		case 3 :
			numCshots+=3;
			c_shots[numCshots-3].x     = paddle.side-2;
			c_shots[numCshots-3].y     = paddle.top+2;
			c_shots[numCshots-3].movex = -3;
			c_shots[numCshots-3].movey = -.75;
			c_shots[numCshots-2].x     = paddle.side-2;
			c_shots[numCshots-2].y     = paddle.top+paddle.length/2;
			c_shots[numCshots-2].movex = -3;
			c_shots[numCshots-2].movey = 0;
			c_shots[numCshots-1].x     = paddle.side-2;
			c_shots[numCshots-1].y     = paddle.top+paddle.length-2;
			c_shots[numCshots-1].movex = -3;
			c_shots[numCshots-1].movey = .75;
			break;
		case 4 :
			numCshots+=5;
			int spc = paddle.length/5;
			for (int n=0;n<5;n++)
			{
				c_shots[numCshots-n-1].x = paddle.side+2;
				c_shots[numCshots-n-1].movex = -3;
				c_shots[numCshots-n-1].movey = 0;
				c_shots[numCshots-n-1].y = paddle.top+n*spc;
			}
			break;
		case 5 :
			numCshots+=7;
			spc = paddle.length/7;
			for (n=0;n<7;n++)
			{
				c_shots[numCshots-n-1].x = paddle.side+2;
				c_shots[numCshots-n-1].movex = 1.5;
				c_shots[numCshots-n-1].movey = .35*(n-3);
				c_shots[numCshots-n-1].y = paddle.top+paddle.length/2+(n-3)*3;
			}
			break;
			case 6 :
			paddle.shotdelay=10;
			numCshots+=4;
			for (n=0;n<4;n++)
			{
				c_shots[numCshots-n-1].x = paddle.side-3;
				c_shots[numCshots-n-1].movex = -(random(3)+1);
				c_shots[numCshots-n-1].basey = paddle.top + n*(paddle.length/4);
				c_shots[numCshots-n-1].frame = 1;
			}
			break;
	   }
	   paddle.delaycount = 0;
	}
	else paddle.delaycount++;
}
void moveshots(shot h_shots[],shot c_shots[],int numHshots,int numCshots,paddle humanpad,paddle comppad)
{
	for (int n=0;n<numHshots;n++)
		{
		h_shots[n].x += h_shots[n].movex;
		if (humanpad.powerups==6) h_shots[n].y = 20*cos(h_shots[n].x/7)+h_shots[n].basey;
		else h_shots[n].y += h_shots[n].movey;
		}
	for (    n=0;n<numCshots;n++)
		{
		c_shots[n].x += c_shots[n].movex;
		if (comppad.powerups==6) c_shots[n].y = 20*cos(c_shots[n].x/7)+c_shots[n].basey;
		else c_shots[n].y += c_shots[n].movey;
		}
}
void updateshots (shot h_shots[],shot c_shots[],int &numHshots,int &numCshots,player &human,player &comp)
{
	for (int n=0;n<numHshots;n++)
		{
			// hit opponent?
			if (h_shots[n].x<=comp.mypaddle.side+3 && h_shots[n].x>=comp.mypaddle.side-3 &&
			h_shots[n].y>comp.mypaddle.top-3 && h_shots[n].y<comp.mypaddle.top+comp.mypaddle.length+3)
			{
				human.mypaddle.length+=2;
				comp.mypaddle.length-=2;
				if (comp.mypaddle.powerups>1 && comp.mypaddle.dgradedelay<15) comp.mypaddle.dgradedelay++;
				else if (comp.mypaddle.dgradedelay>=15)
					{
						comp.mypaddle.powerups--;
						comp.mypaddle.dgradedelay=0;
					}

				if (comp.score>.25) comp.score-=.25;
				for (int m=n;m<numHshots-1;m++) h_shots[m] = h_shots[m+1];
				numHshots--;
				comp.mypaddle.state = 1;
			}
			// off screen?
			if (h_shots[n].x > 314 || h_shots[n].y < 2 || h_shots[n].y > 197)
			{
				for (int m=n;m<numHshots-1;m++) h_shots[m] = h_shots[m+1];
				numHshots--;
			}
			// weapon characteristics
			if (human.mypaddle.powerups==5 && h_shots[n].movex<3) h_shots[n].movex+=.3;
			// update frame
			if (h_shots[n].frame<6) h_shots[n].frame++; else h_shots[n].frame=1;
		}
	for (    n=0;n<numCshots;n++)
		{
			// hit opponent?
			if (c_shots[n].x<=human.mypaddle.side+3 && c_shots[n].x>=human.mypaddle.side-3 &&
			c_shots[n].y>human.mypaddle.top-3 && c_shots[n].y<human.mypaddle.top+human.mypaddle.length+3)
			{
				comp.mypaddle.length+=2;
				human.mypaddle.length-=2;
				if (human.score>.25) human.score-=.25;
				if (human.mypaddle.powerups>1 && human.mypaddle.dgradedelay<15) human.mypaddle.dgradedelay++;
				else if (human.mypaddle.dgradedelay>=15)
					{
						human.mypaddle.powerups--;
						human.mypaddle.dgradedelay=0;
					}
				for (int m=n;m<numCshots-1;m++) c_shots[m] = c_shots[m+1];
				numCshots--;
				human.mypaddle.state = 1;
			}
			// off screen?
			if (c_shots[n].x < 6 || c_shots[n].y < 2 || c_shots[n].y > 197)
			{
				for (int m=n;m<numCshots-1;m++) c_shots[m] = c_shots[m+1];
				numCshots--;
			}
			// weapon characteristics
			if (comp .mypaddle.powerups==5 && c_shots[n].movex<3) c_shots[n].movex-=.3;
			// update frame
			if (c_shots[n].frame<6) c_shots[n].frame++; else c_shots[n].frame=1;
		}
}
void drawshots(shot h_shots[],shot c_shots[],int numHshots,int numCshots,player human,player comp)
{
	for (int n=0;n<numHshots;n++) h_shots[n].draw(human.mypaddle.powerups,h_shots[n].frame,1);
	for (    n=0;n<numCshots;n++) c_shots[n].draw(comp .mypaddle.powerups,c_shots[n].frame,-1);
}
void shot::draw(int type,int frame,int d)
{
// type 1, 2, and 4:
//  -3 -2 -1 x  1  2  3
// [ ][ ][ ][ ][*][*][ ] -2
// [ ][ ][*][*][#][#][*] -1
// [*][*][*][*][#][#][*]  y
// [ ][ ][*][*][*][*][*]  1
// [ ][ ][ ][ ][*][*][ ]  2

	switch (type)
	{
	case 1 :
	case 2 :
		switch (d)
		{
		case 1 :
			for (int n=-3;n<4;n++) putpixel(x+n,y,RED);
			for (    n=-1;n<4;n++) { putpixel(x+n,y-1,RED); putpixel(x+n,y+1,RED); }
			for (    n=1 ;n<3;n++) { putpixel(x+n,y-2,RED); putpixel(x+n,y+2,RED); }
			putpixel(x+1,y-1,YELLOW);
			putpixel(x+2,y-1,YELLOW);
			putpixel(x+1,y  ,YELLOW);
			putpixel(x+2,y  ,YELLOW);
			break;
		case -1:
			for (    n=-3;n<4;n++) putpixel(x+n,y,RED);
			for (    n=-3;n<2;n++) { putpixel(x+n,y-1,RED); putpixel(x+n,y+1,RED); }
			for (    n=-2;n<0;n++) { putpixel(x+n,y-2,RED); putpixel(x+n,y+2,RED); }
			putpixel(x-1,y-1,YELLOW);
			putpixel(x-2,y-1,YELLOW);
			putpixel(x-1,y  ,YELLOW);
			putpixel(x-2,y  ,YELLOW);
			break;
		}
		break;
	case 3 :
		switch (frame)
		{
		case 1 :
		case 2 :
		case 3 :
			putpixel(x-2,y-3,BLUE);
			putpixel(x+2,y-3,BLUE);
			putpixel(x-2,y+3,BLUE);
			putpixel(x+2,y+3,BLUE);
			for (int n=-3;n<0;n++)
			{
				putpixel(x+n,y-2,BLUE);
				putpixel(x+n,y+2,BLUE);
			}
			for (    n=1;n<4;n++)
			{
				putpixel(x+n,y-2,BLUE);
				putpixel(x+n,y+2,BLUE);
			}
			for (    n=-2;n<3;n++)
			{
				putpixel(x+n,y-1,BLUE);
				putpixel(x+n,y+1,BLUE);
			}
			for (    n=-1;n<2;n++) putpixel(x+n,y,BLUE);
			//highlights
			putpixel(x-1,y-1,GREEN);
			putpixel(x+1,y-1,GREEN);
			putpixel(x,y,GREEN);
			putpixel(x-1,y+1,GREEN);
			putpixel(x+1,y+1,GREEN);
			break;
		case 4 :
		case 5 :
		case 6 :
			for (    n=-3;n<4;n++)
			{
				putpixel(x+n,y-1,BLUE);
				putpixel(x+n,y  ,BLUE);
				putpixel(x+n,y+1,BLUE);
			}
			for (    n=-1;n<2;n++)
			{
				putpixel(x+n,y-3,BLUE);
				putpixel(x+n,y-2,BLUE);
				putpixel(x+n,y+2,BLUE);
				putpixel(x+n,y+3,BLUE);
			}
			// highlightes
			putpixel(x-1,y  ,GREEN);
			putpixel(x  ,y  ,GREEN);
			putpixel(x  ,y-1,GREEN);
			putpixel(x  ,y+1,GREEN);
			putpixel(x+1,y  ,GREEN);
			break;
		}
		break;
	case 4 :
		switch (d)
		{
		case 1 :
			for (int n=-3;n<4;n++) putpixel(x+n,y,GREEN);
			for (    n=-1;n<4;n++) { putpixel(x+n,y-1,GREEN); putpixel(x+n,y+1,GREEN); }
			for (    n=1 ;n<3;n++) { putpixel(x+n,y-2,GREEN); putpixel(x+n,y+2,GREEN); }
			putpixel(x+1,y-1,ORANGE);
			putpixel(x+2,y-1,ORANGE);
			putpixel(x+1,y  ,ORANGE);
			putpixel(x+2,y  ,ORANGE);
			break;
		case -1:
			for (    n=-3;n<4;n++) putpixel(x+n,y,GREEN);
			for (    n=-3;n<2;n++) { putpixel(x+n,y-1,GREEN); putpixel(x+n,y+1,GREEN); }
			for (    n=-2;n<0;n++) { putpixel(x+n,y-2,GREEN); putpixel(x+n,y+2,GREEN); }
			putpixel(x-1,y-1,ORANGE);
			putpixel(x-2,y-1,ORANGE);
			putpixel(x-1,y  ,ORANGE);
			putpixel(x-2,y  ,ORANGE);
			break;
		}
		break;
// type 5 and 3:

// frame 1:

//  -3 -2 -1 x  1  2  3
// [ ][*][ ][ ][ ][*][ ]-3
// [*][@][*][ ][*][@][*]-2
// [ ][*][#][*][#][*][ ]-1
// [ ][ ][*][#][*][ ][ ] y
// [ ][*][#][*][#][*][ ] 1
// [*][@][*][ ][*][@][*] 2
// [ ][*][ ][ ][ ][*][ ] 3

// frame 2:

// [ ][ ][*][*][*][ ][ ]
// [ ][ ][*][@][*][ ][ ]
// [*][*][*][#][*][*][*]
// [*][@][#][#][#][@][*]
// [*]* ][*][#][*][*][*]
// [ ][ ][*][@][*][ ][ ]
// [ ][ ][*][*][*][ ][ ]

	case 5 :
		switch (frame)
		{
		case 1 :
		case 2 :
		case 3 :
			putpixel(x-2,y-3,RED);
			putpixel(x+2,y-3,RED);
			putpixel(x-2,y+3,RED);
			putpixel(x+2,y+3,RED);
			for (int n=-3;n<0;n++)
			{
				putpixel(x+n,y-2,RED);
				putpixel(x+n,y+2,RED);
			}
			for (    n=1;n<4;n++)
			{
				putpixel(x+n,y-2,RED);
				putpixel(x+n,y+2,RED);
			}
			for (    n=-2;n<3;n++)
			{
				putpixel(x+n,y-1,RED);
				putpixel(x+n,y+1,RED);
			}
			for (    n=-1;n<2;n++) putpixel(x+n,y,RED);
			//highlights
			putpixel(x-1,y-1,ORANGE);
			putpixel(x+1,y-1,ORANGE);
			putpixel(x,y,ORANGE);
			putpixel(x-1,y+1,ORANGE);
			putpixel(x+1,y+1,ORANGE);
			break;
		case 4 :
		case 5 :
		case 6 :
			for (    n=-3;n<4;n++)
			{
				putpixel(x+n,y-1,RED);
				putpixel(x+n,y  ,RED);
				putpixel(x+n,y+1,RED);
			}
			for (    n=-1;n<2;n++)
			{
				putpixel(x+n,y-3,RED);
				putpixel(x+n,y-2,RED);
				putpixel(x+n,y+2,RED);
				putpixel(x+n,y+3,RED);
			}
			// highlightes
			putpixel(x-1,y  ,ORANGE);
			putpixel(x  ,y  ,ORANGE);
			putpixel(x  ,y-1,ORANGE);
			putpixel(x  ,y+1,ORANGE);
			putpixel(x+1,y  ,ORANGE);
			break;
		}
		break;
	case 6 :
		for (int n=-1;n<2;n++)
		{
			putpixel(x+n,y-2,YELLOW);
			putpixel(x+n,y-1,GREEN);
			putpixel(x+n,y+1,GREEN);
			putpixel(x+n,y  ,YELLOW);
		}
		putpixel(x-2,y-1,GREEN);
		putpixel(x-2,y  ,GREEN);
		putpixel(x+2,y-1,YELLOW);
		putpixel(x+2,y  ,YELLOW);
		putpixel(x-1,y-1,GREEN);
		putpixel(x-1,y  ,GREEN);
		break;
	}
}