#define SPRSIZE		8
#define PITXOFF		(SPRSIZE*2+((MAXPITWIDTH-PITWIDTH)*SPRSIZE/2))
#define PITYOFF		SPRSIZE*4

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

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

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

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

#define NODIR		-1
#define LEFT		0
#define UP		1
#define RIGHT		2
#define DOWN		3
#define PATHLEN		(MAXPITWIDTH*PITDEPTH)

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

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


typedef struct
    {
    int		score;
    int		level;
    char	name[4];
    } Hisc;

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


Game			game;


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

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

	case UPDOWN:
	    return(ACROSS);
	    break;

	case ACROSS:
	    return(UPDOWN);
	    break;

	case LEFTDOWN:
	    return(LEFTUP);
	    break;

	case RIGHTDOWN:
	    return(LEFTDOWN);
	    break;

	case LEFTUP:
	    return(RIGHTUP);
	    break;

	case RIGHTUP:
	    return(RIGHTDOWN);
	    break;

	default:
	    return(BLANK);
	    break;
	}
}


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

	case UPDOWN:
	    return(ACROSS);
	    break;

	case ACROSS:
	    return(UPDOWN);
	    break;

	case LEFTDOWN:
	    return(RIGHTDOWN);
	    break;

	case RIGHTDOWN:
	    return(RIGHTUP);
	    break;

	case LEFTUP:
	    return(LEFTDOWN);
	    break;

	case RIGHTUP:
	    return(LEFTUP);
	    break;

	default:
	    return(BLANK);
	    break;
	}
}


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

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

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

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

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

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

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

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

	default:
	    return(NODIR);
	    break;
	}
}


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

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

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

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

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

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


int FindPath(Path *p)
{
    int f;

    p->len=0;

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

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

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

    return (FALSE);
}


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

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

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

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

    if ((x==ox)&&(y==oy))
    	return (TRUE);
    else
    	return (FindLoopFrom(ox,oy,x,y,dir,p));
}


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

    p->len=0;

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

    return(FALSE);
}


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

    if (tile==BLANK)
    	return;

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


void GetSpecialPath(Path *p)
{
    p->len=0;

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

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

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

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


void DrawPath(Path *p)
{
}


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

#define DSNO	3
#define DSFADE	(SLOW ? (10) : (20))

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

void InitScores(void)
{
    int f;

    for(f=0;f<DSNO;f++)
	{
	strcpy(dispsc[f].p,"X");
	dispsc[f].sc=0;
	dispsc[f].col=BLACK;
	dispsc[DSNO-1].cnt=DSFADE;
	}
}


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

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

    strcpy(dispsc[0].p,s);
    dispsc[0].sc=sc;
    dispsc[0].col=MELTOMAX-1;
    dispsc[0].cnt=DSFADE;
}


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

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

	textout(img,font8,s,SCOREPX,SCREEN_H-(8*f+8),dispsc[f].col);

	if (dispsc[f].col!=BLACK)
	    if (--dispsc[f].cnt==0)
		{
		dispsc[f].cnt=DSFADE;
		if (--dispsc[f].col==MELTOMIN)
		    dispsc[f].col=BLACK;
		}
	}
}


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


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

void LoadHisc(void)
{
}


void SaveHisc(void)
{
}


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

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

    clear(img);

    if (MODE==TETRIS_CLASSIC)
    	{
	for(x=-1;x<=PITWIDTH;x++)
	    draw_rle_sprite(img,SPR(CLASSIC_WALL),PITX(x),PITY(PITDEPTH));

	for(y=0;y<PITDEPTH;y++)
	    {
	    draw_rle_sprite(img,SPR(CLASSIC_WALL),PITX(PITWIDTH),PITY(y));
	    draw_rle_sprite(img,SPR(CLASSIC_WALL),PITX(-1),PITY(y));
	    }
	}
    else
    	{
	for(x=-1;x<=PITWIDTH;x++)
	    {
	    if (x==-1)
		spr=SPR(PIT_BL);
	    else if (x==PITWIDTH)
		spr=SPR(PIT_BR);
	    else
		spr=SPR(PIT_BM);

	    draw_rle_sprite(img,spr,PITX(x),PITY(PITDEPTH));
	    }

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

	    draw_rle_sprite(img,spr,PITX(-1),PITY(y));

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

	    draw_rle_sprite(img,spr,PITX(PITWIDTH),PITY(y));
	    }
	}

    DrawInfo();
}


void RedrawPit(void)
{
    int x,y;

    for(x=0;x<PITWIDTH;x++)
    	for(y=0;y<PITDEPTH;y++)
	    if (pit.data[y][x]!=BLANK)
		draw_rle_sprite(img,SPR(pit.data[y][x]),PITX(x),PITY(y));
}


