/*
 * Plumb -- a pipe-fitting game
 * Bugs:
 *	must tweak timing
 */
#include <u.h>
#include <libc.h>
#include <libg.h>
#include <stdio.h>
int score;
/*
 * Per-piece data
 */
/*
 * Directions
 */
#define	NORTH	0	/* exit north */
#define	EAST	1	/* exit east */
#define	SOUTH	2	/* exit south */
#define	WEST	3	/* exit west */
#define	START	4	/* begin block */
#define	NDIR	5
#define	END	5	/* finish block */
#define	ILL	6	/* entry not allowed (illegal) */
/*
 * Classes (END and START are classes, as well as directions)
 */
#define	CURVE	0		/* curved player pieces */
#define	STR8	1		/* straight player pieces, pun -- 8==AIGHT */
#define	CROSS	2		/* the cross piece */
#define	ONEWAY	3		/* one-way pieces */
#define	NPLAYER	4		/* pieces placed by player have class<NPLAYER */
/*	START	4 */		/* start block */
/*	END	5 */		/* end block */
#define	BLOCK	6		/* blocked squares */
#define	RES	7		/* reservoirs */
#define	BONUS	8		/* bonus pipe */
#define	NCLASS	9
#define	EMPTY	9		/* empty squares */
struct piece{
	int exit[NDIR];		/* exit direction, for each entry */
	int class;		/* What kind of piece is this */
	int s0, s1;		/* score for each passage through */
	Bitmap *image;
}piece[];
#define	NPIECE	(sizeof piece/sizeof piece[0])
struct piece piece[]={
/*	NORTH,  EAST, SOUTH,  WEST, START,  class,  s0,  s1, image */
	 EAST, NORTH,   ILL,   ILL,   ILL,  CURVE, 100,   0, 0, /*  0 N/E */
	SOUTH,   ILL, NORTH,   ILL,   ILL,   STR8, 100,   0, 0, /*  1 N/S */
	 WEST,   ILL,   ILL, NORTH,   ILL,  CURVE, 100,   0, 0, /*  2 N/W */
	  ILL, SOUTH,  EAST,   ILL,   ILL,  CURVE, 100,   0, 0, /*  3 E/S */
	  ILL,  WEST,   ILL,  EAST,   ILL,   STR8, 100,   0, 0, /*  4 E/W */
	  ILL,   ILL,  WEST, SOUTH,   ILL,  CURVE, 100,   0, 0, /*  5 S/W */
	SOUTH,  WEST, NORTH,  EAST,   ILL,  CROSS, 100, 400, 0, /*  6 N/S+E/W */
	 EAST,   ILL,   ILL,   ILL,   ILL, ONEWAY, 200,   0, 0, /*  7 N/E one way */
	SOUTH,   ILL,   ILL,   ILL,   ILL, ONEWAY, 200,   0, 0, /*  8 N/S one way */
	 WEST,   ILL,   ILL,   ILL,   ILL, ONEWAY, 200,   0, 0, /*  9 N/W one way */
	  ILL, NORTH,   ILL,   ILL,   ILL, ONEWAY, 200,   0, 0, /* 10 E/N one way */
	  ILL, SOUTH,   ILL,   ILL,   ILL, ONEWAY, 200,   0, 0, /* 11 E/S one way */
	  ILL,  WEST,   ILL,   ILL,   ILL, ONEWAY, 200,   0, 0, /* 12 E/W one way */
	  ILL,   ILL, NORTH,   ILL,   ILL, ONEWAY, 200,   0, 0, /* 13 S/N one way */
	  ILL,   ILL,  EAST,   ILL,   ILL, ONEWAY, 200,   0, 0, /* 14 S/E one way */
	  ILL,   ILL,  WEST,   ILL,   ILL, ONEWAY, 200,   0, 0, /* 15 S/W one way */
	  ILL,   ILL,   ILL, NORTH,   ILL, ONEWAY, 200,   0, 0, /* 16 W/N one way */
	  ILL,   ILL,   ILL,  EAST,   ILL, ONEWAY, 200,   0, 0, /* 17 W/E one way */
	  ILL,   ILL,   ILL, SOUTH,   ILL, ONEWAY, 200,   0, 0, /* 18 W/S one way */
	  ILL,   ILL,   ILL,   ILL, NORTH,  START,   0,   0, 0, /* 19 start N */
	  ILL,   ILL,   ILL,   ILL,  EAST,  START,   0,   0, 0, /* 20 start E */
	  ILL,   ILL,   ILL,   ILL, SOUTH,  START,   0,   0, 0, /* 21 start S */
	  ILL,   ILL,   ILL,   ILL,  WEST,  START,   0,   0, 0, /* 22 start W */
	  END,   ILL,   ILL,   ILL,   ILL,    END, 500,   0, 0, /* 23 finish N */
	  ILL,   END,   ILL,   ILL,   ILL,    END, 500,   0, 0, /* 24 finish E */
	  ILL,   ILL,   END,   ILL,   ILL,    END, 500,   0, 0, /* 25 finish S */
	  ILL,   ILL,   ILL,   END,   ILL,    END, 500,   0, 0, /* 26 finish W */
	SOUTH,   ILL, NORTH,   ILL,   ILL,    RES, 200,   0, 0, /* 27 N/S reservoir*/
	  ILL,  WEST,   ILL,  EAST,   ILL,    RES, 200,   0, 0, /* 28 E/W reservoir*/
	SOUTH,   ILL, NORTH,   ILL,   ILL,  BONUS, 200,   0, 0, /* 29 N/S bonus */
	  ILL,  WEST,   ILL,  EAST,   ILL,  BONUS, 200,   0, 0, /* 30 E/W bonus */
	  ILL,   ILL,   ILL,   ILL,   ILL,  BLOCK,   0,   0, 0, /* 31 obstacle */
	  ILL,   ILL,   ILL,   ILL,   ILL,  EMPTY,   0,   0, 0, /* 32 empty */
};
#define	empty	(&piece[NPIECE-1])
#define	SIZE	48	/* width or height of square pieces */
#define	RAD	4	/* radius of pipes, must be even and divide RESRAD, SIZE */
#define	RESRAD	18	/* radius of reservoir */
/*
 * Per-level data
 */
