/*
	Hardwire
	
	Sprite based puzzle game.  Based on MSDOS version.
	
	Version history
	---------------
	
	10/05/98	Moved to GCC (hoorah)
	20/07/98	Version 2 to try and come up with a GDUK entry. Cripes!
	13/08/98	Moved to RCS control.  Log follows.

	$Log: hardwire.c,v $
	Revision 1.3  1998/08/23 21:00:39  dosuser
	Version used for GDUK competition

	Revision 1.2  1998/08/13 22:07:23  dosuser
	Working version before moving scroller to credit page and adding SFX

	Revision 1.1  1998/07/13 21:17:04  dosuser
	Initial revision

*/
static char rcs_id[]="$Id: hardwire.c,v 1.3 1998/08/23 21:00:39 dosuser Exp dosuser $";

#include <libps.h>
#include <sys/types.h>
#include <rand.h>

#include "common.h"
#include "sprint.h"
#include "sprite.h"
#include "tmddef.h"

#include "ft16_tim.h"
#include "ft_tim.h"
#include "spr_tim.h"
#include "text_tim.h"

#include "sfx_vb.h"
#include "sfx_vh.h"


#include "t_seq.h"
#include "g_seq.h"

#define TRACE(x)	printf("*** TRACE %d\n",x)


/* PS constants
*/
#define MODE		MODE_PAL
#define SCRW		320
#define SCRH		240
#define CX		160
#define CY		128

#define OT_LEN		10	/* Length of order table */
#define MAXCHAR		500	/* Max sprites allocated to printing */
#define MAXSPRITE	500	/* Max sprites allocated to sprite drawing */
#define TOTSPRITE	MAXCHAR+MAXSPRITE


/* Game definitions
*/
#define NOMODE		3

#define MINPITW		6
#define MAXPITW		9
#define DEFPITW		9
#define PITDEPTH	12
#define PATHLEN		(PITDEPTH*MAXPITW)

#define MAXLEV		10

#define LEVELCTR(x)	MAX(0,(45-(x)*4))

#define SPRSIZE		13
#define SPRCENTRE	7
#define PITXOFF		((SPRSIZE*2)+((MAXPITW-PITW)*SPRSIZE/2))
#define PITYOFF		SPRSIZE*5

#define PITX(x)		(((x)*SPRSIZE)+PITXOFF)
#define PITY(y)		(((y)*SPRSIZE)+PITYOFF)

#define SCOREPX		200
#define SCOREX		(SCOREPX+50)
#define SCOREY		120

#define LEVELPX		200
#define LEVELX		(LEVELPX+50)
#define LEVELY		100

#define NEXTPX		200
#define NEXTX		(NEXTPX+50)
#define NEXTY		20

#define NODIR		-1
#define LEFT		0
#define UP		1
#define RIGHT		2
#define DOWN		3

#define ROR(x)		((x) ? ((x)-1) : (3))
#define ROL(x)		(((x)+1)%4)

int			xi[4]={-1,0,1,0};
int			yi[4]={0,-1,0,1};

char	*mode[NOMODE]=	{" EASY",
			 " HARD",
			 "HECK!"};


/* Sprite definitions
*/
#define PIT_TL		0
#define PIT_ML		1
#define PIT_BL		2
#define PIT_BM		3
#define PIT_BR		4
#define PIT_MR		5
#define PIT_TR		6

#define BLANK		-1
#define PATH		7
#define CROSS		8
#define ACROSS		9
#define UPDOWN		10
#define LEFTDOWN	11
#define LEFTUP		12
#define RIGHTUP		13
#define RIGHTDOWN	14
#define SPECIAL		15

#define PLX_BASE	20

#define SPRADD(no)	(((no)%16)*16),(((no)/16)*16)
#define SPRADDX(no)	(((no)%16)*16)
#define SPRADDY(no)	(((no)/16)*16)

/* Sprite priorities
*/
#define PRI_BACK	10
#define PRI_PIT		5
#define PRI_PIECE	5
#define PRI_PATH	4
#define PRI_TEXT	3
#define PRI_FORE	2
#define PRI_FADE	1
#define PRI_DEBUG	0


/* Font tables - not used
short		fw8[256],fw16[256];
*/


/* Definie pit
*/
typedef struct
	{
	int		data[PITDEPTH][MAXPITW];
	int		id[PITDEPTH][MAXPITW];
	} Pit;

Pit		pit;

typedef struct
	{
	int		x,y;
	} PathElem;

typedef struct
	{
	int		len;
	PathElem	p[PATHLEN];
	int		spr[PATHLEN];
	} Path;


/* Definie piece types and control structs
*/
#define PIECE_SIZE	5

typedef struct
	{
	int		ox,oy;
	int		data[PIECE_SIZE][PIECE_SIZE];
	} Piece;

typedef struct
	{
	int		no;
	int		piece[5];
	} PieceSet;

typedef struct
	{
	int		x,y;
	} Offset;

typedef struct
	{
	int		no;
	Piece		*map;
	Offset		*offset;
	int		*height;
	} PieceMap;

#include "pset.c"
#include "map4.c"

PieceSet	*piece_set;
PieceMap	*piece_map=&piece_map4;

PieceSet	*piece_set_list[NOMODE]=
			{
			piece_set_cross,
			piece_set_rnd,
			piece_set_no_rnd
			};


/* Define the game
*/
typedef struct
    {
    int		score;
    int		level;
    char	name[4];
    } Hisc;

typedef struct
    {
    int		x,y;
    int		level;
    int		score;
    int		rotate;
    int		is_special;
    int		current_type;
    Piece	current;
    int		next_is_special;
    int		next_type;
    Piece	next;
    } Game;


Game		game;


/* Sprite/TIM vars
*/
GsIMAGE		font_img,font16_img,sprite_img,texture_img;
int		font_tp,font16_tp,sprite_tp,texture_tp;


/* PS globals
*/
volatile u_char	*pad1,*pad2;

#define P_UP		0
#define P_DOWN		1
#define P_LEFT		2
#define P_RIGHT		3
#define P_CROSS		4
#define P_SQUARE	5
#define P_START		6
#define P_SELECT	7
#define P_NO		8

typedef struct
	{
	int	bounce;
	int	cnt;
	int	pressed;
	int	code;
	} PadState;

/* Bounce val of -1 effectively no bouncing
*/
PadState	padmap[P_NO]=
			{
				{1,0,0,PS_PADUP},	/* UP */
				{1,0,0,PS_PADDOWN},	/* DOWN */
				{1,0,0,PS_PADLEFT},	/* LEFT */
				{1,0,0,PS_PADRIGHT},	/* DOWN */
				{1,0,0,PS_PADCROSS},	/* CROSS */
				{1,0,0,PS_PADSQUARE},	/* SQUARE */
				{-1,0,0,PS_PADSTART},	/* START */
				{-1,0,0,PS_PADSELECT},	/* SELECT */
			};
						  
int		bounce_weight=1;

#define PRESS(x)	(padmap[(x)].pressed)
#define SetBounce(x)	bounce_weight=(x)


/* Ordering tables and GPU odds and sods...
*/
GsOT		ot[2];
GsOT_TAG	ot_tag[2][1<<OT_LEN];

PACKET		gpu_packet[2][2048*(24)];	/* Plenty of room... ?!? */
int		frame;


/* Sound data
*/
short		vab_id;
short		title_seq_id=-1;
short		game_seq_id=-1;
short		current_seq=-1;

u_long		stdvb[402000/4];
u_long		stdvh[61000/4];