void DrawPiece(void)
{
    int x,y;

    for(x=0;x<4;x++)
	for(y=0;y<4;y++)
	    if (game.current.data[y][x]!=BLANK)
		draw_rle_sprite(img,SPR(game.current.data[y][x]),
				    PITX(game.x+x-game.current.ox),
				    PITY(game.y+y-game.current.oy));
}


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

    textout(img,font8,"SCORE",SCOREPX,SCOREY,WHITE);
    textout(img,font8,"LEVEL",LEVELPX,LEVELY,WHITE);
    textout(img,font8,"NEXT",NEXTPX,NEXTY,WHITE);

    sprintf(sc,"%7d",game.score);
    textout(img,font8,sc,SCOREX,SCOREY,WHITE);

    sprintf(sc,"%7d",game.level);
    textout(img,font8,sc,LEVELX,LEVELY,WHITE);

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

	    if (game.next.data[y][x]==BLANK)
		rectfill(img,px,py,px+SPRSIZE,py+SPRSIZE,BLACK);
	    else
		draw_rle_sprite(img,SPR(game.next.data[y][x]),px,py);
	    }
}


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

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

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

    game.x=PITWIDTH/2;

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

    game.rotate=0;

    game.next_is_special=special;

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

	game.next.ox=0;
	game.next.oy=0;
	}
    else
    	{
	game.next_type=RND(NO_TETRIS_PIECE);

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

	game.next.ox=tetris_off[game.next_type][0].x;
	game.next.oy=tetris_off[game.next_type][0].y;
	}
}


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

    if (game.is_special)
    	return;

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

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

	p.ox=tetris_off[game.current_type][game.rotate].x;
	p.oy=tetris_off[game.current_type][game.rotate].y;
	}
    else
	{
	game.rotate=ROR(game.rotate);

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

	p.ox=tetris_off[game.current_type][game.rotate].x;
	p.oy=tetris_off[game.current_type][game.rotate].y;
	}

    game.current=p;
}


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

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

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

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

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

    return(TRUE);
}


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

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

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

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

    return(FALSE);
}


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

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


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

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

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

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

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

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


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


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

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

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

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



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

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

    game.score+=game.level;

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

	/* Shouldn't be false anyway...
	*/
	if (path.len)
	    {
	    sc=(path.len*game.level);
	    game.score+=sc;
	    AddScore("SPECIAL",sc);
	    DrawPath(&path);
	    RedrawPit();
	    DrawInfo();
	    GameRedraw();
	    CompressPath();
	    RedrawPit();
	    GameRedraw();
	    CompressBlanks();
	    RedrawPit();
	    GameRedraw();
	    }
	}

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

    /* Check for loops
    */
    while (FindLoop(&path))
	{
	sc=(path.len*game.level)*10;
	game.score+=sc;
	AddScore("LOOP",sc);
	DrawPath(&path);
	RedrawPit();
	DrawInfo();
	GameRedraw();
	CompressPath();
	RedrawPit();
	GameRedraw();
	CompressBlanks();
	RedrawPit();
	GameRedraw();
	}

}


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

void PlayGame(void)
{
    struct {int rot_r,rot_l,left,right,drop;} bounce;
    int mvctr;
    int dead;
    int no;
    int id;
    int k;

    bounce.rot_r=0;
    bounce.rot_l=0;
    bounce.left=0;
    bounce.right=0;
    bounce.drop=0;

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

    text_mode(0);
    clear_keybuf();

    if (MUSIC)
    	play_midi(game_midi,TRUE);

    if (MOTION)
	InitStars();

    InitScores();

    while(!dead)
    	{
	/* Not a switch as some are variables now
	*/
	k=GETKEY;

	if (k==KQUIT)
	    dead=TRUE;

	if (k==KPAUSE)
	    DoPause();

	if (k==KBORED)
	    {
	    game.level++;
	    DrawInfo();
	    }

	/* See if it's time for the block to drop
	*/
	if (!(mvctr--))
	    {
	    ErasePiece();

	    /* See if piece can move down
	    */
	    if (MoveOK(game.x,game.y+1))
	    	{
		SoundFX(CLICK_FX);
		game.y++;
		mvctr=LEVELCTR(game.level);
		DrawPiece();
		GameRedraw();
		}
	    else
		{
		SoundFX(POP_FX);

		if (AddAndCheckIsDead(id++))
		    {
		    /* If dead, setup exit of loop.
		    */
		    dead=TRUE;
		    DrawPiece();
		    }
		else
		    {
		    /* Check for scoring and paths
		    */
		    (*gamedef[MODE].do_paths)();

		    /* Generate new piece and reset counters
		    */
		    (*gamedef[MODE].gen_piece)
		    		((id%gamedef[MODE].special_count)==0);

		    bounce.rot_r=0;
		    bounce.rot_l=0;
		    bounce.left=0;
		    bounce.right=0;
		    bounce.drop=0;

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

		    mvctr=LEVELCTR(game.level);

		    RedrawPit();
		    DrawInfo();
		    GameRedraw();
		    }
		}
	    }
	else
	    /* If it's not block dropping time, allow it to move
	    */
	    {
	    ErasePiece();

	    /* Check left/right
	    */
	    if ((key[KLEFT])&&(!bounce.left))
	    	{
		bounce.left=BOUNCEVAL;

		if (MoveOK(game.x-1,game.y))
		    game.x--;
		}
	    else if ((key[KRIGHT])&&(!bounce.right))
	    	{
		bounce.right=BOUNCEVAL;

		if (MoveOK(game.x+1,game.y))
		    game.x++;
		}

	    if ((key[KDROP])&&(!bounce.drop))
	    	{
		bounce.drop=BOUNCEVAL;
		mvctr=0;
		}

	    if ((key[KROTATEL])&&(!bounce.rot_l))
	    	{
		(*gamedef[MODE].rot_piece)(LEFT);

		if (MoveOK(game.x,game.y))
		    bounce.rot_l=BOUNCEVAL;
		else
		    (*gamedef[MODE].rot_piece)(RIGHT);
		}
	    else if ((key[KROTATER])&&(!bounce.rot_r))
	    	{
		(*gamedef[MODE].rot_piece)(RIGHT);

		if (MoveOK(game.x,game.y))
		    bounce.rot_r=BOUNCEVAL;
		else
		    (*gamedef[MODE].rot_piece)(LEFT);
		}

	    DrawPiece();
	    GameRedraw();
	    }

	/* Bounce keys
	*/
	KEYBOUNCE(KROTATEL,bounce.rot_l);
	KEYBOUNCE(KROTATER,bounce.rot_r);
	KEYBOUNCE(KLEFT,bounce.left);
	KEYBOUNCE(KRIGHT,bounce.right);
	KEYBOUNCE(KDROP,bounce.drop);
	}

    if (MUSIC)
    	stop_midi();

    SoundFX(GAMEOVER_FX);
}