int level;		/* current game level */
int goodelay;		/* delay before goo moves */
int igoospeed;		/* initial goo speed */
int goospeed;		/* how fast the goo flows */
int ibonusdist;		/* initial bonus distance */
int bonusdist;		/* distance before bonuses accrue */
int dist[NPLAYER];	/* distribution of pieces given to player */
struct piece *distp[NPLAYER];
#define	NUPCOMING	100
struct piece *upcoming[NUPCOMING];
struct piece **upcomingp=upcoming, **eupcoming=upcoming;
int init[NCLASS];	/* initial number of pieces of each class */
/*
 * Per-board data
 */
#define	BORDER	4
#define	NX	10
#define	NY	7
struct square{
	struct piece *piece;
	int nentry;
	int mark;
}board[NY][NX];
Rectangle boardr, stackr, scorer;
#define	NSTACK	5
struct piece *stack[NSTACK];
/*
 * animation goodies
 */
int busy;		/* should not respond to the mouse */
int goox, gooy;		/* square currently containing goo */
struct square *goosquare;
int goodir;		/* where did the goo enter? (index in piece->exit) */
int goodist;		/* how far through the square has the goo gone? */
#define	FAST	10	/* speed of fast goo */
#define	RESDELAY	200	/* reservoir filling delay */
#define	NAGENDA	5
struct agenda{
	int time;		/* in msec, as read from /dev/cputime */
	int (*f)(void);
}agenda[NAGENDA];
int running;		/* level still active */
int now;		/* time of last event */
int currtime=0;		/* time of last call to getrtime */
rectf(Bitmap *b, Rectangle r, Fcode f){
	bitblt(b, r.min, b, r, f);
}
myborder(Bitmap *b, Rectangle r, int n, Fcode f){
	if(n<0)
		border(b, inset(r, n), -n, f);
	else
		border(b, r, n, f);
}
message(char *s){
	char buf[100];
	sprintf(buf, "Level %2d.  Score %6d.  Dist %2d.  %s",
		level, score, bonusdist, s);
	string(&screen, add(scorer.min, Pt(1, 1)), font, buf, S);
	rectf(&screen,
		Rpt(add(scorer.min, Pt(1+strwidth(font, buf), 1)), scorer.max), 0);
			
}
addscore(int n, int mult){
	if(mult && (bonusdist==0 || goospeed==FAST)) n*=2;
	score+=n;
	if(score<0) score=0;
	message("");
}
/*
 * Get current real time
 */