#define SOUND_BOTH	0
#define SOUND_MUSIC	1
#define SOUND_SFX	2

char		*sound_mode[3]={" BOTH","MUSIC","  SFX"};

#define SFX_GAMEOVER	(short)0
#define SFX_PIECELAND	(short)1
#define SFX_PATH	(short)2
#define SFX_SPECIAL	(short)3

short		sfx_vab_id;


/* Control data for the 3D plasma-ish backdrop
*/
#define BDROPSIZE	2000		/* Size of backdrop object */
#define BDROPNO		6		/* No of backdrop planes */
#define BDROPOBJ	4		/* No of triangles for each plane */
#define BDROPMINDIST	5000
#define BDROPFARDIST	1200
#define BDROPSPEED	0
#define BDROPINC	(BDROPFARDIST/BDROPNO)

TMDVertex		vertex[5]=
			    {
			    	{0,0,0,0},
			    	{-BDROPSIZE,-BDROPSIZE,0,0},
			    	{BDROPSIZE,-BDROPSIZE,0,0},
			    	{BDROPSIZE,BDROPSIZE,0,0},
			    	{-BDROPSIZE,BDROPSIZE,0,0},
			    };

TMDNormal		normal[1]=
			    {
			    	{0,0,ONE,0},
			    };

TMDTriTmapFlat		objdata[BDROPNO][BDROPOBJ];

TMDObject		tmdobj[BDROPNO];

typedef struct
    {
    GsDOBJ2		o;
    VECTOR		pos;
    SVECTOR		rot;
    GsCOORDINATE2	coord;
    } Object3d;

Object3d	obj3d[BDROPNO];
GsRVIEW2	view;

/* Defines various control points for the plasma
*/
int		vert_no[BDROPOBJ][3]=
			{
			    {1,2,0},
			    {0,2,3},
			    {0,3,4},
			    {1,0,4}
			};

int		bdrop_tmy[BDROPNO]={128,0,64,128,0,64};

int		vert_uv[5][2]=
			{
			    {32,32},
			    {0,0},
			    {63,0},
			    {63,63},
			    {0,63},
			};

/* Game control
*/
int		GAME=0;
int		LEVEL=1;
int		PITW=DEFPITW;
int		VOLUME=120;
int		SOUNDMODE=SOUND_BOTH;
int		QUIT=FALSE;
int		BDROP_ON=TRUE;


/* Protos
*/
static void	InitBDrop(void);
static void	UpdateBDrop(void);
static void	PadUpdate(void);
static void	PadFlush(void);

static void	PlayTune(short id);
static void	StopTune(void);
static void	PlaySFX(short id);
static void	FlushSFX(void);

static void	TitlePage(void);
static void	CreditPage(void);
static void	GoodbyePage(void);

static void	PlayGame(void);
static void	UpdateScores(void);
static void	DrawGameScreen(void);
static void	RedrawPit(void);
static void	DrawInfo(void);

static void	LoadCD(char *file, char *msg, u_long *addr);



/* -------------------------------------------------------------------------
				      MAIN
   ------------------------------------------------------------------------- */

main()
{
    int f,r;
    int x,y;
    int red,green,blue;

    /* Initiliase heap
    */
    PS_InitHeap();

    /* Load audio stuff from CD
    */
    LoadCD("\\DATA\\SOUND\\STD0.VB;1","LOADING VB",stdvb);
    LoadCD("\\DATA\\SOUND\\STD0.VH;1","LOADING VH",stdvh);

    /* Initialise PS graphics
    */
    SetVideoMode(MODE);			/* PAL or NTSC */
    GsInitGraph(SCRW,SCRH,4,0,0);	/* 16-bit screen with GPU offset */
    GsDefDispBuff(0,0,0,256);		/* Define two buffers in frame buffer */
    GsInit3D();				/* Init 3D system */

    /* Initialise TIM structures
    */
    PS_DecodeTIM(font_tim,&font_img,&font_tp);
    PS_DecodeTIM(font16_tim,&font16_img,&font16_tp);
    PS_DecodeTIM(sprite_tim,&sprite_img,&sprite_tp);
    PS_DecodeTIM(texture_tim,&texture_img,&texture_tp);

    /* Initialise TMD structures
    */
    for(f=0;f<BDROPNO;f++)
    	{
	tmdobj[f].vert=(u_long *)vertex;
	tmdobj[f].no_vert=5;
	tmdobj[f].norm=(u_long *)normal;
	tmdobj[f].no_norm=1;
	tmdobj[f].prim=(u_long *)&objdata[f][0];
	tmdobj[f].no_prim=BDROPOBJ;

	for(r=0;r<BDROPOBJ;r++)
	    {
	    objdata[f][r].wa_conv=0x07;
	    objdata[f][r].size=0x05;
	    objdata[f][r].flags=0x00;
	    objdata[f][r].mode=0x26;

	    objdata[f][r].cba=TMD_CLUT(texture_img.cx,texture_img.cy);
	    objdata[f][r].tsb=texture_tp|TMD_CLUT15|TMD_50_P_50;

	    objdata[f][r].u0=vert_uv[vert_no[r][0]][0];
	    objdata[f][r].v0=bdrop_tmy[f]+vert_uv[vert_no[r][0]][1];

	    objdata[f][r].u1=vert_uv[vert_no[r][1]][0];
	    objdata[f][r].v1=bdrop_tmy[f]+vert_uv[vert_no[r][1]][1];

	    objdata[f][r].u2=vert_uv[vert_no[r][2]][0];
	    objdata[f][r].v2=bdrop_tmy[f]+vert_uv[vert_no[r][2]][1];

	    objdata[f][r].norm0=0;

	    objdata[f][r].vert0=vert_no[r][0];
	    objdata[f][r].vert1=vert_no[r][1];
	    objdata[f][r].vert2=vert_no[r][2];
	    }

	/* Setup default objects co-ords
	*/
	obj3d[f].pos.vx=0;
	obj3d[f].pos.vy=0;
	obj3d[f].pos.vz=BDROPMINDIST+(f*BDROPINC);

	obj3d[f].rot.vx=0;
	obj3d[f].rot.vy=0;
	obj3d[f].rot.vz=0;

	obj3d[f].o.coord2=&obj3d[f].coord;
	GsInitCoordinate2(WORLD,&obj3d[f].coord);

	/* Link into object
	*/
	GsLinkObject4((u_long)&tmdobj[f],&obj3d[f].o,0);

	obj3d[f].o.attribute=GsALON;
	}

    /* Set the view up
    */
    GsSetProjection(500);

    view.vrx=0;         /* Where we're looking */
    view.vry=0;
    view.vrz=200;

    view.vpx=0;         /* Where we are */
    view.vpy=0;
    view.vpz=0;

    view.rz=0;          /* Rotation */
    view.super=WORLD;   /* Parent co-ord system */

    /* Store pad buffers
    */
    GetPadBuf(&pad1,&pad2);

    /* Set up ordering table info
    */
    for(f=0;f<2;f++)
	{
	ot[f].length=OT_LEN;
	ot[f].org=ot_tag[f];
	}

    /* Set up my library routines
    */
    InitSPrint(CX,CY,MAXCHAR,ot,ot+1,font_tp,font16_tp,
		font_img.cx,font_img.cy,font16_img.cx,font16_img.cy,NULL,NULL);
    InitSprite(CX,CY,MAXSPRITE,ot,ot+1,sprite_tp,sprite_img.cx,sprite_img.cy);
    InitBDrop();

    /* Initialise sounds
    */
    vab_id=SsVabTransfer((u_char *)stdvh,(u_char *)stdvb,-1,1);
    sfx_vab_id=SsVabTransfer((u_char *)sfx_vh,(u_char *)sfx_vb,-1,1);
    title_seq_id=SsSeqOpen(title_seq,vab_id);
    game_seq_id=SsSeqOpen(game_seq,vab_id);

    SsSetMVol(VOLUME,VOLUME);
    SsSeqSetVol(title_seq_id,127,127);
    SsSeqSetVol(game_seq_id,127,127);

    /* Main loop
    */
    TitlePage();

    while (!QUIT)
	{
	game.score=0;
	game.level=LEVEL;

	for(x=0;x<MAXPITW;x++)
	    for(y=0;y<PITDEPTH;y++)
		pit.data[y][x]=BLANK;

	piece_set=piece_set_list[GAME];

	PlayGame();

	TitlePage();
	}

    FlushSFX();
    SsSeqClose(title_seq_id);
    SsSeqClose(game_seq_id);
    SsVabClose(vab_id);
    SsVabClose(sfx_vab_id);

    GoodbyePage();
}


