/*	
 *	PONG! - Nick Slaven 21st April 1998
 * 			written in 2.5 days
 *
 *  www.netyaroze-europe.com/~nslaven/
 *  NickSlaven@Compuserve.com
 *	
 */




#include <libps.h>
#include "pad.h"




//debug flag 
//#define DEBUG




// display stuff with the all important Ordered Table & Packet Area
#define OT_LENGTH		1		
#define MAXPACKETS		25000	/* 	mysterious, just think of a number and double it! */

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




// sound data
#define SND_VH		((unsigned char*)(0x80090000))
#define	SND_VB		((unsigned char*)(0x80091000))
short	VabId;




// display area
#define VIDEO_FLAG	((unsigned char*)(0x80092000)) /* as downloaded by siocons batch file */
#define FRAME_X		320
#define BOUNDARY	4
// chunky text
#define TXC_WH		8
int		VideoMode;
int		FrameY;

typedef struct tagSEGDISPLAY	
		{
		char	D[5][4];
		} SEGDISPLAY;



// joypad 
// macro for quick return of pad status
// _p is the port address (for PSX port 1 use 0, for PSX port 2 use 1)
// _r is the value read from the port (PadRead())
// _t is the value you wanna test against
#define 		IsPAD(_p,_r,_t)				((_t)==((_t)&((_p)?((_r)>>16):(_r))))
#define 		PADexit						(PADstart|PADselect)
// Controller input buffers
volatile u_char *bb0, *bb1;
// current padvalue
u_long			PadValue;

int                     Pad1v, Pad2v;



// game definition 
#define BAT_W			8
#define BAT_H			32
#define	BALL_WH			8
#define COLOUR			0x80
#define BALL_SPEED		5
#define BALL_FAST		10
#define GAME_WIN_SCORE	5

typedef struct tagBALL
	{
	GsBOXF	Bx;			// box for ball
	int		Vx,Vy;		// x & y velocity of ball
	int		InServe;	// Flag for ball being served or in play
	int		Server;		// index of player serving
	} BALL;

typedef struct tagPLAYER
	{
	GsBOXF	Bat;		
	int		Score;		
	int		SlamOn;		// is "circle" button pressed
	int		SlamCnt;	// timing of "circle" button press
	} PLAYER;


BALL	Ball;
PLAYER	Player[2];
GsBOXF	Court[2];
int		GameOn=0;




// function prototypes
u_long	PadRead(void);
void	PadAction(void);
void	InitGFX(void);
void	InitWorld(void);
void	CollisionDetect(void);
void	UpdateBall(void);
void	DispScore(void);
void 	DispDigit(int,int,char);
void	PlayTune(void);
void 	DispTitle(void);
void	GameInit(void);




inline u_long PadRead()
{
        // Get analog pad (vertical) positions
        Pad1v = *(bb0+7) - (BAT_H>>1);
        Pad2v = *(bb1+7) - (BAT_H>>1);

	return(~(*(bb0+3) | *(bb0+2) << 8 | *(bb1+3) << 16 | *(bb1+2) << 24));
}




inline int	BoxColl(GsBOXF * b1,GsBOXF *b2)
{
	int		dx,dy;
	
	dx=b2->x-b1->x;
	dy=b2->y-b1->y;
	if((dx<b1->w)&&(dx>-b2->w)&&(dy<b1->h)&&(dy>-b2->h))	return 1;
	else													return 0;
}




