// Version with memory card support removed (failed sony QA)


/*
Car game

*/


#include <libps.h>
#include <stdlib.h>
#include <sys\file.h>
#include "pad.h"

#include "inv.c"				// inventory numbers
#include "carpak.c"			// offsets into pak file
//#include "anim.c"			// defines for animations

#define	MUSIC			1	// 1 = do music, 0 = not installed

#define	ANIM_PLAYER1	0
#define	ANIM_LAPRECORD	1
#define	ANIM_SHOTS		2
#define	ANIM_SMOKE		3
#define	ANIM_EXPLO1		4
#define	ANIM_OVERLAY	5
#define	ANIM_DUST		6
#define	ANIM_DUSTCLOUD	7

#define	SCREENWIDTH		320
#define	SCREENHEIGHT	256
#define	FPS			50		// frames per second (50 = PAL)

#define	MAXOBJ		1024		// Maximum number of objects
#define	MAXSPRITES		MAXOBJ	// Maximum number of sprites
#define	MAX3DOBJECTS	32		// Maximum number of 3D objects (buildings etc)
#define	MAXPRIMITIVES	4224		// Maximum number of primitives (sprites,lines,polygons etc)
#define	MAXDRIVERS		6		// Maximum number of drivers (including CPU's)

#define	OT_LENGTH		9	// # bits resolution for Z sorting
#define	TOPOT_LENGTH	6
#define	BOTOT_LENGTH	7
#define	OVERLAYOT_LENGTH	3
#define	BACKOT_LENGTH	3

#define	OTPRI_GROUND	28	// priority for the ground (track)
#define	OTPRI_OVERLAY	8	// overlay map (trees, tunnels etc)
#define	OTPRI_CARS		24	// the cars
#define	OTPRI_MISSILES	22	// flying objects under smoke, but over cars
#define	OTPRI_SMOKE		20	// air based objects (over cars i.e. smoke screen)
#define	OTPRI_MINES		26	// ground base (underneath cars i.e. mines)
#define	OTPRI_BACK		(1<<OT_LENGTH)-2	// backdrop picture

#define	MAXTRACKS		20	// maximun number of tracks available
#define	MAXTRACKSPERLOC	8	// max tracks per location
#define	MAXLOCATIONS	8
#define	MAXMEMORYBLOCKS	32
//#define	MAXSINGLEFRAMES	1024
//#define	MAXANIMATIONS	256
#define	MAXENTITIES	512
#define	MAXSTANDARDSPRITES	512
#define	MAXEXTRASPRITES	128
#define	MAXINVENTORY	16			// total number of available items (fuel,weapons etc)
#define	MAXHEADLIGHTS	MAXDRIVERS
#define	MAXGHOSTENTRIES	6072
#define	MAXDUSTPARTICLES	768

#define	MAXMICHAEL		24

#define	MAXMISSILECOUNT	4
#define	MAXMINECOUNT	6

#define	MAXSTARFIELDSTARS	800

#define	MYBITSHIFT	8

#define	DEAD_NOT	0
#define	DEAD_DYING	2
#define	DEAD_YES	3

#define	PAKFILEADDR		0x80090000



#define	limitrange(x,l,h)	((x)=((x)<(l)?(l):(x)>(h)?(h):(x)))

typedef	struct	{
	short		x,y,dx,dy;
	u_char	col,active;
}	dustparticle;

typedef	struct	{					// for unPAK routine(s)
	u_long	offset,length;
	u_char	method,x1,x2,x3;				// method: 1 = standard RLE
}	entryheader;

typedef	struct	{
	u_long	offset;
	u_long	length;
}	movementheader;

typedef	struct	{
	short	dx,dy;
	char	time,control;
}	simplemove;

typedef	struct	{
	u_long	x,y;
}	ghostdatapos;

typedef	struct	{
	u_short	active;					// 0 = don't update/1=update
	short		current,previous,best;			// number of lap array used for current lap,previous lap etc..
	ghostdatapos	stcurrent,stprevious,stbest;	// starting positions for ghost data
	ghostdatapos	cucurrent;				// current positions for input
	short		index;					// index into the lap array (time)
	u_long	ghostobj;					// object index for ghost car
	u_long	obj,x,y;					// object index to pull data from, output x and y
	short		angle;					// output angle
	short		out;						// number of lap array to use for output
	short		outdisp;					// 0 = no display of out, 1 = display
	u_long	laptime;					// lap time of output
	short		lap[3][MAXGHOSTENTRIES];		// lap arrays
}	ghostdatadef;

typedef	struct	{
	u_long	offset;
	u_short	uv0,uv1,uv2,xx;
}	headlightprecalc;

typedef struct	{
	u_short	w,h;
	u_long	offset;
}	maskheader;

typedef struct	{
	u_long	attribute;
	u_short	w,h,tpage;
	u_char	u,v;
	short	cx,cy;
}	singleframe;

typedef	struct	{
	u_long		offset;		// offset into singleframe array
	u_short		nframes;
}	animation;

typedef	struct	{
	u_long	index;
}	entity;

typedef struct	{
	u_char		active,ot,xxx,xxxx;
	u_long		*tmdpt;			// pointer to top of tmd data
	u_long		aoff,hox,hoy;
	GsDOBJ2		handler;
	GsCOORDINATE2	coord;
	VECTOR		origin;
	SVECTOR		rotate;
	u_char		tmd[2048];			// tmd data
}	headlight3D;

typedef	struct	{
	short	active,playerindex;
	u_char	controller,controller_type;
}	extrasprite;

typedef struct	{
	u_char	active,ot,xxx,xxxx;
	u_long		*tmdpt;			// pointer to top of tmd data
	GsDOBJ2		handler;
	GsCOORDINATE2	coord;
	VECTOR		origin;
	SVECTOR		rotate;
}	object3d;

typedef struct	{
	long		x,y,angle;			// object position
	long		momdx,momdy;
	short		speed,maxspeed;
	u_short	cx,cy;			// sprite clut
	animation	*base_sprite;		// pointer to animation
	u_short		frame;		// frame of animation
	u_short		oaindex;		// index in object array that this resides
	long		dx,dy,dangle;			// velocity
	long			prevangle;			// previous angle (for oil slicks etc)
	u_short		hx,hy;		// sprite handle offsets
	long		minx,miny,maxx,maxy;
	long		health,driverindex;
	long		followx,followy;
	u_char		active;		// 0 = not active
	u_char		shottime;
	u_char		chkpoint,lap;	// current checkpointt number and lap number
	u_char		lastchkpoint,dead_flag;	// last checkpoint visited.
	u_char		spritetype,effects;		// spritetype 0=normal, 1=fast. effects b0=on oil  b1=turbo pressed
	u_char		bright,steer,r,g,b,followactive;				// brightness
	u_char		spin,missilecount,minecount;								// spin - is player spinning (from explosion)
	u_short		index;
	u_long		time;				// lifetime (continuously increasing)
	void		(*control)(u_long obj);	// pointer to objects control function
	extrasprite		*extra;
	entity		other;
	u_short		class;		// 0 = null (explosion), 1 = player, 2 = cpu player, 3 = ghost
	u_short		pri;			// OT priority (0=maximum i.e displayed on top)
	u_long		owner;
	short			voice[4];
}	standardsprite;

typedef	struct {
	u_char	active;
	u_char	carcolour;
	u_short	carclut;						// base clut of car
	u_long	object;
	long		score;
	long		cash;
	u_long	laptime,lastlap,bestlap;			// in 1/100ths
	u_char	trigger[4];						// which weapon on which button
	short		inventory[MAXINVENTORY];			// count of each inventory item
	long		fuel;
	short		maxspeed;
	char		name[16];
	u_char	pad,controllertype;					// which pad to use (0 or 1) and what it is
	u_short	paddata[4];							// actual pad data
	long		health;
}	playerdata;

typedef	struct	{
	u_long	time;
	u_long	x,y;
	u_char	type,flag;	// type is 1 for WAVE
	u_short	alien;
	u_short	movement;
	u_short	pad;
}	event;

typedef	struct	{
	long	dx,dy;
}	velocity;

typedef	struct	{
	u_char	lv,rv,sv,xx;
}	volume;

typedef	struct	{
	long	x,y,angle;
}	startpositioninfo;

typedef	struct	{
	u_long	laprecord[4],trackrecord[4];			// records for novice/intermediate/pro/race
	char		bestlapname[4][12],bestname[4][12];		// names
}	recordsentry;

typedef	struct	{
	int	celmblock,mpimblock,colmblock;			// memory blocks used for each part of track data
	int	celtopmblock,mpitopmblock;
	u_short	*maskaddress;					// pointer to track mask (.TBM)
	u_long	celindex,mpiindex,colindex,tim1index,tim2index;		// offsets into PAK file
	u_long	celtopindex,mpitopindex;
	recordsentry	records;
	char		name[32];							// name of track
	u_char	numcheckpoints,numlaps,type,valid,night,xx;				// valid 0=not, 1=yes (available to use this track)
	startpositioninfo	grid[MAXDRIVERS];		// starting positions for each driver
	short		ghost[MAXGHOSTENTRIES/16];						// ghost data for best lap
}	trackinfoheader;		// information about track (to be used for all tracks)

typedef	struct {						// .NFO file contents
	startpositioninfo	grid[4];
}	tracknfofile;

typedef	struct {
	char	name[16];						// location name (england, japan etc..)
	int	index[MAXTRACKSPERLOC];						// index into tracks array for 8 tracks. -1 = not available
}	locationinfoheader;

typedef	struct	{
	u_short	active;
	void	*address;
	u_long	size;
}	memoryblockentry;

typedef	struct	{
	u_long	object;
	u_char	class,active;
}	cardriver;

typedef	struct	{
	u_short	sx,sy;			// coordinates on screen
	u_char	grid[16*22];
}	lcdgrid;

typedef	struct	{
	u_char	x,y;
}	charcoord;

typedef	struct	{
	u_char	current[3];
	u_char	next[3];
	u_char	x,y;
	u_long	speed;
	lcdgrid	*lcdpt;
	u_short	pad,pause;
	u_char	padcount,removecount,status,blocktype;
	charcoord	remove[16];
}	columsdef;

typedef	struct	{
	charcoord	current[4];
	charcoord	next[4];
	u_char	x,y;
	u_long	speed;
	lcdgrid	*lcdpt;
	u_short	pad,pause;
	u_char	padcount,status;
}	tetrisdef;

#include	"invtext.c"

int			titlescreenn;

int			cdebug = 0;
u_short		*cdebuglpt,*cdebugrpt;
short			soundvab,musicvab,musicseq,funkseq;					// VAB id for sound
int			soundvhmblock;
short			musicvolume,mainvolume;

// in font table (look up for font TIM), ~ represents "
char			fontcolour;
char			font8table[]="0123456789!~#$%&'()*+.-,/:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_£";
GsSPRITE		char8sprite,char8spritefast,sprite16bit,blocksprite,tdsprite;
char			timechar[8];

lcdgrid		lcd[2];				// simple screens for mini games (1 per player)
columsdef		game1[2];
tetrisdef		game2[2];
u_short		blockcolours[16*16],fontcolours[16*16];			// 4bit CLUTS for lcd blocks and font8

u_char		nighttime;								// nighttime = 1 when driving at night
u_char		timetrial;								// 0 = race, 1 = time trial

standardsprite	object[MAXSTANDARDSPRITES];
object3d		obj3d[MAX3DOBJECTS];
extrasprite		extrasprites[MAXEXTRASPRITES];
headlight3D		headlight[MAXHEADLIGHTS];
object3d		hlobj;
object3d		backlobj,backrobj;						// background screen object
GsSPRITE	mysprite;
GsSPRITE	laprecordsprite;
long		laprecordx,laprecordy,laprecorddx,laprecorddy,laprecordactive;
playerdata	*laprecordholder;
GsBG		background[2];
GsMAP		backmap[2];
trackinfoheader	trackinfo;
trackinfoheader	tracks[MAXTRACKS];				// data for all the tracks in the game
locationinfoheader	location[MAXLOCATIONS];
u_long		backgroundworkarea[(((SCREENWIDTH/16+1)*(SCREENHEIGHT/16+1+1)*6+4)*2+2)];
u_long		backgroundtopworkarea[(((SCREENWIDTH/16+1)*(SCREENHEIGHT/16+1+1)*6+4)*2+2)];
long			mapwidth,mapheight,mapx,mapy;
memoryblockentry	memoryblock[MAXMEMORYBLOCKS];			// used to keep track of allocated memory
cardriver		driver[MAXDRIVERS];				// keeps track of drivers on the race
playerdata		players[6];						// 2+ are bodges
ghostdatadef	ghostdata;
dustparticle	dust[MAXDUSTPARTICLES];
char			qrand[8] = {2,5,-4,3,-6,1,-5,4};
int			selectedclass,selectedlocation,selectedtrack;
int			optionsreturn;
int			playeri;						// player entering in options screen (for single player)
int			carpositions[MAXDRIVERS];			// list of car drivers in position order

struct	DIRENTRY	de1[15],de2[15],*dept;
char		cardfname[32];
u_char	cardbuff[8200];
char		savegamefilename[20] = "BESLES23981rmshover";

u_short		carcolours[6] = {0x001f,0x17e0,0x7c01,0x03fe,0x7c1b,0x7f80};
u_short		screenline[320];

short			maxspeeds[4] = {180,220,280,350};

int			racetracks[8] = {0,2,1,8,10,4,5,6};

u_char	racestatus;						// 0 = starting grid, 1 = running
u_char	game_paused;
u_char	QUIT_GAME_FLAG;					// 0 = no, 1 = exit program

u_char	postextx[6] = {0,22,60,94,126,157};		// positions of position text textures (1st 2nd 3rd  etc..)
u_char	postextw[6] = {22,38,36,32,31,31};
GsSPRITE	postextspr;
GsSPRITE	ammospr;

u_short	projection;
GsRVIEW2	cameraview;
GsF_LIGHT	light[3];

DISPENV	display;

singleframe		*framespt;		// pointer to frame data
animation		*animspt;		// pointer to animation data
maskheader		*maskheaderpt;	// pointer to frame masks headers
u_short		*maskspt;		// and data
movementheader	*movespt;		// pointer to movementheaders
u_char		*simplemovespt;
velocity		*veltabpt;		// pointer to velocity table
volume		*volumetabpt;	// pointer to volume table
u_char		*colmappt;		// pointer to collision map
u_char		*chkmappt;		// pointer to cpu check map
u_char		*cpudirmappt;	// pointer to cpu dir map
u_long		*headlighttmdpt;	// pointer to headlight tmd data
headlightprecalc	*headlpcpt;		// pointer to headlight pre-calc table
u_long		headlnprims;	// number of prims in headlight tmd
void			*vhptr,*musicvhptr;		// pointer to VH sound header

GsOT		WorldOT[2];
GsOT_TAG	OTTags[2][1<<OT_LENGTH];
PACKET	GpuPacketArea[2][MAXPRIMITIVES*(24)];

GsOT		TopOT[2];
GsOT_TAG	TopOTTags[2][1<<TOPOT_LENGTH];
GsOT		BotOT[2];
GsOT_TAG	BotOTTags[2][1<<BOTOT_LENGTH];
GsOT		OverlayOT[2];
GsOT_TAG	OverlayOTTags[2][1<<OVERLAYOT_LENGTH];
GsOT		BackOT[2];
GsOT_TAG	BackOTTags[2][1<<BACKOT_LENGTH];

int		activebuff;			// Currently active screen buffer
int		quitwithpause,lapsfinished;

char		frames_loaded=0;		// Flag to check if loaded frames data yet

volatile	u_char	*bb0, *bb1;

// Function headers
static	u_long	PadRead();
void racegamemain();
void Initializeframes();
void TransferTextures(u_long *tim);
void FrametoGs(singleframe *frame, GsSPRITE *sprite);
void followcontrol(u_long obj);
void playercontrol(u_long obj);
void DisplayObject(u_long obj);
void DisplayObjectOverlay(u_long obj, int pri);
void OverlaySprite(long x, long y,animation *base_sprite,long frame);
void ObjectHandler();
void UpdateObject(u_long obj);
u_long spawn();
void InitializeObjects();
u_long spawn3d();
void kill3d(u_long obj);
void create3dobject(u_long obj,int index);
void shotcontrol(u_long obj);
void makeshot(u_long shot,long x, long y, u_long owner, u_short pri);
u_long spawnextra();
void	kill(u_long obj);
void newplayer(u_long obj);
void newcpuplayer(u_long obj);
void cpuplayercontrol(u_long obj);
void countdowncontrol(u_long obj);
void playercontrolstart(u_long obj);
void cpuplayercontrolstart(u_long obj);
void checkchangeposition(u_long obj);
void CheckPlayers(GsOT *wot);
void InitializeTrack(trackinfoheader *th);
void Initializebackground(trackinfoheader *th);
void FreeBackground(trackinfoheader *th);
int	checkcollide(u_long obj1, u_long obj2, long nx, long ny);
u_long getpaklength(int index);
u_long	getpakaddress(int index);
void unpakRLE(void *source, void *dest, u_long length);
void unpak(int index, void *dest);
int allocatememory(u_long size);
void freememory(int mb);
void freeallmemory();
void startgridcontrol(u_long obj);
void resetdrivers();
u_long adddriver(long x, long y, u_short angle, u_char class, u_char colour);
void UpdateObjectCoordinates(object3d *objpt);
void DisplayObject3D(object3d *objpt);
void UpdateHeadlightObjectCoordinates(headlight3D *objpt);
void DisplayHeadlightObject3D(headlight3D *objpt);
void	ResetPlayer(int p);
void ReadController(u_char pad, u_short *dest);
void playerfire(u_char trigger, u_long obj);
void dropmine(long x,long y,u_long obj);
void minecontrol(u_long obj);
void hurt(u_long obj, long damage);
void makesmoke(long x,long y,u_long obj);
void smokecontrol(u_long obj);
int	checkcollide16(u_long obj1, u_long obj2, long nx, long ny);
int	checkmask16(u_long lobj, u_long robj, int shift, u_short skip1, u_short skip2, u_short height);
void testcollision();
void testcontrol(u_long obj);
void explosioncontrol(u_long obj);
void makeexplosion(long x,long y);
void firemissile(long x,long y, long dx, long dy,u_long obj);
void missilecontrol(u_long obj);
void fireimissile(long x,long y, long dx, long dy,u_long obj);
void imissilecontrol(u_long obj);
void dropoil(long x,long y,u_long obj);
void oilcontrol(u_long obj);
void getgridnfo(int index, trackinfoheader *thpt);
u_short	carcolourcx(u_char colour);
u_short	carcolourcy(u_char colour);
void char8(short x,short y,short scalex,short scaley, long rotate, char c);
void char8fast(short x,short y, char c);
void print8(short x,short y, char *text);
void int8(short x,short y,short d, int num);
char drawtextentry(short sx,short sy,char highlight);
void arcadeentry(int racenumber);
void TransferTIM(int index);
void time8(short x,short y,u_long time);
void timetd(short x,short y,u_long time);
void playerspincontrol(u_long obj);
void clearlcd(lcdgrid *pt);
int rungame1(columsdef *game, long *cashpt);
void newgame1block(u_char *pt);
void lcddisplay(lcdgrid *lcdpt,u_char fade,u_char type);
void lcdblock(lcdgrid *lcdpt,short x, short y,u_char block);
void backfader(u_short p, u_char *fade);
u_char	lcdread(lcdgrid *lcdpt, short x, short y);
u_char game1movevalid(short x,short y, columsdef *game);
void updategame1delete(columsdef *game);
int updategame1drop(columsdef *game);
void updategame1deletevert(columsdef *game);
void updategame1deletediagdr(columsdef *game);
void updategame1deletediagdl(columsdef *game);
void	updatefontcolour();
int	rungame2(tetrisdef *game, long *cashpt);
void blocktypechange(u_short p, u_char *type);
void optimizeremovelist(columsdef *game);
void initsound();
void closesound();
void thud(short angle);
void prang();
void boom();
void SetupTrack(int trackn);
void DeSetupTrack(int trackn);
void Race(int trackn);
void updateghostdata();
void startghostdata(u_long obj);
void ghostcontrol(u_long obj);
void initializeghostdata();
void ghostdatabestlap();
void soundtest();
void initstarfield(VECTOR *pt);
void makedust(long x,long y,u_long owner);
void dustcontrol(u_long obj);
void nullcontrol(u_long obj);
int optionentry();
void optiondrawtitle();
void drawbox2(int x,int y,int w,int h);
void drawbox(int x,int y,int w,int h);
void drawline(int x, int y, int w, int h);
void optionsmemorycard(long card1,long card2,long save1avail,long save2avail);
void optioncentrescreen();
void optionoptions(int status);
void optionchooseclass();
int optionchooselocation();
int optionchoosetrack(int loc);
void optionchoosetrackinfo(trackinfoheader *tpt);
void optionentername();
int spawndust();
void makecarcolours(u_short col,int car);
int memorycardsave(long card,long avail);
int memorycardload(long card);
void laprecord(playerdata *player);
u_char checktrackcollision16(u_long obj,long nx,long ny);
u_char checktrackcollision16col(short index8);
int checktrackcollisionmask16(short index16,short mrot,u_short *pt,short tmskip,int height);
int checktrackcollisionmask16r(short index16,short mrot,u_short *pt,short tmskip,int height);
void ny_title();
void specialthanks();
void gameoverplayercontrol(u_long obj);
void showrankings();



main ()
{
	u_long	*pt;
	u_long *testpt;
	RECT		rct;
	int f,g,opt,racenumber;

//	printf("Size of standard sprite is %d\n",sizeof(standardsprite));
//	printf("Size of single frame is %d\n",sizeof(singleframe));
//	printf("Size of an animation is %d\n",sizeof(animation));
//	printf("Size of short is %d, size of u_short is %d, size of u_long is %d\n",sizeof(short),sizeof(u_short),sizeof(u_long));
//	printf("Size of GsMAP is %d\n",sizeof(GsMAP));
//	printf("Tpage 768,256 is %d\n",GetTPage(0,0,768,256));

	ny_title();
	specialthanks();

	titlescreenn = 0;//FPS*25;

	QUIT_GAME_FLAG = 0;
	selectedclass = 0;
	selectedlocation = 0;
	selectedtrack = 0;

// Set up background screen objects (left and right)
	testpt = (u_long *) getpakaddress(_PAK_backrmodel_INDEX);
	backlobj.origin.vx = -2870;
	backlobj.origin.vy = -1974;
	backlobj.origin.vz = -300;
	backlobj.rotate.vx = -1024;
	backlobj.rotate.vy = -2048;
	backlobj.rotate.vz = 0;
	GsInitCoordinate2(WORLD, &(backlobj.coord));
	backlobj.handler.coord2 = &(backlobj.coord);
	testpt++;							// skip header ID
	GsMapModelingData(testpt);
	testpt+=2;							// skip past rest of header
	GsLinkObject4( (u_long)testpt, &(backlobj.handler), 0);
	backlobj.handler.attribute = 0x00000000;
	backlobj.active = 1;
	backlobj.ot = 2;
	UpdateObjectCoordinates(&backlobj);
	testpt = (u_long *) getpakaddress(_PAK_backlmodel_INDEX);
	backrobj.origin.vx = 2894;
	backrobj.origin.vy = -1974;
	backrobj.origin.vz = -300;
	backrobj.rotate.vx = -1024;
	backrobj.rotate.vy = -2048;
	backrobj.rotate.vz = 0;
	GsInitCoordinate2(WORLD, &(backrobj.coord));
	backrobj.handler.coord2 = &(backrobj.coord);
	testpt++;							// skip header ID
	GsMapModelingData(testpt);
	testpt+=2;							// skip past rest of header
	GsLinkObject4( (u_long)testpt, &(backrobj.handler), 0);
	backrobj.handler.attribute = 0x00000000;
	backrobj.active = 1;
	backrobj.ot = 2;
	UpdateObjectCoordinates(&backrobj);


// Some small initialization
	musicvolume = 60;
	mainvolume = 100;
	for (f=0;f<8;f++)
		qrand[f] = qrand[f]*16;
	game_paused = 0;
	timechar[7]=0;
	timechar[1]=':';
	timechar[4]=':';
	tdsprite.attribute = 0;
	tdsprite.w = 4;
	tdsprite.h = 6;
	tdsprite.v = 48;
	tdsprite.tpage=GetTPage(0,0,448,0);
	tdsprite.cx = 448; tdsprite.cy = 253;
	tdsprite.r = tdsprite.g = tdsprite.b = 128;
	char8sprite.attribute = 0x00000000;
	char8sprite.w=8;
	char8sprite.h=8;
	char8sprite.tpage=GetTPage(0,0,640,0);
	char8sprite.cx = 640;
	char8sprite.cy = 240;
	char8sprite.r = 128; char8sprite.g = 128; char8sprite.b = 128;
	char8sprite.mx = 4;
	char8sprite.my = 4;
	char8spritefast = char8sprite;
	char8spritefast.scalex = 4096;
	char8spritefast.scaley = 4096;
	char8spritefast.rotate = 0;
	char8spritefast.attribute = 0x08000000;
	sprite16bit = char8spritefast;
	sprite16bit.attribute = 1<<25;
	sprite16bit.tpage = GetTPage(0,0,768,256);
	sprite16bit.cx = 0;
	sprite16bit.cy = 0;
	blocksprite.attribute = 0x00000000;
	blocksprite.w=8;
	blocksprite.h=8;
	blocksprite.r = blocksprite.g = blocksprite.b = 128;
	blocksprite.tpage = GetTPage(0,0,768,256);
	blocksprite.mx = blocksprite.my = 4;
	blocksprite.cx = 816;
	TransferTIM(_PAK_myfont_INDEX);				// put font in frame buffer
	unpak(_PAK_blockcolours_INDEX,blockcolours);
	unpak(_PAK_fontcolours_INDEX,fontcolours);
	rct.x = 640; rct.y = 241; rct.w = 64; rct.h = 3;
	LoadImage(&rct, (u_long *) fontcolours);			// put font colours in frame buffer
	fontcolour = 8;							// colour for font
	updatefontcolour();

// Initialise sound
	initsound();

// Initialize Controller Pad buffers
	GetPadBuf(&bb0, &bb1);		// Get pad buffers

// Initialize memory blocks (Otherwise big crashes possible)
	for (f=0;f<MAXMEMORYBLOCKS;f++)
		memoryblock[f].active = 0;	// Initialize all memory blocks to inactive

// Initialize headers of the tracks we will use
	for (f=0;f<MAXTRACKS;f++)
	{
		tracks[f].valid = 0;
		for (g=0;g<4;g++)
		{
			tracks[f].records.laprecord[g] = (80+f)*FPS;			// some standard data
			tracks[f].records.trackrecord[g] = (240+f)*FPS;
			strcpy(&tracks[f].records.bestlapname[g][0],"RMS");
			strcpy(&tracks[f].records.bestname[g][0],"RMS");
		}
		tracks[f].ghost[0] = -1;
		tracks[f].numlaps = 5;
	}
	tracks[0].celindex = _PAK_track2cells1_INDEX;			// ground map
	tracks[0].mpiindex = _PAK_track2index1_INDEX;
	tracks[0].colindex = _PAK_track2colmap_INDEX;
	tracks[0].celtopindex = _PAK_track2cells2_INDEX;		// overlay map
	tracks[0].mpitopindex = _PAK_track2index2_INDEX;
	tracks[0].type = 0;							// 0 = standard (with overlay), 1 = special (no overlay)
	tracks[0].tim1index = _PAK_track1tim_INDEX;
	tracks[0].tim2index = _PAK_track2tim_INDEX;
	tracks[0].maskaddress = (u_short *)getpakaddress(_PAK_engtrackbitmask_INDEX);
	tracks[0].valid = 1;
	tracks[0].night = 0;
	strcpy(tracks[0].name,"COURSE 1");
	getgridnfo(_PAK_track2nfo_INDEX,&tracks[0]);

	tracks[1].celindex = _PAK_track5cells1_INDEX;			// ground map
	tracks[1].mpiindex = _PAK_track5index1_INDEX;
	tracks[1].colindex = _PAK_track5colmap_INDEX;
	tracks[1].celtopindex = _PAK_track5cells2_INDEX;		// overlay map
	tracks[1].mpitopindex = _PAK_track5index2_INDEX;
	tracks[1].type = 0;							// 0 = standard (with overlay), 1 = special (no overlay)
	tracks[1].tim1index = _PAK_track1tim_INDEX;
	tracks[1].tim2index = _PAK_track2tim_INDEX;
	tracks[1].maskaddress = (u_short *)getpakaddress(_PAK_engtrackbitmask_INDEX);
	tracks[1].valid = 1;
	tracks[1].night = 0;
	strcpy(tracks[1].name,"COURSE 3");
	getgridnfo(_PAK_track5nfo_INDEX,&tracks[1]);

	tracks[2].celindex = _PAK_track4cells1_INDEX;			// ground map
	tracks[2].mpiindex = _PAK_track4index1_INDEX;
	tracks[2].colindex = _PAK_track4colmap_INDEX;
	tracks[2].celtopindex = _PAK_track4cells2_INDEX;		// overlay map
	tracks[2].mpitopindex = _PAK_track4index2_INDEX;
	tracks[2].type = 0;							// 0 = standard (with overlay), 1 = special (no overlay)
	tracks[2].tim1index = _PAK_track1tim_INDEX;
	tracks[2].tim2index = _PAK_track2tim_INDEX;
	tracks[2].maskaddress = (u_short *)getpakaddress(_PAK_engtrackbitmask_INDEX);
	tracks[2].valid = 1;
	tracks[2].night = 0;
	strcpy(tracks[2].name,"COURSE 2");
	getgridnfo(_PAK_track4nfo_INDEX,&tracks[2]);

	tracks[3].celindex = _PAK_track5cells1_INDEX;			// ground map
	tracks[3].mpiindex = _PAK_track5index1_INDEX;
	tracks[3].colindex = _PAK_track5colmap_INDEX;
	tracks[3].celtopindex = _PAK_track5cells2_INDEX;		// overlay map
	tracks[3].mpitopindex = _PAK_track5index2_INDEX;
	tracks[3].type = 0;							// 0 = standard (with overlay), 1 = special (no overlay)
	tracks[3].tim1index = _PAK_track1tim_INDEX;
	tracks[3].tim2index = _PAK_track2tim_INDEX;
	tracks[3].maskaddress = (u_short *)getpakaddress(_PAK_engtrackbitmask_INDEX);
	tracks[3].valid = 1;
	tracks[3].night = 1;
	strcpy(tracks[3].name,"COURSE 3 AT NIGHT");
	getgridnfo(_PAK_track5nfo_INDEX,&tracks[3]);

	tracks[8].celindex = _PAK_track3cells1_INDEX;			// ground map
	tracks[8].mpiindex = _PAK_track3index1_INDEX;
	tracks[8].colindex = _PAK_track3colmap_INDEX;
	tracks[8].celtopindex = _PAK_track3cells2_INDEX;		// overlay map
	tracks[8].mpitopindex = _PAK_track3index2_INDEX;
	tracks[8].type = 0;							// 0 = standard (with overlay), 1 = special (no overlay)
	tracks[8].tim1index = _PAK_track1tim_INDEX;
	tracks[8].tim2index = _PAK_track2tim_INDEX;
	tracks[8].maskaddress = (u_short *)getpakaddress(_PAK_engtrackbitmask_INDEX);
	tracks[8].valid = 1;
	tracks[8].night = 0;
	strcpy(tracks[8].name,"COURSE 4");
	getgridnfo(_PAK_track3nfo_INDEX,&tracks[8]);

	tracks[9].celindex = _PAK_trackncells1_INDEX;			// ground map
	tracks[9].mpiindex = _PAK_tracknindex1_INDEX;
	tracks[9].colindex = _PAK_trackncolmap_INDEX;
	tracks[9].celtopindex = _PAK_trackncells2_INDEX;		// overlay map
	tracks[9].mpitopindex = _PAK_tracknindex2_INDEX;
	tracks[9].type = 0;							// 0 = standard (with overlay), 1 = special (no overlay)
	tracks[9].tim1index = _PAK_track1tim_INDEX;
	tracks[9].tim2index = _PAK_track2tim_INDEX;
	tracks[9].maskaddress = (u_short *)getpakaddress(_PAK_engtrackbitmask_INDEX);
	tracks[9].valid = 1;
	tracks[9].night = 1;
	strcpy(tracks[9].name,"COURSE 5 AT NIGHT");
	getgridnfo(_PAK_tracknnfo_INDEX,&tracks[9]);

	tracks[10].celindex = _PAK_trackncells1_INDEX;			// ground map
	tracks[10].mpiindex = _PAK_tracknindex1_INDEX;
	tracks[10].colindex = _PAK_trackncolmap_INDEX;
	tracks[10].celtopindex = _PAK_trackncells2_INDEX;		// overlay map
	tracks[10].mpitopindex = _PAK_tracknindex2_INDEX;
	tracks[10].type = 0;							// 0 = standard (with overlay), 1 = special (no overlay)
	tracks[10].tim1index = _PAK_track1tim_INDEX;
	tracks[10].tim2index = _PAK_track2tim_INDEX;
	tracks[10].maskaddress = (u_short *)getpakaddress(_PAK_engtrackbitmask_INDEX);
	tracks[10].valid = 1;
	tracks[10].night = 1;
	strcpy(tracks[10].name,"COURSE 5");
	getgridnfo(_PAK_tracknnfo_INDEX,&tracks[10]);


	tracks[4].celindex = _PAK_trackjap1cells1_INDEX;			// ground map
	tracks[4].mpiindex = _PAK_trackjap1index1_INDEX;
	tracks[4].colindex = _PAK_trackjap1colmap_INDEX;
	tracks[4].celtopindex = _PAK_trackjap1cells2_INDEX;		// overlay map
	tracks[4].mpitopindex = _PAK_trackjap1index2_INDEX;
	tracks[4].type = 1;							// 0 = standard (with overlay), 1 = special (no overlay)
	tracks[4].tim1index = _PAK_trackjap1tim_INDEX;
	tracks[4].tim2index = _PAK_trackjap1tim_INDEX;
	tracks[4].maskaddress = (u_short *)getpakaddress(_PAK_japtrackbitmask_INDEX);
	tracks[4].valid = 1;
	tracks[4].night = 0;
	strcpy(tracks[4].name,"JAPAN 1");
	getgridnfo(_PAK_trackjap1nfo_INDEX,&tracks[4]);

	tracks[5].celindex = _PAK_trackjap2cells1_INDEX;			// ground map
	tracks[5].mpiindex = _PAK_trackjap2index1_INDEX;
	tracks[5].colindex = _PAK_trackjap2colmap_INDEX;
	tracks[5].celtopindex = _PAK_trackjap2cells2_INDEX;		// overlay map
	tracks[5].mpitopindex = _PAK_trackjap2index2_INDEX;
	tracks[5].type = 1;							// 0 = standard (with overlay), 1 = special (no overlay)
	tracks[5].tim1index = _PAK_trackjap1tim_INDEX;
	tracks[5].tim2index = _PAK_trackjap1tim_INDEX;
	tracks[5].maskaddress = (u_short *)getpakaddress(_PAK_japtrackbitmask_INDEX);
	tracks[5].valid = 1;
	tracks[5].night = 0;
	strcpy(tracks[5].name,"JAPAN 2");
	getgridnfo(_PAK_trackjap2nfo_INDEX,&tracks[5]);

	tracks[6].celindex = _PAK_trackjap3cells1_INDEX;			// ground map
	tracks[6].mpiindex = _PAK_trackjap3index1_INDEX;
	tracks[6].colindex = _PAK_trackjap3colmap_INDEX;
	tracks[6].celtopindex = _PAK_trackjap3cells2_INDEX;		// overlay map
	tracks[6].mpitopindex = _PAK_trackjap3index2_INDEX;
	tracks[6].type = 1;							// 0 = standard (with overlay), 1 = special (no overlay)
	tracks[6].tim1index = _PAK_trackjap1tim_INDEX;
	tracks[6].tim2index = _PAK_trackjap1tim_INDEX;
	tracks[6].maskaddress = (u_short *)getpakaddress(_PAK_japtrackbitmask_INDEX);
	tracks[6].valid = 1;
	tracks[6].night = 0;
	strcpy(tracks[6].name,"JAPAN 3");
	getgridnfo(_PAK_trackjap3nfo_INDEX,&tracks[6]);


// Now do locations
	for (f=0;f<MAXLOCATIONS;f++)
		for (g=0;g<MAXTRACKSPERLOC;g++)
			location[f].index[g]=-1;				// clear locations
	strcpy(location[0].name,"ENGLAND");
	location[0].index[0]=0;
	location[0].index[1]=2;
	location[0].index[2]=1;
	location[0].index[3]=8;
	location[0].index[4]=9;
	location[0].index[5]=10;
	strcpy(location[1].name,"JAPAN");
	location[1].index[0]=4;
	location[1].index[1]=5;
	location[1].index[2]=6;

// Get address for the velocity table
	veltabpt = (velocity *)getpakaddress(_PAK_veltab_INDEX);

// Unpak volume table
	volumetabpt = (volume *)getpakaddress(_PAK_volumetab_INDEX);




// Reset players
	for (f=0;f<2;f++)
		ResetPlayer(f);

	playeri = 0;			// player entering (in 1 player modes)

// Bodge a player in
//	players[0].active = 1;
//	players[0].carcolour = 0;

//	players[1].active = 1;
//	players[1].carcolour = 10;

// Set up the display
	if (FPS == 50)
		SetVideoMode(MODE_PAL);		// Set video mode
	else
		SetVideoMode(MODE_NTSC);
	GsInitGraph(SCREENWIDTH,SCREENHEIGHT,4,1,0);	// Initialise graphics system. Screen is 320x240 pixels.
					// Non Interlaced/GPU offset for double buffering, no dithering, 16bit VRAM
	GsDefDispBuff(0,0,0,256);	// Define Double buffering. Buffer 0 starts at 0,0
					// Buffer 1 starts at 0,256
	GsInit3D();			// Initialise 3D libraries
	projection = 96;
//	printf("screen x %d\n",GsDISPENV.screen.x);
	GsDISPENV.screen.x = 4;
//	printf("DISP screen%d,%d\n",GsDISPENV.screen.w,GsDISPENV.screen.h);
//	printf("DRAW clip%d,%d\n",GsDRAWENV.clip.w,GsDRAWENV.clip.h);
//	printf("CLIP %d,%d to %d,%d\n",CLIP2.x,CLIP2.y,CLIP2.w,CLIP2.h);


	Initializeframes();			// Do bulk of initialization (saves a little time later on)


	FrametoGs(framespt+(((animspt + ANIM_LAPRECORD)->offset)), &laprecordsprite);
	laprecordsprite.attribute = 0x40000000;
	laprecordsprite.mx = laprecordsprite.w/2;
	laprecordsprite.my = laprecordsprite.h/2;
	laprecordsprite.r = laprecordsprite.g = laprecordsprite.b = 128;
	laprecordsprite.scalex = laprecordsprite.scaley = 4096;
	laprecordsprite.rotate = 0;
	laprecordx = 0;
	laprecordy = -200;
	laprecordactive = 0;

	nighttime = 0;
	timetrial = 0;

	opt = -1;
	optionsreturn = 0;
	while (opt != 0)
	{
		SsSeqPlay(funkseq,SSPLAY_PLAY,SSPLAY_INFINITY);
		opt = optionentry();
		if (opt == 1)			// arcade
		{
			int	racequit;
			racequit = 0;
			for (f=0;f<2;f++)
				ResetPlayer(f);			// initialise all (both) players
			selectedclass = 4;
			racenumber = 0;
			while ( racequit == 0)
			{
				arcadeentry(racenumber);
//				soundtest();
				nighttime = 0;
				timetrial = 0;
				SsSeqStop(funkseq);
				if (players[0].active != 0 || players[1].active != 0)
				{
					Race(racetracks[racenumber%8]);
					backlobj.origin.vx = -2870;
					backlobj.origin.vy = -1974;
					backrobj.origin.vx = 2894;
					backrobj.origin.vy = -1974;
					backlobj.rotate.vy = 2048;
					backrobj.rotate.vy = 2048;
					backlobj.rotate.vz = 0;
					backrobj.rotate.vz = 0;
					if (quitwithpause == 0)
						showrankings();
				}
				if (quitwithpause == 1)
				{
					players[0].fuel = 0;
					players[1].fuel = 0;
				}
				for (f=0;f<2;f++)
					if (players[f].fuel == 0)
						players[f].active = 0;
				racenumber++;
				if (players[0].active == 0 && players[1].active == 0)		// if both players inactive
					racequit = 1;							// quit & return to main screen
			}
		}
		if (opt == 2)			// time trial
		{
			nighttime = 0;
			timetrial = 1;
			SsSeqStop(funkseq);
			Race(location[selectedlocation].index[selectedtrack]);
		}
	}

//	testcollision();

	freeallmemory();

	closesound();
	printf("OUT\n");

	return(0);
}