/* -------------------------------------------------------------------------
				 GRAPHICS UTILS
   ------------------------------------------------------------------------- */

void DebugText(void)
{
    char s[80];
    int x,y;

    return;

    sprintf(s,"CUR:%d  OX:%d  OY:%d  ROT:%d",
    		game.current_type,game.current.ox,game.current.oy,game.rotate);
    SPrint8(s,10,0,0,0,PRI_DEBUG,0x80,0x80,0x80);

    sprintf(s,"NEXT:%d",game.next_type);
    SPrint8(s,10,8,0,0,PRI_DEBUG,0x80,0x80,0x80);

    for(y=0;y<PIECE_SIZE;y++)
	{
	for(x=0;x<PIECE_SIZE;x++)
	    if (game.current.data[y][x]==BLANK)
	    	s[x]='.';
	    else
	    	s[x]='#';

	s[PIECE_SIZE]=0;
	SPrint8(s,10,20+y*8,0,0,PRI_DEBUG,0x80,0x80,0x80);
	}

}


void NewFrame(void)
{
    static RECT clip={0,0,SCRW,SCRH};

    /* Update pad
    */
    PadUpdate();

    /* Find current frame
    */
    frame=GsGetActiveBuff();

    /* Set clip
    */
    GsSetClip2D(&clip);

    /* Reset object users
    */
    SPrintNewFrame(frame);
    SpriteNewFrame(frame);

    /* Give the GPU some workspace
    */
    GsSetWorkBase((PACKET *)gpu_packet[frame]);

    /* Clear ordering table
    */
    GsClearOt(0,0,&ot[frame]);
}


void RedrawNewFrame(int r, int g, int b, int fade_pri)
{
    static RECT clip={0,0,SCRW,SCRH};

    /* Update pad and SFX
    */
    PadUpdate();

    /* Find current frame
    */
    frame=GsGetActiveBuff();

    /* Set clip
    */
    GsSetClip2D(&clip);

    /* Give the GPU some workspace
    */
    GsSetWorkBase((PACKET *)gpu_packet[frame]);

    /* Clear ordering table
    */
    GsClearOt(0,0,&ot[frame]);

    /* Redraw object users
    */
    SPrintRedraw(frame,r,g,b,fade_pri);
    SpriteRedraw(frame,r,g,b,fade_pri);
}


void PageFlip(int bdrop)
{
    if (bdrop)
	{
	DebugText();
	UpdateBDrop();
	}

    /* Wait for end of drawing and VBL
    */
    DrawSync(0);
    VSync(0);

    /* Swap the buffers
    */
    GsSwapDispBuff();

    /* Clear screen
    */
    GsSortClear(0,0,0,&ot[frame]);

    /* Draw pimitives associated to OT
    */
    GsDrawOt(&ot[frame]);
}


void FadeOut(void)
{
    static RECT clip={0,0,SCRW,SCRH};
    static GsBOXF box={(1<<30)|(2<<28),-CX,-CY,SCRW-1,255,0,0,0};
    int f;

    for(f=0x00;f<=0x80;f+=0x08)
	{	
	RedrawNewFrame(0x80,0x80,0x80,PRI_FADE);

	/* Draw the fade rectangle
	*/
	box.r=f;
	box.g=f;
	box.b=f;
	GsSortBoxFill(&box,&ot[frame],PRI_FADE);

	PageFlip(TRUE);
	}

    PageFlip(FALSE);
}


#define Centre8(str,y,trans,trans_mode,pri,r,g,b)	\
	    SPrint8(str,CX-strlen(str)*4,y,trans,trans_mode,pri,r,g,b)

#define Centre16(str,y,trans,trans_mode,pri,r,g,b)	\
	    SPrint16(str,CX-strlen(str)*8,y,trans,trans_mode,pri,r,g,b)


/* -------------------------------------------------------------------------
				 BACKDROP UTILS
   ------------------------------------------------------------------------- */

void InitBDrop(void)
{
    int f;

    view.rz=0;

    for(f=0;f<BDROPNO;f++)
	obj3d[f].rot.vz=0;
}


void UpdateBDrop(void)
{
    static int r=0,ri=16;
    static int g=0,gi=32;
    static int b=4096,bi=-32;
    int f;
    MATRIX mat;

    /* Set up lighting
    */
    GsSetAmbient(r,g,b);

    r+=ri;
    if ((r==0)||(r==4096))
    	ri=-ri;

    g+=gi;
    if ((g==0)||(g==4096))
    	gi=-gi;

    b+=bi;
    if ((b==0)||(b==4096))
    	bi=-bi;

    if (BDROP_ON)
	for(f=0;f<BDROPNO;f++)
	    {
	    if ((obj3d[f].pos.vz-=BDROPSPEED)<BDROPMINDIST)
		obj3d[f].pos.vz+=BDROPFARDIST;

	    if (f&1)
		{
		obj3d[f].rot.vz+=(ONE/2048)*(f+1);
		/* obj3d[f].rot.vx+=(ONE/720)*(f+1); */
		}
	    else
		{
		obj3d[f].rot.vz-=(ONE/2048)*(f+1);
		/* obj3d[f].rot.vy-=(ONE/720)*(f+1); */
		}

	    /* Get rotation matrix
	    */
	    RotMatrix(&obj3d[f].rot,&obj3d[f].coord.coord);

	    /* Set absolute translation
	    */
	    obj3d[f].coord.coord.t[0]=obj3d[f].pos.vx;
	    obj3d[f].coord.coord.t[1]=obj3d[f].pos.vy;
	    obj3d[f].coord.coord.t[2]=obj3d[f].pos.vz;

	    /* Tell GTE it's been updated
	    */
	    obj3d[f].coord.flg=0;

	    /* Calculate drawing, etc matrices
	    */
	    GsSetRefView2(&view);

	    /* Draw the objects
	    */
	    GsGetLs(&obj3d[f].coord,&mat);
	    GsSetLightMatrix(&mat);
	    GsSetLsMatrix(&mat);
	    GsSortObject4(&obj3d[f].o,ot+frame,(14-OT_LEN),getScratchAddr(0));
	    }
}

/* -------------------------------------------------------------------------
				   PAD UTILS
   ------------------------------------------------------------------------- */