// ------------------------------------- MAIN
int main(void)
{
	int				i,cnt;
	
	InitGFX();
	InitWorld();
	VabId=SsVabTransfer(SND_VH,SND_VB,-1,1);

	while (!IsPAD(0,PadValue=PadRead(),PADexit)) 
		{
		activeBuff = GsGetActiveBuff();								// Get working video buffer index
		GsSetWorkBase((PACKET *)GpuPacketArea[activeBuff]);			// set working area accordingly
		GsClearOt(0, 0, &WorldOT[activeBuff]);						// clear working ordered table area
		if(GameOn)
			{
			CollisionDetect();
			PadAction();
			UpdateBall();
			}
		else
			{
			DispTitle();
			if(IsPAD(0,PadValue,PADstart))	
				GameInit();
			}
		GsSortBoxFill(&Ball.Bx,&WorldOT[activeBuff], 0);			// place the "rectangle" primitive for the ball, ..
		for(i=0;i<2;i++)
			{
			GsSortBoxFill(&Player[i].Bat,&WorldOT[activeBuff], 0);	// .. the bats
			GsSortBoxFill(&Court[i]		,&WorldOT[activeBuff], 0);	// .. and the Court,
			}														// into the working ordered table
		DrawSync(0);												// make sure we have drawn all the stuff from
																	// the ordered table we filled last time round the
																	// while loop (see GsDrawOt below)
		cnt = VSync(0);												// wait for vertical blank
		GsSwapDispBuff();											// switch display and working video buffers
		GsSortClear(0, 0, 0, &WorldOT[activeBuff]);					// place the "clear screen" primitive in the
																	// working ordered table
		GsDrawOt(&WorldOT[activeBuff]);								// finally tell GPU to draw working ordered table
																	// contents on working video buffer
																	// remember this is a parallel process, and
																	// items at same level in ordered table are drawn
																	// in reverse placing order
		#ifdef DEBUG		
		FntPrint("VSync:%d\n",cnt);
		FntPrint("X :%d\tY :%d\nvX:%d\tvY:%d\n",Ball.Bx.x,Ball.Bx.y,Ball.Vx,Ball.Vy);
		FntFlush(-1);
		#endif
	}
	SsVabClose(VabId);
	ResetGraph(3);
	return(0);
}




void PadAction(void)
{
	int 	i,x;
	
        // Set bats to analog position
        if ( (*(bb0+1) >> 4) == 0x7 )                   // Analog pad
                Player[0].Bat.y = Pad1v;
        else                                            // Normal pad
                {
                if(IsPAD(0,PadValue,PADRdown))          x=10; else x=1;
                if(IsPAD(0,PadValue,PADLup  ))          Player[0].Bat.y-=x;
                if(IsPAD(0,PadValue,PADLdown))          Player[0].Bat.y+=x;
                }

        if ( (*(bb1+1) >> 4) == 0x7 )                   // Analog pad
                Player[1].Bat.y = Pad2v;
        else                                            // Normal pad
                {
                if(IsPAD(1,PadValue,PADRdown))          x=10; else x=1;
                if(IsPAD(1,PadValue,PADLup  ))          Player[1].Bat.y-=x;
                if(IsPAD(1,PadValue,PADLdown))          Player[1].Bat.y+=x;
                }

	for(i=0;i<2;i++)
		{
                if(!IsPAD(i,PadValue,PADRright))        Player[i].SlamOn=0;
                if(!IsPAD(i,PadValue,PADRright))        Player[i].SlamOn=0;

		if(Player[i].SlamOn && Player[i].SlamCnt)	
			--Player[i].SlamCnt;		
		
		if(IsPAD(i,PadValue,PADRright)&&!Player[i].SlamOn)	
			{
			Player[i].SlamOn =1;
			Player[i].SlamCnt=3;
			}
		
		#ifdef DEBUG
		if(i==1)
			Player[i].Bat.y=Ball.Bx.y+BALL_WH/2-BAT_H/2;
		#endif
		limitRange(Player[i].Bat.y,0,FrameY-BAT_H);
		}
}




void	GameInit(void)
{
	int		i;
	
	GameOn=1;
	for(i=0;i<2;i++)
		{
		Player[i].Score  =0;
		Player[i].Bat.y  =(FrameY-BAT_H)/2;
		Player[i].SlamOn =0;
		Player[i].SlamCnt=0;
		}
}