int getrtime(void){
	char buf[12*6];
	static int timefd=-1;
	int n;
	if(timefd==-1){
		timefd=open("/dev/cputime", OREAD);
		if(timefd<0){
			perror("open /dev/cputime");
			exits("cputime");
		}
	}
	seek(timefd, 0L, 0);
	if((n=read(timefd, buf, sizeof buf))!=sizeof buf){
		perror("read /dev/cputime");
		exits("read cputime");
	}
	currtime=atoi(buf+24);
	return currtime;
}
/*
 * Schedule f to be called at given time
 */
sched(int time, int (*f)(void)){
	struct agenda *p, *q;
	if(time<now) fprintf(stderr, "time %d < now %d\n", time, now);
	for(p=agenda;p!=&agenda[NAGENDA] && p->f && p->time<=time;p++);
	if(p==&agenda[NAGENDA]){
		fprintf(stderr, "agenda full!\n");
		exits("agenda full");
	}
	for(q=&agenda[NAGENDA-1];q!=p;--q) q[0]=q[-1];
	p->time=time;
	p->f=f;
}
/*
 * If f is on the schedule, reschedule it for the given time
 */
resched(int time, int (*f)(void)){
	struct agenda *p;
	for(p=agenda;p!=&agenda[NAGENDA] && p->f;p++){
		if(p->f==f){
			for(;p!=&agenda[NAGENDA-1] && p[1].f;p++)
				p[0]=p[1];
			if(p!=&agenda[NAGENDA-1])
				p->f=0;
			sched(time, f);
			break;
		}
	}
}
/*
 * Call all functions scheduled to be called before current time
 */
fugit(void){
	struct agenda *p;
	int (*f)(void);
	int future;
	if(!agenda[0].f) return;
	future=getrtime();
	while(agenda[0].f && agenda[0].time<future){
		now=agenda[0].time;
		f=agenda[0].f;
		for(p=&agenda[1];p!=&agenda[NAGENDA] && p->f;p++)
			p[-1]=p[0];
		p[-1].f=0;
		(*f)();
	}
	bflush();
}
putpiece(int x, int y, struct piece *p){
	board[y][x].piece=p;
	bitblt(&screen, add(boardr.min, Pt(x*SIZE, y*SIZE)),
			p->image, p->image->r, S);
}
/*
 * Should run explosion here
 */