void SetupTrack(int trackn)
{	// Initializes track trackn ready for use
	Initializebackground(&tracks[trackn]);
	InitializeTrack(&tracks[trackn]);
	trackinfo = tracks[trackn];
}

void DeSetupTrack(int trackn)
{	// copies back some data (best times etc.. to track info)
	int f;
	for (f=0;f<4;f++)
	{
		tracks[trackn].records.laprecord[f] = trackinfo.records.laprecord[f];
		tracks[trackn].records.trackrecord[f] = trackinfo.records.trackrecord[f];
		strcpy(&tracks[trackn].records.bestlapname[f][0],&trackinfo.records.bestlapname[f][0]);
		strcpy(&tracks[trackn].records.bestname[f][0],&trackinfo.records.bestname[f][0]);
	}
}

void Race(int trackn)
{	// Does the race on track trackn
	if (timetrial == 1)
		nighttime = tracks[trackn].night & 1;
	SetupTrack(trackn);
//	printf("calling racegamemain\n");
	racegamemain();
	DeSetupTrack(trackn);
	FreeBackground(&tracks[trackn]);
}

int optionentry()
{		// main options screens
		// returns:  1=arcade entry, 0 = exit
	int f,g,QUIT_FLAG,optstatus,status,num,hcnt,butwait,duston,dustang,qrandi,fpb;
	char	c,cpos,name[16];
	u_short	pc;
	short		dustx,dusty,dustm,dustdx,dustdx2;
	u_long	obj,cubeobj;
	long		card1,card2,save1avail,save2avail;		//card1 and card2 are id's of card. save1avail & save2avail hold whether valid savegame found (0=no, 1=yes)
	GsLINE	dot;
	GsSPRITE	lspr;				// sprite for option selector

//	printf("Option Entry\n");

	card1 = 0; card2 = 0;

	dot.attribute = 0x70000000;
	dot.r = dot.b = dot.g = 0;
	lspr.attribute = 0x41000000;//(1<<24) | (1<<27) | (1<<30) | (3<<28);
	lspr.w = 14; lspr.h = 14;
	lspr.u = 103; lspr.v = 91+48;
	lspr.tpage = GetTPage(0,0,640,256);
	lspr.r = 128;
	lspr.g = 96;
	lspr.b = 0;
	lspr.cx = 640;
	lspr.cy = 496;

	for (f=0;f<2;f++)
	{
		WorldOT[f].length = OT_LENGTH;
		WorldOT[f].org = OTTags[f];
		TopOT[f].length = TOPOT_LENGTH;
		TopOT[f].org = TopOTTags[f];
		BotOT[f].length = BOTOT_LENGTH;
		BotOT[f].org = BotOTTags[f];
		OverlayOT[f].length = OVERLAYOT_LENGTH;
		OverlayOT[f].org = OverlayOTTags[f];
		BackOT[f].length = BACKOT_LENGTH;
		BackOT[f].org = BackOTTags[f];
	}
// Set up text area
	FntLoad(960,256);
	FntOpen(16-SCREENWIDTH/2,16-SCREENHEIGHT/2,256,200,0,512);

	for (f=0;f<2;f++)
		ResetPlayer(f);			// initialise all (both) players
	for (f=0;f<MAX3DOBJECTS;f++)		// clear all 3d objects
		obj3d[f].active = 0;
	for (f=0;f<MAXDUSTPARTICLES;f++)
		dust[f].active = 0;

// Set up the 3D camera view
	projection=96;			// 512
	GsSetProjection(projection);
	cameraview.vrx = 0;
	cameraview.vry = 0;
	cameraview.vrz = 0;
	cameraview.vpx = 0;
	cameraview.vpy = 0;
	cameraview.vpz = -1800;
	cameraview.rz = 0;
	cameraview.super = WORLD;
	GsSetRefView2(&cameraview);
// Set up the 3D Lighting
	GsSetLightMode(0);
	light[0].vx = 0; light[0].vy = 0; light[0].vz = ONE;
	light[1].vx = 0; light[1].vy = ONE; light[1].vz = 0;
	light[2].vx = ONE; light[2].vy = 0; light[2].vz = 0;
	for (f=0;f<3;f++)
	{
//		light[f].vx = 0;
//		light[f].vy = 0;
//		light[f].vz = ONE;
		light[f].r = 128;
		light[f].g = 128;
		light[f].b = 128;
		GsSetFlatLight(f, &light[f]);
	}
	GsSetAmbient(128,128,128);

	TransferTIM(_PAK_choiboxtim_INDEX);
	TransferTIM(_PAK_choosetim_INDEX);
	TransferTIM(_PAK_backtim_INDEX);
	TransferTIM(_PAK_mcardtim_INDEX);

	QUIT_FLAG = 0;
	optstatus = optionsreturn;			// 0 = initial screen
	if (titlescreenn != 0)
		optstatus = 99;
	cubeobj = MAX3DOBJECTS+1;
	obj = 0;
	duston = 0;
	qrandi = 0;
	butwait = 0;
	while (QUIT_FLAG != 1)
	{

		// Clear up display data
		activebuff = GsGetActiveBuff();
		GsSetWorkBase((PACKET *)GpuPacketArea[activebuff]);
		GsClearOt(0, 0, &WorldOT[activebuff]);
		GsClearOt(0, OTPRI_SMOKE, &TopOT[activebuff]);		// 3D above ground
		GsClearOt(0, OTPRI_GROUND+1, &BotOT[activebuff]);	// 3D below ground
		GsClearOt(0, 0, &OverlayOT[activebuff]);
		GsClearOt(0, OTPRI_BACK, &BackOT[activebuff]);		// background object

		// Read Controller 
		for (f=0;f<2;f++)
			ReadController(players[f].pad, players[f].paddata);
		if ( (players[0].paddata[1] & PADselect) && (players[0].paddata[1] & PADstart) )
			QUIT_FLAG = 1;
		pc = players[playeri].paddata[1];		// get pad info for a single player

		// Place camera
		GsSetRefView2(&cameraview);

		if (optstatus == 0)				// title screen
		{
			optiondrawtitle();
			if ( (players[0].paddata[1] & PADstart) || (players[1].paddata[1] & PADstart) )
				optstatus = 1;			// next screen
		/*
			if (players[0].paddata[1] & PADLleft)
				backlobj.origin.vx-=10;
			if (players[0].paddata[1] & PADLright)
				backlobj.origin.vx+=10;
			if (players[0].paddata[1] & PADLup)
				backlobj.origin.vy-=10;
			if (players[0].paddata[1] & PADLdown)
				backlobj.origin.vy+=10;
			if (players[0].paddata[1] & PADRup)
				backlobj.rotate.vx+=16;
			if (players[0].paddata[1] & PADRdown)
				backlobj.rotate.vx-=16;
			if (players[0].paddata[1] & PADRleft)
				backlobj.rotate.vy+=16;
			if (players[0].paddata[1] & PADRright)
				backlobj.rotate.vy-=16;
			if (players[0].paddata[1] & PADL1)
				backlobj.origin.vz+=10;
			if (players[0].paddata[1] & PADL2)
				backlobj.origin.vz-=10;
			if (players[0].paddata[1] & PADL1)
				backlobj.rotate.vz+=16;
			if (players[0].paddata[1] & PADL2)
				backlobj.rotate.vz-=16;
			FntPrint("X,Y,Z %d %d %d\n%d %d %d\n",backlobj.origin.vx,backlobj.origin.vy,backlobj.origin.vz,backlobj.rotate.vx,backlobj.rotate.vy,backlobj.rotate.vz);
		*/
		}
		else if (optstatus == 1)			// initialise main menu screen
		{
			players[0].active = 0;
			players[1].active = 0;
			if ( cubeobj == (MAX3DOBJECTS+1) )
			{
				obj = spawn3d();
				create3dobject(obj,_PAK_choiboxmodel_INDEX);
//				create3dobject(obj,_PAK_rmodel_INDEX);
				obj3d[obj].origin.vx = 0;
				obj3d[obj].origin.vy = 0;
				obj3d[obj].origin.vz = 5000;
				obj3d[obj].rotate.vx = 120;
				obj3d[obj].rotate.vy = 0;
				obj3d[obj].rotate.vz = 0;
				obj3d[obj].active = 2;
				obj3d[obj].ot = 1;				// below track
				obj3d[obj].handler.attribute = 2<<9;
				cubeobj = obj;
			}
			status = 0;				// selection on cube
			butwait = 16;
			if (players[0].paddata[1] == 0 && players[1].paddata[1] == 0)
				optstatus = 2;
//			else
//				printf("Waiting ");
		}
		else if (optstatus == 2)			// do main menu screen
		{
			if ( (players[0].paddata[1] & PADRup) || (players[1].paddata[1] & PADRup) )
			{
				optstatus = 0;
				kill3d(cubeobj);
				cubeobj = MAX3DOBJECTS+1;		// so that it gets spawned again
			}
/*			if (players[0].paddata[1] & PADL1)
				obj3d[cubeobj].origin.vz+=32;
			if (players[0].paddata[1] & PADL2)
				obj3d[cubeobj].origin.vz-=32;
			if (players[0].paddata[1] & PADR1)
				obj3d[cubeobj].origin.vz+=2;
			if (players[0].paddata[1] & PADR2)
				obj3d[cubeobj].origin.vz-=2;
			if (players[0].paddata[1] & PADLup)
				obj3d[cubeobj].rotate.vx+=32;
			if (players[0].paddata[1] & PADLdown)
				obj3d[cubeobj].rotate.vx-=32;
			FntPrint("Z %d\n",obj3d[cubeobj].origin.vz);
*/
			if (status<0)
			{
				obj3d[cubeobj].rotate.vy-=64;
				status++;
			}
			else if (status>0)
			{
				obj3d[cubeobj].rotate.vy+=64;
				status--;
			}
			if (obj3d[cubeobj].rotate.vy < 0)
				obj3d[cubeobj].rotate.vy+=4096;
			if (obj3d[cubeobj].rotate.vy >= 4096)
				obj3d[cubeobj].rotate.vy-=4096;
			FntPrint("status %d, rot %d\n",status,obj3d[cubeobj].rotate.vy/1024);
			switch(obj3d[cubeobj].rotate.vy/1024)
			{
				case 0:
				{
					print8(72,200,"RACE AGAINST THE CLOCK");
					break;
				}
				case 1:
				{
					print8(72,200,"GENERAL OPTIONS SCREEN");
					break;
				}
				case 2:
				{
					print8(124,200,"EXIT GAME");
					break;
				}
				case 3:
				{
					print8(64,200,"ENTER ARCADE CHAMPIONSHIPS");
					break;
				}
			}
			for (f=0;f<2;f++)
			{
				if (butwait == 0)
				{
					if ( players[f].paddata[1] & PADLleft )
					{
						if (status < 0)
							obj3d[cubeobj].rotate.vy = (obj3d[cubeobj].rotate.vy/1024)*1024;
						else if (status > 0)
							obj3d[cubeobj].rotate.vy = (((obj3d[cubeobj].rotate.vy/1024)+1)%4)*1024;
						status=-16;
						thud(-45);
						butwait = 8;
					}
					if ( players[f].paddata[1] & PADLright )
					{
						thud(45);
						if (status < 0)
							obj3d[cubeobj].rotate.vy = (obj3d[cubeobj].rotate.vy/1024)*1024;
						else if (status > 0)
							obj3d[cubeobj].rotate.vy = (((obj3d[cubeobj].rotate.vy/1024)+1)%4)*1024;
						status=16;
						butwait = 8;
					}
				}
				else
					butwait--;
				if ( players[f].paddata[1] & PADRdown )
				{
					switch(obj3d[cubeobj].rotate.vy/1024)
					{
						case 0:
						{
							kill3d(cubeobj);
							cubeobj = MAX3DOBJECTS+1;		// so that it gets spawned again
							optstatus = 3;			// time trial init
							playeri = f;
							players[playeri].active = 1;
							break;
						}
						case 1:
						{
							playeri = f;
							optstatus = 11;
							kill3d(cubeobj);
							cubeobj = MAX3DOBJECTS+1;		// so that it gets spawned again
							break;
						}
						case 2:
						{
							kill3d(cubeobj);
							cubeobj = MAX3DOBJECTS+1;		// so that it gets spawned again
							return(0);
							break;
						}
						case 3:
						{
							kill3d(cubeobj);
							cubeobj = MAX3DOBJECTS+1;		// so that it gets spawned again
							optionsreturn = 0;
							for (fpb=2;fpb<6;fpb++)			// bodge
								players[fpb].score = 0;
							return(1);		// arcade
							break;
						}
					}
				}
			}
		}
		else if (optstatus == 3)						// init time trial
		{
			if (pc == 0)
				optstatus = 4;
			duston = 1;
			dustang = 0;
			limitrange(selectedclass,0,2);
			status = selectedclass;
			dusty = -7680+((status*20)<<7);
			for (f=0;f<MAXDUSTPARTICLES;f++)
				dust[f].active = 0;
		}
		else if (optstatus == 4)						// choose class
		{
			optionchooseclass();
			if (pc & PADRup)
			{
				duston = 0;
				optstatus = 1;
			}
			if (pc & PADRdown)
			{
				selectedclass = status;
				duston = 0;
				optstatus = 5;
			}
			if (butwait == 0)
			{
				if (pc & PADLdown)
				{
					status = (status+1)%3;
					butwait = 8;
				}
				if (pc & PADLup)
				{
					status = (status+2)%3;
					butwait = 8;
				}
			}
			else
				butwait--;
			if (dusty != (-1920+((status*20)<<7)))
				dusty+=((-7680+((status*20)<<7))-dusty)/8;
			if (status == 0)		// novice
			{
				dustx = -3456;
				dustm = 4;
				lspr.y = -64;
			}
			else if (status == 1)	// competent
			{
				dustx = -2880;
				dustm = 6;
				lspr.y = -44;
			}
			else if (status == 2)	// pro
			{
				dustx = -3936;
				dustm = 2;
				lspr.y = -24;
			}
			dustdx = (veltabpt+dustang)->dx;
			dustdx2 = ((float)(dustdx-(veltabpt+((dustang+31)%32))->dx)/10)*(dustm>>1);
			dustdx*=dustm;
			lspr.x = ((dustx+dustdx)>>5)-8;
			lspr.y = (dusty>>7)-5;
			for (g=0;g<2+(rand()&7);g++)
			{
				obj = spawndust();
				if (obj != -1)
				{
					dust[obj].col = 255;
					dust[obj].dx = dustdx2;
					dust[obj].dy = -6+(qrand[qrandi]>>4);//-128+rand()&128;
					dust[obj].x = dustx+dustdx+qrand[(qrandi+1)%8];
					dust[obj].y = dusty+(qrand[qrandi]<<2);
					qrandi=(qrandi+1)%8;
				}
			}
			dustang=(dustang+1)%32;
		}
		else if (optstatus == 5)					// choose loc init
		{
			duston = 1;
			dustang = 0;
			status = selectedlocation;
			dusty = -7680; 
			for (f=0;f<MAXDUSTPARTICLES;f++)
				dust[f].active = 0;
			if (pc == 0)
				optstatus = 6;
		}
		else if (optstatus == 6)					// choose location
		{
			num = optionchooselocation();
			if (pc & PADRup)
				optstatus = 3;
			if (pc & PADRdown)
			{
				optstatus = 7;
				selectedlocation = status;
			}
			if (butwait == 0)
			{
				if (pc & PADLup)
				{
					status = (status+(num-1))%num;
					butwait = 8;
				}
				if (pc & PADLdown)
				{
					status = (status+1)%num;
					butwait = 8;
				}
			}
			else
				butwait--;
			dustx = (-140<<5)+(((strlen(location[status].name)/2)<<3)<<5);
			dusty = ((-54)<<7)+((status*10)<<7);
			dustm = strlen(location[status].name)/2;
			dustdx = (veltabpt+dustang)->dx;
			dustdx2 = ((float)(dustdx-(veltabpt+((dustang+31)%32))->dx)/10)*(dustm>>1);
			dustdx*=dustm;
			lspr.x = ((dustx+dustdx)>>5)-8;
			lspr.y = (dusty>>7)-5;
			for (g=0;g<3+(rand()&3);g++)
			{
				obj = spawndust();
				if (obj != -1)
				{
					dust[obj].col = 255;
					dust[obj].dx = dustdx2;
					dust[obj].dy = -6+(qrand[qrandi]>>4);//+rand()&15;
					dust[obj].x = dustx+dustdx+qrand[(qrandi+1)%8];
					dust[obj].y = dusty+(qrand[qrandi]);
					qrandi=(qrandi+1)%8;
				}
			}
			dustang=(dustang+1)%32;
		}
		else if (optstatus == 7)					// choose track init
		{
			duston = 1;
			dustang = 0;
			status = selectedtrack;
			dusty = -7680; 
			for (f=0;f<MAXDUSTPARTICLES;f++)
				dust[f].active = 0;
			if (pc == 0)
				optstatus = 8;
		}
		else if (optstatus == 8)					// choose track
		{
			num = optionchoosetrack(selectedlocation);
			if (status>=num)
				status = 0;
			optionchoosetrackinfo(&tracks[location[selectedlocation].index[status]]);
			if (pc & PADRup)
				optstatus = 5;
			if (pc & PADRdown)
			{
				selectedtrack = status;
				optstatus = 9;
			}
			if (butwait == 0)
			{
				if (pc & PADLup)
				{
					status = (status+(num-1))%num;
					butwait = 8;
				}
				if (pc & PADLdown)
				{
					status = (status+1)%num;
					butwait = 8;
				}
			}
			else
				butwait--;
			dustx = (-140<<5)+(((strlen(tracks[location[selectedlocation].index[status]].name)/2)<<3)<<5);
			dusty = ((-54)<<7)+((status*10)<<7);
			dustm = strlen(tracks[location[selectedlocation].index[status]].name)/2;
			dustdx = (veltabpt+dustang)->dx;
			dustdx2 = ((float)(dustdx-(veltabpt+((dustang+31)%32))->dx)/10)*(dustm>>1);
			dustdx*=dustm;
			lspr.x = ((dustx+dustdx)>>5)-8;
			lspr.y = (dusty>>7)-5;
			for (g=0;g<3+(rand()&3);g++)
			{
				obj = spawndust();
				if (obj != -1)
				{
					dust[obj].col = 255;
					dust[obj].dx = dustdx2;
					dust[obj].dy = -6+(qrand[qrandi]>>4);
					dust[obj].x = dustx+dustdx+qrand[(qrandi+1)%8];
					dust[obj].y = dusty+(qrand[qrandi]);
					qrandi=(qrandi+1)%8;
				}
			}
			dustang=(dustang+1)%32;
		}
		else if (optstatus == 9)			// final options init
		{
			status = 0;
//			if (pc == 0)
				optstatus = 10;
		}
		else if (optstatus == 10)			// final options
		{
			print8(156,16,"GO");
			if (pc & PADRup)
				optstatus = 7;
			if (status == 0)
			{
				optionsreturn = 40;
				players[playeri].active = 1;		// make player active so that they can drive
				players[playeri].maxspeed = maxspeeds[selectedclass];
				return(2);
			}
		}
		else if (optstatus == 11)			// options init
		{
			status = 0;
			if (pc == 0)
				optstatus = 12;
		}
		else if (optstatus == 12)			// options
		{
			optionoptions(status);
			if (pc & PADRup)
				optstatus = 1;
			if (butwait == 0)
			{
				if (pc & PADRdown && status == 0)
					optstatus = 13;
				if (pc & PADRdown && status == 4)
					optstatus = 1;
//				if (pc & PADRdown && status == 1)
//				{
//					optstatus = 15;
//				}
				if (pc & PADLright)
				{
					status+=1;
					butwait = 6;
				}
				if (pc & PADLleft)
				{
					status-=1;
					butwait = 6;
				}
				if (pc & PADLdown)
				{
					status+=2;
					butwait = 6;
				}
				if (pc & PADLup)
				{
					status-=2;
					butwait = 6;
				}
			}
			else
				butwait--;
			if (status == 1)
				status = 2;
			if (pc & PADL1)
				if (status == 3 && musicvolume>0)
					musicvolume--;
				else if (status == 2 && mainvolume>0)
					mainvolume--;
			if (pc & PADR1)
				if (status == 3 && musicvolume<127)
					musicvolume++;
				else if (status == 2 && mainvolume<127)
					mainvolume++;
			SsSeqSetVol(funkseq,musicvolume,musicvolume);
			SsSeqSetVol(musicseq,musicvolume,musicvolume);
			SsSetMVol(mainvolume,mainvolume);
			if (status == 0)
				print8(64,216,"SCREEN CENTRE ADJUSTMENT");
			else if (status == 2)
				print8(88,216,"ADJUST MAIN VOLUME");
			else if (status == 3)
				print8(88,216,"ADJUST MUSIC VOLUME");
			else if (status == 4)
				print8(64,216,"EXIT FROM OPTIONS SCREEN");
//			else if (status == 1)
//				print8(88,216,"MEMORY CARD OPTIONS");
			limitrange(status,0,4);
			if (status<4)
				drawbox((status%2)*160-107,(status>>1)*50-82,53,37);
			else
				drawbox(-27,18,53,37);
		}
		else if (optstatus == 13)			// centre screen init
		{
			if (pc == 0)
				optstatus = 14;
		}
		else if (optstatus == 14)			// centre screen
		{
			optioncentrescreen();
			if (pc & PADRdown || pc & PADRup)
				optstatus = 11;
			if (pc & PADLleft)
				GsDISPENV.screen.x-=1;
			if (pc & PADLright)
				GsDISPENV.screen.x+=1;
			if (pc & PADLup)
				GsDISPENV.screen.y-=1;
			if (pc & PADLdown)
				GsDISPENV.screen.y+=1;
			limitrange(GsDISPENV.screen.x,-8,64);
			limitrange(GsDISPENV.screen.y,-2,64);
		}
		else if (optstatus == 15)				// memory card init init
		{
			status = 14;
//			optstatus = 16;
			optstatus = 11;
		}
		else if (optstatus>15 && optstatus<40)
			optstatus = 1;
		else if (optstatus == 40)					// return from race here
		{
			if (laprecordholder == NULL)				// if didn't get a lap record
				optstatus = 7;
			else
			{
				for (f=0;f<15;f++)
					name[f]=0;					// clear name
				butwait = 0;
				status = 16;
				cpos = 0;						// name text position
				optstatus = 41;					// go to high score entry
			}
		}
		else if (optstatus == 41)					// high score entry
		{
			optionentername();
			if (pc & PADRup)
				optstatus = 7;
			print8(104,32,"NEW LAP RECORD");
			c=drawtextentry(96,64,status);
			print8(120,120,name);
			if (butwait == 0)
			{
				if (pc & PADLleft)
				{
					status-=1;
					butwait=6;
				}
				if (pc & PADLright)
				{
					status+=1;
					butwait=6;
				}
				if (pc & PADLup)
				{
					status-=8;
					butwait=6;
				}
				if (pc & PADLdown)
				{
					status+=8;
					butwait=6;
				}
				limitrange(status,0,31);
				if (cpos==10)
					limitrange(status,30,31);		// limit to DEL and END if name is 10 chars long
				if (pc & PADRdown)
				{
					if (status == 31)				// if END
					{
						name[cpos]=0;
						strcpy(&tracks[location[selectedlocation].index[selectedtrack]].records.bestlapname[selectedclass][0],name);
						optstatus = 7;
					}
					else if (status == 30)			// if DEL
					{
						name[cpos]=0;
						if (cpos>0)
							cpos--;
						name[cpos]=0;
					}
					else
					{
						name[cpos]=c;
						if (cpos<10)
							cpos++;
					}
					butwait=6;
				}
			}
			else
				butwait--;
			drawbox(92+((status%8)<<4)-SCREENWIDTH/2,68+((status>>3)<<4)-SCREENHEIGHT/2,16,16);
		}
		else if (optstatus == 99)
		{
			print8(16,16,"HOVER CAR RACING");
			print8(16,32,"BY RICHARD SMITHIES");
			print8(16,64,"WITH THANKS TO");
			print8(16,72,"MICHAEL DE CRUZ");
			print8(16,80,"FOR ADDITIONAL TRACK DESIGN");
			if (titlescreenn>0)
				titlescreenn--;
			else
				optstatus = 0;
			if ( (players[0].paddata[1] & PADstart) || (players[1].paddata[1] & PADstart) )
				titlescreenn = 1;
		}
		UpdateObjectCoordinates(&backlobj);
		UpdateObjectCoordinates(&backrobj);
		DisplayObject3D(&backlobj);
		DisplayObject3D(&backrobj);

		for (f=0;f<MAX3DOBJECTS;f++)			// draw 3D objects
			if (obj3d[f].active == 2)				// moving object
			{
				UpdateObjectCoordinates(&obj3d[f]);
				DisplayObject3D(&obj3d[f]);
			}
			else if (obj3d[f].active == 1)			// static object
			{
				DisplayObject3D(&obj3d[f]);
			}
		if (duston != 0)
		{
			if (optstatus == 4 || optstatus == 6 || optstatus == 8)
				GsSortFastSprite(&lspr,&WorldOT[activebuff],5);
			for (f=0;f<MAXDUSTPARTICLES;f++)
			{
				if (dust[f].active != 0)
				{
					dot.x0 = dot.x1 = dust[f].x>>5;
					dot.y0 = dot.y1 = dust[f].y>>7;
					dot.g = dust[f].col;
					GsSortLine(&dot,&WorldOT[activebuff],0*OTPRI_GROUND);
					dust[f].x+=dust[f].dx;
					dust[f].y+=dust[f].dy;
					dust[f].dy+=1;
					dust[f].col-=2;
					if (dust[f].col < 16)
						dust[f].active = 0;
				}
			}
		}

		GsSortOt(&BackOT[activebuff],&WorldOT[activebuff]);
		GsSortOt(&BotOT[activebuff],&WorldOT[activebuff]);
		FntPrint("Hsync:%d\n",hcnt);
//		FntFlush(-1);
		DrawSync(0);
		GsDrawOt(&OverlayOT[activebuff]);
		DrawSync(0);
		hcnt = VSync(0);
		GsSwapDispBuff();
		GsSortClear(0,0,0,&WorldOT[activebuff]);
		GsDrawOt(&WorldOT[activebuff]);
	}
	return(0);
}

int spawndust()
{
	int f;
	for (f=0;f<MAXDUSTPARTICLES;f++)
		if (dust[f].active == 0)
			break;
	if (f!=MAXDUSTPARTICLES)
	{
		dust[f].active = 1;
		return(f);
	}
	return(-1);
}

void optiondrawtitle()
{	// title screen (press start screen)
	print8(120,100,"PRESS START");
}

void drawbox2(int x,int y,int w,int h)
{
	GsLINE	line;
	static	u_char g=32;
	static	u_char gd=4;
	line.attribute = 0;
	line.r = 128;
	line.g = g;
	line.b = 0;
	line.x0 = x; line.y0 = y;
	line.x1 = line.x0 + w;
	line.y1 = line.y0;
	GsSortLine(&line,&WorldOT[activebuff],0);
	line.x1 = line.x0;
	line.y1 = line.y0+h;
	GsSortLine(&line,&WorldOT[activebuff],0);
	line.x1 = x+w;
	line.y1 = y+h;
	line.x0 = x;
	line.y0 = line.y1;
	GsSortLine(&line,&WorldOT[activebuff],0);
	line.x0 = line.x1;
	line.y0 = y;
	GsSortLine(&line,&WorldOT[activebuff],0);
	g+=gd;
	if (g>128)
	{
		g = 128;
		gd = -4;
	}
	if (g<32)
	{
		g = 32;
		gd = 4;
	}
}

void drawbox(int x,int y,int w, int h)
{
	drawbox2(x,y,w,h);
	drawbox2(x+1,y+1,w-2,h-2);
}

void drawline(int x, int y, int w, int h)
{
	GsLINE	line;
	line.attribute = 0;
	line.r = 96;
	line.g = 128;
	line.b = 112;
	line.x0=x-SCREENWIDTH/2; line.y0 = y-SCREENHEIGHT/2;
	line.x1=line.x0+w; line.y1 = line.y0+h;
	GsSortLine(&line,&WorldOT[activebuff],0);
}

int memorycardload(long card)
{	// card is either 1 or 2. returns -1 if failure
	return(0);
}

int memorycardsave(long card,long avail)
{	// card is either 1 or 2. avail is savexavail (x is card) returns -1 if failure
	return(0);
}

void optionsmemorycard(long card1,long card2,long save1avail,long save2avail)
{
}

void optioncentrescreen()
{
	drawline(0,0,0,32);
	drawline(0,0,32,0);
	drawline(319,0,0,32);
	drawline(319,0,-32,0);
	drawline(0,239,0,-32);
	drawline(0,239,32,0);
	drawline(319,239,0,-32);
	drawline(319,239,-32,0);
	drawline(SCREENWIDTH/2,SCREENHEIGHT/2-16,0,32);
	drawline(SCREENWIDTH/2-16,SCREENHEIGHT/2,32,0);
}

void optionoptions(int status)
{
	GsSPRITE	spr;
	GsLINE	line;
	int	vol;
	spr.attribute = (1<<24) | (1<<27);
	spr.w = 76;
	spr.h = 13;
	spr.tpage = GetTPage(0,0,640,256);
	spr.cx = 640;
	spr.cy = 496;
	spr.r = spr.g = spr.b = 128;
	spr.u = 0;							// OPTIONS
	spr.v = 95+48;
	spr.x = -38;
	spr.y = -120;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	spr.u = 0;							// CENTRE SCREEN BOX
	spr.v = 124+48;
	spr.w = 50; spr.h = 34;
	spr.x = -105; spr.y = -80;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
//	spr.u = 200;						// Memory card options
//	spr.x = 55; spr.y = -80;
//	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	spr.u = 50;							// Music Volume
	spr.x = 55; spr.y = -30;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	spr.u = 100;						// Main Volume
	spr.x = -105; spr.y = -30;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	spr.u = 150;						// Exit
	spr.x = -25; spr.y = 20;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	if (status == 3 || status == 2)			// if on volume control box
	{
		vol = mainvolume;
		if (status == 3)
			vol = musicvolume;
		vol = vol/2.35185;
		spr.u = 0; spr.v = 159+48;				// volume bar
		spr.w = 100; spr.h = 13;
		spr.x = -50; spr.y = 70;
		GsSortFastSprite(&spr,&WorldOT[activebuff],4);
		line.r = line.g = line.b = 180;
		line.attribute = 0;
		line.x0 = spr.x + 22;
		line.y0 = spr.y + 6;
		line.x1 = line.x0 + vol;
		line.y1 = line.y0;
		GsSortLine(&line,&WorldOT[activebuff],3);
	}
}