void	CollisionDetect(void)
{
	int 	i,dist,v;

	for(i=0;i<2;i++)
		{
		// ball hits bat ?		
		if(BoxColl(&Player[i].Bat,&Ball.Bx))
			{
			if(Player[i].SlamOn && Player[i].SlamCnt)	
				{
				if(i)	SsUtKeyOn(VabId,0,0,72,0,  0,127);				
				else	SsUtKeyOn(VabId,0,0,69,0,127,  0);	
				v=BALL_FAST;
				}
			else
				v=BALL_SPEED;
			Ball.Vx=i?-v:v;
			dist=Ball.Bx.y-Player[i].Bat.y-(BAT_H-BALL_WH)/2;
			Ball.Vy=dist/2;
			if(i)	SsUtKeyOn(VabId,0,0,60,0,  0,127);				
			else	SsUtKeyOn(VabId,0,0,57,0,127,  0);	
			}
		// ball off left or right edges, then player has scored !!!
		if( ((i==0)&&(Ball.Bx.x>=FRAME_X-BALL_WH/2)) ||
			((i==1)&&(Ball.Bx.x<=-BALL_WH/2		  )) )
			{
			Player[i].Score++;
			if(Player[i].Score==GAME_WIN_SCORE)
				GameOn=0;
			Ball.Server=i;
			Ball.InServe=1;
			PlayTune();
			#ifdef DEBUG
			Ball.Server=0;
			#endif
			}
		// ball hits court walls ?
		if(BoxColl(&Court[i],&Ball.Bx))
			{
			Ball.Vy=-Ball.Vy;
			SsUtKeyOn(VabId,0,0,53,0,127,127);
			}
		}
}




void PlayTune(void)
{
static short	Note[]={48,52,55,57,58,48,52,55,57,58,48,52,55,57,58};
short			i,j,voice;

for(i=0;i<sizeof(Note)/sizeof(short);i++)
	{
	voice=SsUtKeyOn(VabId,0,0,Note[i],0,127,127);
	for(j=0;j<5;j++)// a rather cheap way of timing the tune
		VSync(0);
	SsUtKeyOff(voice,VabId,0,0,Note[i]);		
	}
}




void	InitGFX(void)
{
	int 	i;
	
	if(*VIDEO_FLAG=='N')	{VideoMode=MODE_NTSC;FrameY=240;}
	else					{VideoMode=MODE_PAL; FrameY=256;}
	
	SetVideoMode(VideoMode);				
	GetPadBuf(&bb0, &bb1);					
	GsInitGraph(FRAME_X, FrameY, 4, 0, 0);			
	GsDefDispBuff(0, 0, 0, FrameY);

	// a fix to get the proper 256 lines on the screen ! thank you Alex Herbert (newsgroups 2d programming)
	GsDISPENV.screen.h = FrameY;
        if (VideoMode)
                GsDISPENV.screen.y = 20;

	// Ordering table information setting 
	for (i = 0; i < 2; i++) 
		{
		WorldOT[i].length = OT_LENGTH;
		WorldOT[i].org = OTTags[i];
		}
	#ifdef	DEBUG
	FntLoad(960, 256);	
	FntOpen(16, 16, 256, 200, 0, 512);	
	#endif
}




void	InitWorld(void)
{
	int		i;
	
	for(i=0;i<2;i++)
		{
		Court[i].attribute=0;
		Court[i].x=0;
		Court[i].y=i?FrameY-BOUNDARY:0;
		Court[i].w=FRAME_X;
		Court[i].h=BOUNDARY;
		Court[i].r=Court[i].g=Court[i].b=COLOUR;
		Player[i].Bat.attribute=0;
		Player[i].Bat.x=i?FRAME_X-BAT_W:0;
		Player[i].Bat.y=(FrameY-BAT_H)/2;
		Player[i].Bat.w=BAT_W;
		Player[i].Bat.h=BAT_H;
		Player[i].Bat.r=Player[i].Bat.g=Player[i].Bat.b=COLOUR;
		}
	Ball.Bx.attribute=0;
	Ball.Bx.w=Ball.Bx.h=BALL_WH;
	Ball.Bx.r=Ball.Bx.g=Ball.Bx.b=COLOUR;
	Ball.InServe=1;
	Ball.Server=0;
}



void UpdateBall(void)
{
	if(Ball.InServe)	
		{
		Ball.Bx.x=Player[Ball.Server].Bat.x+Ball.Server?FRAME_X-BAT_W-BALL_WH:BAT_W;
		Ball.Bx.y=Player[Ball.Server].Bat.y+(BAT_H-BALL_WH)/2;
		if(IsPAD(Ball.Server,PadValue,PADRleft))
			{
			Ball.InServe=0;
			Ball.Vx=Ball.Server?-BALL_SPEED:BALL_SPEED;
			Ball.Vy=0;
			}
		DispScore();
		}
	else				
		{
		Ball.Bx.x+=Ball.Vx;
		Ball.Bx.y+=Ball.Vy;
		}
}