#define	NEXPLODE	30	/* # of cycles in explosion */
#define	NDESTROY	10	/* # of cycldes to destroy unused pieces */
#define	XDELAY	33
int explodex, explodey;
struct piece *explodepiece;
explode(void){
	Point p;
	if(--busy==0){
		putpiece(explodex, explodey, explodepiece);
		return;
	}
	p=add(boardr.min, Pt(explodex*SIZE, explodey*SIZE));
	rectf(&screen, Rpt(p, add(p, Pt(SIZE, SIZE))), F&~D);
	sched(now+XDELAY, explode);
}
Point position[]={
	SIZE/2, 0,	/* NORTH */
	SIZE, SIZE/2,	/* EAST */
	SIZE/2, SIZE,	/* SOUTH */
	0, SIZE/2,	/* WEST */
	SIZE/2, SIZE/2,	/* START */
	SIZE/2, SIZE/2,	/* END */
};
fillgoo(int from, int to, int alpha){
	Point p, dp;
	p=add(position[from], add(boardr.min, Pt(goox*SIZE, gooy*SIZE)));
	dp=sub(position[to], position[from]);
	p=add(p, div(mul(dp, alpha), SIZE/2));
	rectf(&screen, Rpt(sub(p, Pt(RAD/2, RAD/2)), add(p, Pt(RAD/2, RAD/2))), 0);
}
Bitmap *resdisk[RESRAD];
mkresdisks(void){
	int i, x, y, xsq;
	Bitmap *b;
	for(i=0;i!=RESRAD;i++){
		b=resdisk[i]=balloc(Rect(0, 0, SIZE, SIZE), 1);
		for(y=0;y!=SIZE/2;y++){
			xsq=i*i-y*y;
			if(xsq>0){
				for(x=1;x*x<xsq;x++);
				segment(b, Pt(SIZE/2-x, SIZE/2-y),
					Pt(SIZE/2+x, SIZE/2-y), 3, S);
				segment(b, Pt(SIZE/2-x, SIZE/2+y),
					Pt(SIZE/2+x, SIZE/2+y), 3, S);
			}
		}
	}
}
fillres(int alpha){
	bitblt(&screen, add(boardr.min, Pt(goox*SIZE, gooy*SIZE)),
		resdisk[alpha], resdisk[alpha]->r, D&~S);
}
movegoo(void){
	int delay=goospeed;
	switch(goosquare->piece->class){
	default:
		fprintf(stderr, "Bad piece class %d in animate\n",
			goosquare->piece->class);
		exits("bad class");
	case EMPTY:
	case BLOCK:
		goto Stop;
	case CURVE:
	case STR8:
	case CROSS:
	case ONEWAY:
	case BONUS:
		if(goodist<SIZE/2) fillgoo(goodir, END, goodist);
		else fillgoo(END, goosquare->piece->exit[goodir], goodist-SIZE/2);
		goodist+=RAD/2;
		if(goodist==SIZE) goto DoneSquare;
		break;
	case RES:
		if(goodist<SIZE/2){
			fillgoo(goodir, END, goodist);
			goodist+=RAD/2;
		}
		else if(goodist<SIZE/2+RESRAD){
			fillres(goodist-SIZE/2);
			if(goospeed!=FAST) delay=RESDELAY;
			goodist++;
		}
		else{
			fillgoo(END, goosquare->piece->exit[goodir],
				goodist-SIZE/2-RESRAD);
			goodist+=RAD/2;
		}
		if(goodist==SIZE+RESRAD) goto DoneSquare;
		break;
	case START:
		fillgoo(END, goosquare->piece->exit[goodir], goodist);
		goodist+=RAD/2;
		if(goodist==SIZE/2) goto DoneSquare;
		break;
	case END:
		fillgoo(goodir, END, goodist);
		goodist+=RAD/2;
		if(goodist==SIZE/2) goto DoneSquare;
		break;
	}
	sched(now+delay, movegoo);
	return;
Stop:
	running=0;
	return;
DoneSquare:
	/*
	 * Finished with this square, score it and move to the next square
	 */
	if(bonusdist) --bonusdist;
	switch(goosquare->nentry){
	case 1: addscore(goosquare->piece->s0, 1); break;
	case 2: addscore(goosquare->piece->s1, 1); break;
	}
	switch(goosquare->piece->exit[goodir]){
	case END: goto Stop;
	case NORTH: if(gooy--==0)  goto Stop; goodir=SOUTH; break;
	case EAST:  if(++goox==NX) goto Stop; goodir=WEST;  break;
	case SOUTH: if(++gooy==NY) goto Stop; goodir=NORTH; break;
	case WEST:  if(goox--==0)  goto Stop; goodir=EAST;  break;
	}
	goosquare=&board[gooy][goox];
	if(goosquare->piece->exit[goodir]==ILL) goto Stop;
	goosquare->nentry++;
	goodist=0;
	sched(now+goospeed, movegoo);
}
fillin(Bitmap *b, int edge){
	switch(edge){
	case NORTH:
		rectf(b, Rect(SIZE/2-RAD, 0, SIZE/2+RAD, SIZE/2+RAD), F);
		break;
	case EAST:
		rectf(b, Rect(SIZE/2-RAD, SIZE/2-RAD, SIZE, SIZE/2+RAD), F);
		rectf(b, Rect(SIZE-RAD, SIZE/2-3*RAD/2,
				SIZE, SIZE/2+3*RAD/2), F);
		break;
	case SOUTH:
		rectf(b, Rect(SIZE/2-RAD, SIZE/2-RAD, SIZE/2+RAD, SIZE), F);
		rectf(b, Rect(SIZE/2-3*RAD/2, SIZE-RAD,
				SIZE/2+3*RAD/2, SIZE), F);
		break;
	case WEST:
		rectf(b, Rect(0, SIZE/2-RAD, SIZE/2+RAD, SIZE/2+RAD), F);
		break;
	}
}
pieceimages(int version){
	struct piece *p;
	int f;
	char name[100];
	static int first=1;
	static int lastversion=-1;
	if(version==lastversion) return;
	sprintf(name, "/sys/games/lib/plumb/pieces.%d", version);
	f=open(name, OREAD);
	if(f<0){
		if(first){
			perror(name);
			exits("Can't read pieces");
		}
		return;
	}
	first=0;
	lastversion=version;
	for(p=piece;p!=&piece[NPIECE];p++){
		if(p->image) bfree(p->image);
		p->image=rdbitmapfile(f);
	}
	close(f);
}
/*
 * An entry in the level file contains:
 * Level BonusDist Delay Speed PieceVersion
 *	CURVE STR8 CROSS ONEWAY
 *	END BLOCK RES BONUS
 */