void PadUpdate(void)
{
    u_short pad;
    int f;

    pad=~(pad1[2]<<8|pad1[3]);

    /* Read pad state
    */
    for(f=0;f<P_NO;f++)
	if (pad&padmap[f].code)
	    {
	    if (!padmap[f].cnt)
		{
		padmap[f].pressed=TRUE;
		padmap[f].cnt=padmap[f].bounce*bounce_weight;
		}
	    else
		{
		padmap[f].cnt--;
		padmap[f].pressed=FALSE;
		}
	    }
	else
	    {
	    padmap[f].pressed=FALSE;
	    padmap[f].cnt=0;
	    }
}


void PadFlush(void)
{
    int f;

    for(f=0;f<P_NO;f++)
	if (padmap[f].bounce!=-1)
	    {
	    padmap[f].cnt=0;
	    padmap[f].pressed=FALSE;
	    }
}


/* -------------------------------------------------------------------------
				  GOODBYE PAGE
   ------------------------------------------------------------------------- */

void GoodbyePage(void)
{
    int f;

    for(f=0;f<0x80;f+=2)
	{
	NewFrame();
	Centre16("THANKS FOR PLAYING",SCRH/2,0,0,PRI_TEXT,f/2,f/2,f);
	PageFlip(FALSE);
	}

    for(f=0x7f;f>-1;f-=2)
	{
	NewFrame();
	Centre16("THANKS FOR PLAYING",SCRH/2,0,0,PRI_TEXT,f/2,f/2,f);
	PageFlip(FALSE);
	}
}


/* -------------------------------------------------------------------------
				  CREDIT PAGE
   ------------------------------------------------------------------------- */

void CreditPage(void)
{
#   define CREDITY(y)		(10+(y)*10)
#   define CREDIT(s,y,r,g,b)	Centre8(s,CREDITY(y),0,0,PRI_TEXT,r,g,b)
#   define CREDITSPR		30
    struct
    	{
	int	x;
	int	y,yi;
	int	r,g,b;
	long	a,ai;
	} crspr[CREDITSPR];

    static char scroll_txt[]=
		{
		"                                     "
		"Welcome to HARDWIRE..."
		"         "
		"Written on the Net Yaroze, "
		"July/August 98 for the GDUK competition"
		"         "
		"Special thanks to "
		"Julianne Regan, "
		"Suzanne Vega, "
		"Natalie Imbruglia, "
		"Laurie Anderson, "
		"Garbage, "
		"Fear Factory, "
		"FSOL, "
		"Misery Loves Co, "
		"Front Line Assembly, "
		"Cubanate and The Prodigy"
		"         "
		"Extra special thanks to Sony and Team Yaroze"
		};

    int scroll_txt_len;
    int tc,c;
    int tx,x;
    int f;

    for(f=0;f<CREDITSPR;f++)
    	{
	crspr[f].x=RND(SCRW);
	crspr[f].y=RND(SCRH);
	crspr[f].yi=RND(5)+1;
	crspr[f].a=0;
	crspr[f].ai=0;
	while (!crspr[f].ai)
	    crspr[f].ai=(RND(5)-2)*ONE;
	crspr[f].r=RND(0x40);
	crspr[f].g=RND(0x40);
	crspr[f].b=RND(0x40);
	}

    tc=0;
    tx=0;
    scroll_txt_len=strlen(scroll_txt);

    while (!PRESS(P_START))
	{
	NewFrame();

	/* Sprite backdrop
	*/
	for(f=0;f<CREDITSPR;f++)
	    {
	    crspr[f].a+=crspr[f].ai;

	    if ((crspr[f].y+=crspr[f].yi)>SCRH+16)
	    	crspr[f].y-=SCRH+16;

	    Sprite(crspr[f].x,crspr[f].y,
		   16,16,7,7,SPRADD(51),
		   crspr[f].a,ONE,ONE,
		   1,1,
		   PRI_BACK+crspr[f].yi,
		   crspr[f].r,crspr[f].g,crspr[f].g);
	    }

	/* Scrolling text
	*/
	c=tc;
	x=tx;

	for(f=0;f<41;f++)
	    {
	    SPutCh8(scroll_txt[c],x,CREDITY(18),0,0,PRI_BACK+2,0x80,0x80,0x80);
	    c=(c+1)%scroll_txt_len;
	    x+=8;
	    }

	if ((tx-=2)==-8)
	    {
	    tx=0;
	    tc=(tc+1)%scroll_txt_len;
	    }

	CREDIT("HARDWIRE",0,0x80,0x80,0x80);
	CREDIT("_________",0,0x80,0x80,0x80);

	CREDIT("Coded and designed by",2,0x80,0x80,0x00);
	CREDIT("Ian C",3,0x80,0x00,0x00);
	CREDIT("For the GDUK competition 1998",4,0x80,0x80,0x00);

	CREDIT("All graphics and music by",7,0x80,0x80,0x00);
	CREDIT("Ian C",8,0x80,0x00,0x00);

	CREDIT("Instrument sounds by",10,0x80,0x80,0x00);
	CREDIT("Sony",11,0x80,0x00,0x00);

	CREDIT("Press START to go back",20,0x80,0x80,0x80);

	CREDIT("ianc@noddybox.demon.co.uk",22,0x80,0x80,0x00);

	PageFlip(TRUE);
	}
}


/* -------------------------------------------------------------------------
				   TITLE PAGE
   ------------------------------------------------------------------------- */