void optionchooseclass()
{
	GsSPRITE	spr;
	spr.attribute = (1<<24) | (1<<27);
	spr.w = 124;
	spr.h = 13;
	spr.tpage = GetTPage(0,0,640,256);
	spr.u = 0;
	spr.v = 48;
	spr.cx = 640;
	spr.cy = 496;
	spr.r = spr.g = spr.b = 128;
	spr.x = -62;
	spr.y = -120;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	spr.w = 64;								// novice
	spr.h = 13;
	spr.u = 0;
	spr.v = 54+48;
	spr.x = -140;
	spr.y = -64;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	spr.w = 100;							// competent
	spr.h = 13;
	spr.u = 0;
	spr.v = 68+48;
	spr.x = -140;
	spr.y = -44;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	spr.w = 34;								// pro
	spr.h = 13;
	spr.u = 0;
	spr.v = 82+48;
	spr.x = -140;
	spr.y = -24;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	spr.w = 104;							// X CHOOSE ^ BACK
	spr.h = 13;
	spr.u = 0;
	spr.v = 109+48;
	spr.x = -52;
	spr.y = 98;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
}

int optionchooselocation()
{
	int f;
	GsSPRITE	spr;
	spr.attribute = (1<<24) | (1<<27);
	spr.w = 158;
	spr.h = 13;
	spr.tpage = GetTPage(0,0,640,256);
	spr.u = 0;
	spr.v = 15+48;
	spr.cx = 640;
	spr.cy = 496;
	spr.r = spr.g = spr.b = 128;
	spr.x = -78;
	spr.y = -120;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	spr.w = 104;							// X CHOOSE ^ BACK
	spr.h = 13;
	spr.u = 0;
	spr.v = 109+48;
	spr.x = -52;
	spr.y = 98;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	for (f=0;f<2;f++)
		print8(16,64+f*10,location[f].name);
	return(2);							// number of locations available
}

int optionchoosetrack(int loc)
{	// gimme index of location
	int f;
	GsSPRITE	spr;
	spr.attribute = (1<<24) | (1<<27);
	spr.w = 140;
	spr.h = 13;
	spr.tpage = GetTPage(0,0,640,256);
	spr.u = 0;
	spr.v = 28+48;
	spr.cx = 640;
	spr.cy = 496;
	spr.r = spr.g = spr.b = 128;
	spr.x = -70;
	spr.y = -120;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	spr.w = 104;							// X CHOOSE ^ BACK
	spr.h = 13;
	spr.u = 0;
	spr.v = 109+48;
	spr.x = -52;
	spr.y = 98;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
	for (f=0;f<MAXTRACKSPERLOC;f++)
		if (location[loc].index[f]!=-1)
			print8(16,64+f*10,tracks[location[loc].index[f]].name);
		else
			break;
	return(f);						// return number of tracks available
}

void optionchoosetrackinfo(trackinfoheader *tpt)
{	// show info about track
	print8(160,48,"LAPS");
	int8(208,48,2,tpt->numlaps);
	print8(160,64,"TRACK RECORD");
	time8(160,72,tpt->records.trackrecord[selectedclass]);
	print8(224,72,&tpt->records.bestname[selectedclass][0]);
	print8(160,88,"LAP RECORD");
	time8(160,96,tpt->records.laprecord[selectedclass]);
	print8(224,96,&tpt->records.bestlapname[selectedclass][0]);
}

void optionentername()
{
	GsSPRITE	spr;
	spr.attribute = (1<<24) | (1<<27);
	spr.w = 156;
	spr.h = 13;
	spr.tpage = GetTPage(0,0,640,256);
	spr.u = 0;
	spr.v = 41+48;
	spr.cx = 640;
	spr.cy = 496;
	spr.r = spr.g = spr.b = 128;
	spr.x = -70;
	spr.y = -120;
	GsSortFastSprite(&spr,&WorldOT[activebuff],4);
}

void arcadeentry(int racenumber)
{	// Displays Arcade entry screens
	int f,g,QUIT_FLAG,numplayersfinished,numplayersactive,hcnt;
	u_long	obj;
	short		scrx;
	u_char	flash;
	u_short	pc;				// player controller
	char		c;
	u_char	fade[2],blocktype[2],gamepaused[2];
	RECT		rct;
	GsLINE	line;
	RECT		huesatrect;
	GsSPRITE	huesatsprite;
	u_long	tmplong;
	GsSPRITE	spr;

	huesatsprite.attribute = 2<<24;
	huesatsprite.w = huesatsprite.h = 64;
	huesatsprite.tpage = GetTPage(0,0,640,256);
	huesatsprite.u = huesatsprite.v = 0;
	huesatsprite.r = huesatsprite.g = huesatsprite.b = 128;

	spr.attribute = (1<<24) | (1<<27);
	spr.tpage = GetTPage(0,0,640,256);
	spr.cx = 640;
	spr.cy = 496;
	spr.r = spr.g = spr.b = 128;

	line.attribute = 0;
	line.r = 128;
	line.g = 128;
	line.b = 128;
	TransferTIM(_PAK_kelly_INDEX);			// LCD background
	TransferTIM(_PAK_smallblocks_INDEX);		// LCD blocks
	rct.x=816; rct.y = 257; rct.w = 16; rct.h = 11;
	LoadImage(&rct, (u_long *) blockcolours);		// copy block CLUTS to frame buffer

	TransferTIM(_PAK_huesattim_INDEX);
	huesatrect.x = 640;
	huesatrect.y = 256;
	huesatrect.w = 64;
	huesatrect.h = 64;

	for (f=0;f<2;f++)
	{
		fade[f]=64;					// brightness of background pic ( for games )
		blocktype[f]=0;
		gamepaused[f]=0;
	}


	for (f=0;f<2;f++)
	{
		WorldOT[f].length = OT_LENGTH;
		WorldOT[f].org = OTTags[f];
		TopOT[f].length = TOPOT_LENGTH;
		TopOT[f].org = TopOTTags[f];
		BotOT[f].length = BOTOT_LENGTH;
		BotOT[f].org = BotOTTags[f];
		OverlayOT[f].length = OVERLAYOT_LENGTH;
		OverlayOT[f].org = OverlayOTTags[f];
		BackOT[f].length = BACKOT_LENGTH;
		BackOT[f].org = BackOTTags[f];
	}
// Set up text area
	FntLoad(960,256);
	FntOpen(16-SCREENWIDTH/2,16-SCREENHEIGHT/2,256,200,0,512);

// Put sprite graphics in frame buffer
	Initializeframes();

// Clear all objects
	InitializeObjects();

	for (f=0;f<MAX3DOBJECTS;f++)
		obj3d[f].active = 0;

	// Set up the 3D camera view
	projection=96;				// 512
	GsSetProjection(projection);
	cameraview.vrx = 0;
	cameraview.vry = 0;
	cameraview.vrz = 0;
	cameraview.vpx = 0;
	cameraview.vpy = 0;
	cameraview.vpz = -1800;
	cameraview.rz = 0;
	cameraview.super = WORLD;
	GsSetRefView2(&cameraview);
	// Set up the 3D Lighting
	for (f=0;f<3;f++)
	{
		light[f].vx = 0;
		light[f].vy = 0;
		light[f].vz = ONE;
		light[f].r = 128;
		light[f].g = 128;
		light[f].b = 128;
		GsSetFlatLight(f, &light[f]);
	}
	GsSetAmbient(128,128,128);

//		obj = spawn3d();
//		create3dobject(obj,_PAK_carmodel_INDEX);
//		obj3d[obj].origin.vx = 0;
//		obj3d[obj].origin.vy = 32;
//		obj3d[obj].origin.vz = -1400;
//		obj3d[obj].rotate.vx = 2048+100;
//		obj3d[obj].ot = 1;				// below track
//		obj3d[obj].active = 2;

	for (f=0;f<2;f++)
	{
		players[f].object = 0;			// reset players car representation to not displayed
		players[f].laptime = 1;
	}

	// Start of Arcade Race Entry
	QUIT_FLAG = 0;
	numplayersfinished = 0;
	mapx = 0;
	mapy = 0;
	while (QUIT_FLAG != 1)
	{
		flash+=4;			// used to make text flash

		// Clear up display data
		activebuff = GsGetActiveBuff();
		GsSetWorkBase((PACKET *)GpuPacketArea[activebuff]);
		GsClearOt(0, 0, &WorldOT[activebuff]);
		GsClearOt(0, OTPRI_SMOKE, &TopOT[activebuff]);		// 3D above ground
		GsClearOt(0, OTPRI_GROUND+1, &BotOT[activebuff]);	// 3D below ground
		GsClearOt(0, 0, &OverlayOT[activebuff]);
		GsClearOt(0, OTPRI_BACK, &BackOT[activebuff]);

		// Read Controller 
		for (f=0;f<2;f++)
			ReadController(players[f].pad, players[f].paddata);
		if ( (players[0].paddata[1] & PADselect) && (players[0].paddata[1] & PADstart) )
			QUIT_FLAG = 1;

		// Place camera
		GsSetRefView2(&cameraview);

		for (f=0;f<2;f++)
		{
			pc = players[f].paddata[1];		// this players pad data
			scrx = 160*f;
			if (players[f].active == 0)		// if player not active
			{
				print8(48+scrx,0,"PLAYER");		// show press start screen
				int8(104+scrx,0,1,f+1);
				if (flash<128)
					print8(36+scrx,112,"PRESS START");

/*
	if (pc & PADLup)
		obj3d[31].origin.vy+=4;
	if (pc & PADLdown)
		obj3d[31].origin.vy+=-4;
	if (pc & PADL1)
		obj3d[31].origin.vz+=4;
	if (pc & PADR1)
		obj3d[31].origin.vz+=-4;
	if (pc & PADL2)
	{
		projection+=2;
		GsSetProjection(projection);
	}
	if (pc & PADR2)
	{
		projection+=-2;
		GsSetProjection(projection);
	}
*/
//	FntPrint("Y %d Z %d proj %d\n",obj3d[31].origin.vy,obj3d[31].origin.vz,projection);

				if (players[f].paddata[1] & PADstart)	// if they press start, make them active
				{
					players[f].active = 1;
					players[f].laptime = 0;			// laptime is used here to denote which screen the player is on
					players[f].cash = 200;
					players[f].bestlap = 0;			// used for pause between moves
					players[f].name[0] = 0;
					players[f].name[15]=18;			// start character number for name entry
					players[f].name[14]=127;		// indicates no selected character
					players[f].name[13]=0;			// cursor position in name
					thud(0);
				}
			}
			else
			{
				if (players[f].laptime == 0)			// if on name entry screen
				{
					print8(40+scrx,0,"ENTER NAME");
					c=drawtextentry(scrx+16,64,players[f].name[15]);
					print8(32+scrx,200,players[f].name);
					if (players[f].bestlap == 0)
					{
						if (pc & PADLleft)	// move cursor about table
						{
							if (players[f].name[15]>0)
								players[f].name[15]-=1;
							players[f].bestlap = 16;
							thud(-90);
						}
						else if (pc & PADLright)
						{
							if (players[f].name[15]<31)
								players[f].name[15]+=1;
							players[f].bestlap = 16;
							thud(90);
						}
						else if (pc & PADLup)
						{
							if (players[f].name[15]>7)
								players[f].name[15]-=8;
							players[f].bestlap = 16;
							thud(0);
						}
						else if (pc & PADLdown)
						{
							if (players[f].name[15]<24)
								players[f].name[15]+=8;
							players[f].bestlap = 16;
							thud(180);
						}
						if (pc & PADL1)
							if (fontcolour>0)
							{
								short vn;
								fontcolour--;
								updatefontcolour();
								players[f].bestlap = 16;
								vn=SsUtKeyOn(soundvab,0,0,63,0,110,60);
//								printf("%d\n",vn);
//								printf("%d\n",SsUtKeyOn(soundvab,0,0,90,0,63,63));
//								printf("%d\n",SsUtKeyOn(soundvab,0,1,60,1,63,63));
//								printf("%d\n",SsUtKeyOn(soundvab,2,0,60,0,63,63));
//								printf("Vol %d\n",SsUtSetVVol(vn,63,63));
							}
						if (pc & PADR1)
							if (fontcolour<11)
							{
								fontcolour++;
								updatefontcolour();
								players[f].bestlap = 16;
								SsUtKeyOn(soundvab,0,0,63,0,60,110);
							}
					}
					else
						if (pc == 0)		// if no key pressed
							players[f].bestlap=0;			// allow instant movement next time
						else
							players[f].bestlap-=1;			// else wait a little for next move
					if (players[f].name[14] == 127)			// if no selected character
					{
						if (pc & PADRdown)	// select character
						{
							if (players[f].name[15]==31)					// if END character selected
							{
								ResetPlayer(f);
								players[f].active = 1;
								players[f].laptime=4;					// go to menu
								players[f].bestlap = 8;
								thud(0);
							}
							else if (players[f].name[15]==30)				// else if DELETE character selected
							{
								if ( (players[f].name[13]>0) && (players[f].bestlap == 0) )
								{
									players[f].name[13]-=1;
									players[f].name[players[f].name[13]]=0;
									players[f].bestlap = 8;
								}
							}
							else									// whizz character
							{
								if (players[f].name[13]<10)		// if not 10th character
								{
									players[f].name[14] = c;		// selected character becomes ASCII of highlighted char
									players[f].inventory[0] = ((players[f].name[15]%8)<<4)+scrx+16;	// whizzy character x
									players[f].inventory[1] = ((players[f].name[15]/8)<<4)+64;		// whizzy character y
									players[f].inventory[2] = ((players[f].name[13])<<3)+scrx+32;	// whizzy destination x
									thud(0);
								}
							}
						}
					}
					else				// if whizzy character needs moving
					{
						if (players[f].inventory[0]<players[f].inventory[2])
							players[f].inventory[0]+=2;
						else if (players[f].inventory[0]>players[f].inventory[2])
							players[f].inventory[0]-=2;
						if (players[f].inventory[1]<200)
							players[f].inventory[1]+=4;
						if ( (players[f].inventory[0] == players[f].inventory[2]) && (players[f].inventory[1] >= 200) )		// if got to destination
						{
							players[f].name[players[f].name[13]] = players[f].name[14];
							players[f].name[13]+=1;
							players[f].name[players[f].name[13]] = 0;
							players[f].name[14]=127;
						}
						else
							char8fast(players[f].inventory[0],players[f].inventory[1],players[f].name[14]);
					}
				}
				else if (players[f].laptime == 1)				// MENU SCREEN
				{
					print8(scrx+80-(strlen(players[f].name)*4),0,players[f].name);			// display player name
					char8fast(scrx+0,16,'$');
					int8(scrx+8,16,5,players[f].cash);
					if (pc & PADstart)					// if pressed START
						players[f].laptime=2;				// goto finished screen
					print8(scrx+36,64,"RESPRAY");
					print8(scrx+36,72,"TRADE");
					print8(scrx+36,80,"GAMBLE");
					print8(scrx+36,88,"RACE");
					print8(scrx+36,96,"EXIT");
					print8(scrx+28,64+players[f].name[15]*8,"*");		// selector
					if (players[f].bestlap>0)				// bestlap used to slow down pad input
					{
						players[f].bestlap--;				// wait a while
						if (pc == 0)
							players[f].bestlap = 0;			// or until pad is released
					}
					if (players[f].bestlap == 0)				// to stop fast key repeat
					{
						if ( (pc & PADLup) && (players[f].name[15]>0) )
						{
							players[f].name[15]--;			// menu selector up
							players[f].bestlap = 8;
							thud(0);
						}
						else if ( (pc & PADLdown) && (players[f].name[15]<4) )
						{
							players[f].name[15]++;			// menu selector down
							players[f].bestlap = 8;
							thud(0);
						}
						if (pc & PADRdown)
						{
							players[f].bestlap = 8;
							switch(players[f].name[15])
							{
								case 0:			// respray
								{
									players[f].laptime = 5;
									players[f].name[14] = 32;	// Hue
									players[f].name[13] = 32;	// Sat
									break;
								}
								case 1:			// trade
								{
									players[f].laptime = 13;
									break;
								}
								case 2:			// gamble
								{
									players[f].laptime = 6;
									break;
								}
								case 3:			// race
								{
									players[f].laptime = 2;
									break;
								}
								case 4:
								{
									players[0].active = 0;
									players[1].active = 0;
									players[0].fuel = 0;
									players[1].fuel = 0;
									return;
									break;
								}
							}
						}
					}
				}
				else if (players[f].laptime == 2)		// just finished
				{
					kill(players[f].object);
					players[f].object = 0;
					players[f].laptime++;
					numplayersfinished++;
				}
				else if (players[f].laptime == 3)		// has finished, is waiting
				{
					print8(scrx+80-(strlen(players[f].name)*4),0,players[f].name);			// display player name
					print8(scrx+36,80,"WAITING FOR");
					print8(scrx+32,96,"OTHER PLAYER");
					if (pc & PADRup)					// if TRIANGLE pressed
					{
						players[f].laptime = 4;			// return to menu
						players[f].bestlap = 8;
						numplayersfinished--;
					}
				}
				else if (players[f].laptime == 4)		// menu screen entry point
				{
					players[f].name[15] = 0;			// menu selector
					players[f].laptime = 1;				// menu screen
					players[f].bestlap = 8;
					if (players[f].object == 0)			// if car not already displayed
					{
						obj = spawn();				// set up a car object to represent the players car
						object[obj].x = (f*160+80)<<MYBITSHIFT;
						object[obj].y = 64<<MYBITSHIFT;
						object[obj].angle = 0;
						object[obj].hx = 8;
						object[obj].hy = 8;
						object[obj].base_sprite = animspt + ANIM_PLAYER1;
						object[obj].frame = 0;
						object[obj].control = playerspincontrol;
						object[obj].cx = 576+(players[f].carcolour%4)*16;
						object[obj].cy = 241+(players[f].carcolour/4);
						object[obj].class = 1;
						players[f].object = obj;
					}
				}
				else if (players[f].laptime == 5)		// respray
				{
					GsLINE	cursline;
					huesatsprite.x = 48+160*f-SCREENWIDTH/2;
					huesatsprite.y = 96-SCREENHEIGHT/2;
					GsSortFastSprite(&huesatsprite,&WorldOT[activebuff],4);
					cursline.x0 = 48+160*f+players[f].name[14]-4-SCREENWIDTH/2;
					cursline.y0 = 96+players[f].name[13]-SCREENHEIGHT/2;
					cursline.x1 = cursline.x0 + 8;
					cursline.y1 = cursline.y0;
					cursline.attribute = 0;
					cursline.r = cursline.g = cursline.b = 10;
					GsSortLine(&cursline,&WorldOT[activebuff],0);
					cursline.x0 = 48+160*f+players[f].name[14]-SCREENWIDTH/2;
					cursline.y0 = 96+players[f].name[13]-4-SCREENHEIGHT/2;
					cursline.x1 = cursline.x0;
					cursline.y1 = cursline.y0+8;
					GsSortLine(&cursline,&WorldOT[activebuff],0);
					huesatrect.x = players[f].name[14]+640;		// address of single pixel in HUE SAT
					huesatrect.y = players[f].name[13]+256;
					huesatrect.w = 1;
					huesatrect.h = 1;
					StoreImage(&huesatrect,&tmplong);				// get colour from HUE SAT texture
					makecarcolours(tmplong,players[f].carcolour);
					players[f].carclut = tmplong;
					if (players[f].bestlap>0)				// bestlap used to slow down pad input
					{
						players[f].bestlap--;				// wait a while
						if (pc == 0)
							players[f].bestlap = 0;			// or until pad is released
					}
					if (players[f].bestlap == 0)				// to stop fast key repeat
					{
						if ( (pc & PADLleft))
						{
							if (players[f].name[14]>0)
								players[f].name[14]--;
							players[f].bestlap = 1;
						}
						else if ( (pc & PADLright) )
						{
							if (players[f].name[14]<63)
								players[f].name[14]++;
							players[f].bestlap = 1;
						}
						if (pc & PADLup)
						{
							if (players[f].name[13]>0)
								players[f].name[13]--;
							players[f].bestlap = 1;
						}
						else if (pc & PADLdown)
						{
							if (players[f].name[13]<63)
								players[f].name[13]++;
							players[f].bestlap = 1;
						}
						if (pc & PADRdown)
							players[f].laptime = 4;				// back to menu
					}
				}
				else if (players[f].laptime == 6)		// gamble
				{
					print8(scrx+80-(strlen(players[f].name)*4),0,players[f].name);			// display player name
					char8fast(scrx+0,16,'$');
					int8(scrx+8,16,5,players[f].cash);
					print8(scrx+36,64,"STACKS $20");
					print8(scrx+36,72,"????");
					print8(scrx+36,80,"????");
					print8(scrx+36,88,"EXIT");
					print8(scrx+28,64+players[f].name[15]*8,"*");		// selector
					limitrange(players[f].name[15],0,3);
					if (players[f].bestlap>0)				// bestlap used to slow down pad input
					{
						players[f].bestlap--;				// wait a while
						if (pc == 0)
							players[f].bestlap = 0;			// or until pad is released
					}
					if (players[f].bestlap == 0)				// to stop fast key repeat
					{
						if ( (pc & PADLup) && (players[f].name[15]>0) )
						{
							players[f].name[15]--;			// gamble selector up
							players[f].bestlap = 8;
							thud(0);
						}
						else if ( (pc & PADLdown) && (players[f].name[15]<3) )
						{
							players[f].name[15]++;			// gamble selector down
							players[f].bestlap = 8;
							thud(0);
						}
						if (pc & PADRdown)
						{
							players[f].bestlap = 8;
							switch(players[f].name[15])
							{
								case 0:
								{
									if (players[f].cash>=20)
									{
										players[f].laptime = 7;		// goto game1
										players[f].cash-=20;
									}
									break;
								}
//								case 1:
//								{
//									if (players[f].cash>=20)
//									{
//										players[f].laptime = 11;
//										players[f].cash-=20;
//									}
//									break;
//								}
								case 3:
								{
									players[f].laptime = 4;		// return to menu
									break;
								}
							}
						}
					}
				}
				else if (players[f].laptime == 7)					// game1 entry
				{
					clearlcd(&lcd[f]);
					lcd[f].sx = f*160+16;
					lcd[f].sy = 48;
					game1[f].lcdpt = &lcd[f];
					game1[f].speed = 25<<8;
					game1[f].x=8;
					game1[f].y=0;
					game1[f].pause = 25;				// to slow block fall
					game1[f].padcount = 0;				// to slow key repeat
					game1[f].status = 0;				// 0 = falling blocks
					newgame1block(game1[f].current);
					newgame1block(game1[f].next);
					players[f].laptime = 8;
					for (g=0;g<3;g++)
						lcdblock(game1[f].lcdpt,0,g,game1[f].next[g]);		// draw 'NEXT' block in corner
				}
				else if (players[f].laptime == 8)			// columns running
				{
					spr.w = 46;							// BUY
					spr.h = 11;
					spr.u = 108;
					spr.v = 159+48;
					spr.x = scrx+24-SCREENWIDTH/2-23;
					spr.y = 180-SCREENHEIGHT/2;
					if (gamepaused[f]==0)
						GsSortFastSprite(&spr,&WorldOT[activebuff],4);
					print8(scrx+80-(strlen(players[f].name)*4),0,players[f].name);			// display player name
					char8fast(scrx+0,16,'$');
					int8(scrx+8,16,5,players[f].cash);
					game1[f].pad = pc;		// pass pad status to game
					if (gamepaused[f]==0)		// if not paused
					{
						if ( rungame1(&game1[f],&players[f].cash) != 0)		// run game (1 frame) and if game is over
							players[f].laptime = 10;				// go to game over
						backfader(pc, &fade[f]);
						blocktypechange(pc, &blocktype[f]);
						lcddisplay(&lcd[f],fade[f],blocktype[f]);
						if (players[f].bestlap == 0)
						{
							if (pc & PADstart)		// if START
							{
								gamepaused[f] = 1;
								players[f].bestlap = 8;
							}
						}
						else
						{
							players[f].bestlap--;
						}
					}
					else
					{
						print8(scrx+16,64,"  GAME PAUSED");
						print8(scrx+16,80,"START  CONTINUE");
						print8(scrx+16,88,"SELECT   QUIT");
						if (players[f].bestlap == 0)
						{
							if (pc & PADstart)
							{
								gamepaused[f] = 0;
								players[f].bestlap = 8;
							}
							if (pc & PADselect)
							{
								players[f].laptime = 9;	// wait to release,
								players[f].bestlap = 6;	// then go back to gamble menu
							}
						}
						else
							players[f].bestlap--;
					}
				}
				else if (players[f].laptime == 9)			// wait to release all buttons
				{
					if (pc == 0)
						players[f].laptime = players[f].bestlap;
				}
				else if (players[f].laptime == 10)
				{
					print8(scrx+80-(strlen(players[f].name)*4),0,players[f].name);			// display player name
					char8fast(scrx+0,16,'$');
					int8(scrx+8,16,5,players[f].cash);
					print8(scrx+72,88,"GAME");
					print8(scrx+72,104,"OVER");
					if (pc & PADstart)		// if START
					{
						players[f].laptime = 9;	// wait to release,
						players[f].bestlap = 6;	// then go back to gamble menu
					}
				}
				else if (players[f].laptime == 11)				// game 2 (tetris) init
				{
					clearlcd(&lcd[f]);
					lcd[f].sx = f*160+16;
					lcd[f].sy = 48;
					game2[f].lcdpt = &lcd[f];
					game2[f].speed = 25<<8;
					game2[f].x=8;
					game2[f].y=0;
					game2[f].pause = 25;				// to slow block fall
					game2[f].padcount = 0;				// to slow key repeat
					game2[f].status = 0;				// 0 = falling blocks
					players[f].laptime = 12;
				}
				else if (players[f].laptime == 12)				// game 2 running
				{
					print8(scrx+80-(strlen(players[f].name)*4),0,players[f].name);			// display player name
					char8fast(scrx+0,16,'$');
					int8(scrx+8,16,5,players[f].cash);
					game2[f].pad = pc;						// pass pad status to game
					if ( rungame2(&game2[f],&players[f].cash) != 0)		// run game (1 frame) and if game is over
						players[f].laptime = 10;				// go to game over
					backfader(pc, &fade[f]);
					lcddisplay(&lcd[f],fade[f],blocktype[f]);
					if (pc & PADstart)		// if START
					{
						players[f].laptime = 9;	// wait to release,
						players[f].bestlap = 6;	// then go back to gamble menu
					}
				}
				else if (players[f].laptime == 13)				// trade start
				{
					players[f].name[15] = 0;				// selected inv number
					players[f].laptime = 14;
				}
				else if (players[f].laptime == 14)				// trade running
				{
					spr.w = 42;							// BUY
					spr.h = 14;
					spr.u = 156;
					spr.v = 108+48;
					spr.x = scrx+80-SCREENWIDTH/2-22;
					spr.y = 208-SCREENHEIGHT/2;
					GsSortFastSprite(&spr,&WorldOT[activebuff],4);
					spr.w = 48;							// SELL
					spr.u = 198;
					spr.y = 222-SCREENHEIGHT/2;
					GsSortFastSprite(&spr,&WorldOT[activebuff],4);
					spr.w = 46;							// BACK
					spr.u = 58;
					spr.y = 194-SCREENHEIGHT/2;
					GsSortFastSprite(&spr,&WorldOT[activebuff],4);
					print8(scrx+80-(strlen(players[f].name)*4),0,players[f].name);			// display player name
					char8fast(scrx+0,16,'$');
					int8(scrx+8,16,5,players[f].cash);
					char8spritefast.r = char8spritefast.g = char8spritefast.b = 80;
					players[f].inventory[INV_FUEL] = players[f].fuel>>MYBITSHIFT;
					if (players[f].name[15]>0)
					{
						print8(scrx+16,80-8,&invtext[players[f].name[15]-1][0]);			// display previous inv text
						int8(scrx+120,80-8,3,players[f].inventory[players[f].name[15]-1]);		// and number of it
					}
					if (players[f].name[15]<4)
					{
						print8(scrx+16,80+8,&invtext[players[f].name[15]+1][0]);			// display next inv text
						int8(scrx+120,80+8,3,players[f].inventory[players[f].name[15]+1]);		// and number of it
					}
					char8spritefast.r = char8spritefast.g = char8spritefast.b = 128;
					print8(scrx+16,80,&invtext[players[f].name[15]][0]);			// display selected inv text
					int8(scrx+120,80,3,players[f].inventory[players[f].name[15]]);	// and number of it
					print8(scrx+16,152,"BUY  $");
					int8(scrx+64,152,4,inventorylist[players[f].name[15]].buy);
					print8(scrx+16,160,"SELL $");
					int8(scrx+64,160,4,inventorylist[players[f].name[15]].sell);
					print8(scrx+16,168,"UNIT SIZE");
					int8(scrx+96,168,3,inventorylist[players[f].name[15]].amount);
					print8(scrx+16,176,"LIMIT");
					int8(scrx+96,176,3,inventorylist[players[f].name[15]].max);
					if (players[f].bestlap == 0)
					{
						if (pc & PADLup)
							if (players[f].name[15] > 0)
							{
								players[f].name[15]-=1;
								players[f].bestlap = 10;
							}
						if (pc & PADLdown)
							if (players[f].name[15]<4)
							{
								players[f].name[15]+=1;
								players[f].bestlap = 10;
							}
						if (pc & PADRdown)				// X - Buy item
						{
							if (players[f].inventory[players[f].name[15]] < inventorylist[players[f].name[15]].max)	// if has space
								if (players[f].cash > inventorylist[players[f].name[15]].buy)				// if can afford
								{
									if (players[f].name[15] == INV_FUEL)
										players[f].fuel += 100<<MYBITSHIFT;
									players[f].inventory[players[f].name[15]]+=inventorylist[players[f].name[15]].amount;		// buy it
									players[f].cash-=inventorylist[players[f].name[15]].buy;
									limitrange(players[f].inventory[players[f].name[15]],0,999);
									limitrange(players[f].fuel,0,999<<MYBITSHIFT);
								}
							players[f].bestlap = 12;
						}
						if (pc & PADRright)				// O - Sell item
						{
							if (players[f].inventory[players[f].name[15]] >= inventorylist[players[f].name[15]].amount)	// if have enough
							{
								if (players[f].name[15] == INV_FUEL)
									players[f].fuel -= 100<<MYBITSHIFT;
								players[f].inventory[players[f].name[15]]-=inventorylist[players[f].name[15]].amount;
								players[f].cash+=inventorylist[players[f].name[15]].sell;
								limitrange(players[f].inventory[players[f].name[15]],0,999);
								limitrange(players[f].fuel,0,999<<MYBITSHIFT);
							}
							players[f].bestlap = 12;
						}
						if (pc & PADRup)
							players[f].laptime = 4;			// back to main menu
					}
					else
						players[f].bestlap-=1;
				}
			}
		}

		numplayersactive = 0;
		for (f=0;f<2;f++)
			if (players[f].active != 0)
				numplayersactive++;
		if ( (numplayersactive>0) && (numplayersactive == numplayersfinished) )
			QUIT_FLAG = 1;

		ObjectHandler();			// display and handle objects


		obj3d[31].rotate.vy+=4;
		for (f=0;f<MAX3DOBJECTS;f++)
			if (obj3d[f].active == 2)				// moving object
			{
				UpdateObjectCoordinates(&obj3d[f]);
				DisplayObject3D(&obj3d[f]);
			}
			else if (obj3d[f].active == 1)			// static object
			{
				DisplayObject3D(&obj3d[f]);
			}

		UpdateObjectCoordinates(&backlobj);
		UpdateObjectCoordinates(&backrobj);
		DisplayObject3D(&backlobj);
		DisplayObject3D(&backrobj);

		GsSortOt(&BackOT[activebuff],&WorldOT[activebuff]);
		GsSortOt(&BotOT[activebuff],&WorldOT[activebuff]);
		FntPrint("Hsync:%d\n",hcnt);
//		FntFlush(-1);
		DrawSync(0);
		GsDrawOt(&OverlayOT[activebuff]);
		DrawSync(0);
		hcnt = VSync(0);
		GsSwapDispBuff();
		GsSortClear(0,0,0,&WorldOT[activebuff]);
		GsDrawOt(&WorldOT[activebuff]);
	}

}

void makecarcolours(u_short col,int car)
{	// convert a 15bit CLUT (col) into 16 car colours and copies to car colour area for car (car)
	u_short	clut[16];
	float		brightmult;
	u_char	cr,cg,cb;
	RECT		rct;
	int g;
	clut[0] = clut[1] = clut[15] = 0;
//	clut[2] = 0x56b5;
//	clut[3] = 0x39d4;
//	clut[4] = 0x210d;
	clut[8] = 0x39d4;
	clut[9] = 0x56b5;
	for (g=1;g<=7;g++)
	{
		clut[g] = col;
		cr = clut[g]&31;
		cb = (clut[g]>>5)&31;
		cg = (clut[g]>>10)&31;
		brightmult = ( ((float)(g-1)/10.0) );			// set brightness multiplier
		cr = cr * brightmult;
		cg = cg * brightmult;
		cb = cb * brightmult;
//		printf("colour %d   %d %d %d  mult=%f\n",g,cr,cg,cb,brightmult);
		clut[g] = ((cg&31)<<10) | ((cb&31)<<5) | (cr&31);
	}
	for (g=10;g<=14;g++)
	{
		clut[g] = col;
		cr = clut[g]&31;
		cb = (clut[g]>>5)&31;
		cg = (clut[g]>>10)&31;
		brightmult = ( ((float)(g-4)/10.0) );			// set brightness multiplier
		cr = cr * brightmult;
		cg = cg * brightmult;
		cb = cb * brightmult;
//		printf("colour %d   %d %d %d  mult=%f\n",g,cr,cg,cb,brightmult);
		clut[g] = ((cg&31)<<10) | ((cb&31)<<5) | (cr&31);
	}
	rct.x = 576 + (car%4)*16; rct.y = 241+(car>>2); rct.w = 16; rct.h = 1;
	LoadImage(&rct,(u_long *)clut);					// copy clut to carcolour area
}

void initstarfield(VECTOR *pt)
{
	int f;
	for (f=0;f<MAXSTARFIELDSTARS;f++)
	{
		pt->vx = (rand()-16384)/16;
		pt->vy = (rand()-16384)/16;
		pt->vz = (rand()-16384)/16;
		pt++;
	}
}

void thud(short angle)
{	// makes thud sound for menu movement etc. angle is 0 for forwards, -90 left 90 right
	volume	*pt;
	if (angle<0)
		angle+=360;
	angle=angle%360;
	pt=volumetabpt+angle;
	SsUtKeyOn(soundvab,0,0,63,0,pt->lv,pt->rv);
}

void prang()
{	// car prang sound
	SsUtKeyOn(soundvab,6,0,62,0,80,80);
}

void boom()
{	// explosion sound
	SsUtKeyOn(soundvab,6,0,52,0,120,120);
}

void backfader(u_short p, u_char *fade)
{	// fades fade with L2 and R2
	if ( p & PADL2 )
		if ((*fade)>0)
			(*fade)-=1;
	if ( p & PADR2 )
		if ((*fade)<255)
			(*fade)+=1;
}

void blocktypechange(u_short p, u_char *type)
{	// alters block type with L1 and R1
	static u_char count = 0;
	if (count == 0)
	{
	if (p & PADL1)
		if ( (*type)>0 )
		{
			(*type)-=1;
			count = 12;
		}
	if (p & PADR1)
		if ( (*type)<3 )
		{
			(*type)+=1;
			count = 12;
		}
	}
	else
		count--;
	if (p == 0)
		count = 0;
}

void clearlcd(lcdgrid *pt)
{	// clears lcd grid
	int f;
	for (f=0;f<(16*22);f++)
		pt->grid[f]=0;
}