FILE *param;
levelparams(int really){
	int i, piecenum, total;
	if(param==0){
		param=fopen("/sys/games/lib/plumb/levels", "r");
		if(param==0){
			perror("/sys/games/lib/plumb/levels");
			exits("can't open levels");
		}
	}
	if(fscanf(param, "%d", &i)==1){
		if(i!=level){
			fprintf(stderr,
				"parameter phase error, level %d!=%d\n", level, i);
			exits("parameter phase");
		}
		if(fscanf(param, "%d%d%d%d",
			&ibonusdist, &goodelay, &igoospeed, &piecenum)!=4){
		Bad:
			fprintf(stderr, "parameter error, level %d\n", level);
			exits("bad levels");
		}
		total=0;
		for(i=CURVE;i!=NPLAYER;i++){
			if(fscanf(param, "%d", &dist[i])!=1)
				goto Bad;
			distp[i]=piece;
			total+=dist[i];
		}
		if(total==0 || total>NUPCOMING)
			goto Bad;
		for(i=END;i!=NCLASS;i++)
			if(fscanf(param, "%d", &init[i])!=1)
				goto Bad;
	}
	if(really) pieceimages(piecenum);
	init[START]=1;
}
replacable(int x, int y){
	struct square *p;
	if(y<0 || NY<=y || x<0 || NX<=x) return 0;
	p=&board[y][x];
	if(p->nentry) return 0;
	switch(p->piece->class){
	case CURVE:
	case STR8:
	case CROSS:
	case ONEWAY:
	case EMPTY:
		return 1;
	default:
		return 0;
	}
}
okdir(int x, int y, int dir){
	switch(dir){
	case NORTH: --y; break;
	case EAST:  x++; break;
	case SOUTH: y++; break;
	case WEST:  --x; break;
	default:    return 1;
	}
	return 1<=x && x<NX-1 && 1<y && y<NY-1 && board[y][x].piece->class==EMPTY;
}
floodboard(int x, int y){
	if(x<0 || NX<=x || y<0 || NY<=y
	|| board[y][x].piece!=empty || board[y][x].mark) return;
	board[y][x].mark=1;
	floodboard(x+1, y);
	floodboard(x-1, y);
	floodboard(x, y-1);
	floodboard(x, y+1);
}
/*
 * Check that no exit is blocked and that the
 * empty cells form a single 4-connected component.
 */