void TitlePage(void)
{
#   define MENUY(y)	(65+(y)*18)
#   define MENU(s,y)	Centre16(s,MENUY(y),1,0,PRI_TEXT,0x80,0x80,0x80)

    char sp[80];
    int red,redi;
    int f;
    int choice=0;
    int ch_cnt=0;
    int ch_del=0;
    int start_game=FALSE;
    int	bh_col=0x00;
    int lastmode;
	
    red=0x40;
    redi=1;
    SetBounce(12);

    StopTune();
    PlayTune(title_seq_id);

    while (!start_game)
	{
	NewFrame();

	/* Draw title text 
	*/		
	Centre16("HARDWIRE",10,0,0,PRI_TEXT,red,0,0);
	Centre16("NODDYBOX 1998",30,0,0,PRI_TEXT,0x80,0x80,0x80);

	red+=redi;

	if ((red==0x40)||(red==0x80))
	    redi=-redi;

	Centre8("Press START to play",SCRH-20,0,0,PRI_TEXT,red,red,0x80-red);
	Centre8("Press SELECT to quit",SCRH-12,0,0,PRI_TEXT,0x80-red,red,red);

	/* Redraw menu
	*/
	MENU("PLAY GAME",0);
	sprintf(sp,"DIFFICULTY  %5s",mode[GAME]);
	MENU(sp,1);
	sprintf(sp,"SPEED        %4d",LEVEL);
	MENU(sp,2);
	sprintf(sp,"PIT WIDTH    %4d",PITW);
	MENU(sp,3);
	sprintf(sp,"BACKDROP     %4s",(BDROP_ON ? "ON" : "OFF"));
	MENU(sp,4);
	sprintf(sp,"SOUND MODE  %5s",sound_mode[SOUNDMODE]);
	MENU(sp,5);
	sprintf(sp,"VOLUME       %-4s","");
	MENU(sp,6);
	MENU("VIEW CREDITS",7);

	for(f=0;f<12;f++)
	    if (VOLUME>(f*10))
		FastSprite(234+f*5,MENUY(6),16,16,SPRADD(52),
			0,0,PRI_TEXT,0x40,0x40,0x40);
	    else
		FastSprite(234+f*5,MENUY(6),16,16,SPRADD(53),
			0,0,PRI_TEXT,0x40,0x40,0x40);

	sprintf(sp,"%c`````````````````%c",'a'+ch_cnt,'k'+ch_cnt);

	if (ch_del++==8)
	    {
	    ch_cnt=(ch_cnt+1)%4;
	    ch_del=0;
	    }

	Centre16(sp,MENUY(choice),1,1,PRI_FORE,0x40,0x40,0x40);

	/* Menu inputs
	*/
	if (PRESS(P_UP))
	    {
	    if (choice)
		choice--;
	    else
	    	choice=7;
	    }

	if (PRESS(P_DOWN))
	    {
	    if (choice<7)
		choice++;
	    else
	    	choice=0;
	    }

	if (PRESS(P_START))
	    {
	    start_game=TRUE;
	    }

	if (PRESS(P_SELECT))
	    {
	    start_game=TRUE;
	    QUIT=TRUE;
	    }

	if (((PRESS(P_CROSS))||(PRESS(P_SQUARE)))&&(choice==0))
	    start_game=TRUE;

	if ((PRESS(P_CROSS))||(PRESS(P_RIGHT)))
	    switch(choice)
		{
		case 0:
		    break;
		case 1:
		    if (++GAME==NOMODE)
			GAME=0;
		    break;
		case 2:
		    if (LEVEL<MAXLEV)
			LEVEL++;
		    break;
		case 3:
		    if (PITW<MAXPITW)
			PITW++;
		    break;
		case 4:
		    BDROP_ON=!BDROP_ON;
		    break;
		case 5:
		    lastmode=SOUNDMODE;

		    if (++SOUNDMODE>SOUND_SFX)
			SOUNDMODE=SOUND_BOTH;

		    if (lastmode==SOUND_SFX)
			PlayTune(title_seq_id);

		    if (SOUNDMODE==SOUND_SFX)
			StopTune();
		    break;
		case 6:
		    VOLUME=MIN(VOLUME+10,127);
		    SsSetMVol(VOLUME,VOLUME);
		    break;
		}

	if ((PRESS(P_SQUARE))||(PRESS(P_LEFT)))
	    switch(choice)
		{
		case 0:
		    break;
		case 1:
		    if (--GAME==-1)
			GAME=NOMODE-1;
		    break;
		case 2:
		    if (LEVEL>1)
			LEVEL--;
		    break;
		case 3:
		    if (PITW>MINPITW)
			PITW--;
		    break;
		case 4:
		    BDROP_ON=!BDROP_ON;
		    break;
		case 5:
		    lastmode=SOUNDMODE;

		    if (--SOUNDMODE<SOUND_BOTH)
			SOUNDMODE=SOUND_SFX;

		    if (lastmode==SOUND_SFX)
			PlayTune(title_seq_id);

		    if (SOUNDMODE==SOUND_SFX)
			StopTune();
		    break;
		case 6:
		    VOLUME=MAX(VOLUME-10,0);
		    SsSetMVol(VOLUME,VOLUME);
		    break;
		}

	/* Redraw
	*/
	PageFlip(TRUE);

	if (bh_col<0x80)
	    bh_col++;

	/* Check for credits screen
	*/
	if (((PRESS(P_CROSS))||(PRESS(P_SQUARE)))&&(choice==7))
	    CreditPage();
	}

    FadeOut();
    PadFlush();
}

/* -------------------------------------------------------------------------
			    WIRE ROTATE PIECE UTILS
   ------------------------------------------------------------------------- */

int ROL_Piece(int tile)
{
    /* This should be in a table, but using sprite numbers for the tile
       codes makes that not so neat
    */
    switch(tile)
        {
	case CROSS:
	    return(CROSS);
	    break;

	case UPDOWN:
	    return(ACROSS);
	    break;

	case ACROSS:
	    return(UPDOWN);
	    break;

	case LEFTDOWN:
	    return(LEFTUP);
	    break;

	case RIGHTDOWN:
	    return(LEFTDOWN);
	    break;

	case LEFTUP:
	    return(RIGHTUP);
	    break;

	case RIGHTUP:
	    return(RIGHTDOWN);
	    break;

	default:
	    return(BLANK);
	    break;
	}
}


int ROR_Piece(int tile)
{
    /* This should be in a table, but using sprite numbers for the tile
       codes makes that not so neat
    */
    switch(tile)
        {
	case CROSS:
	    return(CROSS);
	    break;

	case UPDOWN:
	    return(ACROSS);
	    break;

	case ACROSS:
	    return(UPDOWN);
	    break;

	case LEFTDOWN:
	    return(RIGHTDOWN);
	    break;

	case RIGHTDOWN:
	    return(RIGHTUP);
	    break;

	case LEFTUP:
	    return(LEFTDOWN);
	    break;

	case RIGHTUP:
	    return(LEFTUP);
	    break;

	default:
	    return(BLANK);
	    break;
	}
}


/* -------------------------------------------------------------------------
				WIRE PATH UTILS
   ------------------------------------------------------------------------- */

int Dir(int tile,int dir)
{
    switch(tile)			/* This should be in a table, but */
        {				/* using sprite numbers for the tile */
	case CROSS:			/* codes makes that not so neat */
	    return(dir);
	    break;

	case UPDOWN:
	    if ((dir==UP)||(dir==DOWN))
		return(dir);
	    else
	    	return(NODIR);
	    break;

	case ACROSS:
	    if ((dir==LEFT)||(dir==RIGHT))
		return(dir);
	    else
	    	return(NODIR);
	    break;

	case LEFTDOWN:
	    if (dir==RIGHT)
	    	return(DOWN);
	    else if (dir==UP)
	    	return(LEFT);
	    else
	    	return(NODIR);
	    break;

	case RIGHTDOWN:
	    if (dir==LEFT)
	    	return(DOWN);
	    else if (dir==UP)
	    	return(RIGHT);
	    else
	    	return(NODIR);
	    break;

	case LEFTUP:
	    if (dir==RIGHT)
	    	return(UP);
	    else if (dir==DOWN)
	    	return(LEFT);
	    else
	    	return(NODIR);
	    break;

	case RIGHTUP:
	    if (dir==LEFT)
	    	return(UP);
	    else if (dir==DOWN)
	    	return(RIGHT);
	    else
	    	return(NODIR);
	    break;

	default:
	    return(NODIR);
	    break;
	}
}


int FindPathFrom(int sx,int sy,int dir,Path *p)
{
    dir=Dir(pit.data[sy][sx],dir);

    if (dir==NODIR)
	{
	p->len=0;
    	return (FALSE);
	}

    p->p[p->len].x=sx;
    p->p[p->len].y=sy;
    p->spr[p->len]=pit.data[sy][sx];
    p->len++;

    sx+=xi[dir];
    sy+=yi[dir];

    if (sy==-1)
	{
    	return (FALSE);
	p->len=0;
	}

    if ((sx==-1)||(sx==PITW)||(sy==PITDEPTH))
    	return (TRUE);
    else
    	return (FindPathFrom(sx,sy,dir,p));
}


int FindPath(Path *p)
{
    int f;

    p->len=0;

    for(f=PITDEPTH-1;f>=0;f--)
	{
	if (FindPathFrom(0,f,RIGHT,p))
	    return (TRUE);

	if (FindPathFrom(PITW-1,f,LEFT,p))
	    return (TRUE);
	}

    for(f=0;f<PITW;f++)
	if (FindPathFrom(f,PITDEPTH-1,UP,p))
	    return (TRUE);

    return (FALSE);
}