void lcddisplay(lcdgrid *lcdpt,u_char fade,u_char type)
{	// shows lcd on screen
	u_short	x,y;
	u_char	b;
	sprite16bit.x = (lcdpt->sx)-160+32;
	sprite16bit.y = (lcdpt->sy)-120;
	sprite16bit.u = 0;
	sprite16bit.v = 16;
	sprite16bit.r = sprite16bit.g = sprite16bit.b = fade;
	sprite16bit.w = 64;
	sprite16bit.h = 176;
	GsSortFastSprite(&sprite16bit,&WorldOT[activebuff],8);
	for (y=0;y<22;y++)
		for (x=0;x<16;x++)
		{
			b = lcdpt->grid[x+y*16];
			if (b>0 && b<254)
			{
				blocksprite.x = (lcdpt->sx)-160+x*8;
				blocksprite.y = (lcdpt->sy)-120+y*8;
				blocksprite.u = (((type)>>1)<<5)+((b>>6)<<3);
				blocksprite.v = ((type)%2)<<3;
				blocksprite.cy = 256+(b&15);
				GsSortFastSprite(&blocksprite,&WorldOT[activebuff],0);
			}
		}
}

void lcdblock(lcdgrid *lcdpt,short x, short y,u_char block)
{	// puts a block onto the lcd
	u_long	offset;
	offset = x+(y<<4);
	if ( (offset>=0) && (offset<(16*22)) )
		lcdpt->grid[offset] = block;
}

u_char	lcdread(lcdgrid *lcdpt, short x, short y)
{		// returns block on lcd at x,y
	u_long	offset;
	offset = x+(y<<4);
	if ( (x>=0) && (x<16) && (y>=0) && (y<22) )
		return(lcdpt->grid[offset]);
	else
		return(255);				// if off screen, return a 255
}

void newgame1block(u_char *pt)
{	// generates next block for colums game
	long	r;
	r = rand();
	pt[0]=((r%7)+1)+48;
	pt[1]=(((r>>4)%7)+1)+48;
	pt[2]=(((r>>8)%7)+1)+48;
}

u_char	game1movevalid(short x,short y, columsdef *game)
{	// returns 0 if stack (3blocks) can move to these x,y
	if (lcdread(game->lcdpt,x,y)!=0)
		return(1);
	if (y>0)
		if (lcdread(game->lcdpt,x,y-1)!=0)
			return(2);
	if (y>1)
		if (lcdread(game->lcdpt,x,y-2)!=0)
			return(3);
	return(0);
}

void updategame1delete(columsdef *game)
{	// deletes matching blocks horizontally (marks them for deletion actually)
	short	x,y;
	int	count,f;
	u_char	prev,curr;
	for (y=0;y<22;y++)
	{
		count = 0;
		prev = 255;
		for (x=4;x<13;x++)				// check horizontal (reads 255 if over actual lcd) (if don't read 17, ignores rows that end on last line)
		{
			curr = lcdread(game->lcdpt,x,y);
			if ( (curr == prev) && (curr != 255) && (curr != 0) )
				count++;
			else
			{
				if (count>1)
					for (f=0;f<=count;f++)
					{
						game->remove[game->removecount].x = x-f-1;	// put into remove list
						game->remove[game->removecount].y = y;
						game->removecount++;
					}
				prev = curr;
				count = 0;
			}
		}
	}
}

void updategame1deletevert(columsdef *game)
{	// deletes matching blocks vertically
	short	x,y;
	int	count,f;
	u_char	prev,curr;
	for (x=4;x<12;x++)
	{
		count = 0;
		prev = 255;
		for (y=0;y<23;y++)				// check horizontal (reads 255 if over actual lcd) (if don't read 17, ignores rows that end on last line)
		{
			curr = lcdread(game->lcdpt,x,y);
			if ( (curr == prev) && (curr != 255) && (curr != 0) )
				count++;
			else
			{
				if (count>1)
					for (f=0;f<=count;f++)
					{
						game->remove[game->removecount].x = x;	// put into remove list
						game->remove[game->removecount].y = y-f-1;
						game->removecount++;
					}
				prev = curr;
				count = 0;
			}
		}
	}
}

void updategame1deletediagdr(columsdef *game)
{	// deletes diagonals (down right)
	short	x,y,d;
	int	count,f;
	u_char	prev,curr;
	for (y=-12;y<21;y++)				// start above screen
	{
		count = 0;
		prev = 255;
		for (x=0;x<12;x++)			// do diagonals
		{
			curr = lcdread(game->lcdpt,x+4,y+x);
			if ( (curr == prev) & (curr != 255) & (curr != 0) )
				count++;
			else
			{
				if (count>1)
				{
					for (f=0;f<=count;f++)
					{
						game->remove[game->removecount].x = x+4-f-1;
						game->remove[game->removecount].y = y+(x-f-1);
						game->removecount++;
					}
				}
			prev = curr;
			count = 0;
			}
		}
	}
}

void updategame1deletediagdl(columsdef *game)
{	// deletes diagonals (down left)
	short	x,y,d;
	int	count,f;
	u_char	prev,curr;
	for (y=-12;y<21;y++)				// start above screen
	{
		count = 0;
		prev = 255;
		for (x=12;x>=-1;x-=1)			// do diagonals
		{
			curr = lcdread(game->lcdpt,x+4,y+12-x);
			if ( (curr == prev) & (curr != 255) & (curr != 0) )
				count++;
			else
			{
				if (count>1)
				{
					for (f=0;f<=count;f++)
					{
						game->remove[game->removecount].x = x+4+f+1;
						game->remove[game->removecount].y = y+12-(x+f+1);
						game->removecount++;
					}
				}
			prev = curr;
			count = 0;
			}
		}
	}
}

void optimizeremovelist(columsdef *game)
{	// clears duplicates from list
	// otherwise, blocks do not get fully dissolved on overlapping horiz/vert matches
	int f,g;
	u_char	x,y;
	if (game->removecount<2)
		return;
	for (f=0;f<game->removecount-1;f++)			// step through all bar last
	{
		x = game->remove[f].x;
		y = game->remove[f].y;
		for (g=f+1;g<game->removecount;g++)		// check rest against this
		{
			if ( (game->remove[g].x == x) && (game->remove[g].y == y) )
				game->remove[g].x = 255;			// if duplicate, mark as x=255
		}
	}
}


int updategame1drop(columsdef *game)
{	// drops all blocks
	short x,y;
	int c,totalc;
	totalc = 0;
//	printf("Dropping\n");
	for (y=20;y>=0;y--)
	{
		for (x=4;x<12;x++)
		{
			c = 0;
			if ( (lcdread(game->lcdpt,x,y) > 0) && (lcdread(game->lcdpt,x,y) < 254) )
			{
				while (lcdread(game->lcdpt,x,y+1+c) == 0)
					c++;							// count number of gaps below block
				if (c>0)
				{
//					printf("DROP %d,%d of %d  c=%d\n",x,y,lcdread(game->lcdpt,x,y),c);
					lcdblock(game->lcdpt,x,y+c,lcdread(game->lcdpt,x,y));		// put old block at bottom
					lcdblock(game->lcdpt,x,y,0);			// remove old block
				}
				totalc+=c;
			}
		}
	}
	return(totalc);
}

int rungame1(columsdef *game, long *cashpt)
{	// colums game
	int f;
	u_char	tmp;

	for (f=0;f<3;f++)
		if ( (game->y-f) >= 0 )
			lcdblock(game->lcdpt,game->x,game->y-f,0);		// clear old blocks
	if (game->padcount == 0)
	{
		if (game->pad & PADLleft)		// move left
			if (game->x>4)
				if (game1movevalid(game->x-1,game->y,game)==0)
				{
					game->x-=1;
					game->padcount = 8;
				}
		if (game->pad & PADLright)		// move right
			if (game->x<11)
				if (game1movevalid(game->x+1,game->y,game)==0)
				{
					game->x+=1;
					game->padcount = 8;
				}
		if (game->pad & PADRdown)		// rotate
		{
			tmp = game->current[0];
			game->current[0]=game->current[1];
			game->current[1]=game->current[2];
			game->current[2]=tmp;
			game->padcount = 8;
		}
	}
	else
		game->padcount-=1;
	if (game->pad == 0)				// if released keys,
		game->padcount = 0;			// then can press immediately after
	if (game->pad == PADLdown)			// if down
		game->pause = 0;				// speed up block fall

	if (game->status == 0)				// make next block fall
	{
		if (game->pause == 0)
		{
			game->pause = game->speed>>8;	// reset pause to speed
			if (game->speed>(2<<8))
				game->speed-=1;				// speed up gradually
			if ( (game->y<21) && (game1movevalid(game->x,game->y+1,game)==0) )	// if not at bottom, and not blocked
				game->y+=1;				// move down automatically
			else						// or, if at bottom, do new block
			{
				SsUtKeyOn(soundvab,1,0,63,0,110,110);
				for (f=0;f<3;f++)					// display old block at bottom
					if ( (game->y-f) >= 0 )
						lcdblock(game->lcdpt,game->x,game->y-f,game->current[f]);
				game->status = 1;
				game->current[0] = game->next[0];
				game->current[1] = game->next[1];
				game->current[2] = game->next[2];
				newgame1block(game->next);
				for (f=0;f<3;f++)
					lcdblock(game->lcdpt,0,2-f,game->next[f]);		// draw 'NEXT' block in corner
				game->y=0;
				game->x=8;
				if ( lcdread(game->lcdpt,game->x,game->y+2) != 0)
					game->status = 16;			// GAME OVER
			}
		}
		else
			game->pause-=1;

		for (f=0;f<3;f++)					// display new block
			if ( (game->y-f) >= 0 )
				lcdblock(game->lcdpt,game->x,game->y-f,game->current[f]);
	}
	else if (game->status == 1)			// check remove blocks horiz
	{
		game->removecount = 0;
		updategame1delete(game);				// check and remove lines
		game->status = 2;
	}
	else if (game->status == 2)			// check vert
	{
		updategame1deletevert(game);
		game->status = 3;
	}
	else if (game->status == 3)			// check diag
	{
		updategame1deletediagdr(game);
		game->status = 7;
	}
	else if (game->status == 7)			// check diag (2)
	{
		updategame1deletediagdl(game);
		game->status = 4;
	}
	else if (game->status == 4)			// make blocks disappear
	{
		optimizeremovelist(game);
		if (game->removecount>14)
			printf("OOOOOOOOOOOOOOOOPS,  remove count %d\n",game->removecount);
		if (game->removecount>3)
			(*cashpt)+=game->removecount*2;
//		printf("CASH: %d",*cashpt);
		game->pause = 3;
		if (game->removecount>0)
			game->status = 6;
		else
			game->status = 5;
	}
	else if (game->status == 5)
	{
		if (updategame1drop(game) == 0)		// drop blocks, and if total dropped is zero
			game->status = 0;
		else
		{
			SsUtKeyOn(soundvab,7,0,63,0,110,110);
			game->status = 1;
		}
	}
	else if (game->status == 6)				// dissolve blocks
	{
		if (game->pause == 0)
		{
			game->pause = 3;
			for (f=0;f<game->removecount;f++)
			{
				if (game->remove[f].x != 255)		// 255 means DO NOT DISSOLVE
				{
					tmp = lcdread(game->lcdpt,game->remove[f].x,game->remove[f].y);
					tmp+=64;
					if (tmp<64)
					{
						game->status = 5;
						tmp = 0;
					}
					lcdblock(game->lcdpt,game->remove[f].x,game->remove[f].y,tmp);
				}
			}
		}
		else
			game->pause--;
	}
	else if (game->status == 16)
		return(1);
	return(0);
}

int	rungame2(tetrisdef *game, long *cashpt)
{	// tetris game
	return(1);
}

void playerspincontrol(u_long obj)
{	// spins car for arcade entry
	object[obj].angle=(object[obj].angle+(2<<MYBITSHIFT))%(360<<MYBITSHIFT);
	object[obj].frame=((object[obj].angle>>MYBITSHIFT)/11.25);
	object[obj].frame=object[obj].frame<<8;
}

char drawtextentry(short sx,short sy,char highlight)
{	// draws text entry screen at coordinate sx,sy and highlights character number highlight
	// returns ASCII code for highlight
	char	c;
	int f;
	short	x,y;
	static short ang1 = 0;
	static short ang2 = 8;
	short scalex,scaley;
	long rotate = 4096*45;
	static char table[]=" ABCDEFGHIJKLMNOPQRSTUVWXYZ.!$<^";
	long	v1dx,v1dy,v2dx,v2dy;

	v1dx=((veltabpt+ang1/8)->dx);
	v1dy=((veltabpt+ang1/8)->dy);
	v2dx=((veltabpt+ang2/8)->dx);
	v2dy=((veltabpt+ang2/8)->dy);
	ang1=(ang1+3)%256;				// update angles (scaled by 8)
	ang2=(ang2+1)%256;
	rotate = (v1dx*4096)/8;
	scalex = 6096+v2dx*6;
	scaley = 6096+v1dy*6;
	for (f=0;f<32;f++)
	{
		c = table[f];
		x = sx+((f%8)<<4);
		y = sy+((f>>3)<<4);
		if (f!=highlight)
			char8fast(x,y,c);
		else
		{
			char8sprite.r = 128+v1dx/3; char8sprite.g = 128+v1dy/3;
			char8(x,y,scalex,scaley,rotate,c);
			char8sprite.r = 128;
		}
	}
	return(table[highlight]);
}


void soundtest()
{
	int QUIT,f,hcnt;
	short	prog,tone,note,voice,adj;
	char	*atrpt,*pt,wt;
	short	ar,dr,sr,rr,sl,vol,edit;
	GsLINE	linear,linedr,linesr,linerr;

	QUIT = 0;
	prog =0;
	tone = 0;
	note = 63;
	voice= -1;
	adj = 16;
	wt = 0;
	ar = 127;
	dr = sr = rr = 0;
	sl = 15;
	vol = 120;
	edit = 0;

	linear.attribute = linedr.attribute = linesr.attribute = linerr.attribute = 0;

	atrpt = (char *)vhptr;
	atrpt += 2048+32;

	for (f=0;f<2;f++)
	{
		WorldOT[f].length = OT_LENGTH;	// Very important this, don't forget it
		WorldOT[f].org = OTTags[f];	// it initialises the OT
		TopOT[f].length = TOPOT_LENGTH;
		TopOT[f].org = TopOTTags[f];
		BotOT[f].length = BOTOT_LENGTH;
		BotOT[f].org = BotOTTags[f];
		OverlayOT[f].length = OVERLAYOT_LENGTH;
		OverlayOT[f].org = OverlayOTTags[f];
	}


	while (QUIT == 0)
	{
// Clear up display data
		activebuff = GsGetActiveBuff();		//Get buffer we can use
		GsSetWorkBase((PACKET *)GpuPacketArea[activebuff]);	// Tell the system where the packet buffer is
		GsClearOt(0, 0, &WorldOT[activebuff]);			// Clear the Ordering Table

		GsClearOt(0, OTPRI_SMOKE, &TopOT[activebuff]);		// 3D above ground
		GsClearOt(0, OTPRI_GROUND+1, &BotOT[activebuff]);	// 3D below ground
		GsClearOt(0, 0, &OverlayOT[activebuff]);			// overlay (status, scores etc..)

// Read Controller 
		for (f=0;f<2;f++)
			ReadController(players[f].pad, players[f].paddata);
		if (players[0].paddata[1] & PADselect)
			QUIT = 1;

		pt = atrpt+(tone*32+(prog*32*16));

/*
	atrpt = (char *)vhptr;
	atrpt += 2048+32;
	pt = atrpt+(tone*32+(prog*32*16));
	*(pt+17) = 0-(127+1);
	*(pt+16) = (15&15) | ((15-(0&15))<<4);
*/


	if (wt == 0)
	{
		if (players[0].paddata[1] & PADRdown)
			if (voice == voice)
			{
				SsUtAllKeyOff(0);
				voice = SsUtKeyOn(soundvab,prog,tone,note,0,120,120);
			}

		if (players[0].paddata[1] & PADRright)
			if (voice != -1)
			{
				SsUtKeyOff(voice,soundvab,prog,tone,note);
				SsUtAllKeyOff(0);
				voice = -1;
			}

		if (players[0].paddata[1] & PADLleft)
			if (prog>0)
				prog-=1;
		if (players[0].paddata[1] & PADLright)
			if (prog<126)
				prog+=1;
		if (players[0].paddata[1] & PADLdown)
			if (tone>0)
				tone-=1;
		if (players[0].paddata[1] & PADLup)
			if (tone<16)
				tone+=1;
		if (players[0].paddata[1] & PADL1)
			if (note>0)
				note-=1;
		if (players[0].paddata[1] & PADR1)
			if (note<99)
				note+=1;


		if (players[0].paddata[1] & PADL2)
			if (edit == 0)
				ar-=1;
			else if (edit == 1)
				dr-=1;
			else if (edit == 2)
				sr-=1;
			else if (edit == 3)
				rr-=1;
			else if (edit == 4)
				sl-=1;

		if (players[0].paddata[1] & PADR2)
			if (edit == 0)
				ar+=1;
			else if (edit == 1)
				dr+=1;
			else if (edit == 2)
				sr+=1;
			else if (edit == 3)
				rr+=1;
			else if (edit == 4)
				sl+=1;

		if (players[0].paddata[1] & PADRup)
			edit=(edit+1)%5;

		wt = 1;
	}
	else
		wt-=1;

	limitrange(edit,0,4);
	limitrange(ar,0,127);
	limitrange(dr,0,15);
	limitrange(sr,0,127);
	limitrange(rr,0,31);
	limitrange(sl,0,15);

	if (players[0].paddata[1] & PADRleft)
	{
	*(pt+17) = 0-(ar+1);
	*(pt+16) = (sl&15) | ((15-(dr&15))<<4);
	}
	linear.x0 = -150;
	linear.y0 = 110;
	linear.x1 = linear.x0+(127-ar)/2;
	linear.y1 = 110-vol;
	linear.r = linear.g = linear.b = 120;
	linedr.x0 = linear.x1;
	linedr.y0 = linear.y1;
	linedr.x1 = linedr.x0 + dr;
	linedr.y1 = linedr.y0 + sl*2;
	linedr.r = linedr.g = linedr.b = 120;
	linesr.x0 = linedr.x1;
	linesr.y0 = linedr.y1;
	linesr.x1 = linesr.x0 + sr/2;
	linesr.y1 = linesr.y0 + sr/2;
	linesr.r = linesr.g = linesr.b = 120;

	GsSortLine(&linear,&WorldOT[activebuff],0);
	GsSortLine(&linedr,&WorldOT[activebuff],0);
	GsSortLine(&linesr,&WorldOT[activebuff],0);

		FntPrint("prog %d tone %d note %d\n",prog,tone,note);
		FntPrint("Voice %d  adj %d\n",voice,adj);
		if (edit == 0)
			FntPrint("AR\n");
		else if (edit == 1)
			FntPrint("DR\n");
		else if (edit == 2)
			FntPrint("SR\n");
		else if (edit == 3)
			FntPrint("RR\n");
		else if (edit == 4)
			FntPrint("SL\n");

		for (f=0;f<32;f+=4)
		{
			FntPrint("%d\t%d\t%d\t%d\n",*pt,*(pt+1),*(pt+2),*(pt+3));
			pt+=4;
		}
//		GsDrawOt(&OverlayOT[activebuff]);
		DrawSync(0);
		hcnt = VSync(0);		// Wait for the V-Blank period
		GsSwapDispBuff();		// Swap screens
		GsSortClear(0,0,0,&WorldOT[activebuff]);
		GsDrawOt(&WorldOT[activebuff]);			// Start drawing the OT
		FntFlush(-1);

	}
}



// *****************************
// *****************************
// **				      **
// ** THE MAIN RACE GAME LOOP **
// **				      **
// *****************************
// *****************************