okboard(void){
	int x, y, x0=-1, y0=-1, i;
	struct piece *p;
	for(y=0;y!=NY;y++) for(x=0;x!=NX;x++){
		board[y][x].mark=0;
		p=board[y][x].piece;
		if(p==empty){
			x0=x;
			y0=y;
		}
		for(i=0;i!=NDIR;i++) if(p->exit[i]!=ILL){
			if(!okdir(x, y, i)) return 0;
			if(!okdir(x, y, p->exit[i])) return 0;
		}
	}
	if(x0==-1){
		fprintf(stderr, "Board full!\n");
		exits("board full");
	}
	floodboard(x0, y0);
	for(y=0;y!=NY;y++) for(x=0;x!=NX;x++)
		if(board[y][x].piece==empty && !board[y][x].mark) return 0;
	return 1;
}
struct piece *stackpiece(void){
	struct piece *p, *v, **pp;
	int i, j, k;
	if(upcomingp==eupcoming){
		eupcoming=upcomingp=upcoming;
		for(i=0;i!=NPLAYER;i++) for(j=0;j!=dist[i];j++){
			do{
				if(++distp[i]==&piece[NPIECE])
					distp[i]=piece;
			}while(distp[i]->class!=i);
			++eupcoming;
			pp=upcoming+nrand(eupcoming-upcoming);
			eupcoming[-1]=*pp;
			*pp=distp[i];
		}
	}
	p=*upcomingp++;
	v=stack[0];
	for(i=1;i!=NSTACK;i++)
		stack[i-1]=stack[i];
	stack[NSTACK-1]=p;
	bitblt(&screen, add(stackr.min, Pt(0, SIZE)),
		&screen, Rpt(stackr.min, sub(stackr.max, Pt(0, SIZE))), S);
	bitblt(&screen, stackr.min, p->image, p->image->r, S);
	return v;
}
clearboard(void){
	int x, y, i, j, n, ntry, nrestart=0;
	struct piece *p, *q;
Restart:
	if(nrestart++==20){
		fprintf(stderr, "plumb: clearboard failed\n");
		exits("can't init");
	}
	for(y=0;y!=NY;y++) for(x=0;x!=NX;x++){
		board[y][x].nentry=0;
		board[y][x].piece=empty;
	}
	for(i=0;i!=NCLASS;i++) for(j=0;j!=init[i];j++){
		n=0;
		q=0;
		for(p=piece;p!=&piece[NPIECE];p++)
			if(p->class==i && nrand(++n)==0)
				q=p;
		if(q==0){
			fprintf(stderr, "No piece of class %d\n", i);
			exits("bad class");
		}
		for(ntry=0;;ntry++){
			if(ntry==200)
				goto Restart;
			x=nrand(NX);
			y=nrand(NY);
			if(board[y][x].piece==empty){
				board[y][x].piece=q;
				if(okboard()) break;
				board[y][x].piece=empty;
			}
		}
		if(q->class==START){
			goox=x;
			gooy=y;
			goodir=START;
			goosquare=&board[gooy][goox];
		}
	}
	for(y=0;y!=NY;y++) for(x=0;x!=NX;x++) putpiece(x, y, board[y][x].piece);
}
place(Point p){
	Point cell;
	cell=div(sub(p, boardr.min), SIZE);
	if(replacable(cell.x, cell.y)){
		if(board[cell.y][cell.x].piece!=empty){
			addscore(-50, 0);
			explodex=cell.x;
			explodey=cell.y;
			explodepiece=stackpiece();
			busy=NEXPLODE;
			putpiece(cell.x, cell.y, empty);
			disc(&screen, add(mul(cell, SIZE),
				add(boardr.min, Pt(SIZE/2, SIZE/2))),
				SIZE/2, ~0, S);
			sched(now, explode);
		}
		else
			putpiece(cell.x, cell.y, stackpiece());
	}
}
newlevel(void){
	int i;
	levelparams(1);
	clearboard();
	for(i=0;i!=NSTACK;i++) stackpiece();
	now=getrtime();
	bonusdist=ibonusdist;
	goospeed=igoospeed;
	goodist=0;
	running=1;
	busy=0;
	sched(now+goodelay, movegoo);
}
void ereshaped(Rectangle r){
	int x, y, i;
	screen.r=r;
	scorer.min=add(screen.r.min, Pt(3*BORDER, 3*BORDER));
	scorer.max=add(scorer.min, Pt((NX+2)*SIZE, font->height+2));
	stackr.min=add(scorer.min, Pt(0, font->height+2+3*BORDER));
	stackr.max=add(stackr.min, Pt(SIZE, NSTACK*SIZE));
	boardr.min=add(stackr.min, Pt(2*SIZE, 0));
	boardr.max=add(boardr.min, Pt(NX*SIZE, NY*SIZE));
	if(!ptinrect(add(boardr.max, Pt(BORDER-1, BORDER-1)), screen.r)){
		fprintf(stderr, "window too small, must be at least %d x %d\n",
			boardr.max.x-boardr.min.x+BORDER-1,
			boardr.max.y-boardr.min.y+BORDER-1);
		exits("window too small");
	}
	rectf(&screen, screen.r, 0);
	border(&screen, screen.r, BORDER, F);
	myborder(&screen, screen.r, BORDER, F);
	myborder(&screen, scorer, -BORDER, F);
	myborder(&screen, stackr, -BORDER, F);
	myborder(&screen, boardr, -BORDER, F);
	for(i=0;i!=NSTACK;i++) if(stack[i])
		bitblt(&screen, add(stackr.min, Pt(0, i*SIZE)),
			stack[i]->image, stack[i]->image->r, S);
	for(y=0;y!=NY;y++) for(x=0;x!=NX;x++) if(board[y][x].piece)
		bitblt(&screen, add(boardr.min, Pt(x*SIZE, y*SIZE)),
			board[y][x].piece->image,
			board[y][x].piece->image->r, S);
}
cleanscreen(void){
	rectf(&screen, screen.r, 0);
	border(&screen, screen.r, BORDER, F);
}
outscore(void){
	char buf[100];
	int n;
	int f;
	if(score==0) return;
	f=open("/dev/user", OREAD);
	if(f<0 || (n=read(f, buf, sizeof buf))<=0){
		strcpy(buf, "nobody");
		n=6;
	}
	sprintf(buf+n, " %d %d\n", score, level);
	close(f);
	f=open("/sys/games/lib/plumb/scores", OWRITE);
	write(f, buf, strlen(buf));
	close(f);
}
/*
 * int menuhit(int but, Mouse *m, Menu *menu)
 */