int FindLoopFrom(int ox,int oy,int x,int y,int dir,Path *p)
{
    dir=Dir(pit.data[y][x],dir);

    if (dir==NODIR)
	{
	p->len=0;
    	return (FALSE);
	}

    p->p[p->len].x=x;
    p->p[p->len].y=y;
    p->spr[p->len]=pit.data[y][x];
    p->len++;

    x+=xi[dir];
    y+=yi[dir];

    if ((p->len>2)&&(x==p->p[1].x)&&(y==p->p[1].y))
    	return (TRUE);
    else
    	return (FindLoopFrom(ox,oy,x,y,dir,p));
}


int FindLoop(Path *p)
{
    int x,y;

    p->len=0;

    for(y=PITDEPTH-1;y>=0;y--)
    	for(x=0;x<PITW;x++)
	    switch(pit.data[y][x])
	    	{
		case CROSS:
		case ACROSS:
		case LEFTDOWN:
		case LEFTUP:
		    if (FindLoopFrom(x,y,x,y,LEFT,p))
		    	return(TRUE);
		default:
		    break;
		}

    return(FALSE);
}


void GetSpecialPathFromTile(int tile,Path *p)
{
    int x,y;

    if (tile==BLANK)
    	return;

    for(x=0;x<PITW;x++)
	for(y=0;y<PITDEPTH;y++)
	    if (pit.data[y][x]==tile)
		{
		p->p[p->len].x=x;
		p->p[p->len].y=y;
		p->spr[p->len]=pit.data[y][x];
		p->len++;

		/* The specials are a special(?!) case, as they must become 
		   PATHs as going along, or else the same pieces may be picked
		   up twice and the Path object overflow.  Note this will be
		   replaced by a PATH object on DrawPath() anyway.
		*/
		pit.data[y][x]=BLANK;
		}
}


void GetTotalPath(Path *p)
{
    int x,y;

    p->len=0;

    for(y=PITDEPTH-1;y>=0;y--)
	for(x=0;x<PITW;x++)
	    if (pit.data[y][x]!=BLANK)
		{
		p->p[p->len].x=x;
		p->p[p->len].y=y;
		p->spr[p->len]=pit.data[y][x];
		p->len++;
		}
}


void GetSpecialPath(Path *p)
{
    int x,y;

    p->len=0;

    if (game.y>0)
	GetSpecialPathFromTile(pit.data[game.y-1][game.x],p);

    if (game.y<(PITDEPTH-1))
	GetSpecialPathFromTile(pit.data[game.y+1][game.x],p);

    if (game.x>0)
	GetSpecialPathFromTile(pit.data[game.y][game.x-1],p);

    if (game.x<(PITW-1))
	GetSpecialPathFromTile(pit.data[game.y][game.x+1],p);
}


void DrawPath(Path *p)
{
    int c;
    int f;
    short scale;

    for(f=0;f<p->len;f++)
	pit.data[p->p[f].y][p->p[f].x]=PATH;

    scale=ONE;

    for(c=0x80;c>=0;c-=8)
	{
	/* The redraw and pageflip is the inverse of the main loop so that it
	   appears more transparent
	*/
	DrawGameScreen();
	RedrawPit();
	DrawInfo();
	UpdateScores();

	for(f=0;f<p->len;f++)
	    Sprite(PITX(p->p[f].x)+SPRCENTRE,PITY(p->p[f].y)+SPRCENTRE,
		   SPRSIZE,SPRSIZE,SPRCENTRE,SPRCENTRE,SPRADD(p->spr[f]),
		   0,scale,scale,
		   1,1,PRI_FORE,c,c,c);

    	scale+=ONE/6;

	PageFlip(TRUE);

	/* Start new frame
	*/
	NewFrame();
	}
}


void DebugPath(Path *p)
{
    char s[80];
    int c;
    int f;

    if (PRESS(P_SELECT))
    	exit(0);

    sprintf(s,"len : %d",p->len);
    SPrint8(s,10,10,0,0,PRI_DEBUG,0x80,0x80,0x80);

    for(f=0;f<p->len;f++)
	pit.data[p->p[f].y][p->p[f].x]=BLANK;

    for(c=0x80;c>=0;c-=8)
	{
	/* The redraw and pageflip is the inverse of the main loop so that it
	   appears more transparent
	*/
	DrawGameScreen();
	RedrawPit();
	DrawInfo();
	UpdateScores();

	for(f=0;f<p->len;f++)
	    FastSprite(PITX(p->p[f].x),PITY(p->p[f].y),SPRSIZE,SPRSIZE,
	    		SPRADD(PATH),1,1,PRI_PIT,RND(0x80),RND(0x80),RND(0x80));

	PageFlip(TRUE);

	/* Start new frame
	*/
	NewFrame();
	}
}


/* -------------------------------------------------------------------------
				  SCORE UTILS
   ------------------------------------------------------------------------- */

#define DSNO	10
#define DSFADE	1

struct
	{
	char	p[80];
	int	sc;
	int	col;
	int	cnt;
	int	y;
	} dispsc[DSNO];

void InitScores(void)
{
    int f;

    for(f=0;f<DSNO;f++)
	{
	strcpy(dispsc[f].p,"X");
	dispsc[f].sc=0;
	dispsc[f].col=0x00;
	dispsc[f].cnt=DSFADE;
	dispsc[f].y=SCOREY+10;
	}
}


void AddScore(char *s,int sc)
{
    int f;

    for(f=DSNO-2;f>=0;f--)
	dispsc[f+1]=dispsc[f];

    strcpy(dispsc[0].p,s);
    dispsc[0].sc=sc;
    dispsc[0].col=0x80;
    dispsc[0].cnt=DSFADE;
    dispsc[0].y=SCOREY+10;
}


void UpdateScores(void)
{
    int f;
    char s[80];

    for(f=0;f<DSNO;f++)
	{
	if (dispsc[f].col!=0x00)
	    {
	    sprintf(s,"%-7s +%5d",dispsc[f].p,dispsc[f].sc);

	    SPrint8(s,SCOREPX,dispsc[f].y,1,1,PRI_TEXT,
			dispsc[f].col/3,dispsc[f].col/3,dispsc[f].col);

	    if (--dispsc[f].cnt==0)
		{
		dispsc[f].cnt=DSFADE;
		--dispsc[f].col;
		++dispsc[f].y;
		}
	    }
	}
}


/* -------------------------------------------------------------------------
				  SOUND UTILS
   ------------------------------------------------------------------------- */

void PlayTune(short id)
{
    if ((id!=-1)&&(SOUNDMODE!=SOUND_SFX))
    	{
	SsSeqPlay(id,SSPLAY_PLAY,SSPLAY_INFINITY);
	current_seq=id;
	}
}


void StopTune(void)
{
    if (current_seq!=-1)
	{
	SsSeqStop(current_seq);
	current_seq=-1;
	}
}


void PlaySFX(short id)
{
    if (SOUNDMODE!=SOUND_MUSIC)
	SsUtKeyOn(sfx_vab_id,id,0,48,0,127,127);
}


void FlushSFX(void)
{
    SsUtAllKeyOff(0);
}


/* -------------------------------------------------------------------------
			       HISCORE FILE CODE
   ------------------------------------------------------------------------- */

void LoadHisc(void)
{
}


void SaveHisc(void)
{
}


/* -------------------------------------------------------------------------
				  PAUSE SCREEN
   ------------------------------------------------------------------------- */