void DispScore(void)
{
	int		i,j,N,XStart,YStart;
	char	Nums[2];

	if(Player[Ball.Server].Bat.y<FrameY/2)	YStart=FrameY-(BOUNDARY*2+5*BALL_WH);
	else									YStart=BOUNDARY*2;
	
	for(i=0;i<2;i++)
		{
		Nums[0]=Player[i].Score%10;
		Nums[1]=Player[i].Score/10;
		
		if(Nums[1])	N=2;
		else 		N=1;
		
		if(i==0)	XStart=BOUNDARY+BAT_W+((N-1)*5+1)*BALL_WH;
		else		XStart=FRAME_X-(BOUNDARY+BAT_W+5*BALL_WH);
			
		for(j=0;j<N;j++,XStart-=5*TXC_WH)
			DispDigit(XStart,YStart,Nums[j]);
		}
}




void DispTitle(void)
{
	static char	Title[]={'P',0,'N','G'};
	int			XStart,YStart,i;

	XStart=(FRAME_X-4*5*TXC_WH)/2;
	YStart=(FrameY-5*TXC_WH)/2;
	for (i=0;i<4;i++,XStart+=5*TXC_WH)
		DispDigit(XStart,YStart,Title[i]);
	DispScore();
}




void DispDigit(int XStart,int YStart,char DigNo)
{
	static SEGDISPLAY Zero	={1,1,1,1,1,0,0,1,1,0,0,1,1,0,0,1,1,1,1,1};
	static SEGDISPLAY One	={0,1,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,1,1};				
	static SEGDISPLAY Two	={1,1,1,1,0,0,0,1,1,1,1,1,1,0,0,0,1,1,1,1};				
	static SEGDISPLAY Three	={1,1,1,1,0,0,0,1,0,1,1,1,0,0,0,1,1,1,1,1};				
	static SEGDISPLAY Four	={1,0,0,0,1,0,1,0,1,0,1,0,1,1,1,1,0,0,1,0};				
	static SEGDISPLAY Five	={1,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,1};				
	static SEGDISPLAY Six	={1,0,0,0,1,0,0,0,1,1,1,1,1,0,0,1,1,1,1,1};				
	static SEGDISPLAY Seven	={1,1,1,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1};				
	static SEGDISPLAY Eight	={1,1,1,1,1,0,0,1,1,1,1,1,1,0,0,1,1,1,1,1};				
	static SEGDISPLAY Nine	={1,1,1,1,1,0,0,1,1,1,1,1,0,0,0,1,0,0,0,1};				
	static SEGDISPLAY P		={1,1,1,1,1,0,0,1,1,1,1,1,1,0,0,0,1,0,0,0};
	static SEGDISPLAY N		={1,0,0,1,1,1,0,1,1,0,1,1,1,0,0,1,1,0,0,1};
	static SEGDISPLAY G		={1,1,1,1,1,0,0,0,1,0,1,1,1,0,0,1,1,1,1,1};
	
	static SEGDISPLAY *Seg[13]={&Zero,&One,&Two,&Three,&Four,&Five,&Six,&Seven,&Eight,&Nine,&P,&N,&G};
	static GsBOXF	  SBox	={0L,0,0,TXC_WH,TXC_WH,COLOUR,COLOUR,COLOUR};
	
	int		x,y;
	
	if(DigNo=='P')	DigNo=10;
	if(DigNo=='N')	DigNo=11;
	if(DigNo=='G')	DigNo=12;

	for(x=0;x<4;x++)
		{
		for(y=0;y<5;y++)
			{
			if(Seg[DigNo]->D[y][x])
				{
				SBox.x=XStart+x*TXC_WH;
				SBox.y=YStart+y*TXC_WH;
				GsSortBoxFill(&SBox,&WorldOT[activeBuff], 0);		
				}
			}
		}
}