/* -------------------------------------------------------------------------
				   GAME OVER
   ------------------------------------------------------------------------- */

void GameOver(void)
{
}


/* -------------------------------------------------------------------------
				 ENTER HISCORE
   ------------------------------------------------------------------------- */

void EnterHisc(void)
{
    static char hisc_let[]="ABCDEFGHIJKLMNOPQRSTUVXYZ. ~<>";

    char s[80];
    int sc;
    int f;
    int sl;
    int sbx;
    int done;
    int curs;
    int len;
    int spr;
    int ctr;
    int k;

    clear(img);
    sl=strlen(hisc_let);
    sbx=CX-text_length(font8,hisc_let)/2-3;
    len=0;
    done=FALSE;
    curs=0;
    spr=HISC_CURS1;
    ctr=0;

    /* Work out which hiscore to use
    */
    for(f=0,sc=-1;(f<HISC)&&(sc==-1);f++)
    	if (game.score>hisc[MODE][f].score)
	   sc=f;

    for(f=HISC-1;f>sc;f--)
    	hisc[MODE][f]=hisc[MODE][f-1];

    strcpy(hisc[MODE][sc].name,"");
    hisc[MODE][sc].level=LEVEL;
    hisc[MODE][sc].score=game.score;

    if (MUSIC)
    	play_midi(score_midi,TRUE);

    text_mode(0);

    /* Go and do entry
    */
    while(!done)
    	{
	rectfill(img,0,0,SCREEN_W-1,50,BLACK);

	CENTRE(hisc_let,20,WHITE);

    	draw_rle_sprite(img,SPR(spr),sbx+curs*8,17);

	if ((ctr++%10)==0)
	    if (++spr>HISC_CURS3)
		spr=HISC_CURS1;

	CENTRE("ENTER YOUR INITIALS",CY,CYAN);

	k=GETKEY;

	if ((k==KLEFT)||(k==KEY_LEFT))
	    {
	    SoundFX(CLICK_FX);
	    if (len==3)
		{
		if (curs==sl-2)
		    curs=sl-1;
		else
		    curs=sl-2;
		}
	    else
		{
		if (curs)
		    curs--;
		else
		    curs=sl-1;
		}
	    }

	else if((k==KRIGHT)||(k==KEY_RIGHT))
	    {
	    SoundFX(CLICK_FX);
	    if (len==3)
		{
		if (curs==sl-2)
		    curs=sl-1;
		else
		    curs=sl-2;
		}
	    else
		{
		if (curs==(sl-1))
		    curs=0;
		else
		    curs++;
		}
	    }
	else if ((k==KDROP)||(k==KEY_SPACE))
	    {
	    SoundFX(POP_FX);
	    switch(hisc_let[curs])
		{
		case '<':
		    if (len)
			{
			len--;
			hisc[MODE][sc].name[len]=0;
			}
		    break;

		case '>':
		    done=TRUE;
		    break;

		default:
		    hisc[MODE][sc].name[len]=hisc_let[curs];
		    hisc[MODE][sc].name[++len]=0;

		    if (len==3)
			curs=sl-1;
		    break;
		}
	    }

	for(f=0;f<HISC;f++)
	    {
	    sprintf(s,"%d  %-3s  %3d  %7d", f+1,
					    hisc[MODE][f].name,
					    hisc[MODE][f].level,
					    hisc[MODE][f].score);
	    if (f==sc)
		CENTRE(s,150+f*8,WHITE);
	    else
		CENTRE(s,150+f*8,RED);
	    }

	if (MOTION)
	    UpdateStars();

	Redraw();
	}

    if (MUSIC)
    	stop_midi();
}