int Pause(void)
{
    Centre16("P    D",CY-20,0,0,PRI_FORE,0x40,0x40,0x40);
    Centre16(" A  E ",CY-20,0,0,PRI_FORE,0x48,0x48,0x48);
    Centre16("  US  ",CY-20,0,0,PRI_FORE,0x50,0x50,0x50);

    Centre16("START TO CONTINUE",CY+20,0,0,PRI_FORE,0x00,0x40,0x00);
    Centre16("SELECT TO QUIT",CY+40,0,0,PRI_FORE,0x40,0x00,0x00);

    while(TRUE)
    	{
	PageFlip(TRUE);
    	RedrawNewFrame(0x28,0x28,0x28,PRI_FORE);

	if (PRESS(P_START))
	    return(FALSE);

	if (PRESS(P_SELECT))
	    return(TRUE);
	}
}



/* -------------------------------------------------------------------------
			   GAME SCREEN GRAPHICS UTILS
   ------------------------------------------------------------------------- */

void DrawGameScreen(void)
{
    int x,y;
    int spr;

    for(x=-1;x<=PITW;x++)
	{
	if (x==-1)
	    spr=PIT_BL;
	else if (x==PITW)
	    spr=PIT_BR;
	else
	    spr=PIT_BM;

	FastSprite(PITX(x),PITY(PITDEPTH),SPRSIZE,SPRSIZE,SPRADD(spr),
			0,0,PRI_PIT,0x80,0x80,0x80);
	}

    for(y=0;y<PITDEPTH;y++)
	{
	if (y==0)
	    spr=PIT_TL;
	else
	    spr=PIT_ML;

	FastSprite(PITX(-1),PITY(y),SPRSIZE,SPRSIZE,SPRADD(spr),
			0,0,PRI_PIT,0x80,0x80,0x80);

	if (y==0)
	    spr=PIT_TR;
	else
	    spr=PIT_MR;

	FastSprite(PITX(PITW),PITY(y),SPRSIZE,SPRSIZE,SPRADD(spr),
			0,0,PRI_PIT,0x80,0x80,0x80);
	}

    DrawInfo();
}


void RedrawPit(void)
{
    int x,y;

    for(x=0;x<PITW;x++)
    	for(y=0;y<PITDEPTH;y++)
	    if ((pit.data[y][x]!=BLANK)&&(pit.data[y][x]!=PATH))
		FastSprite(PITX(x),PITY(y),
			    SPRSIZE,SPRSIZE,SPRADD(pit.data[y][x]),
					    0,0,PRI_PIT,0x80,0x80,0x80);
}


void DrawPiece(void)
{
    int x,y;

    for(x=0;x<PIECE_SIZE;x++)
	for(y=0;y<PIECE_SIZE;y++)
	    if (game.current.data[y][x]!=BLANK)
		FastSprite(PITX(game.x+x-game.current.ox),
			   PITY(game.y+y-game.current.oy),
			   SPRSIZE,SPRSIZE,SPRADD(game.current.data[y][x]),
			   0,0,PRI_PIT,0x80,0x80,0x80);
}


void DrawInfo(void)
{
    char sc[80];
    int x,y,px,py;

    SPrint8("SCORE",SCOREPX,SCOREY,0,0,PRI_TEXT,0x80,0x80,0x80);
    SPrint8("LEVEL",LEVELPX,LEVELY,0,0,PRI_TEXT,0x80,0x80,0x80);
    SPrint8("NEXT",NEXTPX,NEXTY,0,0,PRI_TEXT,0x80,0x80,0x80);

    sprintf(sc,"%7d",game.score);
    SPrint8(sc,SCOREX,SCOREY,0,0,PRI_TEXT,0x80,0x80,0x80);

    sprintf(sc,"%7d",game.level);
    SPrint8(sc,LEVELX,LEVELY,0,0,PRI_TEXT,0x80,0x80,0x80);

    for(x=0;x<PIECE_SIZE;x++)
	for(y=0;y<PIECE_SIZE;y++)
	    {
	    px=NEXTX+x*SPRSIZE;
	    py=NEXTY+y*SPRSIZE;

	    if (game.next.data[y][x]!=BLANK)
		FastSprite(px,py,SPRSIZE,SPRSIZE,SPRADD(game.next.data[y][x]),
					       0,0,PRI_PIT,0x80,0x80,0x80);
	    }
}


/* -------------------------------------------------------------------------
				TETRIS WIRE CODE
   ------------------------------------------------------------------------- */

void GenPiece(int special)
{
    PieceSet *ps;
    int x,y;

    game.current=game.next;
    game.current_type=game.next_type;
    game.is_special=game.next_is_special;

    game.x=PITW/2;

    if (game.is_special)
	game.y=-1;
    else
	game.y=-piece_map->height[game.current_type]+game.current.oy;

    game.rotate=0;

    game.next_is_special=special;

    if (special)
    	{
	game.next_type=-1;
	for(x=0;x<PIECE_SIZE;x++)
	    for(y=0;y<PIECE_SIZE;y++)
	    	if ((x)||(y))
		    game.next.data[y][x]=BLANK;
		else
		    game.next.data[y][x]=SPECIAL;

	game.next.ox=0;
	game.next.oy=0;
	}
    else
    	{
	game.next_type=RND(piece_map->no);

	for(x=0;x<PIECE_SIZE;x++)
	    for(y=0;y<PIECE_SIZE;y++)
		if (piece_map->map[game.next_type].data[y][x]==NON_PS)
		    game.next.data[y][x]=BLANK;
		else
		    {
		    ps=piece_set+piece_map->map[game.next_type].data[y][x];
		    game.next.data[y][x]=ps->piece[RND(ps->no)];
		    }

	game.next.ox=piece_map->offset[game.next_type*4].x;
	game.next.oy=piece_map->offset[game.next_type*4].y;
	}
}


void RotPiece(int dir)
{
    int x,y;
    Piece p;

    if (game.is_special)
    	return;

    if (dir==LEFT)
	{
	game.rotate=ROL(game.rotate);

	for(x=0;x<PIECE_SIZE;x++)
	    for(y=0;y<PIECE_SIZE;y++)
	    	p.data[x][PIECE_SIZE-y-1]=ROL_Piece(game.current.data[y][x]);

	p.ox=piece_map->offset[game.current_type*4+game.rotate].x;
	p.oy=piece_map->offset[game.current_type*4+game.rotate].y;
	}
    else
	{
	game.rotate=ROR(game.rotate);

	for(x=0;x<PIECE_SIZE;x++)
	    for(y=0;y<PIECE_SIZE;y++)
	    	p.data[PIECE_SIZE-x-1][y]=ROR_Piece(game.current.data[y][x]);

	p.ox=piece_map->offset[game.current_type*4+game.rotate].x;
	p.oy=piece_map->offset[game.current_type*4+game.rotate].y;
	}

    game.current=p;
}


/* -------------------------------------------------------------------------
				PLAY GAME UTILS
   ------------------------------------------------------------------------- */

int MoveOK(int x, int y)
{
    int cx,cy,nx,ny;

    for(cx=0;cx<PIECE_SIZE;cx++)
	for(cy=0;cy<PIECE_SIZE;cy++)
	    if (game.current.data[cy][cx]!=BLANK)
		{
		nx=x+cx-game.current.ox;
		ny=y+cy-game.current.oy;

		if ((nx<0)||(nx>=PITW)||(ny>=PITDEPTH))
		    return(FALSE);

		if ((ny>=0)&&(pit.data[ny][nx]!=BLANK))
		    return(FALSE);
		}

    return(TRUE);
}