void racegamemain ()
{

	int		QUIT_FLAG,hcnt,fuelpause = 0;
	int		showback,backx,backdx,backr,backdr,backstyle;				// showback 0 = backdrop picture not shown
	int		i,f,g,pause_time = 0;
	int		numplayers,singleplayer,player2;
	int		pl1,pl2,pltmp;
	int		mblock;
	u_long	playtime,cameraplayer;
	u_long	ghostobj;					// object for ghost car
	long		xdiff,ydiff;				// diffs for map camera calc
	long		imapx,imapy,cameraspeed;
	u_long	obj,objediting;
	u_long	objindex[8];
	u_char	cameramaxchkpoint;
	GsSPRITE	countdown;
	short		countdownsize,countdownframe;
	u_long	screen3dobj,screenpathpos;
	u_long	studioobj[8];
	u_long	*testpt;
	u_long	tt_attr;				// trans test
	u_char	tt_r,tt_g,tt_b;			// trans test
	u_short	c;
	u_long	cang;					// headlight test
	u_long	hs;					// headlight test scale
	GsFOGPARAM	fog;

	tt_attr = 0x60000000;
	tt_r = 0xf0;
	tt_g = 0xf0;
	tt_b = 0xf0;
	hs = 19;

	showback = 50;
	backx = 4;
	backdx = 32;
	backr = 0;
	backdr = 16;
	backstyle = rand()%3;

	laprecordholder = NULL;

// Initialize OT
	for (f=0;f<2;f++)
	{
		WorldOT[f].length = OT_LENGTH;	// Very important this, don't forget it
		WorldOT[f].org = OTTags[f];	// it initialises the OT
		TopOT[f].length = TOPOT_LENGTH;
		TopOT[f].org = TopOTTags[f];
		BotOT[f].length = BOTOT_LENGTH;
		BotOT[f].org = BotOTTags[f];
		OverlayOT[f].length = OVERLAYOT_LENGTH;
		OverlayOT[f].org = OverlayOTTags[f];
		BackOT[f].length = BACKOT_LENGTH;
		BackOT[f].org = BackOTTags[f];
	}


// Set up text area
	FntLoad(960,256);		// Load standard 256x128 font pattern to the frame buffer at coords specified
	FntOpen(16-SCREENWIDTH/2,64-SCREENHEIGHT/2,256,160,0,512);	// Setup a text window. x,y,w,h,isbg,n where x,y is coords in frame buffer
					// w,h are width and height. isbg is 0 for background clear/1 no clear, n = number of letters

// Init car positions
	for (f=0;f<MAXDRIVERS;f++)
		carpositions[f] = f;				// holds list of drivers in position order (gets changed when drivers put on grid)

// Init position text sprite and ammo counter sprite
	postextspr.attribute = 0;
	postextspr.tpage = 9;
	postextspr.v = 16;
	postextspr.h = 24;
	postextspr.cx = 592;
	postextspr.cy = 240;
	postextspr.r = postextspr.g = postextspr.b = 128;
	ammospr = postextspr;
	ammospr.w = 8;
	ammospr.v = 120;
	ammospr.h = 8;

// Set up some players stuff
	numplayers = 0;
	singleplayer = -1;
	for (f=0;f<2;f++)
	{
		if (players[f].active != 0)
		{
			numplayers++;			// count players and
			if (singleplayer == -1)		// get player indexes
				singleplayer = f;
			else
				player2 = f;
		}
		players[f].laptime = 0;				// current lap
		players[f].bestlap = 24000;			// personal best this race
	}

// Put sprite graphics in frame buffer
	Initializeframes();

// Clear all objects
	InitializeObjects();

	TransferTIM(_PAK_cloudstim_INDEX);
	TransferTIM(_PAK_trafficlightstim_INDEX);
	TransferTIM(_PAK_thindigitstim_INDEX);

// Initialize the background for display
	GsInitFixBg16(&background[0], backgroundworkarea);
	GsInitFixBg16(&background[1], backgroundtopworkarea);

	TransferTIM(_PAK_skymaptim_INDEX);


// Set up the 3D camera view
	projection=96;
	GsSetProjection(projection);
	cameraview.vrx = 0;
	cameraview.vry = 0;
	cameraview.vrz = 0;
	cameraview.vpx = 0;
	cameraview.vpy = 0;
	cameraview.vpz = -1800;
	cameraview.rz = 0;
	cameraview.super = WORLD;
	GsSetRefView2(&cameraview);

// Set up the 3D Lighting
	for (f=0;f<3;f++)
	{
		light[f].vx = 0;
		light[f].vy = 0;
		light[f].vz = ONE;
		light[f].r = 128;
		light[f].g = 128;
		light[f].b = 128;
		GsSetFlatLight(f, &light[f]);
	}
	GsSetAmbient(128,128,128);

	for (f=0;f<MAX3DOBJECTS;f++)
		obj3d[f].active = 0;

	for (f=0;f<8;f++)
		objindex[f]=0;
	objediting = 0;
	if (trackinfo.type == 1)
	{
		obj = spawn3d();
		create3dobject(obj,_PAK_ss1topmodel_INDEX);
		obj3d[obj].origin.vx = 1334;
		obj3d[obj].origin.vy = 1286;
		obj3d[obj].origin.vz = 900;
		obj3d[obj].ot = 0;				// above track
		objindex[0]=obj;

		obj = spawn3d();
		create3dobject(obj,_PAK_ss1botmodel_INDEX);
		obj3d[obj].origin.vx = 1234;
		obj3d[obj].origin.vy = 1286;
		obj3d[obj].origin.vz = 900;
		obj3d[obj].handler.attribute = 2<<9;
		obj3d[obj].ot = 1;				// below track
		objindex[1]=obj;

		obj = spawn3d();
		create3dobject(obj,_PAK_twintowmodel_INDEX);
		obj3d[obj].origin.vx = -1264;
		obj3d[obj].origin.vy = 646;
		obj3d[obj].origin.vz = 900;
		obj3d[obj].handler.attribute = 2<<9;
		obj3d[obj].ot = 1;				// below track
		objindex[2]=obj;

		obj = spawn3d();
		create3dobject(obj,_PAK_ss3highmodel_INDEX);
		obj3d[obj].origin.vx = -864;
		obj3d[obj].origin.vy = -1446;
		obj3d[obj].origin.vz = 900;
		obj3d[obj].handler.attribute = 2<<9;
		obj3d[obj].ot = 1;				// below track
		objindex[3]=obj;

		obj = spawn3d();
		create3dobject(obj,_PAK_sf1model_INDEX);
		obj3d[obj].origin.vx = 1864;
		obj3d[obj].origin.vy = -1846;
		obj3d[obj].origin.vz = 900;
		obj3d[obj].handler.attribute = 2<<9;
		obj3d[obj].ot = 1;				// below track
		objindex[4]=obj;

		obj = spawn3d();
		create3dobject(obj,_PAK_arch1model_INDEX);
		obj3d[obj].origin.vx = -264;
		obj3d[obj].origin.vy = -846;
		obj3d[obj].origin.vz = 900;
		obj3d[obj].handler.attribute = 2<<9;
		obj3d[obj].ot = 1;				// below track
		objindex[5]=obj;

	}

//

/*
	fog.dqa=-100*(4096/64/projection);
	fog.dqb=1.25*4096*4096;
	fog.rfc = fog.gfc = fog.bfc = 0;
	fog.rfc = 0xf0;
	GsSetLightMode(1);
	GsSetFogParam(&fog);
*/

	resetdrivers();
// Add the player drivers
	{
		int pin;
		pin = 0;
	for (f=0;f<2;f++)
	{
		if (players[f].active != 0)
		{
			obj = adddriver(trackinfo.grid[pin].x,trackinfo.grid[pin].y,trackinfo.grid[pin].angle,1,players[f].carcolour);
			carpositions[f]=object[obj].driverindex;		// make car positions according to grid layout
			players[f].object = obj;
			object[obj].extra->playerindex = f;
			object[obj].extra->controller = players[f].pad;
			makecarcolours(players[f].carclut,players[f].carcolour);
			pin++;
		}
	}
	}

// Add CPU drivers
	if (timetrial == 0)				// only if normal race
		for (f=0;f<(4-numplayers);f++)
		{
			obj = adddriver(trackinfo.grid[f+numplayers].x,trackinfo.grid[f+numplayers].y,trackinfo.grid[f+numplayers].angle,2,f+2);
			carpositions[f+numplayers]=object[obj].driverindex;
			object[obj].extra->playerindex = 2+f;
			makecarcolours(carcolours[f+2],f+2);
		}

// Add Ghost driver
	if (timetrial == 1)
	{
		ghostobj = spawn();
		newplayer(ghostobj);
		object[ghostobj].control = ghostcontrol;
		object[ghostobj].health = 0;					// initially not displayed (health = 0)
		object[ghostobj].class = 3;
		object[ghostobj].cx = 624;
		object[ghostobj].cy = 240;
		ghostdata.ghostobj = ghostobj;
		initializeghostdata();
	}


// Update coordinates for all 3D objects (because static objects don't get this again)
	for (f=0;f<MAX3DOBJECTS;f++)
	{
		if (obj3d[f].active != 0)
		{
			UpdateObjectCoordinates(&obj3d[f]);
		}
	}


	if (nighttime == 1)
	{
		testpt = (u_long *) getpakaddress(_PAK_headlightmodel_INDEX);
		headlnprims = *(testpt+8);				// number of primitives
		headlpcpt = (headlightprecalc *) getpakaddress(_PAK_headliteprecalc_INDEX);		// pointer to pre-calc table
		for (f=0;f<MAXHEADLIGHTS;f++)
		{
			testpt = (u_long *) getpakaddress(_PAK_headlightmodel_INDEX);
			memcpy((void *)headlight[f].tmd,(void *)testpt,2040);
			headlight[f].tmdpt = (u_long *)headlight[f].tmd;
			printf("Headlight %d: pt = %x\n",f,headlight[f].tmdpt);
			headlight[f].origin.vx = 664;
			headlight[f].origin.vy = 506;
			headlight[f].origin.vz = -900;
			headlight[f].rotate.vx = 0;
			headlight[f].rotate.vy = 0;
			headlight[f].rotate.vz = 0;
			GsInitCoordinate2(WORLD, &(headlight[f].coord));
			headlight[f].handler.coord2 = &(headlight[f].coord);
			testpt = headlight[f].tmdpt;
			testpt++;							// skip header ID
			GsMapModelingData(testpt);				// Re-map TMD to addresses
			testpt+=2;							// skip past rest of header
			GsLinkObject4( (u_long)testpt, &(headlight[f].handler), 0);
			headlight[f].handler.attribute = 0x40000000;
			headlight[f].active = 1;
			headlight[f].ot = 0;		// Use TopOT
			UpdateHeadlightObjectCoordinates(&headlight[f]);
		}
	}


//	printf("Starting Game\n");

// MAIN RACE LOOP
	racestatus = 0;					// 0 = counting down
	countdownsize = 32737;				// zoom of countdown number
	countdownframe = 0;				// countdown number
	fuelpause = 100;
	quitwithpause = 0;
	lapsfinished = 0;
	game_paused = 0;
//	printf("map %d x %d\n",mapwidth,mapheight);
	QUIT_FLAG = 0;
	while (QUIT_FLAG != 1)
	{
// Clear up display data
		activebuff = GsGetActiveBuff();		//Get buffer we can use
		GsSetWorkBase((PACKET *)GpuPacketArea[activebuff]);	// Tell the system where the packet buffer is
		GsClearOt(0, 0, &WorldOT[activebuff]);			// Clear the Ordering Table

		GsClearOt(0, OTPRI_SMOKE, &TopOT[activebuff]);		// 3D above ground
		GsClearOt(0, OTPRI_GROUND+1, &BotOT[activebuff]);	// 3D below ground
		GsClearOt(0, 0, &OverlayOT[activebuff]);			// overlay (status, scores etc..)
		if (showback != 0)
			GsClearOt(0, 0, &BackOT[activebuff]);

		if (lapsfinished > 0)
		{
			lapsfinished++;
			print8(124,80,"RACE OVER");
		}
		if (lapsfinished > 100)
			QUIT_FLAG = 1;

		if (numplayers == 2)
			if (players[singleplayer].fuel == 0)
			{
				singleplayer = player2;
				numplayers = 1;
			}
			else if (players[player2].fuel == 0)
			{
				numplayers = 1;
			}

		if (numplayers == 1)
			if (players[singleplayer].fuel == 0)
			{
				fuelpause--;
				if (fuelpause==0)
					QUIT_FLAG = 1;
			}
		if (numplayers == 2)
			if (players[singleplayer].fuel  == 0)
				if (players[player2].fuel == 0)
				{
					fuelpause--;
					if (fuelpause==0)
						QUIT_FLAG = 1;
				}

// Read Controller 
		for (f=0;f<2;f++)
			ReadController(players[f].pad, players[f].paddata);

//		if (players[0].paddata[1] & PADL1)
//			for (f=0;f<MAXHEADLIGHTS;f++)
//				headlight[f].origin.vz+=2;
//		if (players[0].paddata[1] & PADR1)
//			for (f=0;f<MAXHEADLIGHTS;f++)
//			{
//				headlight[f].origin.vz-=2;
//				FntPrint("VZ %d\n",headlight[f].origin.vz);
//			}

//		FntPrint("Objediting %d\n",objediting);
//		FntPrint("Origin %d %d %d\n",obj3d[objindex[objediting]].origin.vx,obj3d[objindex[objediting]].origin.vy,obj3d[objindex[objediting]].origin.vz);
		if (players[0].paddata[1] & PADRup)
		{
			FntPrint("Objediting %d\n",objediting);
			FntPrint("Origin %d %d %d\n",obj3d[objindex[objediting]].origin.vx,obj3d[objindex[objediting]].origin.vy,obj3d[objindex[objediting]].origin.vz);
			if (players[0].paddata[1] & PADLleft)
				obj3d[objindex[objediting]].origin.vx-=16;
			if (players[0].paddata[1] & PADLright)
				obj3d[objindex[objediting]].origin.vx+=16;
			if (players[0].paddata[1] & PADLup)
				obj3d[objindex[objediting]].origin.vy-=16;
			if (players[0].paddata[1] & PADLdown)
				obj3d[objindex[objediting]].origin.vy+=16;
			if (players[0].paddata[1] & PADL1)
				obj3d[objindex[objediting]].origin.vz+=16;
			if (players[0].paddata[1] & PADL2)
				obj3d[objindex[objediting]].origin.vz-=16;
			if (players[0].paddata[1] & PADR2)
			{
				objediting = (objediting+1)%8;
				printf("Objediting %d\n",objediting);
			}
			UpdateObjectCoordinates(&obj3d[objindex[objediting]]);
		}

//		if (players[0].paddata[1] & (PADselect & PADstart))
//			QUIT_FLAG = 1;
		if ((players[0].paddata[1] & PADstart) || (players[1].paddata[1] & PADstart))
			if (game_paused == 0)				// if not paused
			{
				if (pause_time == 0)
					if (object[0].time>50)		// if not immediately after game starts
					{
						RECT	r;
						game_paused = 1;			// pause
						r.x = 0;
						r.y = (1-activebuff)*256;
						r.w = 320;
						r.h = 256;
						MoveImage(&r,320,256);		// copy screen
						DrawSync(0);
						r.x = 320;
						r.h = 1;
						for (f=0;f<256;f++)		// remove all transparant black
						{
							r.y = 256+f;
							StoreImage(&r,(u_long *)screenline);
							DrawSync(0);
							for (g=0;g<320;g++)
							{
//								if (f==0)
//									printf("%x ",screenline[g]);
								if (screenline[g]==0)
									screenline[g]=0x8000;
							}
							LoadImage(&r,(u_long *)screenline);
							DrawSync(0);
						}
						screen3dobj = spawn3d();
						create3dobject(screen3dobj,_PAK_screenmodel_INDEX);
						obj3d[screen3dobj].origin.vx = cameraview.vpx;
						obj3d[screen3dobj].origin.vy = cameraview.vpy;
						obj3d[screen3dobj].origin.vz = -1687;
						obj3d[screen3dobj].active = 2;
						obj3d[screen3dobj].ot = 0;
						obj3d[screen3dobj].handler.attribute = 0x00000000 | (3<<9) | (0<<30);
						screenpathpos = 0;		// start of path
						studioobj[0] = spawn3d();
						create3dobject(studioobj[0],_PAK_ndeskmodel_INDEX);
						obj3d[studioobj[0]].active = 1;
						obj3d[studioobj[0]].ot = 0;
						obj3d[studioobj[0]].origin.vx = cameraview.vpx;
						obj3d[studioobj[0]].origin.vy = cameraview.vpy+160;
						obj3d[studioobj[0]].origin.vz = -1720;
						obj3d[studioobj[0]].rotate.vz = 2048;
						for (f=0;f<MAXDRIVERS;f++)	// kill sound for drivers
							if (driver[f].active != 0)
								for (g=0;g<4;g++)
									object[driver[f].object].voice[g] = -1;
						SsSeqPause(musicseq);
						SsUtAllKeyOff(0);
//						printf("Pause bit out\n");
					}
			}
			else if (game_paused > 25)
			{
				game_paused = 0;			// unless already paused
				kill3d(screen3dobj);
				kill3d(studioobj[0]);
				pause_time = 25;
			}

// 3D Camera
	GsSetRefView2(&cameraview);

// Game Pause state
	while ( game_paused > 0 )
	{
		if (game_paused<250)
			game_paused++;
		if ( (players[0].paddata[1] & PADstart) || (players[1].paddata[1] & PADstart))
			if (game_paused>25)
			{
				game_paused = 0;
				kill3d(screen3dobj);
				kill3d(studioobj[0]);
				pause_time = 25;
				SsSeqReplay(musicseq);
			}
		if ((players[0].paddata[1] & PADselect) || (players[1].paddata[1] & PADselect))
			if (game_paused>25)
			{
				game_paused = 0;
				kill3d(screen3dobj);
				kill3d(studioobj[0]);
				pause_time = 25;
				SsSeqReplay(musicseq);
				QUIT_FLAG = 1;
				quitwithpause = 1;
			}


		for (f=0;f<2;f++)
			ReadController(players[f].pad, players[f].paddata);

		screenpathpos++;
		GsSetRefView2(&cameraview);

		if (screenpathpos<50)
		{
			obj3d[screen3dobj].origin.vx = cameraview.vpx-screenpathpos*4;
			obj3d[screen3dobj].origin.vy = cameraview.vpy-screenpathpos*4;
			obj3d[screen3dobj].origin.vz = -1687 + screenpathpos*6;
		}
//		if (screenpathpos>0 && screenpathpos<25)
//			obj3d[screen3dobj].rotate.vx-=8;
//		if (screenpathpos>24 && screenpathpos<50)
//			obj3d[screen3dobj].rotate.vx-=6;
		if (screenpathpos>0 && screenpathpos<50)
			obj3d[screen3dobj].rotate.vy-=12;
//		if (screenpathpos>0 && screenpathpos<50)
//			obj3d[screen3dobj].rotate.vz-=2;

	// 3D position test
/*
		if (players[0].paddata[1] & PADRleft)
		{
			objediting=(objediting+1)%MAX3DOBJECTS;
			while (obj3d[objediting].active == 0)
				objediting=(objediting+1)%MAX3DOBJECTS;
		}
*/

		if (players[0].paddata[1] & PADRup)
			obj3d[screen3dobj].origin.vz-=(20);
		if (players[0].paddata[1] & PADRdown)
			obj3d[screen3dobj].origin.vz+=(20);
		if (players[0].paddata[1] & PADLup)
			obj3d[screen3dobj].origin.vy-=(20);
		if (players[0].paddata[1] & PADLdown)
			obj3d[screen3dobj].origin.vy+=(20);
//		FntPrint("Z %d Y %d\n",obj3d[studioobj[0]].origin.vz,obj3d[studioobj[0]].origin.vy);
		if (players[0].paddata[1] & PADLleft)
			obj3d[screen3dobj].rotate.vy-=(10);
		if (players[0].paddata[1] & PADLright)
			obj3d[screen3dobj].rotate.vy+=(10);
/*
		if (players[0].paddata[1] & PADL2)
			cameraview.vpz-=10;
		if (players[0].paddata[1] & PADR2)
			cameraview.vpz+=10;
		if (players[0].paddata[1] & PADL1)
		{
			projection -= 2;
			GsSetProjection(projection);
		}
		if (players[0].paddata[1] & PADR1)
		{
			projection += 2;
			GsSetProjection(projection);
		}
*/
//		UpdateObjectCoordinates(&obj3d[objediting]);
/*
		if (players[0].paddata[1] & PADRdown)
			tt_r = (tt_r+254)%256;
		if (players[0].paddata[1] & PADRup)
			tt_r = (tt_r+2)%256;
		if (players[0].paddata[1] & PADL1)
			tt_attr = 0x40000000;
		if (players[0].paddata[1] & PADR1)
			tt_attr = 0x50000000;
		if (players[0].paddata[1] & PADL2)
			tt_attr = 0x60000000;
		if (players[0].paddata[1] & PADR2)
			tt_attr = 0x70000000;
*/

		UpdateObjectCoordinates(&obj3d[screen3dobj]);
		DisplayObject3D(&obj3d[screen3dobj]);
		for (f=0;f<1;f++)
		{
			UpdateObjectCoordinates(&obj3d[studioobj[f]]);
			DisplayObject3D(&obj3d[studioobj[f]]);
		}

		print8(180,80,"GAME PAUSED");
		print8(180,100," START   CONTINUE");
		print8(180,108,"SELECT     QUIT");

// Pause section tie up frame
		GsSortOt(&TopOT[activebuff],&WorldOT[activebuff]);
		GsSortOt(&BotOT[activebuff],&WorldOT[activebuff]);
		DrawSync(0);
		GsDrawOt(&OverlayOT[activebuff]);
		DrawSync(0);
		FntPrint("Hsyncs:%d\n",hcnt);		//print into stream
//		FntFlush(-1);
		hcnt = VSync(0);
		GsSwapDispBuff();
		GsSortClear(0,0,0,&WorldOT[activebuff]);
		GsDrawOt(&WorldOT[activebuff]);

		activebuff = GsGetActiveBuff();		//Get buffer we can use
		GsSetWorkBase((PACKET *)GpuPacketArea[activebuff]);	// Tell the system where the packet buffer is
		GsClearOt(0, 0, &WorldOT[activebuff]);			// Clear the Ordering Table
		GsClearOt(0, OTPRI_SMOKE, &TopOT[activebuff]);		// 3D above ground
		GsClearOt(0, OTPRI_GROUND+1, &BotOT[activebuff]);	// 3D below ground
		GsClearOt(0, 0, &OverlayOT[activebuff]);			// overlay (status, scores etc..)

	}
	if (game_paused == 0)
		if (pause_time>0)
			pause_time--;


//	printf("3d\n");
	// 3D Objects
		for (f=0;f<MAX3DOBJECTS;f++)
		{
			if (obj3d[f].active == 2)				// moving object
			{
				UpdateObjectCoordinates(&obj3d[f]);
				DisplayObject3D(&obj3d[f]);
			}
			else if (obj3d[f].active == 1)			// static object
			{
				DisplayObject3D(&obj3d[f]);
			}
		}
//		obj3d[0].rotate.vx+=01;
//		obj3d[0].rotate.vy+=20;

//	printf("Backdrop\n");
// Backdrop picture
	if (showback != 0)
	{
		backlobj.origin.vx = cameraview.vpx-2870-backx;
		backlobj.origin.vy = cameraview.vpy-1974;
		backrobj.origin.vx = cameraview.vpx+2894+backx;
		backrobj.origin.vy = cameraview.vpy-1974;
		if (backstyle == 0)
		{
			backlobj.rotate.vz += backr;
			backrobj.rotate.vz -= backr;
			backr+=(backdr>>2);
			backdr+=3;
			if (backlobj.rotate.vz>1600)
				showback = 0;
		}
		else if (backstyle == 1)
		{
			backx+=backdx;
			backdx+=12;
			if (backx>3000)
				showback = 0;
		}
		else if (backstyle == 2)
		{
			backlobj.rotate.vy -= backr;
			backrobj.rotate.vy += backr;
			backr+=(backdr>>2);
			backdr+=3;
			if (backlobj.rotate.vy<1024)
				showback = 0;
		}
		UpdateObjectCoordinates(&backlobj);
		UpdateObjectCoordinates(&backrobj);
		DisplayObject3D(&backlobj);
		DisplayObject3D(&backrobj);
	}


//	printf("Map\n");
// Move background track map camera
		if (numplayers == 1)
		{
			mapx = object[players[singleplayer].object].x-((SCREENWIDTH/2)<<MYBITSHIFT);
			mapy = object[players[singleplayer].object].y-((SCREENHEIGHT/2)<<MYBITSHIFT);
		}
		else if (numplayers == 2)		// 2 player camera track
		{
			xdiff = (object[players[player2].object].x-object[players[singleplayer].object].x);
			ydiff = (object[players[player2].object].y-object[players[singleplayer].object].y);
			if (abs(xdiff)>((SCREENWIDTH-32)<<MYBITSHIFT) || abs(ydiff)>((SCREENHEIGHT-32)<<MYBITSHIFT))
			{
				pl1 = singleplayer;
				pl2 = player2;
				if ( ((object[players[pl2].object].lap == object[players[pl1].object].lap) && (object[players[pl2].object].chkpoint > object[players[pl1].object].chkpoint)) || (object[players[pl2].object].lap > object[players[pl1].object].lap) )			// if p2 is same lap and higher chkpoint, or higher lap
					{
						pltmp = pl2;
						pl2 = pl1;												// make player 1 catch up
						pl1 = pltmp;
					}
				object[players[pl2].object].followactive = 1;
				object[players[pl2].object].followx = object[players[pl1].object].x;
				object[players[pl2].object].followy = object[players[pl1].object].y;
				object[players[pl2].object].angle = object[players[pl1].object].angle;
				object[players[pl2].object].control = followcontrol;
				object[players[pl2].object].chkpoint = object[players[pl1].object].chkpoint;			// because he won't drive over them
				object[players[pl2].object].lap = object[players[pl1].object].lap;				// has to be same lap as both on same screen
			}
			mapx = object[players[singleplayer].object].x+xdiff/2-((SCREENWIDTH/2)<<MYBITSHIFT);
			mapy = object[players[singleplayer].object].y+ydiff/2-((SCREENHEIGHT/2)<<MYBITSHIFT);
		}
		limitrange(mapx,0,(mapwidth-SCREENWIDTH)<<MYBITSHIFT);
		limitrange(mapy,0,(mapheight-SCREENHEIGHT)<<MYBITSHIFT);
		background[0].scrollx = mapx>>MYBITSHIFT;
		background[0].scrolly = mapy>>MYBITSHIFT;
		background[1].scrollx = background[0].scrollx;
		background[1].scrolly = background[0].scrolly;

		cameraview.vpx = cameraview.vrx = ( (mapx+((SCREENWIDTH/2)<<MYBITSHIFT))>>MYBITSHIFT )<<1;
		cameraview.vpy = cameraview.vry = ( (mapy+((SCREENHEIGHT/2)<<MYBITSHIFT))>>MYBITSHIFT )<<1;

// Display the background
		GsSortFixBg16(&background[0], backgroundworkarea, &WorldOT[activebuff], OTPRI_GROUND);
//		if (trackinfo.type == 0)
//			GsSortFixBg16(&background[1], backgroundtopworkarea, &WorldOT[activebuff], OTPRI_OVERLAY);


// Headlite test
	if (nighttime == 1)
	{
		for (f=0;f<MAXDRIVERS;f++)
			if (driver[f].active != 0)			// if driver active
			{
				cang = (long)((object[driver[f].object].angle>>MYBITSHIFT)/11.25)%32;
				headlight[f].rotate.vz = cang*128;
				headlight[f].aoff = cang*headlnprims;			// offset into pre-calc table
				headlight[f].hox = (((veltabpt+cang)->dx*78)/256)*1.1;	// pixel offset to centre of mapping box
				headlight[f].hoy = (((veltabpt+cang)->dy*78)/256)*1.1;
				headlight[f].origin.vx = cameraview.vpx+((((object[driver[f].object].x>>MYBITSHIFT)-(mapx>>MYBITSHIFT))-SCREENWIDTH/2+headlight[f].hox)*10);
				headlight[f].origin.vy = cameraview.vpy+((((object[driver[f].object].y>>MYBITSHIFT)-(mapy>>MYBITSHIFT))-SCREENHEIGHT/2+headlight[f].hoy)*10);
			}
	}

//	printf("Obj\n");
// Handle Objects
		ObjectHandler();

//	printf("Chk\n");
// Show player status bars/times etc
		CheckPlayers(&WorldOT[activebuff]);

// Show lap record flyer
		if (laprecordactive != 0)
		{
			laprecordsprite.x = laprecordx;
			laprecordsprite.y = laprecordy;
			GsSortSprite(&laprecordsprite,&OverlayOT[activebuff],0);
			laprecordx+=(laprecorddx-laprecordx)>>3;
			laprecordy+=(laprecorddy-laprecordy)>>3;
			laprecordactive--;
			if (laprecordactive == 50)
			{
				laprecorddx = 0;
				laprecorddy = -150;
			}
		}

// Increase players laptimes
		if ( (racestatus == 1) && (game_paused == 0) )
		{
			players[0].laptime+=2;
			players[1].laptime+=2;
			if (timetrial == 1)
				updateghostdata();
		}

// Do countdown if applicable
		if ( (countdownframe<5) && (game_paused == 0) )
		{
			countdown.x = 96-SCREENWIDTH/2;
			countdown.y = 96-SCREENHEIGHT/2;
			countdown.r = 128;
			countdown.g = 128;
			countdown.b = 128;
			countdown.w = 14;
			countdown.h = 32;
			countdown.tpage = GetTPage(0,0,448,0);
			if (countdownframe>0)
				countdown.u = 14*(countdownframe-1);
			else
				countdown.u = 0;
			countdown.v = 16;
			countdown.cx = 448;
			countdown.cy = 254;
			countdown.attribute = 0x00000000;
			countdown.mx = countdown.w/2;
			countdown.my = countdown.h/2;
			countdown.scalex = 4096;
			countdown.scaley = 4096;
			countdown.rotate = 0;
			if (showback == 0)
			{
//				if (countdownframe>0)
					GsSortSprite(&countdown, &OverlayOT[activebuff], 0);
				countdownsize-=600;
			}
			if (countdownsize<600)
			{
				countdownframe++;
//				printf("count %d\n",countdownframe);
				countdownsize = 32737;
				if (countdownframe==4)
				{
					SsUtKeyOn(soundvab,5,0,62,0,120,120);
					racestatus = 1;
//					printf("Race has started\n");
					if (MUSIC == 1)
					{
						SsSeqPlay(musicseq, SSPLAY_PLAY, SSPLAY_INFINITY);
						SsSetTempo(musicseq, 0, 204);
					}
				}
				else if (countdownframe>1 && countdownframe<4)
					SsUtKeyOn(soundvab,4,0,62,0,120,120);
			}
		}

//	printf("Status\n");
// Status screens
		OverlaySprite(-32,-SCREENHEIGHT/2,animspt+ANIM_OVERLAY,0);
		timetd(42-32,-SCREENHEIGHT/2+18,trackinfo.records.laprecord[selectedclass]);

//		GsSortOt(&TopOT[activebuff],&WorldOT[activebuff]);
		if (showback != 0)
			GsSortOt(&BackOT[activebuff],&OverlayOT[activebuff]);
		GsSortOt(&BotOT[activebuff],&WorldOT[activebuff]);


// Debug information
//		if ( checkcollide(players[0].object,players[1].object,object[players[0].object].x,object[players[0].object].y) != 0)
//			FntPrint("Crash\n");
//		FntPrint("Obj %d X%d Y%d Z%d\n",objediting,obj3d[objediting].origin.vx,obj3d[objediting].origin.vy,obj3d[objediting].origin.vz);
//		FntPrint("Screen %dX%d Y%d Z%d\n",screen3dobj,obj3d[screen3dobj].origin.vx,obj3d[screen3dobj].origin.vy,obj3d[screen3dobj].origin.vz);
//		FntPrint("Obj X%d Y%d Z%d\n",hlobj.origin.vx,hlobj.origin.vy,hlobj.origin.vz);
//		FntPrint("Camera X %d Y %d Z %d\n",cameraview.vpx,cameraview.vpy,cameraview.vpz);
//		FntPrint("Projection %d\n",projection);
//		FntPrint("RGB %d %d %d",tt_r,tt_g,tt_b);
		FntPrint("Hsyncs:%d\n",hcnt);		//print into stream
//		FntPrint("Map %d,%d\n",mapx,mapy);
//		FntPrint("X:%d\n",object[1].x);
//		FntPrint("Scrolly:%d",background[0].scrolly);
//		FntFlush(-1);				//flush all streams (displays text)


// Finish frame
		if (nighttime == 1)
		{
			RECT	r;			// headlight background area
			GsBOXF	bf;		// screen dimmer
			u_short	*hpt,drivern;
			DrawSync(0);		// Wait for the previous frame to finish drawing
			bf.x = -160;
			bf.y = -128;
			bf.w = 320;
			bf.h = 256;
			bf.r = bf.g = bf.b = tt_r;
			bf.attribute = tt_attr;
			r.w = 256;
			r.h = 256;
			drivern = 0;
// backup screen bits
			for (g=0;g<MAXDRIVERS;g++)
				if (driver[g].active != 0)
				{
					r.x = ((object[driver[g].object].x>>MYBITSHIFT)-(mapx>>MYBITSHIFT))+headlight[g].hox-128;		// adjust to fit onto map
					r.y = ((object[driver[g].object].y>>MYBITSHIFT)-(mapy>>MYBITSHIFT))+headlight[g].hoy-128;
					r.y += (activebuff)*256;
					MoveImage(&r, 640+(drivern%2)*256,256+((drivern>>1)%2)*128);		// copy screen to spare memory
//					FntPrint("%d,%d\n",640+(drivern%2)*128,256+((drivern>>1)%2)*128);
//					drivern++;
				}
// Dim screen (draw dark version)
			DrawSync(0);
			GsClearOt(0, 0, &TopOT[activebuff]);
//			GsSortClear(0,0,0,&TopOT[activebuff]);
//			background[0].r = background[0].g = background[0].b = 16;
//			GsSortFixBg16(&background[1], backgroundtopworkarea, &TopOT[activebuff], 3);
			GsSortBoxFill(&bf,&TopOT[activebuff],62);
//			background[0].r = background[0].g = background[0].b = 128;
			GsDrawOt(&TopOT[activebuff]);
			DrawSync(0);
// Overlay headlights
			drivern = 0;
			for (g=0;g<MAXDRIVERS;g++)
				if (driver[g].active != 0)
				{
					DrawSync(0);
					for (f=0;f<headlnprims;f++)
					{
						hpt = (u_short *)headlight[g].tmdpt;		// pointer to tmd
						hpt+=((headlpcpt+headlight[g].aoff+f)->offset)>>1;		// move to primitive
						hpt+=2;					// move to CBA V0 U0
						*hpt = ((headlpcpt+headlight[g].aoff+f)->uv0);
						*hpt+=(((drivern>>1)%2)*128)<<8;
						hpt++;
						hpt++;					// move to TSB V1 U1
						*hpt = ((headlpcpt+headlight[g].aoff+f)->uv1);
						*hpt+=(((drivern>>1)%2)*128)<<8;
						hpt++;
						*hpt = (26+(drivern%2)*2)|0x0100;				// Tpage + 15bit
						hpt++;
						*hpt = ((headlpcpt+headlight[g].aoff+f)->uv2);
						*hpt+=(((drivern>>1)%2)*128)<<8;
					}
					drivern++;
					DrawSync(0);
					GsClearOt(0, 0, &TopOT[activebuff]);
					UpdateHeadlightObjectCoordinates(&headlight[g]);
					DisplayHeadlightObject3D(&headlight[g]);
					GsDrawOt(&TopOT[activebuff]);
					DrawSync(0);
				}
					DrawSync(0);
			DisplayObjectOverlay(ghostdata.ghostobj,2);
			GsDrawOt(&OverlayOT[activebuff]);
		}
		else
			GsSortOt(&OverlayOT[activebuff],&WorldOT[activebuff]);
//		FntFlush(-1);
		DrawSync(0);
		hcnt = VSync(0);		// Wait for the V-Blank period
		GsSwapDispBuff();		// Swap screens
		if (trackinfo.type == 1)			// if 3D track
		{
			GsBOXF	box;
			box.attribute = tt_attr;
			box.x = -32; box.y = -80; box.w = 64; box.h = 64;
			box.r = tt_r ; box.g = tt_g; box.b = tt_b;
			GsSortClear(0,0,0,&WorldOT[activebuff]);
//			GsSortBoxFill(&box,&WorldOT[activebuff],30);
		}
		GsDrawOt(&WorldOT[activebuff]);			// Start drawing the OT
	}
//	printf("RACEMAIN QUIT\n");
	SsUtAllKeyOff(0);
	SsSeqStop(musicseq);
	backlobj.origin.vx = -2870;
	backlobj.origin.vy = -1974;
	backrobj.origin.vx = 2894;
	backrobj.origin.vy = -1974;
	backlobj.rotate.vy = 2048;
	backrobj.rotate.vy = 2048;
	backlobj.rotate.vz = 0;
	backrobj.rotate.vz = 0;
}









void testcontrol(u_long obj)
{
	playerdata	*player;
	u_short	stdpad;

	player = &(players[object[obj].extra->playerindex]);
	stdpad = player->paddata[1];				// get standard pad data
	if (stdpad & PADLright)
		object[obj].x+=(1<<MYBITSHIFT);
	if (stdpad & PADLleft)
		object[obj].x-=(1<<MYBITSHIFT);
	if (stdpad & PADLup)
		object[obj].y-=(1<<MYBITSHIFT);
	if (stdpad & PADLdown)
		object[obj].y+=(1<<MYBITSHIFT);
	if (stdpad & PADRleft)
	{
		object[obj].frame-=(1<<8);
		if (object[obj].frame>60000)
			object[obj].frame = (31<<8);
	}
	if (stdpad & PADRright)
	{
		object[obj].frame+=(1<<8);
		if (object[obj].frame>(31<<8))
			object[obj].frame = 0;
	}
}

void testcollision()
{
	int		f,g,QUIT_FLAG;
	u_long	obj,obj1,obj2;
	GsBOXF	box;

// Initialize OT
	for (f=0;f<2;f++)
	{
		WorldOT[f].length = OT_LENGTH;	// Very important this, don't forget it
		WorldOT[f].org = OTTags[f];	// it initialises the OT
	}

// Set up text area
	FntLoad(960,256);		// Load standard 256x128 font pattern to the frame buffer at coords specified
	FntOpen(16-SCREENWIDTH/2,16-SCREENHEIGHT/2,256,200,0,512);	// Setup a text window. x,y,w,h,isbg,n where x,y is coords in frame buffer
					// w,h are width and height. isbg is 0 for background clear/1 no clear, n = number of letters

// Put sprite graphics in frame buffer
	Initializeframes();

// Clear all objects
	InitializeObjects();

	obj=spawn();
	newplayer(obj);
	object[obj].extra->controller = 0;
	object[obj].control = testcontrol;
	object[obj].extra->playerindex = 0;
	obj1 = obj;

	obj=spawn();
	newplayer(obj);
	object[obj].extra->controller = 1;
	object[obj].control = testcontrol;
	object[obj].extra->playerindex = 1;
	object[obj].x+=(16<<MYBITSHIFT);
	object[obj].y+=(16<<MYBITSHIFT);
	object[obj].cy = 243;
	obj2 = obj;


	QUIT_FLAG = 0;
	while (QUIT_FLAG == 0)
	{
// Clear up display data
		activebuff = GsGetActiveBuff();		//Get buffer we can use
		GsSetWorkBase((PACKET *)GpuPacketArea[activebuff]);	// Tell the system where the packet buffer is
		GsClearOt(0, 0, &WorldOT[activebuff]);			// Clear the Ordering Table

// Read Controller 
		for (f=0;f<2;f++)
			ReadController(players[f].pad, players[f].paddata);
		if (players[0].paddata[1] & PADselect)
			QUIT_FLAG = 1;

		cdebug = 0;
		if (players[0].paddata[1] & PADL1)
			cdebug = 1;

		mapx = 0;
		mapy = 0;

// Handle Objects
		ObjectHandler();

		if (checkcollide16(obj1,obj2,object[obj1].x,object[obj1].y)!= 0)
			FntPrint("HIT\n");
		else
			FntPrint("MISS\n");

		for (g=0;g<16;g++)
			for (f=0;f<16;f++)
			{
				box.attribute = 0;
				box.x = f*4-100;
				box.y = g*4-64;
				box.w = 4;
				box.h = 4;
				box.r = 0;
				if ( (((*(cdebuglpt+g))<<f)&0x8000) == 0x8000)
					box.r = 128;
				box.g = box.r;
				box.b = box.g;
				GsSortBoxFill(&box,&WorldOT[activebuff],0);
			}

		for (g=0;g<16;g++)
			for (f=0;f<16;f++)
			{
				box.attribute = 0;
				box.x = f*4-100;
				box.y = g*4;
				box.w = 4;
				box.h = 4;
				box.r = 0;
				if ( (((*(cdebugrpt+g))<<f)&0x8000) == 0x8000)
					box.r = 128;
				box.g = box.r;
				box.b = box.g;
				GsSortBoxFill(&box,&WorldOT[activebuff],0);
			}


		FntPrint("Offset %x, frame %d\n",object[obj1].base_sprite->offset,object[obj1].frame>>8);
		FntPrint("X:%d,Y:%d\n",object[obj1].x>>MYBITSHIFT,object[obj1].y>>MYBITSHIFT);
		FntFlush(-1);
		DrawSync(0);		// Wait for the previous frame to finish drawing
		VSync(0);		// Wait for the V-Blank period
		GsSwapDispBuff();		// Swap screens
		GsSortClear(60,120,120,&WorldOT[activebuff]);
		GsDrawOt(&WorldOT[activebuff]);			// Start drawing the OT

	}

}










void updateghostdata()
{	// updates ghost data, including replay data (CALLED EVERY FRAME)
	short		entry;
	u_long	obj,dx,dy;
	if (ghostdata.active == 0)
		return;
	obj = ghostdata.obj;
	dx = (object[obj].x>>MYBITSHIFT)-(ghostdata.cucurrent.x);
	dy = (object[obj].y>>MYBITSHIFT)-(ghostdata.cucurrent.y);
	ghostdata.cucurrent.x = object[obj].x>>MYBITSHIFT;
	ghostdata.cucurrent.y = object[obj].y>>MYBITSHIFT;
	entry = ((dx+16)&31)|(((dy+16)&31)<<5)|((long)((object[obj].angle>>MYBITSHIFT)/11.25)<<10);
	ghostdata.lap[ghostdata.current][ghostdata.index] = entry;
	entry = ghostdata.lap[ghostdata.out][ghostdata.index];		// get output entry
	if (entry < 0)									// if end of lap
		ghostdata.outdisp = 0;
	if (ghostdata.outdisp==1)							// if not at end of lap
	{
		ghostdata.x+=(entry&31)-16;
		ghostdata.y+=((entry>>5)&31)-16;
		ghostdata.angle = (entry>>10)&31;
	}
	ghostdata.index++;
	if (ghostdata.index>=(MAXGHOSTENTRIES-2))
		ghostdata.index = MAXGHOSTENTRIES-2;
}

void initializeghostdata()
{
	ghostdata.current = 0;
	ghostdata.previous = 1;
	ghostdata.best = 2;
	ghostdata.active = 0;
}

void startghostdata(u_long obj)
{	// re-starts ghost data on input object obj
	// makes output the previous or best lap
	short	tmp;
	ghostdata.active = 0;						// temporarily disable
	ghostdata.lap[ghostdata.current][ghostdata.index] = -1;		// siginify end of lap
	ghostdata.index = 0;						// restart time
	ghostdata.obj = obj;						// input object
	ghostdata.stprevious.x = ghostdata.stcurrent.x;
	ghostdata.stprevious.y = ghostdata.stcurrent.y;
	ghostdata.cucurrent.x = object[obj].x>>MYBITSHIFT;	// current & start coordinates
	ghostdata.cucurrent.y = object[obj].y>>MYBITSHIFT;
	ghostdata.stcurrent.x = ghostdata.cucurrent.x;
	ghostdata.stcurrent.y = ghostdata.cucurrent.y;
	tmp = ghostdata.current;					// swap current and previous
	ghostdata.current = ghostdata.previous;
	ghostdata.previous = tmp;
	{
	ghostdata.out = ghostdata.best;				// new output
	ghostdata.x = ghostdata.stbest.x;			// output start coordinates
	ghostdata.y = ghostdata.stbest.y;
	}
//	{
//	ghostdata.out = ghostdata.previous;				// new output
//	ghostdata.x = ghostdata.stprevious.x;			// output start coordinates
//	ghostdata.y = ghostdata.stprevious.y;
//	}
	ghostdata.outdisp = 1;
	ghostdata.active = 1;						// start it up again
}

void ghostdatabestlap()
{	// copies current to best
	short f;
	short	p,b,l;
	ghostdata.lap[ghostdata.current][ghostdata.index] = -1;		// siginify end of lap
	b = ghostdata.best;
	p = ghostdata.current;
	l = (MAXGHOSTENTRIES-1);
	for (f=0;f<l;f++)
		ghostdata.lap[b][f] = ghostdata.lap[p][f];
	ghostdata.stbest = ghostdata.stcurrent;
}

void ghostcontrol(u_long obj)
{	// object control function for ghost car
	object[obj].x = ghostdata.x<<MYBITSHIFT;
	object[obj].y = ghostdata.y<<MYBITSHIFT;
	object[obj].angle = (long)(ghostdata.angle*11.25)<<MYBITSHIFT;
	object[obj].frame = ghostdata.angle<<8;
}

void laprecord(playerdata *player)
{	// performs lap record bit for player (called when breaks lap record)
// quick & dirty bodge
	laprecordactive = 100;
	laprecorddx = -100;
	laprecorddy = -80;
	if (player == &players[1])
		laprecorddx = 100;
	laprecordholder = player;
}


void ReadController(u_char pad, u_short *dest)
{ // pad is 0 for left, 1 for right. Dest is pointer to 8 bytes where info should go
	// reading from dest->paddata[1] gives standard pad readout (if dest is type playerdata)
	u_long	*pt;
	u_char	tmp;
	if (pad == 0)
		pt = (u_long *) bb0;
	else if (pad == 1)
		pt = (u_long *) bb1;
	*((u_long *)dest) = *pt;			// 1st 4 bytes
	*(((u_long *)dest)+1) = *(pt+1);		// 2nd 4 bytes
	*(((u_short *)dest)+1)=~(*(((u_short *)dest)+1));		// invert std controller
	tmp = *(((u_char *)dest)+2);
	*(((u_char *)dest)+2) = *(((u_char *)dest)+3);
	*(((u_char *)dest)+3) = tmp;
}

/* Controller state reading */
static u_long PadRead(void)
{
	return(~(*(bb0+3) | *(bb0+2) << 8 | *(bb1+3) << 16 | *(bb1+2) << 24));
}

void create3dobject(u_long obj,int index)
{
	u_long *testpt;
	testpt = (u_long *) getpakaddress(index);
	obj3d[obj].origin.vx = 664;
	obj3d[obj].origin.vy = 646;
	obj3d[obj].origin.vz = 160;
	obj3d[obj].rotate.vx = 0;
	obj3d[obj].rotate.vy = 0;
	obj3d[obj].rotate.vz = 0;
	GsInitCoordinate2(WORLD, &(obj3d[obj].coord));
	obj3d[obj].handler.coord2 = &(obj3d[obj].coord);
	testpt++;							// skip header ID
	GsMapModelingData(testpt);
	testpt+=2;							// skip past rest of header
	GsLinkObject4( (u_long)testpt, &(obj3d[obj].handler), 0);
	obj3d[obj].handler.attribute = 0x00000000;
	obj3d[obj].active = 1;
	obj3d[obj].ot = 1;				// below track
	UpdateObjectCoordinates(&obj3d[obj]);
}

void UpdateObjectCoordinates(object3d *objpt)
{
	MATRIX	tmp;
	tmp.t[0] = objpt->origin.vx;
	tmp.t[1] = objpt->origin.vy;
	tmp.t[2] = objpt->origin.vz;
	RotMatrix(&(objpt->rotate), &tmp);
	objpt->coord.coord = tmp;
	objpt->coord.flg = 0;
}

void DisplayObject3D(object3d *objpt)
{
	MATRIX	tmp;
	GsGetLs(&(objpt->coord), &tmp);
	GsSetLightMatrix(&tmp);
	GsSetLsMatrix(&tmp);
//	GsSortObject4( &(objpt->handler), &WorldOT[activebuff], 14-OT_LENGTH, getScratchAddr(0));
	if (objpt->ot == 0)
		GsSortObject4( &(objpt->handler), &TopOT[activebuff], 14-TOPOT_LENGTH, getScratchAddr(0));
	else if (objpt->ot == 1)
		GsSortObject4( &(objpt->handler), &BotOT[activebuff], 14-BOTOT_LENGTH, getScratchAddr(0));
	else if (objpt->ot == 2)
		GsSortObject4( &(objpt->handler), &BackOT[activebuff], 14-BACKOT_LENGTH, getScratchAddr(0));
}

void UpdateHeadlightObjectCoordinates(headlight3D *objpt)
{
	MATRIX	tmp;
	tmp.t[0] = objpt->origin.vx;
	tmp.t[1] = objpt->origin.vy;
	tmp.t[2] = objpt->origin.vz;
	RotMatrix(&(objpt->rotate), &tmp);
	objpt->coord.coord = tmp;
	objpt->coord.flg = 0;
}

void DisplayHeadlightObject3D(headlight3D *objpt)
{
	MATRIX	tmp;
	GsGetLs(&(objpt->coord), &tmp);
	GsSetLightMatrix(&tmp);
	GsSetLsMatrix(&tmp);
	if (objpt->ot == 0)
		GsSortObject4( &(objpt->handler), &TopOT[activebuff], 14-TOPOT_LENGTH, getScratchAddr(0));
	else
		GsSortObject4( &(objpt->handler), &BotOT[activebuff], 14-BOTOT_LENGTH, getScratchAddr(0));
}

void nullcontrol(u_long obj)
{
}

void playerexplode(u_long obj)
{

	if (object[obj].frame < 1792)
	{
		object[obj].frame += 64;
	}
	else
	{
		players[object[obj].extra->playerindex].active = 0;
		kill (obj);
	}

}

void hurt(u_long obj, long damage)
{	//Give damage to object
	object[obj].health -= damage;
	if (object[obj].class == 1)
		players[object[obj].extra->playerindex].fuel -= 16<<MYBITSHIFT;
}

void explosioncontrol(u_long obj)
{
	object[obj].frame+=96;
	if (object[obj].frame >= (10<<8) )
		kill(obj);
}

void makeexplosion(long x,long y)
{
	u_long	obj;
	obj = spawn();
	object[obj].x = x;
	object[obj].y = y;
	object[obj].class = 0;
	object[obj].pri = OTPRI_SMOKE;
	object[obj].base_sprite = animspt + ANIM_EXPLO1;
	object[obj].frame = 0;
	object[obj].control = explosioncontrol;
	object[obj].hx = 8;
	object[obj].hy = 8;
	object[obj].maxx = 16;
	object[obj].maxy = 16;
	boom();
}

void dustcontrol(u_long obj)
{
	object[obj].frame+=8;
	object[obj].r-=2;
	object[obj].g=object[obj].r>>1;
	if (object[obj].r<=4)
		kill(obj);
	object[obj].x+=object[obj].dx;
	object[obj].y+=object[obj].dy;
}