char *but2[]={
	"fast",
	0
};
Menu m2={but2};
menu2(Mouse *m){
	switch(menuhit(2, m, &m2)){
	case 0:
		goospeed=FAST;
		resched(now, movegoo);
		break;
	}
}
char *but3[]={
	"exit",
	0
};
Cursor confirmcursor={
	0, 0,
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

	0x00, 0x0E, 0x07, 0x1F, 0x03, 0x17, 0x73, 0x6F,
	0xFB, 0xCE, 0xDB, 0x8C, 0xDB, 0xC0, 0xFB, 0x6C,
	0x77, 0xFC, 0x00, 0x00, 0x00, 0x01, 0x00, 0x03,
	0x94, 0xA6, 0x63, 0x3C, 0x63, 0x18, 0x94, 0x90,
};
confirm(int b){
	Mouse down, up;
	cursorswitch(&confirmcursor);
	do down=emouse(); while(!down.buttons);
	do up=emouse(); while(up.buttons);
	cursorswitch(0);
	return down.buttons==(1<<(b-1));
}
Menu m3={but3};
menu3(Mouse *m){
	switch(menuhit(3, m, &m3)){
	case 0:
		if(confirm(3)){
			outscore();
			cleanscreen();
			exits("");
		}
	}
}
/*
 * return a mouse event, preempting button 3 hits so
 * that the player can always exit.
 */
Mouse emouse3(void){
	Mouse m;
	for(;;){
		m=emouse();
		if(m.buttons!=4) break;
		menu3(&m);
	}
	return m;
}
waitclick(void){
	do;while(emouse3().buttons==0);
	do;while(emouse3().buttons!=0);
}
main(int argc, char *argv[]){
	int i, x, y, doublecross, firstlevel;
	Mouse oldm, m;
	char buf[100];
	srand(time(0));
	binit(0, 0, 0);
	einit(Emouse|Ekeyboard);
	if(argc>1){
		firstlevel=atoi(argv[1]);
		if(firstlevel<=0){
			fprintf(stderr, "%s: start level must be positive\n",
				argv[0]);
			exits("level<1");
		}
	}
	else
		firstlevel=1;
	ereshaped(screen.r);
	mkresdisks();
	m.buttons=0;
	for(;;){
		score=0;
		if(param){
			fclose(param);
			param=0;
		}
		for(level=1;level!=firstlevel;level++) levelparams(0);
		for(;;level++){
			newlevel();
			addscore(0, 0);	/* to force redisplay */
			bflush();
			while(ecanmouse()) emouse3();
			do{
				if(ecanmouse()){
					oldm=m;
					m=emouse3();
					if(oldm.buttons==0){
						if(m.buttons==1 && !busy && goospeed!=FAST)
							place(m.xy);
						else if(m.buttons==2)
							menu2(&m);
					}
				}
				fugit();
			}while(running);
			while(busy) fugit();
			doublecross=0;
			for(y=0;y!=NY;y++) for(x=0;x!=NX;x++){
				if(board[y][x].piece->class<NPLAYER){
					switch(board[y][x].nentry){
					case 0:
						addscore(-100, 0);
						explodex=x;
						explodey=y;
						explodepiece=empty;
						busy=NDESTROY;
						putpiece(x, y, empty);
						sched(now, explode);
						while(busy) fugit();
						break;
					case 2:
						doublecross++;
						break;
					}
				}
			}
			doublecross=doublecross/5*5;
			if(doublecross){
				sprintf(buf, "Bonus for %d crosses", doublecross);
				message(buf);
				bflush();
				sleep(2000);
				addscore(2000+1000*doublecross, 0);
			}
			while(ecanmouse()) emouse3();
			if(bonusdist) break;
			message("Click to continue");
			waitclick();
		}
		outscore();
		message("Game over [click]");
		waitclick();
		score=0;
		message("New game ...");
	}
}