int AddAndCheckIsDead(int id)
{
    int cx,cy,nx,ny;

    if (game.is_special)
    	return(game.y<0);
    else
	for(cx=0;cx<PIECE_SIZE;cx++)
	    for(cy=0;cy<PIECE_SIZE;cy++)
		if (game.current.data[cy][cx]!=BLANK)
		    {
		    nx=game.x+cx-game.current.ox;
		    ny=game.y+cy-game.current.oy;

		    if ((nx<0)||(nx>=PITW)||(ny<0)||(ny>=PITDEPTH))
			return(TRUE);

		    pit.data[ny][nx]=game.current.data[cy][cx];
		    pit.id[ny][nx]=id;
		    }

    return(FALSE);
}


void UnglueID(int id)
{
    int x,y;

    for(x=0;x<PITW;x++)
	for(y=0;y<PITDEPTH;y++)
	    if (pit.id[y][x]==id)
		pit.id[y][x]=0;
}


void CompressPath(void)
{
    int x,y,ny;

    for(x=0;x<PITW;x++)
	{
	y=PITDEPTH-1;

	while(y)
	    {
	    if (pit.data[y][x]==PATH)
		{
		if (pit.id[y][x])
		    UnglueID(pit.id[y][x]);

		for(ny=y;ny;ny--)
		    {
		    pit.data[ny][x]=pit.data[ny-1][x];
		    pit.id[ny][x]=pit.id[ny-1][x];

		    if (pit.id[ny][x])
			UnglueID(pit.id[ny][x]);
		    }

		pit.data[0][x]=BLANK;
		pit.id[0][x]=0;
		}
	    else
	    	y--;
	    }
	}
}


int IsDropPieceAbove(int x, int y)
{
    while(y>=0)
    	if (pit.data[y][x]!=BLANK)
	    return (pit.id[y][x]==0);
	else
	    y--;
    return(FALSE);
}


void CompressBlanks(void)
{
    int x,y,ny;

    for(x=0;x<PITW;x++)
	{
	y=PITDEPTH-1;

	while(y)
	    /* This is a bit wasteful, but will ensure that no checks are missed
	       out...
	    */
	    if ((pit.data[y][x]==BLANK)&&(IsDropPieceAbove(x,y-1)))
		{
		for(ny=y;(ny)&&(!pit.id[ny][x]);ny--)
		    {
		    pit.data[ny][x]=pit.data[ny-1][x];
		    pit.id[ny][x]=pit.id[ny-1][x];
		    }

		if (ny!=y)
		    {
		    pit.data[ny][x]=BLANK;
		    pit.id[ny][x]=0;
		    }
		else
		    y--;
		}
	    else
	    	y--;
	}
}



/* -------------------------------------------------------------------------
			    PATH AND SCORE CHECKERS
   ------------------------------------------------------------------------- */

void CheckPaths(void)
{
    int sc;
    int no;
    Path path;

    game.score+=game.level;
    no=1;

    if (game.is_special)
	{
	GetSpecialPath(&path);

	if (path.len)
	    {
	    PlaySFX(SFX_SPECIAL);
	    sc=(path.len*game.level*no++);
	    game.score+=sc;
	    AddScore("SPECIAL",sc);
	    DrawPath(&path);
	    CompressPath();
	    CompressBlanks();
	    }
	}

    /* Check for paths
    */
    while (FindPath(&path))
	{
	PlaySFX(SFX_PATH);
	sc=(path.len*game.level)*(10+no++);
	game.score+=sc;
	AddScore("CIRCUIT",sc);
	DrawPath(&path);
	CompressPath();
	CompressBlanks();
	}

    /* Check for loops - disabled as it isn't working properly
    while (FindLoop(&path))
	{
	sc=(path.len*game.level)*(10+no++);
	game.score+=sc;
	AddScore("LOOP",sc);
	DrawPath(&path);
	CompressPath();
	CompressBlanks();
	}
    */

}


void GameOverPaths(void)
{
    int sc;
    Path path;

    GetTotalPath(&path);

    if (path.len)
	{
	sc=(path.len*game.level)*5;
	game.score+=sc;
	AddScore("BONUS",sc);
	DrawPath(&path);
	CompressPath();
	CompressBlanks();
	}
}


/* -------------------------------------------------------------------------
				   PLAY GAME
   ------------------------------------------------------------------------- */

void PlayGame(void)
{
    int mvctr;
    int dead,quitgame;
    int no;
    int id;
    int f;

    no=0;
    id=1;
    dead=FALSE;
    quitgame=FALSE;
    mvctr=LEVELCTR(game.level);

    SetBounce(6);

    StopTune();
    PlayTune(game_seq_id);

    InitScores();

    GenPiece(FALSE);
    GenPiece(FALSE);

    while((!dead)&&(!quitgame))
    	{
	/* Check pause
	*/
	if (PRESS(P_START))
	    quitgame=Pause();

	/* Start new frame
	*/
	NewFrame();

	/* See if it's time for the block to drop
	*/
	if (!(mvctr--))
	    {
	    /* See if piece can move down
	    */
	    if (MoveOK(game.x,game.y+1))
	    	{
		game.y++;
		mvctr=LEVELCTR(game.level);
		}
	    else
		{
		PlaySFX(SFX_PIECELAND);

		if (AddAndCheckIsDead(id++))
		    {
		    /* If dead, setup exit of loop.
		    */
		    dead=TRUE;
		    }
		else
		    {
		    /* Check for scoring and paths
		    */
		    CheckPaths();

		    /* Generate new piece and reset counters
		    */
		    GenPiece((id%30)==0);

		    PadFlush();

		    if (++no==(game.level*5))
			{
			game.level++;
			no=0;
			}

		    mvctr=LEVELCTR(game.level);
		    }
		}
	    }
	else
	    /* If it's not block dropping time, allow it to move
	    */
	    {
	    /* Check left/right
	    */
	    if (PRESS(P_LEFT))
	    	{
		if (MoveOK(game.x-1,game.y))
		    game.x--;
		else
		    PadFlush();
		}
	    else if (PRESS(P_RIGHT))
	    	{
		if (MoveOK(game.x+1,game.y))
		    game.x++;
		else
		    PadFlush();
		}

	    if (PRESS(P_DOWN))
		mvctr=0;

	    if (PRESS(P_SQUARE))
	    	{
		RotPiece(RIGHT);

		if (!MoveOK(game.x,game.y))
		    {
		    RotPiece(LEFT);
		    PadFlush();
		    }
		}
	    else if (PRESS(P_CROSS))
	    	{
		RotPiece(LEFT);

		if (!MoveOK(game.x,game.y))
		    {
		    RotPiece(RIGHT);
		    PadFlush();
		    }
		}

	    /* Draw screen
	    */
	    DrawGameScreen();
	    RedrawPit();
	    DrawPiece();
	    DrawInfo();
	    UpdateScores();
	    PageFlip(TRUE);
	    }
	}

    if (!quitgame)
    	{
	GameOverPaths();

	PlaySFX(SFX_GAMEOVER);

	PadFlush();

	for(f=0x80*2;(f>=0)&&(!PRESS(P_CROSS));f--)
	    {
	    NewFrame();
	    DrawGameScreen();
	    RedrawPit();
	    DrawInfo();
	    UpdateScores();
	    Centre16("GAME OVER",SCRH/2-8,1,1,PRI_FORE,f/2,f/4,f/8);
	    PageFlip(TRUE);
	    }
	}

    FadeOut();
    PadFlush();
}


/* -------------------------------------------------------------------------
				    CD UTILS 
   ------------------------------------------------------------------------- */

void LoadCD(char *file, char *msg, u_long *addr)
{
    CdReadFile(file,addr,0);
    if (CdReadSync(0,NULL)==-1)
	{
	printf("CD Read error!!");
	exit(0);
	}
    VSync(0);
}

/* END OF FILE */