void makedust(long x,long y,u_long owner)
{
	u_long	obj;
	long		ang,dx,dy,rdx,rdy;
	ang = (object[owner].angle>>MYBITSHIFT)/11.25;
	dx = ((veltabpt+((ang+8)%32))->dx)<<1;
	dy = ((veltabpt+((ang+8)%32))->dy)<<1;
	rdx = ((veltabpt+((ang+16)%32))->dx)<<2;
	rdy = ((veltabpt+((ang+16)%32))->dy)<<2;
	obj = spawn();
	object[obj].x = x+dx+rdx;
	object[obj].y = y+dy+rdy;
	object[obj].dx = dx>>3;
	object[obj].dy = dy>>3;
	object[obj].class = 4;
	object[obj].r = 140;
	object[obj].g = 80;
	object[obj].b = 0;
	object[obj].pri = OTPRI_MINES;
	object[obj].base_sprite = animspt + ANIM_DUSTCLOUD;
	object[obj].frame = (((x+y)&3)<<1)<<8;
	object[obj].control = dustcontrol;
	object[obj].hx = 8;
	object[obj].hy = 8;

	obj = spawn();
	object[obj].x = x-dx+rdx;
	object[obj].y = y-dy+rdy;
	object[obj].dx = -dx>>3;
	object[obj].dy = -dy>>3;
	object[obj].class = 4;
	object[obj].r = 140;
	object[obj].g = 80;
	object[obj].b = 0;
	object[obj].pri = OTPRI_MINES;
	object[obj].base_sprite = animspt + ANIM_DUSTCLOUD;
	object[obj].frame = 0;//+((x+y)&1)<<8;
	object[obj].control = dustcontrol;
	object[obj].hx = 8;
	object[obj].hy = 8;

}

void smokecontrol(u_long obj)
{
//	object[obj].frame += 16;
	object[obj].bright-=1;
	object[obj].x += object[obj].dx>>2;
	object[obj].y += object[obj].dy>>2;
	if (object[obj].bright <= 64 )
	{
		kill(obj);
	}
}

void makesmoke(long x,long y,u_long obj)
{
	u_long	shot;
	long		ang;

	shot = spawn();
	makeshot(shot,x,y,obj,OTPRI_SMOKE);
	object[shot].class = 128+INV_SMOKESCREEN;
	object[shot].base_sprite = animspt + ANIM_SMOKE;
	object[shot].frame = 0;
	object[shot].control = smokecontrol;
	object[shot].dx = 0;
	object[shot].dy = 0;
	ang = (object[obj].angle>>MYBITSHIFT)/11.25;
	shot = spawn();
	makeshot(shot,x,y,obj,OTPRI_SMOKE);
	object[shot].class = 128+INV_SMOKESCREEN;
	object[shot].base_sprite = animspt + ANIM_SMOKE;
	object[shot].frame = 0;
	object[shot].control = smokecontrol;
	object[shot].dx = ((veltabpt+((ang+8)%32))->dx);
	object[shot].dy = ((veltabpt+((ang+8)%32))->dy);
	shot = spawn();
	makeshot(shot,x,y,obj,OTPRI_SMOKE);
	object[shot].class = 128+INV_SMOKESCREEN;
	object[shot].base_sprite = animspt + ANIM_SMOKE;
	object[shot].frame = 0;
	object[shot].control = smokecontrol;
	object[shot].dx = ((veltabpt+((ang-8)&31))->dx);
	object[shot].dy = ((veltabpt+((ang-8)&31))->dy);
}


void minecontrol(u_long obj)
{
	int f;
	u_long	dobj;

	if (object[obj].time > (FPS*120) )	// die after a short time
	{
		object[object[obj].owner].minecount--;
		kill(obj);
		return;
	}
	if (object[obj].time < 2)
		return;				// some time before it activates
	for (f=0;f<MAXDRIVERS;f++)
		if (driver[f].active != 0)
			if ( checkcollide16(obj,driver[f].object,object[obj].x,object[obj].y) != 0)
			{
				dobj = driver[f].object;
				hurt(dobj,25);
				object[dobj].dx = (object[dobj].x-object[obj].x)<<2;		// make other recoil in explosion
				object[dobj].dy = (object[dobj].y-object[obj].y)<<2;
//				object[dobj].momdx = object[dobj].dx;
//				object[dobj].momdy = object[dobj].momdy;
				object[dobj].momdx = -object[dobj].momdx;
				object[dobj].momdy = -object[dobj].momdy;
				object[dobj].speed/=3;
				makeexplosion(object[obj].x,object[obj].y);
				object[object[obj].owner].minecount--;
				kill(obj);
				return;
			}
}

void dropmine(long x,long y,u_long obj)
{
	u_long	shot;
	shot = spawn();
	makeshot(shot, x, y, obj,OTPRI_MINES);
	object[shot].class = 128+INV_MINE;
	object[shot].control = minecontrol;
}

void oilcontrol(u_long obj)
{
	int f;
	u_long	dobj;

	if (object[obj].time > (FPS*120) )	// die after a short time
	{
		kill(obj);
	}
	if (object[obj].time < 1)
		return;				// some time before it activates
	for (f=0;f<MAXDRIVERS;f++)
		if (driver[f].active != 0)
			if ( checkcollide16(obj,driver[f].object,object[obj].x,object[obj].y) != 0)
			{
				dobj = driver[f].object;
				object[dobj].effects = object[dobj].effects|1;
				object[obj].health--;
				if (object[obj].health<2)
					kill(obj);
			}
}


void dropoil(long x,long y,u_long obj)
{
	u_long	shot;
	shot = spawn();
	makeshot(shot, x, y, obj,OTPRI_MINES);
	object[shot].class = 128+INV_OIL;
	object[shot].control = oilcontrol;
	object[shot].health = 30;
	object[shot].frame = 3<<8;
}


void missilecontrol(u_long obj)
{
	int f;
	u_long	dobj;
	u_char	col;

	// check if hit car
	for (f=0;f<MAXDRIVERS;f++)
		if (driver[f].active != 0)
			if (driver[f].object != object[obj].owner)			/// make sure not hit owner
				if ( checkcollide16(obj,driver[f].object,object[obj].x,object[obj].y) != 0)
				{
					dobj = driver[f].object;
					hurt(dobj,25);
//					object[dobj].dx = (object[dobj].x-object[obj].x)<<2;		// make other recoil in explosion
//					object[dobj].dy = (object[dobj].y-object[obj].y)<<2;
//					object[dobj].momdx = object[dobj].dx;
//					object[dobj].momdy = object[dobj].momdy;
					object[dobj].dx = object[obj].dx<<3;
					object[dobj].dy = object[obj].dy<<3;
					object[dobj].momdx = object[obj].dx<<2;
					object[dobj].momdy = object[obj].dy<<2;
					object[dobj].speed/=3;
					object[dobj].spin = 20;
					makeexplosion(object[obj].x,object[obj].y);
					object[object[obj].owner].missilecount--;
					kill(obj);
					return;
				}
	// check if hit wall
	col = *(colmappt + (object[obj].x>>MYBITSHIFT)/8 + ((object[obj].y>>MYBITSHIFT)/8)*(mapwidth/8));
	if ( (col&3) != 0)
	{
		makeexplosion(object[obj].x,object[obj].y);
		object[object[obj].owner].missilecount--;
		kill(obj);
		return;
	}

//	if (object[obj].time > 3)
//	{
//	object[obj].time = 0;
//	dobj = spawn();
//	makeshot(dobj,object[obj].x,object[obj].y,obj,OTPRI_SMOKE);
//	object[dobj].class = 128+INV_SMOKESCREEN;
//	object[dobj].base_sprite = animspt + ANIM_SMOKE;
//	object[dobj].frame = 0;
//	object[dobj].control = smokecontrol;
//	object[dobj].dx = 0;
//	object[dobj].dy = 0;
//	}

	object[obj].frame+=32;
	if (object[obj].frame>=(3<<8))
		object[obj].frame=1<<8;

	object[obj].x+=object[obj].dx;
	object[obj].y+=object[obj].dy;
	if ( (object[obj].x<0) || (object[obj].x>(mapwidth<<MYBITSHIFT)) )
	{
		object[object[obj].owner].missilecount--;
		kill(obj);
		return;
	}
	if ( (object[obj].y<0) || (object[obj].y>(mapheight<<MYBITSHIFT)) )
	{
		object[object[obj].owner].missilecount--;
		kill(obj);
		return;
	}
}

void firemissile(long x,long y, long dx, long dy,u_long obj)
{
	u_long	shot;
	shot = spawn();
	makeshot(shot, x, y, obj, OTPRI_MISSILES);
	object[shot].dx = dx;
	object[shot].dy = dy;
	object[shot].class = 128+INV_MISSILE;
	object[shot].spritetype = 0;
	object[shot].frame = 1<<8;
	object[shot].control = missilecontrol;
	object[shot].angle = object[obj].angle;
}

void imissilecontrol(u_long obj)
{
	int f;
	u_long	dobj,mapoffset;
	u_char	col,chk,dir;
	u_short	frameang;
	long		idealangle;

	// check if hit car
	for (f=0;f<MAXDRIVERS;f++)
		if (driver[f].active != 0)
			if ( (driver[f].object != object[obj].owner) || ( (driver[f].object == object[obj].owner) && (object[obj].time>25) ) )			/// make sure not hit owner during first few frames
				if ( checkcollide16(obj,driver[f].object,object[obj].x,object[obj].y) != 0)
				{
					dobj = driver[f].object;
					hurt(dobj,25);
//					object[dobj].dx = (object[dobj].x-object[obj].x)<<2;		// make other recoil in explosion
//					object[dobj].dy = (object[dobj].y-object[obj].y)<<2;
//					object[dobj].momdx = object[dobj].dx;
//					object[dobj].momdy = object[dobj].momdy;
					object[dobj].dx = object[obj].dx<<3;
					object[dobj].dy = object[obj].dy<<3;
					object[dobj].momdx = object[obj].dx<<2;
					object[dobj].momdy = object[obj].dy<<2;
					object[dobj].speed/=3;
					object[dobj].spin = 20;
					makeexplosion(object[obj].x,object[obj].y);
					object[object[obj].owner].missilecount--;
					kill(obj);
					return;
				}
	mapoffset = ((object[obj].x>>MYBITSHIFT)>>3) + ((object[obj].y>>MYBITSHIFT)>>3)*(mapwidth>>3);
	// check if hit wall
	col = *(colmappt + mapoffset);
	if ( (col&3) != 0)
	{
		makeexplosion(object[obj].x,object[obj].y);
		object[object[obj].owner].missilecount--;
		kill(obj);
		return;
	}

	if (object[obj].time > FPS*16)			// die after a while
	{
		makeexplosion(object[obj].x,object[obj].y);
		object[object[obj].owner].missilecount--;
		kill(obj);
		return;
	}

//	if ((object[obj].time&3) == 0)
//	{
//	object[obj].time = 0;
//	dobj = spawn();
//	makeshot(dobj,object[obj].x,object[obj].y,obj,OTPRI_SMOKE);
//	object[dobj].class = 128+INV_SMOKESCREEN;
//	object[dobj].base_sprite = animspt + ANIM_SMOKE;
//	object[dobj].frame = 0;
//	object[dobj].control = smokecontrol;
//	object[dobj].dx = 0;
//	object[dobj].dy = 0;
//	}

// rotate missile
	chk = *(chkmappt+ ((object[obj].x>>MYBITSHIFT)>>4) + ((object[obj].y>>MYBITSHIFT)>>4)*(mapwidth>>4) );
	if (chk != 0)
		object[obj].lastchkpoint = chk;	// last checkpoint visited

	dir = (*(cpudirmappt + mapoffset));

	if ( (dir&64) != 0)				// if ideal dir is valid
	{
		if (object[obj].lastchkpoint&1 == 1)
			dir = dir&7;				// odd cpu dir
		else
			dir = (dir>>3)&7;				// even cpu dir
		idealangle = (dir*45)<<MYBITSHIFT;
		if ( abs(idealangle-object[obj].angle) < 46080)		// 46080 = 180<<MYBITSHIFT (if 8 bitshift)
		{
			if (idealangle>object[obj].angle)
				object[obj].angle+=2048;
			else if (idealangle<object[obj].angle)
				object[obj].angle-=2048;
		}
		else
		{
			if (idealangle>object[obj].angle)
				object[obj].angle-=2048;
			else if (idealangle<object[obj].angle)
				object[obj].angle+=2048;
		}

		if (object[obj].angle<0)
			object[obj].angle+=92160;			// 360<<8
		if (object[obj].angle>=92160)
			object[obj].angle-=92160;
	}

// move missile forward
	frameang = (object[obj].angle>>MYBITSHIFT)/11.25;
	object[obj].speed = 360;
	object[obj].dx = (((veltabpt+frameang)->dx)*object[obj].speed)>>6;
	object[obj].dy = (((veltabpt+frameang)->dy)*object[obj].speed)>>6;

// animate
	object[obj].frame+=32;
	if (object[obj].frame>=(3<<8))
		object[obj].frame=1<<8;

// update
	object[obj].x+=object[obj].dx;
	object[obj].y+=object[obj].dy;
	if ( (object[obj].x<0) || (object[obj].x>(mapwidth<<MYBITSHIFT)) )
	{
		kill(obj);
		object[object[obj].owner].missilecount--;
		return;
	}
	if ( (object[obj].y<0) || (object[obj].y>(mapheight<<MYBITSHIFT)) )
	{
		kill(obj);
		object[object[obj].owner].missilecount--;
		return;
	}
}


void fireimissile(long x,long y, long dx, long dy,u_long obj)
{
	u_long	shot;
	shot = spawn();
	makeshot(shot, x, y, obj, OTPRI_MISSILES);
	object[shot].dx = dx;
	object[shot].dy = dy;
	object[shot].class = 128+INV_IMISSILE;
	object[shot].spritetype = 0;
	object[shot].frame = 1<<8;
	object[shot].control = imissilecontrol;
	object[shot].angle = object[obj].angle;
}


void playerfire(u_char trigger, u_long obj)
{// controls weapons firing. trigger is inventory item
	u_long	shot;
	long		x,y,angle,dx,dy;

	if (object[obj].class == 1)		// if human
		if (players[object[obj].extra->playerindex].inventory[trigger] == 0)	// if no ammo
			return;
	x = object[obj].x;
	y = object[obj].y;
//	angle = ((long)((object[obj].angle>>MYBITSHIFT)/11.25)+16)%32;
	angle = (long )((object[obj].angle>>MYBITSHIFT)/11.25);
	dx = ((veltabpt+angle)->dx);
	dy = ((veltabpt+angle)->dy);		// get coordinates at rear of car
	if (object[obj].shottime == 0)
	{
	switch (trigger)
	{
		case	INV_CANNON:
		{
//			firecannon(x+dx*16,y+dy*16,obj);
			players[object[obj].extra->playerindex].inventory[trigger]-=1;
			break;
		}
		case	INV_SMOKESCREEN:
		{
			players[object[obj].extra->playerindex].inventory[trigger]-=1;
			makesmoke(x-dx*16,y-dy*16,obj);
			object[obj].shottime = 3;
			break;
		}
		case	INV_OIL:
		{
			players[object[obj].extra->playerindex].inventory[trigger]-=1;
			dropoil(x-dx*14,y-dy*14,obj);
			object[obj].shottime = 4;
			break;
		}
		case	INV_MISSILE:
		{
			if (object[obj].missilecount < MAXMISSILECOUNT)
			{
				players[object[obj].extra->playerindex].inventory[trigger]-=1;
				firemissile(x+dx*4,y+dy*4,dx*8,dy*8,obj);
				object[obj].shottime = FPS/2;
				object[obj].missilecount++;
			}
			break;
		}
		case	INV_IMISSILE:
		{
			if (object[obj].missilecount < MAXMISSILECOUNT)
			{
				players[object[obj].extra->playerindex].inventory[trigger]-=1;
				fireimissile(x+dx*4,y+dy*4,dx*4,dy*4,obj);
				object[obj].shottime = FPS/2;
				object[obj].missilecount++;
			}
			break;
		}
		case	INV_MINE:
		{
			if (object[obj].minecount < MAXMINECOUNT)
			{
				players[object[obj].extra->playerindex].inventory[trigger]-=1;
				dropmine(x-dx*14,y-dy*14,obj);
				object[obj].shottime = FPS/4;
				object[obj].minecount++;
			}
			break;
		}
		case	INV_TURBO:
		{
			players[object[obj].extra->playerindex].inventory[trigger]-=1;
			object[obj].effects = object[obj].effects | 2;
			if ( (players[object[obj].extra->playerindex].inventory[trigger] & 7) > 5)
				makesmoke(x-dx*16,y-dy*16,obj);
			break;
		}
	}
	}
}

void followcontrol(u_long obj)
{	// player control when being zipped to another player
	long dx,dy,collide,newx,newy,frameang,frameadj;
	int f;
	dx=(object[obj].followx-object[obj].x)>>3;
	dy=(object[obj].followy-object[obj].y)>>3;
	object[obj].x+=dx;
	object[obj].y+=dy;
	frameang = (object[obj].angle>>MYBITSHIFT)/11.25;	// angle of car (0-32 as 0-360)
	frameadj = frameang;
	if (abs(dx) < 300 && abs(dy) < 300)					// if reached destination
	{
		collide = 0;
		newx = object[obj].x;
		newy = object[obj].y;
		for (f=0;f<MAXDRIVERS;f++)			// check can drop
			if (driver[f].active != 0)
				if (driver[f].object != obj)
					if (checkcollide16(obj,driver[f].object,newx,newy) != 0)
						collide++;
		if (collide == 0)		// if no collisions
		{
			object[obj].followactive = 0;
			object[obj].control = playercontrol;
			checkchangeposition(obj);
		}
	}
	object[obj].frame = 0 + frameadj<<8;
	players[object[obj].extra->playerindex].fuel-=512;
}

void playercontrol(u_long obj)
{
// Player control function called from object
	u_short	stdpad;
	u_long	shot,dobj;
	int		frameang,frameangperp;
	int		f;
	long frameadj;
	long		newx,newy,oldangle;
	u_long	offset;
	u_char	col,chk;
	short		usespeed;
	playerdata	*player;

	player = &(players[object[obj].extra->playerindex]);

	if (object[obj].shottime > 0)
		object[obj].shottime--;

	newx = object[obj].x + (object[obj].dx>>4);
	newy = object[obj].y + (object[obj].dy>>4);
	oldangle = object[obj].angle;
	object[obj].angle = object[obj].angle + (object[obj].dangle);
	if (object[obj].angle<0)
		object[obj].angle+=360<<MYBITSHIFT;
	else if (object[obj].angle>=(360<<MYBITSHIFT))
		object[obj].angle-=360<<MYBITSHIFT;
	frameang = (object[obj].angle>>MYBITSHIFT)/11.25;	// angle of car (0-32 as 0-360)
	object[obj].frame = frameang<<8;
// check if going to hit another car
	for (f=0;f<MAXDRIVERS;f++)
		if (driver[f].active != 0)
			if (driver[f].object != obj)
				if (checkcollide16(obj,driver[f].object,newx,newy) != 0)
				{
					if (object[driver[f].object].followactive == 0)
					{
						dobj = driver[f].object;
						object[dobj].momdx = object[obj].dx/1.2; //momdx/2 //+object[obj].dx;
						object[dobj].momdy = object[obj].dy/1.2; //+object[obj].dy;
						object[obj].momdx = -object[obj].momdx/2;
						object[obj].momdy = -object[obj].momdy/2;
						object[obj].dx = -object[obj].dx/2;
						object[obj].dy = -object[obj].dy/2;
						if (object[obj].dy >= 0 && object[dobj].dy >= 0)	// if both dy in same direction (+ve)
							if (object[obj].y > object[dobj].y)	// if obj ahead
							{
								object[obj].dy = (object[obj].dy+16)*1.5;	// object in front gets boost
								object[dobj].dy = 0;		// object behind suffers
								object[dobj].speed/=2;
							}
							else
							{
								object[dobj].dy = (object[dobj].dy+16)*1.5;
								object[obj].dy = 0;		// object behind suffers
								object[obj].speed/=2;
							}
						if (object[obj].dy < 0 && object[dobj].dy < 0)	// if both dy in same direction (-ve)
							if (object[obj].y < object[dobj].y)	// if obj ahead
							{
								object[obj].dy = (object[obj].dy-16)*1.5;
								object[dobj].dy = 0;		// object behind suffers
								object[dobj].speed/=2;
							}
							else
							{
								object[dobj].dy = (object[dobj].dy-16)*1.5;
								object[obj].dy = 0;		// object behind suffers
								object[obj].speed/=2;
							}
						if (object[obj].dx >= 0 && object[dobj].dx >= 0)	// if both dx in same direction (+ve)
							if (object[obj].x > object[dobj].x)	// if obj ahead
							{
								object[obj].dx = (object[obj].dx+16)*1.5;
								object[dobj].dx = 0;		// object behind suffers
								object[dobj].speed/=2;
							}
							else
							{
								object[dobj].dx = (object[dobj].dx+16)*1.5;
								object[obj].dx = 0;		// object behind suffers
								object[obj].speed/=2;
							}
						if (object[obj].dx < 0 && object[dobj].dx < 0)	// if both dx in same direction (-ve)
							if (object[obj].x < object[dobj].x)	// if obj ahead
							{
								object[obj].dx = (object[obj].dx-16)*1.5;
								object[dobj].dx = 0;		// object behind suffers
								object[dobj].speed/=2;
							}
							else
							{
								object[dobj].dx = (object[dobj].dx-16)*1.5;
								object[obj].dx = 0;		// object behind suffers
								object[obj].speed/=2;
							}
//						FntPrint("BANG %d\n",obj);
						prang();
						newx = object[obj].x;				// put car back to old coords and angle
						newy = object[obj].y;
						object[obj].angle = oldangle;
					}
				}

// check if going to hit wall
	offset = (newx>>MYBITSHIFT)/8 + ((newy>>MYBITSHIFT)/8)*(mapwidth/8);	// get collision data under car's next coordinates
	col = *(colmappt + offset);
	col = checktrackcollision16(obj,newx,newy);
	if (col!=0)
	{
//		FntPrint("Col:%d %d,%d = %d,%d\n",col,newx,newy,(newx>>MYBITSHIFT)/8,((newy>>MYBITSHIFT)/8)*(mapwidth/8) );
		if ( (col&3) != 0 )		// if hit something solid
		{
			newx = object[obj].x;	// put car back
			newy = object[obj].y;
			object[obj].angle = oldangle;
			object[obj].momdx/= 2;	// reduce momentum
			object[obj].momdy/= 2;
			object[obj].speed/=1.5;
		}
		if ( (col&1) != 0)			// hit horiz wall
		{
			object[obj].dy = -object[obj].dy;
			object[obj].momdy = -object[obj].momdy;
		}
		if ( (col&2) != 0)			// hit vert wall
		{
			object[obj].dx = -object[obj].dx;
			object[obj].momdx = -object[obj].momdx;
		}
	}

	object[obj].x = newx;
	object[obj].y = newy;

/*
	if (object[obj].health<=0)
	{
		object[obj].dead_flag = DEAD_DYING;
		object[obj].base_sprite = animspt + 4;
		object[obj].frame = 0;
		object[obj].dx = 0;
		object[obj].dy = 0;
		object[obj].health = 0;
		object[obj].control = playerexplode;
	}
*/

	chk = *(chkmappt+ ((object[obj].x>>MYBITSHIFT)>>4) + ((object[obj].y>>MYBITSHIFT)>>4)*(mapwidth>>4) );
	if (chk != 0)
		object[obj].lastchkpoint = chk;	// last checkpoint visited

	if (chk == object[obj].chkpoint+1)
	{
		object[obj].chkpoint = chk;		// update checkpoint number if new checkpoint
		checkchangeposition(obj);
		if (chk == 1)				// if first lap starts
		{
			player->laptime = 0;
			if (timetrial == 1)
				startghostdata(obj);
		}
	}

	if ( (chk == 1) && (object[obj].chkpoint == trackinfo.numcheckpoints) )		// Done a lap
	{
		object[obj].lap++;
		if (object[obj].lap > trackinfo.numlaps)
			lapsfinished = 1;
		object[obj].chkpoint = 1;
		checkchangeposition(obj);
		player->lastlap = player->laptime;
		player->laptime = 0;
		if (player->lastlap<player->bestlap)
			player->bestlap = player->lastlap;
		if (player->lastlap<trackinfo.records.laprecord[selectedclass])			// if broke track lap record
		{
			trackinfo.records.laprecord[selectedclass] = player->lastlap;
			laprecord(player);
		}
		if (timetrial == 1)
		{
			if (player->bestlap == player->lastlap)		// if was best lap
				ghostdatabestlap();				// copy ghost data
			startghostdata(obj);
			object[ghostdata.ghostobj].health = 1;
			if (ghostdata.out == ghostdata.previous)		// if showing previous lap
				ghostdata.laptime = player->lastlap;
			else if (ghostdata.out == ghostdata.best)		// if showing best lap
				ghostdata.laptime = player->bestlap;
		}
	}

	stdpad = player->paddata[1];				// get standard pad data
	if (player->fuel == 0)			// if out of fuel, ignore pad
	{
		stdpad = 0;
		object[obj].lap = 0;
		object[obj].chkpoint = 1;
		checkchangeposition(obj);
	}
	if (racestatus == 0)
		stdpad = 0;				// if race not running then ignore pad

	object[obj].dangle = 0;
	if (stdpad & PADLleft)
	{
		object[obj].dangle=-4<<MYBITSHIFT;
		if (object[obj].steer<32)
			object[obj].steer++;
	}
	else if (stdpad & PADLright)
	{
		object[obj].dangle=4<<MYBITSHIFT;
		if (object[obj].steer<32)
			object[obj].steer++;
	}
	else
	{
		if (object[obj].steer > 0)
			object[obj].steer -= 1;
		if (object[obj].steer > 0)
			object[obj].steer -= 1;
	}

	if (object[obj].spin>0)
	{
		object[obj].dangle += 32<<MYBITSHIFT;
		object[obj].spin--;
	}

	limitrange(object[obj].x,16<<MYBITSHIFT,mapwidth<<MYBITSHIFT);
	limitrange(object[obj].y,8<<MYBITSHIFT, mapheight<<MYBITSHIFT);

// Weapons firing
	if (timetrial == 0)
	{
		if (stdpad & PADL1)
			playerfire(player->trigger[0],obj);
		if (stdpad & PADR1)
			playerfire(player->trigger[1],obj);
		if (stdpad & PADL2)
			playerfire(player->trigger[2],obj);
		if (stdpad & PADR2)
			playerfire(player->trigger[3],obj);
	}


	frameang = (object[obj].angle>>MYBITSHIFT)/11.25;	// angle of car (0-32 as 0-360)
	frameangperp = (frameang + 8)%32;		// perpendicular angle
	frameadj = frameang;

	if ( (object[obj].effects&1) )
	{
		frameang = (object[obj].prevangle>>MYBITSHIFT)/11.25;
		stdpad = stdpad & ( PADRdown^0xffff );			// stop from accelerating
	}
	else
		object[obj].prevangle = object[obj].angle;

	object[obj].maxspeed = player->maxspeed;		//228 358
	if (object[obj].effects & 2)				// If TURBO pressed
	{
		object[obj].maxspeed*=1.3;
		object[obj].effects = object[obj].effects & 0xfd;
	}

	player->fuel-=abs(object[obj].speed)/30;

//	if (stdpad & PADRleft)				// if SQUARE pressed
//		(object[obj].maxspeed = 228);		// maxspeed is higher (high gear)

	offset = ((object[obj].y>>MYBITSHIFT)/8)*(mapwidth/8);
	offset = offset + ((object[obj].x>>MYBITSHIFT)/8);
	col = *(colmappt + offset);
	if ( (col&16) != 0 )				// if bit4 of col map (slow track)
	{
		object[obj].maxspeed=28;		// reduce maximum speed
		if (object[obj].speed > 45)
		{
			if ( (object[obj].time & 2) == 0 )
				makedust(object[obj].x,object[obj].y,obj);
		}
		else if (object[obj].speed > 25)
		{
			if ( (object[obj].time & 4) == 0 )
				makedust(object[obj].x,object[obj].y,obj);
		}
	}
	else if ( (col&32) != 0 )			// if bit5 (speed up)
	{
		object[obj].maxspeed*=1.3;
		if (object[obj].speed > 0)
			object[obj].speed = object[obj].maxspeed;
	}
	object[obj].maxspeed-=object[obj].steer;
	if ( (stdpad & PADRdown) && (!(stdpad & PADRleft)) && (!(stdpad & PADRright)) )		// accelerate
	{
		if (object[obj].speed < object[obj].maxspeed)
			object[obj].speed+=2;
		else
			if (object[obj].speed>1)
				object[obj].speed-=2;			// decrease speed if in low gear
	}
	else					// decelerate
	{
		if (~(object[obj].effects&1))				// if not on oil
			if (object[obj].speed>0)
				object[obj].speed-=1;
			else if (object[obj].speed<0)
				object[obj].speed+=1;
		if ( abs(object[obj].momdx) < 40 )			// if momentum is small, make it none.
			object[obj].momdx = 0;
		if ( abs(object[obj].momdy) < 40 )
			object[obj].momdy = 0;
		if (stdpad & PADRleft)			// brake
		{
			object[obj].speed-=2;
//			frameadj+=32;
			object[obj].momdx-=object[obj].momdx/32;
			object[obj].momdy-=object[obj].momdy/32;		//16
		}
		if (object[obj].speed<-80)
			object[obj].speed = -80;
	}

	object[obj].dx = (((veltabpt+frameang)->dx)*object[obj].speed)>>6;
	object[obj].dy = (((veltabpt+frameang)->dy)*object[obj].speed)>>6;

	if (stdpad & PADRright)
	{
		object[obj].dx/=8;
		object[obj].dy/=8;
		if (object[obj].speed>1)
			object[obj].speed-=2;
	}

	if (object[obj].voice[0] == -1)			// engine sound
		object[obj].voice[0] = SsUtKeyOn(soundvab,2,0,52,0,80,80);
	else
		SsUtChangePitch(object[obj].voice[0],soundvab,2,52,0,52+(object[obj].speed>>4),(object[obj].speed&15)<<3);

	if (object[obj].voice[1] == -1)			// skid sound
		object[obj].voice[1] = SsUtKeyOn(soundvab,3,0,52,0,0,0);
	else
		SsUtSetVVol(object[obj].voice[1],object[obj].steer<<1,object[obj].steer<<1);

	object[obj].momdx+=object[obj].dx;
	object[obj].momdy+=object[obj].dy;

//	FntPrint("ddx %d ddy %d\n",object[obj].momdx-object[obj].dx,object[obj].momdy-object[obj].dy);

	object[obj].momdx-=object[obj].momdx/25;	// 30
	object[obj].momdy-=object[obj].momdy/25;


	object[obj].dx += object[obj].momdx;
	object[obj].dy += object[obj].momdy;

//	FntPrint("MOMDX %d   DY %d\n",object[obj].momdx,(object[obj].dy>>4)>>MYBITSHIFT);


//	limitrange(object[obj].dx,-1024,1024);
//	limitrange(object[obj].dy,-1024,1024);

	if (player->fuel<=0)
	{
//		object[obj].control = gameoverplayercontrol;
		player->fuel=0;
	}

	object[obj].frame = 0 + (frameadj<<8);
	object[obj].effects = object[obj].effects&0xfe;		// clear oil effects

}

void gameoverplayercontrol(u_long obj)
{
}




void cpuplayercontrol(u_long obj)
{
	u_long	offset,dobj;
	long		idealangle;
	u_short	frameang;
	u_char	dir,chk,col,dircmp;
	long		newx,newy;
	int		f;

	if (racestatus == 0)
	{
		frameang = ((object[obj].angle>>MYBITSHIFT)/11.25);
		object[obj].frame = frameang<<8;
		return;
	}

	newx = object[obj].x + (object[obj].dx>>4);
	newy = object[obj].y + (object[obj].dy>>4);
//	FntPrint("CPU:%d  X:%d Y:%d  Nx:%d Ny:%d\n",obj,object[obj].x,object[obj].y,newx,newy);
	object[obj].steer = 0;
	for (f=0;f<MAXDRIVERS;f++)
		if (driver[f].active != 0)
			if (driver[f].object != obj)
				if (checkcollide16(obj,driver[f].object,newx,newy) != 0)
				{
					if (object[driver[f].object].followactive == 0)
					{
						dobj = driver[f].object;
						object[dobj].momdx = object[obj].dx/1.2;
						object[dobj].momdy = object[obj].dy/1.2;
						object[obj].momdx = -object[obj].momdx/2;
						object[obj].momdy = -object[obj].momdy/2;
						object[obj].dx = -object[obj].dx/2;
						object[obj].dy = -object[obj].dy/2;
						newx = object[obj].x;
						newy = object[obj].y;
						object[obj].angle = object[obj].dangle;
						object[obj].steer++;
//						object[obj].speed=0;
						if (object[obj].dy >= 0 && object[dobj].dy >= 0)	// if both dy in same direction (+ve)
							if (object[obj].y > object[dobj].y)	// if obj ahead
							{
								object[obj].dy = (object[obj].dy+16)*1.5;	// object in front gets boost
								object[dobj].dy = 0;		// object behind suffers
								object[dobj].speed/=2;
							}
							else
							{
								object[dobj].dy = (object[dobj].dy+16)*1.5;	// object in front gets boost
								object[obj].dy = 0;		// object behind suffers
								object[obj].speed/=2;
							}
						if (object[obj].dy < 0 && object[dobj].dy < 0)	// if both dy in same direction (-ve)
							if (object[obj].y < object[dobj].y)	// if obj ahead
							{
								object[obj].dy = (object[obj].dy-16)*1.5;	// object in front gets boost
								object[dobj].dy = 0;		// object behind suffers
								object[dobj].speed/=2;
							}
							else
							{
								object[dobj].dy = (object[dobj].dy-16)*1.5;	// object in front gets boost
								object[obj].dy = 0;		// object behind suffers
								object[obj].speed/=2;
							}
						if (object[obj].dx >= 0 && object[dobj].dx >= 0)	// if both dx in same direction (+ve)
							if (object[obj].x > object[dobj].x)	// if obj ahead
							{
								object[obj].dx = (object[obj].dx+16)*1.5;	// object in front gets boost
								object[dobj].dx = 0;		// object behind suffers
								object[dobj].speed/=2;
							}
							else
							{
								object[dobj].dx = (object[dobj].dx+16)*1.5;	// object in front gets boost
								object[obj].dx = 0;		// object behind suffers
								object[obj].speed/=2;
							}
						if (object[obj].dx < 0 && object[dobj].dx < 0)	// if both dx in same direction (-ve)
							if (object[obj].x < object[dobj].x)	// if obj ahead
							{
								object[obj].dx = (object[obj].dx-16)*1.5;	// object in front gets boost
								object[dobj].dx = 0;		// object behind suffers
								object[dobj].speed/=2;
							}
							else
							{
								object[dobj].dx = (object[dobj].dx-16)*1.5;	// object in front gets boost
								object[obj].dx = 0;		// object behind suffers
								object[obj].speed/=2;
							}
//						prang();
					}
				}

//	FntPrint("%d Steer %d\n",obj,object[obj].steer);

// check if going to hit wall
	offset = (newx>>MYBITSHIFT)/8 + ((newy>>MYBITSHIFT)/8)*(mapwidth/8);	// get collision data under car's next coordinates
	col = *(colmappt + offset);
	if (col!=0)
	{
		if ( (col&3) != 0 )		// if hit something solid
		{
			newx = object[obj].x;	// put car back
			newy = object[obj].y;
			object[obj].momdx/= 2;	// reduce momentum
			object[obj].momdy/= 2;
		}
		if ( (col&1) != 0)			// hit horiz wall
		{
			object[obj].dy = -object[obj].dy;
			object[obj].momdy = -object[obj].momdy;
		}
		if ( (col&2) != 0)			// hit vert wall
		{
			object[obj].dx = -object[obj].dx;
			object[obj].momdx = -object[obj].momdx;
		}
		if ( (col&16) != 0)			// if on dusty road (slow road)
			if (object[obj].speed > 45)
			{
				if ( (object[obj].time & 2) == 0 )
					makedust(object[obj].x,object[obj].y,obj);
			}
			else if (object[obj].speed > 25)
			{
				if ( (object[obj].time & 4) == 0 )
					makedust(object[obj].x,object[obj].y,obj);
			}
	}

	object[obj].x = newx;
	object[obj].y = newy;

	limitrange(object[obj].x,16<<MYBITSHIFT,(mapwidth<<MYBITSHIFT)-1);
	limitrange(object[obj].y,8<<MYBITSHIFT, (mapheight<<MYBITSHIFT)-1);

	chk = *(chkmappt+ ((object[obj].x>>MYBITSHIFT)>>4) + ((object[obj].y>>MYBITSHIFT)>>4)*(mapwidth>>4) );
	if (chk != 0)
		object[obj].lastchkpoint = chk;	// last checkpoint visited


	if (chk == object[obj].chkpoint+1)
	{
		object[obj].chkpoint = chk;		// update checkpoint number if new checkpoint
		checkchangeposition(obj);
	}

	if ( (chk == 1) && (object[obj].chkpoint == trackinfo.numcheckpoints) )		// Done a lap
	{
		object[obj].lap++;
		object[obj].chkpoint = 1;
		checkchangeposition(obj);
	}


	offset = ((object[obj].x>>MYBITSHIFT)>>3) + ((object[obj].y>>MYBITSHIFT)>>3)*(mapwidth>>3);
	dir = (*(cpudirmappt + offset));
	dircmp = 64;
//	if (object[obj].lastchkpoint&1 == 0)		// if even, check against even valid
//		dircmp = 128;

	if ( (dir&dircmp) != 0)				// if ideal dir is valid (i.e. car should change direction)
	{
		if (object[obj].lastchkpoint&1 == 1)
			dir = dir&7;				// odd cpu dir
		else
			dir = (dir>>3)&7;				// even cpu dir

		idealangle = (dir*45)<<MYBITSHIFT;

		object[obj].dangle = object[obj].angle;			// old angle is stored here instead of angle direction
//		idealangle = object[players[0].object].angle;

		if (~(object[obj].effects & 1))
		{
		if ( abs(idealangle-object[obj].angle) < (180<<MYBITSHIFT) )
		{
			if (idealangle>object[obj].angle)
				object[obj].angle+=12<<MYBITSHIFT;		// 8
			else if (idealangle<object[obj].angle)
				object[obj].angle-=12<<MYBITSHIFT;
		}
		else
		{
			if (idealangle>object[obj].angle)
				object[obj].angle-=12<<MYBITSHIFT;
			else if (idealangle<object[obj].angle)
				object[obj].angle+=12<<MYBITSHIFT;
		}
		}

	}

	if (object[obj].spin>0)
	{
		object[obj].angle+=32<<MYBITSHIFT;
		object[obj].spin--;
	}

	if (object[obj].angle<0)
		object[obj].angle+=360<<MYBITSHIFT;
	if (object[obj].angle>=(360<<MYBITSHIFT))
		object[obj].angle-=360<<MYBITSHIFT;


	limitrange(object[obj].angle,0,360<<MYBITSHIFT);

	if (object[obj].speed < object[obj].maxspeed)			// cpu accelerate
		object[obj].speed+=2;
	if (object[obj].speed > object[obj].maxspeed)
		object[obj].speed = object[obj].maxspeed;

	frameang = (object[obj].angle>>MYBITSHIFT)/11.25;	// angle of car (0-32 as 0-360)

	object[obj].dx = (((veltabpt+frameang)->dx)*object[obj].speed)>>6;
	object[obj].dy = (((veltabpt+frameang)->dy)*object[obj].speed)>>6;
	object[obj].momdx+=object[obj].dx;
	object[obj].momdy+=object[obj].dy;

	object[obj].momdx-=object[obj].momdx/20;
	object[obj].momdy-=object[obj].momdy/20;

	object[obj].dx += object[obj].momdx;
	object[obj].dy += object[obj].momdy;

//	limitrange(object[obj].dx,-8192,8192);
//	limitrange(object[obj].dy,-8192,8192);



	object[obj].frame = frameang<<8;
	object[obj].effects = object[obj].effects&0xfe;		// clear oil effects
}

void startgridcontrol(u_long obj)
{
}

void shotcontrol(u_long obj)
{
	object[obj].x += object[obj].dx;
	object[obj].y += object[obj].dy;

	if (object[obj].y<0 | object[obj].y>240<<MYBITSHIFT | object[obj].x<0 | object[obj].x>320<<MYBITSHIFT)
	{
		object[obj].active = 0;
//		printf("kill\n");
	}
}

void countdowncontrol(u_long obj)
{
}

u_char checktrackcollision16(u_long obj,long nx,long ny)
{	// checks for collision of a 16x16 object on the track (nx and ny are coordinates of object to check)
	long	x,y;
	short	index16,index8;
	u_char	col;
	u_short	*pt,tmskip,mrot;
	pt = maskspt + ((maskheaderpt+(object[obj].base_sprite->offset)+(object[obj].frame>>8)-0)->offset)/2;	// get to mask data
	x = (nx>>MYBITSHIFT)-object[obj].hx;
	y = (ny>>MYBITSHIFT)-object[obj].hy;
	tmskip = y-((y>>4)<<4);					// (track mask skip) lines to skip in track mask (how far down the object is in the top block)
	mrot = x-((x>>4)<<4);					// (mask rotate) bits to rotate object mask right by
	index16 = (x>>4)+(y>>4)*(mapwidth>>4);		// top left map block (object usually crosses 4 different map blocks)
	index8 = (x>>3)+(y>>3)*(mapwidth>>3);			// top left col block
	col = checktrackcollision16col(index8);					// check for collision on colmap
	if (col != 0)									// if so,
	{
//		FntPrint("COL TL ");
		if (checktrackcollisionmask16(index16,mrot,pt,tmskip,16-tmskip) != 0)	// check at pixel level
//		{
//			FntPrint("PIXEL\n");
			return(col);							// and return if hit
//		}
//		else
//			FntPrint("No\n");
	}
	index16++;							// top right map block
	if (mrot != 0)			// don't do right if car wholly aligned horizontally on 16x16 block
	{
		col = checktrackcollision16col(index8+2);
		if (col != 0)
		{
//			FntPrint("COL TR ");
			if (checktrackcollisionmask16r(index16,16-mrot,pt,tmskip,16-tmskip) != 0)	// check at pixel level
//			{
//				FntPrint("PIXEL\n");
				return(col);
//			}
//			else
//				FntPrint("No\n");
		}
	}
	if (tmskip == 0)			// don't do bottom if car wholly aligned vertically on 16x16 block
		return(0);
	index16+=(mapwidth>>4)-1;				// bottom left map block
	index8+=(mapwidth>>3);
	pt+=tmskip;					// skip down object mask to bit in bottom block
	col = checktrackcollision16col(index8);
	if (col != 0)
	{
//		FntPrint("COL BL tm%d ",tmskip);
		if (checktrackcollisionmask16(index16,mrot,pt+16-tmskip,0,tmskip) != 0)	// check at pixel level
//		{
//			FntPrint("PIXEL\n");
			return(col);
//		}
//		else
//			FntPrint("No\n");
	}
	index16++;							// bottom right map block
	if (mrot != 0)			// don't do right if car wholly aligned horizontally on 16x16 block
	{
		col = checktrackcollision16col(index8+2);
		if (col != 0)
		{
//			FntPrint("COL BR ");
			if (checktrackcollisionmask16r(index16,16-mrot,pt+16-tmskip,0,tmskip) != 0)	// check at pixel level
//			{
//				FntPrint("PIXEL\n");
				return(col);
//			}
//			else
//				FntPrint("No\n");
		}
	}
	return(0);
}

u_char checktrackcollision16col(short index8)
{	// checks all 4 colmap blocks in a map block. returns 0 if none, otherwise a normal value (1-3)
	u_char	col;
	col = (*(colmappt + index8))&3;
//	FntPrint("0");
	if (col != 0)								// if something solid
			return(col);						// then quit
	col = (*(colmappt + index8 + 1))&3;					// otherwise do next col block
//	FntPrint("1");
	if (col != 0)
		return(col);
	index8+=(mapwidth>>3);
	col = (*(colmappt + index8))&3;
//	FntPrint("2");
	if (col != 0)
		return(col);
	col = (*(colmappt + index8 + 1))&3;
//	FntPrint("3");
	if (col != 0)
		return(col);
	return(0);
}

int checktrackcollisionmask16(short index16,short mrot,u_short *pt,short tmskip,int height)
{	//  pt is pointer into mask data for object, tmskip is amount to skip into map mask (vertically)
	//  mrot is right shift for object mask, index16 is index of map block
	//  height is number of lines to do
	u_short	*mpt,mi;		// pointer to tile mask
	GsCELL	*cpt;
	int f;

// sort this bit out (dirty address obtaining)
	mpt = (u_short *)memoryblock[trackinfo.mpimblock].address;
	mpt+=2;
	mi = *(mpt+index16);	// get index into .CEL
	mpt = trackinfo.maskaddress; //(u_short *)getpakaddress(_PAK_engtrackbitmask_INDEX);
	cpt = (GsCELL *) (( (u_char *)memoryblock[trackinfo.celmblock].address ) + 4 );
	cpt+=mi;
	mpt+= (((cpt->u)>>4) + ((cpt->v)>>4)*16)*16;
//	printf("Addr:%x  u:%d v:%d mi:%d  tmskip:%d height:%d\n",mpt,cpt->u,cpt->v,mi,tmskip,height);
	mpt += tmskip;

/*
	{	// DEBUG section
		GsBOXF	b;
		int		bf,bg,by;
		b.attribute = 0;
		b.w = 4;
		b.h = 4;
		b.r = 120;
		b.g = 120;
		b.b = 120;
		by = tmskip;
		for (bg=0;bg<height;bg++)
			for (bf=0;bf<16;bf++)
			{
				if ( ((*(mpt+bg))>>(15-bf))&1 != 0)
				{
					b.attribute = 0;
					b.r = b.g = b.b = 128;
					b.x = bf*4;
					b.y = (bg+by)*4;
					GsSortBoxFill(&b,&WorldOT[activebuff],0);
				}
				else
				{
					b.attribute = 1<<30;
					b.r = 80;
					b.g = b.b = 0;
					b.x = bf*4;
					b.y = (bg+by)*4;
					GsSortBoxFill(&b,&WorldOT[activebuff],0);
				}
				if ( (((*(pt+bg))>>mrot)>>(15-bf))&1 != 0)
				{
					b.attribute = 0;
					b.r = b.g = b.b = 128;
					b.x = bf*4;
					b.y = (bg+by)*4-80;
					GsSortBoxFill(&b,&WorldOT[activebuff],0);
				}
				else
				{
					b.attribute = 1<<30;
					b.r = 80;
					b.g = b.b = 0;
					b.x = bf*4;
					b.y = (bg+by)*4-80;
					GsSortBoxFill(&b,&WorldOT[activebuff],0);
				}
			}
	}
*/

	for (f=0;f<height;f++)
	{
//		printf("%x  %x\n",*mpt,(*pt)>>mrot);
		if ( (*mpt & ((*pt)>>mrot)) != 0 )
			return(1);
		pt++;
		mpt++;
	}
	return(0);
}

int checktrackcollisionmask16r(short index16,short mrot,u_short *pt,short tmskip,int height)
{	//  pt is pointer into mask data for object, tmskip is amount to skip into map mask (vertically)
	//  mrot is right shift for object mask, index16 is index of map block
	//  same as previous function, but rotates car mask left (for right hand side)
	u_short	*mpt,mi;		// pointer to tile mask
	GsCELL	*cpt;
	int f;

// sort this bit out
	mpt = (u_short *)memoryblock[trackinfo.mpimblock].address;
	mpt+=2;
	mi = *(mpt+index16);	// get index into .CEL
	mpt = trackinfo.maskaddress; //(u_short *)getpakaddress(_PAK_engtrackbitmask_INDEX);
	cpt = (GsCELL *) (( (u_char *)memoryblock[trackinfo.celmblock].address ) + 4 );
	cpt+=mi;
	mpt+= (((cpt->u)>>4) + ((cpt->v)>>4)*16)*16;

	mpt += tmskip;
	for (f=0;f<height;f++)
	{
		if ( (*mpt & (*pt)<<mrot) != 0 )
			return(1);
		pt++;
		mpt++;
	}
	return(0);
}


void checkchangeposition(u_long obj)
{
	int	f,g,pos,obj2,currpos;
	if (lapsfinished > 0)
		return;
	pos = object[obj].lap*trackinfo.numcheckpoints + object[obj].chkpoint - 1;
	currpos = -1;
	for (f=0;f<MAXDRIVERS;f++)					// find current position
		if (carpositions[f] == object[obj].driverindex)
		{
			currpos = f;
			break;
		}
	if (currpos == -1)
		printf("ERROR: can't find current car position\n");
	for (f=0;f<currpos;f++)
	{
		obj2 = driver[carpositions[f]].object;
		if ( pos > (object[obj2].lap*trackinfo.numcheckpoints + object[obj2].chkpoint - 1) )
		{
			for (g=currpos;g>f;g-=1)				// shift down from new pos to old pos
				carpositions[g] = carpositions[g-1];
			carpositions[f] = object[obj].driverindex;
			break;
		}
	}
}


void CheckPlayers(GsOT *wot)
{	// Check Credits and players starting
	int f,g;
	short	x0;
	GsGLINE	line;
	u_long	obj;
	if (timetrial == 1 && object[ghostdata.ghostobj].health > 0)
		time8(16,220,ghostdata.laptime);
	for (f=0;f<2;f++)
	{
		if (players[f].active != 0)
		{
//			FntPrint("Player %d CHK:%d LAP:%d \n",f+1, object[players[f].object].chkpoint, object[players[f].object].lap);
			if (players[f].laptime < 300 && object[players[f].object].lap>0)
			{
				time8(f*232+16,0,players[f].lastlap);
//				FntPrint("%d:%d\n",players[f].lastlap/100,players[f].lastlap%100);
			}
			else
			{
				time8(f*232+16,0,players[f].laptime);
//				FntPrint("%d:%d\n",players[f].laptime/100,players[f].laptime%100);
			}
			print8(f*232+16,8,"LAP");
			int8(f*232+48,8,2,object[players[f].object].lap);
			if (timetrial == 0)
			{
				if (players[f].laptime > 0)			// if running,
					for (g=0;g<MAXDRIVERS;g++)		// display position
						if (carpositions[g] == object[players[f].object].driverindex)
						{
							postextspr.u = postextx[g];
							postextspr.w = postextw[g];
							if (f==0)
								postextspr.x = 80-SCREENWIDTH/2;
							else
								postextspr.x = 232-24-SCREENWIDTH/2;
							postextspr.y = 8-SCREENHEIGHT/2;
							GsSortFastSprite(&postextspr,&OverlayOT[activebuff],0);
							break;
						}
				// bodge text colour if can't fire weapon
				if ( players[f].trigger[2] == INV_MISSILE || players[f].trigger[2] == INV_IMISSILE)
					if ( object[players[f].object].missilecount >= MAXMISSILECOUNT )
					{
						char8spritefast.r = 128;
						char8spritefast.g = char8spritefast.b = 0;
					}
				int8(f*232+16,16,3,players[f].inventory[players[f].trigger[2]]);		// display ammo counters
				int8(f*232+56,16,3,players[f].inventory[players[f].trigger[3]]);
				char8spritefast.r = char8spritefast.g = char8spritefast.b = 128;
				int8(f*232+16,24,3,players[f].inventory[players[f].trigger[0]]);
				if ( players[f].trigger[1] == INV_MINE )
					if ( object[players[f].object].minecount >= MAXMINECOUNT )
					{
						char8spritefast.r = 128;
						char8spritefast.g = char8spritefast.b = 0;
					}
				int8(f*232+56,24,3,players[f].inventory[players[f].trigger[1]]);
				char8spritefast.r = char8spritefast.g = char8spritefast.b = 128;
				int8(f*232+16,32,4,players[f].fuel>>MYBITSHIFT);
				ammospr.u = players[f].trigger[2]*8;						// display ammo images relevent for trigger selection
				ammospr.x = f*232+6-SCREENWIDTH/2;
				ammospr.y = 24-SCREENHEIGHT/2;
				GsSortFastSprite(&ammospr,&OverlayOT[activebuff],0);
				ammospr.u = players[f].trigger[3]*8;
				ammospr.x = f*232+46-SCREENWIDTH/2;
				GsSortFastSprite(&ammospr,&OverlayOT[activebuff],0);
				ammospr.u = players[f].trigger[0]*8;
				ammospr.x = f*232+6-SCREENWIDTH/2;
				ammospr.y = 32-SCREENHEIGHT/2;
				GsSortFastSprite(&ammospr,&OverlayOT[activebuff],0);
				ammospr.u = players[f].trigger[1]*8;
				ammospr.x = f*232+46-SCREENWIDTH/2;
				GsSortFastSprite(&ammospr,&OverlayOT[activebuff],0);
			}
//			FntPrint("BEST LAP: %d:%d\n",players[f].bestlap/100,players[f].bestlap%100);
/*			x0 = (f*160 + 16)-SCREENWIDTH/2;
			line.attribute = 0x40000000;
			line.x0 = x0;
			line.x1 = x0 + (object[players[f].object].speed);
			line.r0 = 128;
			line.r1 = 100;
			line.g0 = 80;
			line.g1 = 128;
			line.b0 = 0;
			line.b1 = 0;
			for (g=0;g<16;g++)
			{
				line.y0 = 200+g-SCREENHEIGHT/2;
				line.y1 = 200+g-SCREENHEIGHT/2;
//				GsSortGLine(&line, wot, 0);
			}
*/
		}
	}
}

void makeshot(u_long shot,long x, long y, u_long owner, u_short pri)
{	// makes a standard shot with default vars
	object[shot].x = x;
	object[shot].y = y;
	object[shot].dx = 0;
	object[shot].dy = 0;
	object[shot].base_sprite = animspt + ANIM_SHOTS;
	object[shot].frame = 0;
	object[shot].hx = 8;
	object[shot].hy = 8;
	object[shot].maxx = 16;
	object[shot].maxy = 16;
	object[shot].control = shotcontrol;
	object[shot].owner = owner;
	object[shot].pri = pri;
}






void FrametoGs(singleframe *frame,GsSPRITE *sprite)
{
// Copies data from single frame to GsSprite structure
	sprite->attribute = frame->attribute;
	sprite->w = frame->w;
	sprite->h = frame->h;
	sprite->tpage = frame->tpage;
	sprite->u = frame->u;
	sprite->v = frame->v;
	sprite->cx = frame->cx;
	sprite->cy = frame->cy;
}

void ObjectHandler()
{
	u_long	f;

	object[0].time++;
	for (f=1;f<MAXSTANDARDSPRITES;f++)
	{
		if (object[f].active != 0)
			UpdateObject(f);
	}
}

void UpdateObject(u_long obj)
{
// Do all control,display and movement for object obj
	if (game_paused == 0)
	{
		object[obj].control(obj);		// Call objects controller function
		object[obj].time++;			// increase time (31 bits holds over a year and a half at 50fps)
	}
	DisplayObject(obj);
}

int	checkcollide(u_long obj1, u_long obj2, long nx, long ny)
{
	int	collide;
	long	x1,y1,x2,y2;
	collide = 0;
	x1=(nx>>MYBITSHIFT)-object[obj1].hx;
	x2=(object[obj2].x>>MYBITSHIFT)-object[obj2].hx;
	y1=(ny>>MYBITSHIFT)-object[obj1].hy;
	y2=(object[obj2].y>>MYBITSHIFT)-object[obj2].hy;
	if (x1<=x2)		// if obj1 is on left
	{
		if (x2<(x1+object[obj1].maxx))	// if x collision
		{
			if (y1<y2)	// if obj1 is above
			{
				if (y2<(y1+object[obj1].maxy))	// if y collision
					collide = 1;
			}
			else if (y1>y2)	// if obj1 is below
			{
				if (y1<(y2+object[obj2].maxy))
					collide = 1;
			}
			else			// y1==y2
				collide = 1;
		}
	}
	else if (x1>x2)
	{
		if (x1<(x2+object[obj2].maxx))
		{
			if (y1<y2)	// if obj1 is above
			{
				if (y2<(y1+object[obj1].maxy))	// if y collision
					collide = 1;
			}
			else if (y1>y2)	// if obj1 is below
			{
				if (y1<(y2+object[obj2].maxy))
					collide = 1;
			}
			else			// y1==y2
				collide = 1;
		}
	}
	return(collide);
}

int	checkmask16(u_long lobj, u_long robj, int shift, u_short skip1, u_short skip2, u_short height)
{ // checks left obj and right obj. skip is y offset to skip, height is height left to do.
	int f,hit;
	u_short	*lpt,*rpt;

	lpt = maskspt + ((maskheaderpt+(object[lobj].base_sprite->offset)+(object[lobj].frame>>8)-0)->offset)/2;	// get to mask data
	rpt = maskspt + ((maskheaderpt+(object[robj].base_sprite->offset)+(object[robj].frame>>8)-0)->offset)/2;	// div by 2 because it adds in shorts
	lpt+=skip1;
	rpt+=skip2;

//	cdebuglpt = lpt;
//	cdebugrpt = rpt;

	hit = 0;					// hasn't collided yet
//	if (cdebug == 1)
//		printf("Checkmask16 l %d on r %d\n",lobj,robj);
	for (f=0;f<height;f++)
	{
		if ( ( (*lpt)&((*rpt)>>shift) ) != 0 )
			hit = 1;
//	if (cdebug == 1)
//	{
//		printf("F:%d  %x,%x   shft:%d sk1:%d,sk2:%d\n",f,*lpt,*rpt,shift,skip1,skip2);
//	}
		lpt++;
		rpt++;
	}
	return(hit);
}

int	checkcollide16(u_long obj1, u_long obj2, long nx, long ny)
{
	int	collide;
	long	x1,y1,x2,y2;
	collide = 0;
	x1=(nx>>MYBITSHIFT)-object[obj1].hx;
	x2=(object[obj2].x>>MYBITSHIFT)-object[obj2].hx;
	y1=(ny>>MYBITSHIFT)-object[obj1].hy;
	y2=(object[obj2].y>>MYBITSHIFT)-object[obj2].hy;
	if (x1<=x2)		// if obj1 is on left
	{
		if (x2<(x1+16))	// if x collision
		{
			if (y1<y2)	// if obj1 is above
			{
				if (y2<(y1+16))	// if y collision
					if (checkmask16(obj1,obj2,x2-x1,y2-y1,0,16-(y2-y1)) != 0)
						collide = 1;
			}
			else if (y1>y2)	// else if obj1 is below
			{
				if (y1<(y2+16))
					if (checkmask16(obj1,obj2,x2-x1,0,y1-y2,16-(y1-y2)) != 0)
						collide = 1;
			}
			else			// else if y1==y2
				if (checkmask16(obj1,obj2,x2-x1,0,0,16) != 0)
					collide = 1;
		}
	}
	else if (x1>x2)	// else if obj1 is on right
	{
		if (x1<(x2+16))
		{
			if (y1<y2)	// if obj1 is above
			{
				if (y2<(y1+16))	// if y collision
					if (checkmask16(obj2,obj1,x1-x2,0,y2-y1,16-(y2-y1)) != 0)
						collide = 1;
			}
			else if (y1>y2)	// else if obj1 is below
			{
				if (y1<(y2+16))
					if (checkmask16(obj2,obj1,x1-x2,y1-y2,0,16-(y1-y2)) != 0)
						collide = 1;
			}
			else			// else if y1==y2
				if (checkmask16(obj2,obj1,x1-x2,0,0,16) != 0)
					collide = 1;
		}
	}
	return(collide);
}




void	kill(u_long obj)
{	// kills object & extra object attached
	object[obj].active = 0;
	if (object[obj].extra != 0)
		(object[obj].extra)->active = 0;
}

void kill3d(u_long obj)
{	// kills 3d object
	obj3d[obj].active = 0;
}

u_long spawn3d()
{// spawn new object3d
	int f;
	u_long	n;
	n=0;
	for (f=1;f<MAX3DOBJECTS;f++)
		if (obj3d[f].active == 0)
			n = f;
	if (n != 0)
	{
		obj3d[n].active = 1;
		return(n);
	}
	else
		printf("BIG ERROR: No more free 3D objects\n");
}

u_long spawn()
{// Spawn new object (returns obj number and sets it active and zeroes it's time)
	int f;
	u_long	n;
	n = 0;
	for (f=1;f<MAXSTANDARDSPRITES;f++)	// object 0 = world
		if (object[f].active == 0)
		{
			n = f;
			break;
		}
	if (n != 0)
	{
		object[n].active = 1;
		object[n].time = 0;
		object[n].spritetype = 1;
		object[n].effects = 0;
		object[n].bright = 128;
		return(n);
	}
	else
		printf("BIG ERROR:  No more free objects\n");
}

u_long spawnextra()
{// Spawn new extra object (returns obj number and sets it active)
	int f;
	u_long	n;
	n = 0;
	for (f=1;f<MAXEXTRASPRITES;f++)
		if (extrasprites[f].active == 0)
		{
			n = f;
			break;
		}
	if (n != 0)
	{
		extrasprites[n].active = 1;
		return(n);
	}
	else
	{
		printf("BIG ERROR:  No more free extra sprites\n");
		return(0);
	}
}



void DisplayObject(u_long obj)
{
// Display object obj
	GsSPRITE	sprite;
	int		fast=1;			// 1 = use fast sprite, 0 = use normal sprite (rotated by object.angle)
	int		ov=0;

	FrametoGs(framespt+((object[obj].base_sprite->offset) + (object[obj].frame>>8)), &sprite);	// copy frames data to GsSPRITE structure
	sprite.x = ((object[obj].x>>MYBITSHIFT)-(mapx>>MYBITSHIFT))-SCREENWIDTH/2;		// adjust to fit onto map
	sprite.y = ((object[obj].y>>MYBITSHIFT)-(mapy>>MYBITSHIFT))-SCREENHEIGHT/2;
	if (object[obj].class == 3)			// if ghost car
	{
		sprite.attribute = 0x40000000;
		if (object[obj].health == 0)
			return;
	}
	if (object[obj].class == 4)		// if dustcloud
	{
		sprite.attribute = 0x70000000;
		sprite.r = object[obj].r;
		sprite.g = object[obj].g;
		sprite.b = object[obj].b;
	}
	else
		sprite.r = sprite.g = sprite.b = object[obj].bright;
	if (object[obj].spritetype == 0)
		fast = 0;
	if (fast != 0)
	{
		sprite.x-= object[obj].hx;
		sprite.y-= object[obj].hy;		// handle for fast sprite
	}
	if ( (object[obj].class >= 1) && (object[obj].class <= 3) )		// if player, cpu car or ghost car
	{
		sprite.cx = object[obj].cx;
		sprite.cy = object[obj].cy;
		if (object[obj].followactive != 0)
			sprite.r = sprite.g = sprite.b = 64;
		if (nighttime == 1)
			ov = 1;
	}

	if (object[obj].pri >= (1<<OT_LENGTH))
		object[obj].pri = 1<<OT_LENGTH;
	if (ov==0)
	{
		if (fast == 0)							// rotation/scaling sprite draw
		{
			sprite.mx = object[obj].hx;
			sprite.my = object[obj].hy;
			sprite.scalex = 4096;
			sprite.scaley = 4096;
			sprite.rotate = (object[obj].angle>>MYBITSHIFT)*4096;
			GsSortSprite(&sprite, &WorldOT[activebuff], object[obj].pri);
		}
		else									// fast sprite draw
		{
			GsSortFastSprite(&sprite, &WorldOT[activebuff], object[obj].pri);
		}
	}
	else
	{
		if (fast == 0)							// rotation/scaling sprite draw
		{
			sprite.mx = object[obj].hx;
			sprite.my = object[obj].hy;
			sprite.scalex = 4096;
			sprite.scaley = 4096;
			sprite.rotate = (object[obj].angle>>MYBITSHIFT)*4096;
			GsSortSprite(&sprite, &OverlayOT[activebuff], 2);
		}
		else									// fast sprite draw
		{
			GsSortFastSprite(&sprite, &OverlayOT[activebuff], 2);
		}
	}
}

void OverlaySprite(long x, long y,animation *base_sprite,long frame)
{	// display sprite on overlay OT
	GsSPRITE sprite;
	FrametoGs(framespt+((base_sprite->offset) + (frame>>8)), &sprite);	// copy frames data to GsSPRITE structure
	sprite.x = x;
	sprite.y = y;
	sprite.r = sprite.g = sprite.b = 128;
	GsSortFastSprite(&sprite, &OverlayOT[activebuff], 0);
}

void DisplayObjectOverlay(u_long obj, int pri)
{
// Display object obj in overlay OT at priority pri
	GsSPRITE	sprite;
	int		fast=1;			// 1 = use fast sprite, 0 = use normal sprite
	FrametoGs(framespt+((object[obj].base_sprite->offset) + (object[obj].frame>>8)), &sprite);	// copy frames data to GsSPRITE structure
	sprite.x = ((object[obj].x>>MYBITSHIFT)-(mapx>>MYBITSHIFT))-SCREENWIDTH/2;		// adjust to fit onto map
	sprite.y = ((object[obj].y>>MYBITSHIFT)-(mapy>>MYBITSHIFT))-SCREENHEIGHT/2;
	if (object[obj].class == 3)			// if ghost car
	{
		sprite.attribute = 0x40000000;
		if (object[obj].health == 0)
			return;
	}
	if (object[obj].spritetype == 0)
		fast = 0;
	if (fast != 0)
	{
		sprite.x-= object[obj].hx;
		sprite.y-= object[obj].hy;		// handle for fast sprite
	}
	if ( (object[obj].class >= 1) && (object[obj].class <= 3) )		// if player, cpu car or ghost car
	{
		sprite.cx = object[obj].cx;
		sprite.cy = object[obj].cy;
	}
	sprite.r = sprite.g = sprite.b = object[obj].bright;
	if (object[obj].pri >= (1<<OT_LENGTH))
		object[obj].pri = 1<<OT_LENGTH;
	if (fast == 0)							// rotation/scaling sprite draw
	{
		sprite.mx = object[obj].hx;
		sprite.my = object[obj].hy;
		sprite.scalex = 4096;
		sprite.scaley = 4096;
		sprite.rotate = (object[obj].angle>>MYBITSHIFT)*4096;
		GsSortSprite(&sprite, &WorldOT[activebuff], object[obj].pri);
	}
	else									// fast sprite draw
	{
		GsSortFastSprite(&sprite, &OverlayOT[activebuff], pri);
	}
}


void resetdrivers()
{
	int f;
	for (f=0;f<MAXDRIVERS;f++)
	{
		driver[f].active = 0;
	}
}

u_long adddriver(long x, long y, u_short angle, u_char class, u_char colour)
{	// adds a driver and sets up the object
	// coordinates and angle are in pixel units
	// class = 1(player), 2(cpu)
	int f,nf;
	u_long	obj;
	long		longangle;

	nf = MAXDRIVERS;
	for (f=0;f<MAXDRIVERS;f++)
		if (driver[f].active == 0)
			nf = f;
	if (nf<MAXDRIVERS)			// if found a free driver slot
	{
		obj = spawn();
		if (obj != 0)			// if got object
		{
			driver[nf].active = 1;
			driver[nf].class = class;
			driver[nf].object = obj;
			object[obj].driverindex = nf;
			if (class == 1)
				newplayer(obj);		// human
			else
				newcpuplayer(obj);	// computer
			object[obj].cx = carcolourcx(colour);
			object[obj].cy = carcolourcy(colour);
			object[obj].x = x<<MYBITSHIFT;
			object[obj].y = y<<MYBITSHIFT;
			longangle = angle<<MYBITSHIFT;
			object[obj].angle = longangle;
		}
		return(obj);
	}
}

u_short	carcolourcx(u_char colour)
{
	return(576+((colour%4)<<4));
}

u_short	carcolourcy(u_char colour)
{
	return(241+(colour>>2));
}

void newcpuplayer(u_long obj)
{
	u_long	eobj;
	newplayer(obj);						// set up a new player
	object[obj].control = cpuplayercontrol;		// and override the significant parts
	object[obj].maxspeed = 210+rand()%20;
	object[obj].class = 2;
	object[obj].lap = 0;
	object[obj].cx = 576+16;
	object[obj].cy = 242;
}


void newplayer(u_long obj)
{
	u_long	eobj;
	int	f;
	object[obj].x = 160<<MYBITSHIFT;
	object[obj].y = 100<<MYBITSHIFT;
	object[obj].angle = 90<<MYBITSHIFT;
	object[obj].spritetype = 1;			// don't make sprite rotate using hardware and angle
	object[obj].speed = 0;
	object[obj].dx = 0;
	object[obj].dy = 0;
	object[obj].momdx = 0;
	object[obj].momdy = 0;
	object[obj].dangle = 0;
	object[obj].base_sprite = animspt + ANIM_PLAYER1;
	object[obj].frame = 0<<8;
	object[obj].active = 1;
	object[obj].hx = 8;
	object[obj].hy = 8;
	object[obj].maxx = 16;
	object[obj].maxy = 16;
	object[obj].control = playercontrol;
	object[obj].class = 1;
	object[obj].dead_flag = DEAD_NOT;
	object[obj].chkpoint = 0;
	object[obj].lastchkpoint = 0;
	object[obj].lap = 0;
	object[obj].cx = 576;
	object[obj].cy = 240;
	object[obj].health = 100;
	object[obj].shottime = 0;
	object[obj].pri = OTPRI_CARS;
	object[obj].followactive = 0;
	object[obj].spin = 0;
	object[obj].missilecount = 0;			// missiles you have currently flying around
	object[obj].minecount = 0;
	for (f=0;f<4;f++)
		object[obj].voice[f] = -1;
	object[obj].steer = 0;
	eobj = spawnextra();
	object[obj].extra = &extrasprites[eobj];
	extrasprites[eobj].controller = 0;
	extrasprites[eobj].controller_type = 0;
}

void InitializeObjects()
{
	int f;
	u_long	obj;
	for (f=0;f<MAXSTANDARDSPRITES;f++)
	{
		object[f].active = 0;
		object[f].time = 0;
	}
	for (f=0;f<MAXEXTRASPRITES;f++)
	{
		extrasprites[f].active = 0;
	}

}

void FreeBackground(trackinfoheader *th)
{
// Free's memory used by background
	int mb;
	mb = th->celmblock;
	if (mb != 0)
		freememory(mb);
	mb = th->mpimblock;
	if (mb != 0)
		freememory(mb);
	mb = th->celtopmblock;
	if (mb != 0)
		freememory(mb);
	mb = th->mpitopmblock;
	if (mb != 0)
		freememory(mb);
	mb = th->colmblock;
	if (mb != 0)
		freememory(mb);
}

void Initializebackground(trackinfoheader *th)
{
// Unpack background data and set up background array.
	int f,g;
	void	*celladdress,*mpiaddress,*coladdress;
	void	*celltopaddress,*mpitopaddress;
	u_short	ctpage;
	int mblock;
	GsCELL	*cpt,*fcpt;


// First, unpack all the track data and set pointers to that data
// ground track
	mblock=allocatememory(getpaklength(th->celindex));		// get memory for cells
	if (mblock == 0)
		printf("CRASH: no memory for cells\n");
	th->celmblock = mblock;
	celladdress = memoryblock[mblock].address;
	unpak(th->celindex, memoryblock[mblock].address);
	mblock=allocatememory(getpaklength(th->mpiindex));		// get memory for index (mpi)
	if (mblock == 0)
		printf("CRASH: no memory for map index table\n");
	th->mpimblock = mblock;
	mpiaddress = memoryblock[mblock].address;
	unpak(th->mpiindex, mpiaddress);
// overlay track
	mblock=allocatememory(getpaklength(th->celtopindex));		// get memory for cells
	if (mblock == 0)
		printf("CRASH: no memory for overlay cells\n");
	th->celtopmblock = mblock;
	celltopaddress = memoryblock[mblock].address;
	unpak(th->celtopindex, memoryblock[mblock].address);
	mblock=allocatememory(getpaklength(th->mpitopindex));		// get memory for index (mpi)
	if (mblock == 0)
		printf("CRASH: no memory for overlay map index table\n");
	th->mpitopmblock = mblock;
	mpitopaddress = memoryblock[mblock].address;
	unpak(th->mpitopindex, mpitopaddress);
// other track data
	mblock=allocatememory(getpaklength(th->colindex));		// get memory for colmap
	if (mblock == 0)
		printf("CRASH: no memory for track col map\n");
	th->colmblock = mblock;
	coladdress=memoryblock[mblock].address;
	unpak(th->colindex, coladdress);

// Initialize background structures
	for (f=0;f<2;f++)
	{
	background[f].attribute = 0x41000000;		// 8 bit CLUT
	background[f].x = 0;
	background[f].y = 0;
	background[f].w = SCREENWIDTH;
	background[f].h = SCREENHEIGHT;
	background[f].scrollx = 0;
	background[f].scrolly = 0;
	background[f].r = 128;
	background[f].g = 128;
	background[f].b = 128;
	background[f].map = &backmap[f];		// pointer to MAP header
	background[f].mx = SCREENWIDTH/2;
	background[f].my = SCREENHEIGHT/2;
	background[f].scalex = 4096;
	background[f].scaley = 4096;
	background[f].rotate = 0;
	}

// Set up ground map address info and Tpages
	cpt = (GsCELL *)( ((u_long *)celladdress + 1) );	// get address of first cell in map
	background[0].map->base = cpt;
	background[0].map->index = (u_short *)( ((u_long *)mpiaddress + 1) );
	for (f=0;f<*((u_long *)celladdress);f++)			// for each cell
	{
		ctpage = cpt->tpage;
		ctpage = 0;
		cpt->cba = (768/16)|((240+ctpage)<<6);
		cpt->tpage = GetTPage(1,0,768+ctpage*128,0);	// recalculate tpages
		cpt++;
	}

// Set up overlay map address info and Tpages
	cpt = (GsCELL *)( ((u_long *)celltopaddress + 1) );	// get address of first cell in map
	background[1].map->base = cpt;
	background[1].map->index = (u_short *)( ((u_long *)mpitopaddress + 1) );
	for (f=0;f<*((u_long *)celltopaddress);f++)			// for each cell
	{
		ctpage = cpt->tpage;
		cpt->cba = (768/16)|((240+ctpage)<<6);
		cpt->tpage = GetTPage(1,0,768+ctpage*128,0);	// recalculate tpages
		cpt++;
	}

// Setup sizes for GsMAP structures
	for (f=0;f<2;f++)
	{
		background[f].map->cellw = 16;
		background[f].map->cellh = 16;
		background[f].map->ncellw = *((u_short *) mpiaddress);
		background[f].map->ncellh = *(((u_short *) mpiaddress)+1);
	}

// Set up some global variables
	mapwidth = background[0].map->ncellw *16;
	mapheight = background[0].map->ncellh *16;
	mapx = 0;
	mapy = 0;
	colmappt = (u_char *) coladdress;			// pointer to col map
	colmappt+=2;						// skip size info
	chkmappt=colmappt+(background[0].map->ncellw*2 * background[0].map->ncellh*2);	// pointer to cpu chkpoint map
	cpudirmappt=chkmappt+(background[0].map->ncellw*background[0].map->ncellh);		// pointer to cpu dir map

// Calculate total number of checkpoints
	th->numcheckpoints = 0;
	for (f=0;f<(background[0].map->ncellw*background[0].map->ncellh);f++)
		if ( *(chkmappt + f) > th->numcheckpoints )
			th->numcheckpoints = *(chkmappt + f);			// calculate total number of cpu checkpoints

}

void InitializeTrack(trackinfoheader *th)
{
// Loads track graphics into frame buffer
	int mblock;
	u_long	*laddress;

	mblock=allocatememory(getpaklength(th->tim1index));				// allocate memory for track pixel data
	if (mblock == 0)
		printf("CRASH: no memory for track1.tim\n");
	laddress = (u_long *)memoryblock[mblock].address;
	unpak(th->tim1index, (void *)laddress);
	TransferTextures(laddress+1);							// Copy track to framebuffer. +1 means skip header (4bytes).
	freememory(mblock);

	mblock=allocatememory(getpaklength(th->tim2index));				// allocate memory for track pixel data
	if (mblock == 0)
		printf("CRASH: no memory for track2.tim\n");
	laddress = (u_long *)memoryblock[mblock].address;
	unpak(th->tim2index, (void *)laddress);
	TransferTextures(laddress+1);							// Copy track to framebuffer. +1 means skip header (4bytes).
	freememory(mblock);

}

void getgridnfo(int index, trackinfoheader *thpt)
{		// copy grid information from track .NFO file to thpt
	int	mblock,f;
	tracknfofile	*nfopt;

	nfopt = (tracknfofile *)getpakaddress(index);
	for (f=0;f<4;f++)
	{
		thpt->grid[f].x = nfopt->grid[f].x;
		thpt->grid[f].y = nfopt->grid[f].y;
		thpt->grid[f].angle = nfopt->grid[f].angle;
	}
}

void Initializeframes()
{
//Copy frames/pixel data from system memory to frame buffer for the animation frames
	u_long f;
	u_long	offset;
	u_long	*laddress;
	int		mblock;
	singleframe	*framept;
	u_long	numberofframes;
	RECT	recttrans;

// Copy animation and frames information
//	printf("Check frames loaded\n");
	if (frames_loaded == 0)				// unless already loaded
	{
//		printf("Loading frames\n");
		frames_loaded = 1;
		mblock=allocatememory(getpaklength(_PAK_frames_INDEX));					// allocate memory for frames
		if (mblock == 0)
			printf("CRASH: no memory for animation frames\n");
		laddress = (u_long *)memoryblock[mblock].address;			// pointer to frames memory address
		unpak(_PAK_frames_INDEX,(void *)laddress);	// unpack frames data
		numberofframes = *(laddress+2);						// get number of frames in the file (we use this later)
		framespt = (singleframe *)(laddress+4);					// start of single frames is skip 4 u_long header
		animspt = (animation *)( (u_char *)laddress + (*(laddress+1)) );	// value of 2nd u_long in frames memory is offset to animations
		framept = framespt;

//		for (f=0;f<4;f++)
//			printf("Anim %d, offset %d length %d\n",f,*(animspt+f),*((u_long *)(animspt+f) +1));

		// Assign Correct Texture page and Clut data to frame data
		// N.B. TIM X and Y positions are dependent on this routine
// This bit is total RUBBISH. SORT IT OUT NOW!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! (well, next time)
		for (f=0;f<numberofframes;f++)
		{
//			framept->attribute = 0;
			if (framept->tpage<2)
			{
				framept->cx = 576+framept->tpage*16;
				framept->cy = 240;
				framept->tpage = GetTPage(0,0,512+framept->tpage*64,0);
			}
			else
			{
				framept->tpage = GetTPage(0,0,448,0);
				framept->cx = 448;
				framept->cy = 255;
			}
//			if (f>(numberofframes-14))
//				printf("%d CX=%d CY=%d TP=%d\n",f,framept->cx,framept->cy,framept->tpage);
			framept++;
		}

// Do Masks
		mblock=allocatememory(getpaklength(_PAK_masks_INDEX));
		if (mblock == 0)
			printf("CRASH: no memory for masks\n");
		laddress = (u_long *)memoryblock[mblock].address;
		unpak(_PAK_masks_INDEX,(void *)laddress);
		laddress++;
		maskspt = (u_short *)(laddress-1);			// point to start of headers
//		maskspt+=( *(laddress)*sizeof(maskheader) )/2;	// and point past header to start of data
		laddress++;							// skip to start of headers
		maskheaderpt = (maskheader *)laddress;		// set up pointer to mask headers
	}

// Copy frames sprite pixel data
//	printf("Sprite pixel");
	mblock=allocatememory(getpaklength(_PAK_cartim_INDEX));					// allocate memory for car sprite pixel data
	if (mblock == 0)
		printf("CRASH: no memory for car.tim\n");
	laddress = (u_long *)memoryblock[mblock].address;
	unpak(_PAK_cartim_INDEX, (void *)laddress);
	TransferTextures(laddress+1);							// Copy car to framebuffer. +1 means skip header (4bytes).
	freememory(mblock);								// We don't need this in main memory anymore

// Copy extra sprite pixel data
//	printf("Extra pixel");
	mblock=allocatememory(getpaklength(_PAK_extratim_INDEX));					// allocate memory for extra frames
	if (mblock == 0)
		printf("CRASH: no memory for extra frames\n");
	laddress = (u_long *)memoryblock[mblock].address;			// pointer to frames memory address
	unpak(_PAK_extratim_INDEX,(void *)laddress);	// unpack frames data
	TransferTextures(laddress+1);
// Warning: This memory block is used for the car colours as well.

// Copy car colours
//	unpak(_PAK_carcolours_INDEX, (void *)laddress);		// unpack car colours to same area
//	recttrans.x = 576;
//	recttrans.y = 241;
//	recttrans.w = 64;
//	recttrans.h = 3;
//	LoadImage (&recttrans, laddress);			// Transfer colours to frame buffer
	unpak(_PAK_ghostcolours_INDEX, (void *)laddress);	// unpak ghost car colours
	recttrans.x = 624;
	recttrans.y = 240;
	recttrans.w = 16;
	recttrans.h = 1;
	LoadImage (&recttrans, laddress);			// Transfer ghost colours
	freememory(mblock);								// We don't need this in main memory anymore
//	printf("init frames out\n");
}

void TransferTIM(int index)
{	// Unpacks TIM from pak and copies to framebuffer
	int mblock;
	u_long	*addr;
	mblock = allocatememory(getpaklength(index));
//	printf("Transfer TIM block %d, index %d\n",mblock,index);
	if (mblock == 0)
		printf("\nCRASH no memory for TIM\n");
	addr = (u_long *)memoryblock[mblock].address;
	unpak(index,(void *)addr);
	TransferTextures(addr+1);
	freememory(mblock);
}


void TransferTextures(u_long *tim)
{
// Give me
// (address of TIM data(not including 4 byte header)

	GsIMAGE	imgtrans;
	RECT	recttrans;

	GsGetTimInfo(tim, &imgtrans);	// Set up the IMAGE struct from the TIM data
	recttrans.x = imgtrans.px;	// pixel data destination coords
	recttrans.y = imgtrans.py;
	recttrans.w = imgtrans.pw;	// pixel data size
	recttrans.h = imgtrans.ph;
//	printf("rt.x:%d, rt.y:%d, rt.w:%d, rt.h:%d\n",recttrans.x,recttrans.y,recttrans.w,recttrans.h);
	LoadImage (&recttrans, imgtrans.pixel);			// Transfer it to the frame buffer
	recttrans.x = imgtrans.cx;	//CLUT data dest coords
	recttrans.y = imgtrans.cy;
	recttrans.w = imgtrans.cw;	//CLUT data size
	recttrans.h = imgtrans.ch;
//	printf("Clut x:%d y:%d\n",recttrans.x,recttrans.y);
	LoadImage (&recttrans, imgtrans.clut);			// Transfer palette
	DrawSync(0);		// Wait for it to finish transferring
}

void	ResetPlayer(int p)
{	// Resets player to initial state
	int f;

	players[p].active = 0;
	players[p].score = 0;
	players[p].health = 0;
	players[p].carclut = carcolours[p];
	for (f=0;f<MAXINVENTORY;f++)
		players[p].inventory[f]=0;
	players[p].maxspeed = 180;
	players[p].fuel = 200<<MYBITSHIFT;
	players[p].inventory[INV_FUEL]=200;
	players[p].carcolour = p;
//	players[p].credits = 0;
	players[p].pad = p%2;	
	players[p].controllertype = 0;
	players[p].trigger[0] = INV_TURBO;
	players[p].trigger[1] = INV_MINE;
	players[p].trigger[2] = INV_MISSILE;
	players[p].trigger[3] = INV_IMISSILE;
}

u_long getpaklength(int index)
{	// returns length of file in PAK
	u_long	length,*pakheadpt,version,hsize;
	entryheader	*headpt;

//	printf("Get paklength %d\n",index);
	pakheadpt = (u_long *)( ((u_char *)PAKFILEADDR) + _PAKHEAD);		// pointer to pak headers
//	printf("Get Pak Length HeadPT %x  ",pakheadpt);
	version = *pakheadpt;
	hsize = *(pakheadpt+1);
//	printf("Version %d, size %d\n",version,hsize);
	headpt = (entryheader *)(pakheadpt+2);
	headpt+=index;					// skip to file header we want
//	printf("Headpt %x\n",headpt);
	length = headpt->length;
//	printf("Length %d\n",length);
	return(length);
}

u_long	getpakaddress(int index)
{	// returns address of file in PAK (used to get address of uncompressed files)
	u_long	length,*pakheadpt,version,hsize;
	entryheader	*headpt;
	pakheadpt = (u_long *)( ((u_char *)PAKFILEADDR) + _PAKHEAD);		// pointer to pak headers
	version = *pakheadpt;
	hsize = *(pakheadpt+1);
	headpt = (entryheader *)(pakheadpt+2);
	headpt+=index;					// skip to file header we want
	return((u_long)PAKFILEADDR+headpt->offset);

}

void unpak(int index, void *dest)
{	// unpacks index (#number of file in pak) to destination
	void		*source;
	u_long	length,*pakheadpt,version,hsize;
	entryheader	*headpt;

	pakheadpt = (u_long *)( ((u_char *)PAKFILEADDR) + _PAKHEAD);		// pointer to pak headers
	version = *pakheadpt;
	hsize = *(pakheadpt+1);
	headpt = (entryheader *)(pakheadpt+2);
	headpt+=index;					// skip to file header we want
	source = (void *)( ((u_char *)PAKFILEADDR) + headpt->offset );
	length = headpt->length;
	if (headpt->method == 0)
		printf("DOH: trying to unpack a stored file\n");
	else if (headpt->method == 1)
		unpakRLE(source, dest, length);
}

void unpakRLE(void *source, void *dest, u_long length)
{	// Unpacks from address source to dest. length is total size after unpacking
	u_char	*src,*dst;
	u_char	rlec,tmp;
	u_long	count;
	int		f;

	src = (u_char *) source;
	dst = (u_char *) dest;
//	printf("Unpack %d,%d,%d,%d,%d\n",*src,*(src+1),*(src+2),*(src+3),*(src+4));
//	printf("From %x to %x\n",src,dst);
	count = 0;
	while (count<length)
	{
		rlec = *src++;		// read count value from RLE
		if (rlec>127)		// if single byte
		{
			tmp = *src;	// read data
			src++;
			for (f=0;f<(256-rlec)+1;f++)
			{
				*dst=tmp;	// write it many times
				dst++;
			}
			count+=(256-rlec)+1;
		}
		else				// if multiple bytes
		{
			for (f=0;f<rlec;f++)
			{
				*dst=*src;	// write multiple bytes
				src++;
				dst++;
			}
			count+=rlec;
		}
	}

	dst = (u_char *) dest;
/*
	printf("Unpacked = ");
	for (f=0;f<12;f++)
	{
		printf("%d ",*dst);
		dst++;
	}
*/
//	printf("\nTotalled %x of %x\n",count,length);
}

int allocatememory(u_long size)
{	// allocates memory using memory block. returns offset into memoryblock array
	int f;
	int mb;
	void	*address;

	mb = 0;
	for (f=0;f<MAXMEMORYBLOCKS;f++)
		if (memoryblock[f].active == 0)
			mb = f;
	if (mb != 0)
	{
// NOW LOOK. I HAVE TO INCREASE THE SIZE TO GET IT WORKING. DODGY DECOMPRESSION !!!!!!!!!
		size+=8;

		if ( (address = malloc(size)) != NULL)		// try to get memory
		{
			memoryblock[mb].active = 1;
			memoryblock[mb].address = address;
			memoryblock[mb].size = size;
//			printf("Mem Alloc Block %d. Address %x size %x\n",mb,address,size);
		}
		else
			mb = 0;
	}
	else
		printf("Could not get a free memory block\n");
	return(mb);
}

void freememory(int mb)
{	// free memory
	if (memoryblock[mb].active != 0)
	{
		free(memoryblock[mb].address);
		memoryblock[mb].active = 0;
	}
}

void freeallmemory()
{	// frees all remaining memory used
	int f;
	for (f=0;f<MAXMEMORYBLOCKS;f++)
		if (memoryblock[f].active != 0)
		{
			free(memoryblock[f].address);
			memoryblock[f].active = 0;
		}
}

void char8(short x,short y,short scalex,short scaley, long rotate, char c)
{	// prints character c from font 8 at pixels x,y with scaling/rotation
	if (c==32)				// if space
		return;
	if ( (c<32) || (c>96) )		// if invalid character
		return;
	c-=33;
	char8sprite.u = (c%32)<<3;			// position on font texture
	char8sprite.v = (c>>5)<<3;
	char8sprite.x = x-160+4;			// 3D makes origin in center of screen
	char8sprite.y = y-120+4;			// +4 because of mx,my origin
	char8sprite.scalex = scalex;
	char8sprite.scaley = scaley;
	char8sprite.rotate = rotate;
	GsSortSprite(&char8sprite,&OverlayOT[activebuff],0);
}

void char8fast(short x,short y, char c)
{	// prints character c from font 8 at pixels x,y
	if (c==32)
		return;
	c-=33;
	char8spritefast.u = (c%32)<<3;			// position on font texture
	char8spritefast.v = (c>>5)<<3;
	char8spritefast.x = x-160;
	char8spritefast.y = y-120;
	GsSortFastSprite(&char8spritefast,&OverlayOT[activebuff],0);
}

void print8(short x,short y, char *text)
{	// prints text at x,y (null terminated)
	char	c;
	c = *text;
	while (c!=0)
	{
		char8fast(x,y,c);
		text++;
		x+=8;
		c=*text;
	}
}

void int8(short x,short y,short d, int num)
{	// prints number with d digits at x,y
	char	n[16];
	if (d>14)
	{
		d=14;
		printf("Too many digits to int8\n");
	}
	n[d] = 0;
	while (d>0)
	{
		n[d-1]=(num%10)+48;
//		char8fast(x,y,n[d-1]);
		d--;
		num/=10;
//		x+=8;
	}
	print8(x,y,n);
}

void time8(short x,short y,u_long time)
{	// prints time at x,y in format m:ss:hh
	int	s,m;
	s = time/100;
	m = s/60;
	timechar[0]=48+(m%10);				// minutes
	s-=m*60;
	timechar[2]=48+(s/10);				// seconds
	timechar[3]=48+(s%10);
	timechar[5]=48+((time/10)%10);		// hundredths
	timechar[6]=48+(time%10);
	print8(x,y,timechar);
}

void timetd(short x,short y,u_long time)
{	// prints time using thind digits (4x6) in m:ss:hh
	int s,m,tc;
	s = time/100;
	m = s/60;
	tdsprite.x = x;
	tdsprite.y = y;
	tc=(m%10);				// minutes
	tdsprite.u = tc<<2;
	GsSortFastSprite(&tdsprite,&OverlayOT[activebuff],0);
	tdsprite.x+=4;
	tdsprite.u = 40;			// :
	GsSortFastSprite(&tdsprite,&OverlayOT[activebuff],0);
	tdsprite.x+=4;
	s-=m*60;
	tc=(s/10);				// seconds
	tdsprite.u = tc<<2;
	GsSortFastSprite(&tdsprite,&OverlayOT[activebuff],0);
	tdsprite.x+=4;
	tc=(s%10);
	tdsprite.u = tc<<2;
	GsSortFastSprite(&tdsprite,&OverlayOT[activebuff],0);
	tdsprite.x+=4;
	tdsprite.u = 40;			// :
	GsSortFastSprite(&tdsprite,&OverlayOT[activebuff],0);
	tdsprite.x+=4;
	tc=((time/10)%10);		// hundredths
	tdsprite.u = tc<<2;
	GsSortFastSprite(&tdsprite,&OverlayOT[activebuff],0);
	tdsprite.x+=4;
	tc=(time%10);
	tdsprite.u = tc<<2;
	GsSortFastSprite(&tdsprite,&OverlayOT[activebuff],0);
	tdsprite.x+=4;
}

void	updatefontcolour()
{	// creates clut address in char sprites from global fontcolour
	if (fontcolour>0)
	{
	char8sprite.cx=((fontcolour%4)<<4)+640;
	char8sprite.cy=(fontcolour>>2)+241;
	char8spritefast.cx=((fontcolour%4)<<4)+640;
	char8spritefast.cy=(fontcolour>>2)+241;
	}
	else
	{
	char8sprite.cx = char8spritefast.cx = 640;
	char8sprite.cy = char8spritefast.cy = 240;
	}
}

void initsound()
{
	int mblockvh,mblockvb,prog,tone;
	char	*atrpt,*pt;
// Sound FX
	mblockvh = allocatememory(getpaklength(_PAK_soundvh_INDEX));
	if (mblockvh == 0)
		printf("CRASH: no memory for sound VH");
	mblockvb = allocatememory(getpaklength(_PAK_soundvb_INDEX));
	if (mblockvb == 0)
		printf("CRASH: no memory for sound VB");
	unpak(_PAK_soundvh_INDEX, (void *)memoryblock[mblockvh].address);
	vhptr = (void *)memoryblock[mblockvh].address;
	unpak(_PAK_soundvb_INDEX, (void *)memoryblock[mblockvb].address);
	soundvab = SsVabTransfer( (u_char *)memoryblock[mblockvh].address, (u_char *)memoryblock[mblockvb].address, -1, 1);
	if (soundvab<0)
		printf("CRASH: COULD NOT TRANSFER SOUND\n");
//	else
//		printf("Sound VAB on %d\n",soundvab);
//	freememory(mblockvh);				// don't free otherwise sound won't work
	freememory(mblockvb);

// Sound Fix Hack
	for (prog=0;prog<15;prog++)
	{
		for (tone=0;tone<5;tone++)
		{
			atrpt = (char *)vhptr;
			atrpt += 2048+32;
			pt = atrpt+(tone*32+(prog*32*16));
			*(pt+17) = 0-(127+1);
			*(pt+16) = (15&15) | ((15-(0&15))<<4);
		}
	}


// MUSIC

	if (MUSIC == 1)
	{

	mblockvh = allocatememory(getpaklength(_PAK_musicvh_INDEX));
	if (mblockvh == 0)
		printf("CRASH: no memory for music VH\n");
	unpak(_PAK_musicvh_INDEX, (void *)memoryblock[mblockvh].address);
	musicvhptr = (void *)memoryblock[mblockvh].address;
	musicvab = SsVabTransfer( (u_char *)memoryblock[mblockvh].address, (u_char *)getpakaddress(_PAK_musicvb_INDEX), -1, 1);
	if (musicvab<0)
		printf("CRASH: Could not transfer music sound\n");
//	else
//		printf("Music VAB on %d\n",musicvab);

// Fix Hack
	for (prog=0;prog<15;prog++)
	{
		for (tone=0;tone<5;tone++)
		{
			atrpt = (char *)musicvhptr;
			atrpt += 2048+32;
			pt = atrpt+(tone*32+(prog*32*16));
			*(pt+17) = 0-(127+1);
			*(pt+16) = (15&15) | ((15-(0&15))<<4);
		}
	}


	SsSetMVol(mainvolume,mainvolume);
	SsSetMute(SS_MUTE_OFF);

	musicseq = SsSeqOpen((u_long *)getpakaddress(_PAK_raceseq_INDEX), musicvab);
	if (musicseq < 0)
		printf("Failed to open SEQ\n");
	SsSeqSetVol(musicseq,musicvolume,musicvolume);

	funkseq = SsSeqOpen((u_long *)getpakaddress(_PAK_funkseq_INDEX), musicvab);
	if (funkseq < 0)
		printf("Failed to open FUNK seq\n");
	SsSeqSetVol(funkseq,musicvolume,musicvolume);
	}


// STd0 test
//	vhptr = (void *)getpakaddress(_PAK_std0vh_INDEX);
//	soundvab = SsVabTransfer ( (u_char *)getpakaddress(_PAK_std0vh_INDEX), (u_char *)getpakaddress(_PAK_std0vb_INDEX),-1,1);
//	if (soundvab<0)
//		printf("CRASH: COULD NOT TRANSFER std0 SOUND\n");
//	else
//		printf("Sound VAB on %d\n",soundvab);

}

void closesound()
{
	SsVabClose(soundvab);
}

void ny_title()
{
	GsIMAGE	img;
	RECT		r;
	long		x,y;
	GsSPRITE	t1,t2;
	u_long	*tim;
	int		f,count;

	if (FPS == 50)
		SetVideoMode(MODE_PAL);		// Set video mode
	else
		SetVideoMode(MODE_NTSC);
	GsInitGraph(SCREENWIDTH,SCREENHEIGHT,4,1,0);	// Initialise graphics system. Screen is 320x240 pixels.
					// Non Interlaced/GPU offset for double buffering, no dithering, 16bit VRAM
	GsDefDispBuff(0,0,0,256);	// Define Double buffering. Buffer 0 starts at 0,0
					// Buffer 1 starts at 0,256
	GsInit3D();			// Initialise 3D libraries
	projection = 96;
	GsDISPENV.screen.x = 4;


	t1.attribute = 2<<24;
	t1.w=160;
	t1.h=240;
	t1.tpage = GetTPage(2,0,512,0);
	t1.u = 0;
	t1.v = 0;
	t1.r = t1.g = t1.b = 0;
	t1.mx = 160;
	t1.my = 120;
	t1.scalex = t1.scaley = ONE;
	t1.rotate = 4096*50;
	t2 = t1;
	t2.tpage = GetTPage(2,0,512,256);
	t2.u = 0;
	t2.mx = 0;

	tim = (u_long *)getpakaddress(_PAK_nytitletim_INDEX);
	tim++;
	TransferTextures(tim);				// copy title screen to frame buffer

	r.x = 512+160;					// copy second half of image to seperate tpage
	r.y = 0;
	r.w = 160;
	r.h = 240;
	MoveImage(&r,512,256);

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

	x = 0<<MYBITSHIFT;
	y = 0<<MYBITSHIFT;
	count = 325;
	while (count>0)
	{
		activebuff = GsGetActiveBuff();
		GsSetWorkBase((PACKET *)GpuPacketArea[activebuff]);
		GsClearOt(0, 0, &WorldOT[activebuff]);

		if (count>275)
		{
			t1.rotate -= 4096;
			t2.rotate = t1.rotate;
			t1.scalex = t1.scaley = ONE/(count-275);
			t2.scalex = t2.scaley = t1.scalex;
		}
		if (count>197)
			t1.r = t1.g = t1.b = t2.r = t2.g = t2.b = t1.r + 1;

		if (count<63)
			t1.r = t1.g = t1.b = t2.r = t2.g = t2.b = t1.r - 2;

		t1.x = t2.x = x>>MYBITSHIFT;
		t1.y = t2.y = y>>MYBITSHIFT;
		GsSortSprite(&t1,&WorldOT[activebuff],1);
		GsSortSprite(&t2,&WorldOT[activebuff],1);


		DrawSync(0);
		VSync(0);
		GsSwapDispBuff();
		GsSortClear(0,0,0,&WorldOT[activebuff]);
		GsDrawOt(&WorldOT[activebuff]);
		count--;
	}

}

void specialthanks()
{
	int	count,f;
	GsSPRITE	sp1,sp2,mspr[MAXMICHAEL],tmpspr;
	short		*sintab;

	sintab = (short *)getpakaddress(_PAK_sintab_INDEX);

	TransferTIM(_PAK_specialtim_INDEX);
	TransferTIM(_PAK_michaeltim_INDEX);

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

	for (f=0;f<MAXMICHAEL;f++)
	{
		mspr[f].attribute = (1<<30) | (3<<28);
		mspr[f].w = 152;
		mspr[f].h = 14;
		mspr[f].u = 0;
		mspr[f].v = 50;
		mspr[f].cx = 768;
		mspr[f].cy = 49;
		mspr[f].tpage = 12;
		mspr[f].r = mspr[f].g = mspr[f].b = (128-f*(128/MAXMICHAEL))/2;
		mspr[f].mx = mspr[f].w/2;
		mspr[f].my = 7;
		mspr[f].scalex = mspr[f].scaley = ONE;
		mspr[f].rotate = 0;
	}
	mspr[0].r = mspr[0].g = mspr[0].b = 128;
	mspr[0].cy = 48;
	mspr[0].tpage = GetTPage(1,0,768,0);
	mspr[0].attribute = 1<<24;
	mspr[0].v = 16;
	mspr[0].x = 300;
	mspr[0].y = 100;

	sp1 = sp2 = mspr[0];
	sp1.w = 124;
	sp1.h = 14;
	sp1.v = 0;
	sp2.w = 182;
	sp2.h = 14;
	sp2.v = 32;
	sp1.mx = sp1.w/2;
	sp1.my = sp1.h/2;
	sp2.mx = sp2.w/2;
	sp2.my = sp2.h/2;
	sp1.r = sp1.g = sp1.b = sp2.r = sp2.g = sp2.b = 0;
	sp1.x = sp2.x = 0;
	sp1.y = -64;
	sp2.y = 64;

	count = 0;
	while (count<464)
	{
		activebuff = GsGetActiveBuff();
		GsSetWorkBase((PACKET *)GpuPacketArea[activebuff]);
		GsClearOt(0, 0, &WorldOT[activebuff]);

		if (count<64)
			sp1.r = sp1.g = sp1.b = sp1.r + 2;			// fade 'with special thanks to' in

		if (count<128 && count>64)					// spin in 'michael de cruz'
		{
			mspr[0].x = (32767-*(sintab+(154-(count-64))))/102;
			mspr[0].y = (32767-*(sintab+(154-(count-64))))/164;
			mspr[0].rotate = (32767-*(sintab+(154-(count-64))))*8;
			mspr[0].scalex = mspr[0].scaley = 4096-(32767-*(sintab+(154-(count-64))))/6;
		}

		if (count>128 && count<192)					// fade 'for ...' in
			sp2.r = sp2.g = sp2.b = sp2.r + 2;

		if (count==392)							// clear michael
			mspr[0].y = -200;

		if (count>400)
		{
			sp1.r = sp1.g = sp1.b = sp1.r - 2;
			sp2.r = sp2.g = sp2.b = sp2.r - 2;
			for (f=0;f<MAXMICHAEL;f++)
			{
				if (mspr[f].r > 1)
					mspr[f].r = mspr[f].g = mspr[f].b = mspr[f].r - 2;
			}
		}

		for (f=MAXMICHAEL-1;f>0;f-=1)
		{
			mspr[f].x = mspr[f-1].x;
			mspr[f].y = mspr[f-1].y;
			mspr[f].rotate = mspr[f-1].rotate;
			mspr[f].scalex = mspr[f-1].scalex;
			mspr[f].scalex = mspr[f-1].scalex;
		}

		if (count>64)
			for (f=0;f<MAXMICHAEL;f++)
				GsSortSprite(&mspr[f],&WorldOT[activebuff],f+1);

		GsSortSprite(&sp1,&WorldOT[activebuff],0);
		if (count > 128)
			GsSortSprite(&sp2,&WorldOT[activebuff],0);

		DrawSync(0);
		VSync(0);
		GsSwapDispBuff();
		GsSortClear(0,0,0,&WorldOT[activebuff]);
		GsDrawOt(&WorldOT[activebuff]);
		count++;
	}

}

void showrankings()
{
	int	count,screen,f,g;
	int	rankd[4],rankp[4],tmp;

	for (f=0;f<4;f++)
	{
//		printf("%d  %d\n",carpositions[f],players[object[driver[carpositions[f]].object].extra->playerindex].cash);
		players[object[driver[carpositions[f]].object].extra->playerindex].score+=8-f*1.3;
		players[object[driver[carpositions[f]].object].extra->playerindex].cash+=(600-f*150);
//		printf("%d  %d\n\n",carpositions[f],players[object[driver[carpositions[f]].object].extra->playerindex].cash);
	}

	for (f=0;f<4;f++)				// set up list of drivers and scores
	{
		rankd[f]=carpositions[f];
		rankp[f]=players[object[driver[rankd[f]].object].extra->playerindex].score;
	}

	for (g=0;g<4;g++)
		for (f=1;f<4;f++)
		{
			if (rankp[f]>rankp[f-1])
			tmp = rankp[f];
			rankp[f] = rankp[f-1];
			rankp[f-1] = tmp;
			tmp = rankd[f];
			rankd[f] = rankd[f-1];
			rankd[f-1]=tmp;
		}

	projection=96;			// 512
	GsSetProjection(projection);
	cameraview.vrx = 0;
	cameraview.vry = 0;
	cameraview.vrz = 0;
	cameraview.vpx = 0;
	cameraview.vpy = 0;
	cameraview.vpz = -1800;
	cameraview.rz = 0;
	cameraview.super = WORLD;
	GsSetRefView2(&cameraview);

	count = 0;
	screen = 0;
	while (count<600)
	{
		activebuff = GsGetActiveBuff();
		GsSetWorkBase((PACKET *)GpuPacketArea[activebuff]);
		GsClearOt(0, 0, &WorldOT[activebuff]);
		GsClearOt(0, OTPRI_BACK, &BackOT[activebuff]);		// background object
		GsClearOt(0, 0, &OverlayOT[activebuff]);

		GsSetRefView2(&cameraview);

		if (count == 300)
			screen = 1;

		if (screen == 0)
		{
			print8(112,64,"RACE RESULTS");
			print8(16,80,"POS");
			print8(160,80,"PTS");
			print8(190,80,"CASH");
			for (f=0;f<4;f++)
			{
				if (count > f*25)
				{
					int8(16,f*8+100,1,f+1);
					if (driver[carpositions[f]].class == 1)		// if human
						print8(32,f*8+100,players[object[driver[carpositions[f]].object].extra->playerindex].name);
					else
						print8(32,f*8+100,"CPU");
					int8(160,f*8+100,1,8-f*1.3);
					int8(190,f*8+100,3,600-f*150);
				}
			}
		}
		else if (screen == 1)
		{
			print8(112,64,"OVERALL RANKINGS");
			for (f=0;f<4;f++)
			{
				if (driver[rankd[f]].class == 1)
					print8(32,f*8+100,players[object[driver[rankd[f]].object].extra->playerindex].name);
				else
					print8(32,f*8+100,"CPU");
				int8(160,f*8+100,3,players[object[driver[rankd[f]].object].extra->playerindex].score);
			}
		}

		UpdateObjectCoordinates(&backlobj);
		UpdateObjectCoordinates(&backrobj);
		DisplayObject3D(&backlobj);
		DisplayObject3D(&backrobj);

		GsSortOt(&BackOT[activebuff],&WorldOT[activebuff]);
		DrawSync(0);
		GsDrawOt(&OverlayOT[activebuff]);
		DrawSync(0);
		VSync(0);
		GsSwapDispBuff();
		GsSortClear(0,0,0,&WorldOT[activebuff]);
		GsDrawOt(&WorldOT[activebuff]);
		count++;
	}

}