/*
 * Plumb -- a pipe-fitting game
 * Bugs:
 *	must tweak timing
 *                                           min
 *                                             |------------------------------------|
 *                                             |    scorer                                                                  |
 *                                             |------------------------------------|
 *                                                               min
 *                                     min |-----|       |---------------------------|
 *                                             |           |       |                                                             |
 *                                             |           |       |                                                             |
 *                                             |           |       |                                                             |
 *                                             |           |       |                                                             |
 *          stackr-----------|->      |       |                                                             |
 *                                             |           |       |                                                             |
 *                                             |           |       |            boardr                                     |
 *                                             |           |       |                                                             |
 *                                             |           |       |                                                             |
 *                                             |           |       |                                                             |
 *                                             |           |       |                                                             |
 *                                             |           |       |                                                             |
 *                                             |           |       |                                                             |
 *                                             |           |       |                                                             |
 *                                             |-----|       |---------------------------|
 *                                                     max                                                              max
 *
 *		goo:           flowing oil (red)
 *		explode:   explosion piece (large red circle) indicates busy to do something
 *		resdisk[]:  goo (oil) reservoir where time will be gotten while goo is filling it.
 */

#include <u.h>
#include <libc.h>
#include <draw.h>
#include <event.h>
#include <cursor.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 */
	Image *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 */
	void (*f)(void);
}agenda[NAGENDA];

int running;		/* level still active */
int now;			/* time of last event */
int currtime=0;		/* time of last call to getrtime */

/* colors for plumb */
Image *black;
Image *white;
Image *red;
Image *paleyellow;
Image *darkgreen;
Image *palegreen;
Image *darkblue;
Image *darkgrey;
Image *medgreen;
Image *bgcolor;
Image *whitemask;

void fillres(int);

void rectf(Image *b, Rectangle r, Image *color){
	draw(b, r, color, 0, ZP);
}

void message(char *s){
	char buf[100];
	sprintf(buf, "Level %2d.  Score %6d.  Dist %2d.  %s",
		level, score, bonusdist, s);
	rectf(screen, Rpt(scorer.min, scorer.max), bgcolor);
	string(screen, addpt(scorer.min, Pt(1, 1)), paleyellow, ZP, font, buf);
}

void 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;
	if(timefd==-1){
		timefd=open("/dev/cputime", OREAD);
		if(timefd<0){
			perror("open /dev/cputime");
			exits("cputime");
		}
	}
	seek(timefd, 0L, 0);
	if(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
 */
void sched(int time, void (*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
 */
void resched(int time, void (*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
 */
void fugit(void){
	struct agenda *p;
	void (*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)();
	}
}

/*  put pieces read from /sys/games/lib/plumb/piece.x file */
void putpiece(int x, int y, struct piece *p){
	Point pp;
	board[y][x].piece=p;
	pp = addpt(boardr.min, Pt(x*SIZE, y*SIZE));
	draw(screen, Rpt(pp, addpt(pp, Pt(SIZE, SIZE))), p->image, 0, p->image->r.min);
}

/*
 * Should run explosion here
 */
#define	NEXPLODE	30	/* # of cycles in explosion */
#define	NDESTROY	10	/* # of cycles to destroy unused pieces */
#define	XDELAY	33
int explodex, explodey;
struct piece *explodepiece;

void explode(void){
	Point p;
	if(--busy==0){
		putpiece(explodex, explodey, explodepiece);
		return;
	}
	p=addpt(boardr.min, Pt(explodex*SIZE, explodey*SIZE));
	// draw(screen, Rpt(p, addpt(p, Pt(SIZE, SIZE))), explodepiece->image , black, ZP);
	draw(screen, Rpt(addpt(p, Pt(1,1)), addpt(p, Pt(SIZE-1, SIZE-1))), display->white, whitemask, ZP);
	flushimage(display, 1);
	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 */
};

/* fill goo (flowing oil) */
void fillgoo(int from, int to, int alpha){
	Point p, dp;
	p=addpt(position[from], addpt(boardr.min, Pt(goox*SIZE, gooy*SIZE)));
	dp=subpt(position[to], position[from]);
	p=addpt(p, divpt(mulpt(dp, alpha), SIZE/2));
	/* draw goo flow */
	rectf(screen, Rpt(subpt(p, Pt(RAD/2, RAD/2)), addpt(p, Pt(RAD/2, RAD/2))), red);
}

Image *resdisk[RESRAD];			/* reserviors */
Image *resmask[RESRAD];			/* reservior masks */

/*  draw a red reservior */
void mkresdisks(void){
	int i, x, y, xsq;
	for(i=0; i!=RESRAD; i++){
		resdisk[i]=allocimage(display, Rect(0, 0, SIZE, SIZE), display->windows->chan, 0, DTransparent);
		resmask[i]=allocimage(display, Rect(0, 0, SIZE, SIZE), display->windows->chan, 0, DBlack);
		for(y=0; y!=SIZE/2; y++){
			xsq=i*i - y*y;
			if(xsq>0){
				for(x=1; x*x<xsq; x++) {
					line(resdisk[i], Pt(SIZE/2-x, SIZE/2-y), Pt(SIZE/2+x, SIZE/2-y), 0, 0, 0, red, ZP);
					line(resdisk[i], Pt(SIZE/2-x, SIZE/2+y), Pt(SIZE/2+x, SIZE/2+y), 0, 0, 0, red, ZP);
					line(resmask[i], Pt(SIZE/2-x, SIZE/2-y), Pt(SIZE/2+x, SIZE/2-y), 0, 0, 0, display->white, ZP);
					line(resmask[i], Pt(SIZE/2-x, SIZE/2+y), Pt(SIZE/2+x, SIZE/2+y), 0, 0, 0, display->white, ZP);
				}
			}
		}
	}
}

/* fill reservior */
void fillres(int alpha){
	Point p;
	p=addpt(boardr.min, Pt(goox*SIZE, gooy*SIZE));

	draw(screen, Rpt(p, addpt(p, Pt(SIZE, SIZE))), resdisk[alpha], resmask[alpha], ZP);
}

void 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);
}

void fillin(Image *b, int edge, Image *color){
	switch(edge){
	case NORTH:
		rectf(b, Rect(SIZE/2-RAD, 0, SIZE/2+RAD, SIZE/2+RAD), color);
		break;
	case EAST:
		rectf(b, Rect(SIZE/2-RAD, SIZE/2-RAD, SIZE, SIZE/2+RAD), color);
		rectf(b, Rect(SIZE-RAD, SIZE/2-3*RAD/2,
				SIZE, SIZE/2+3*RAD/2), color);
		break;
	case SOUTH:
		rectf(b, Rect(SIZE/2-RAD, SIZE/2-RAD, SIZE/2+RAD, SIZE), color);
		rectf(b, Rect(SIZE/2-3*RAD/2, SIZE-RAD,
				SIZE/2+3*RAD/2, SIZE), color);
		break;
	case WEST:
		rectf(b, Rect(0, SIZE/2-RAD, SIZE/2+RAD, SIZE/2+RAD), color);
		break;
	}
}

void 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) freeimage(p->image);
		p->image=readimage(display, f, 0);
	}
	close(f);
}
/*
 * An entry in the level file contains:
 * Level BonusDist Delay Speed PieceVersion
 *	CURVE STR8 CROSS ONEWAY
 *	END BLOCK RES BONUS
 */
FILE *param;
void 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;
}

int 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;
	}
}

int 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;
}

void 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.
 */
int 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;
	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;
		/* slide down stacks */
	draw(screen, Rpt(addpt(stackr.min, Pt(0, SIZE)), stackr.max), screen, 0, stackr.min);
		/* put a new stack at the top */
	draw(screen, Rpt(stackr.min, addpt(stackr.min, Pt(SIZE, SIZE))), p->image, 0, p->image->r.min);
	return v;
}

void 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);
}

void place(Point p){
	Point cell;
	cell=divpt(subpt(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);
				/* draw red pipe where oil has flown */
			/*  use SIZE/2-2 to avoid touching (overwriting) border */
			fillellipse(screen, addpt(mulpt(cell, SIZE), addpt(boardr.min, 
						Pt(SIZE/2, SIZE/2))), SIZE/2-2, SIZE/2-2, red, ZP);
			sched(now, explode);
		}
		else
			putpiece(cell.x, cell.y, stackpiece());
	}
}

void 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 eresized(int new){
	int x, y, i;
	Image *color;

	if(new && getwindow(display, Refmesg) < 0)
		fprint(2,"can't reattach to window");
	scorer.min=addpt(screen->r.min, Pt(3*BORDER, 3*BORDER));
	scorer.max=addpt(scorer.min, Pt((NX+2)*SIZE, font->height+2));
	stackr.min=addpt(scorer.min, Pt(0, font->height+2+3*BORDER));
	stackr.max=addpt(stackr.min, Pt(SIZE, NSTACK*SIZE));
	boardr.min=addpt(stackr.min, Pt(2*SIZE, 0));
	boardr.max=addpt(boardr.min, Pt(NX*SIZE, NY*SIZE));
	if(!ptinrect(addpt(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");
	}
	color = medgreen;
	rectf(screen, screen->r, darkgreen);			/* background of the screen */
	border(screen, screen->r, BORDER, color, ZP);
	border(screen, scorer, -BORDER, color, ZP);
	border(screen, stackr, -BORDER, paleyellow, ZP);
	border(screen, boardr, -BORDER, color, ZP);
	for(i=0; i!=NSTACK; i++) 
	    if(stack[i])			/* redraw stack rectangular */
		draw(screen, Rpt(stackr.min, addpt(stackr.min, Pt(SIZE, i*SIZE))), stack[i]->image, 
			0, stack[i]->image->r.min);

	for(y=0; y!=NY; y++) for(x=0; x!=NX; x++) 
	    if(board[y][x].piece)	/* redraw pieces in the board rectangular */
		draw(screen, Rpt(addpt(boardr.min, Pt(x*SIZE, y*SIZE)), 
			addpt(boardr.min, Pt((x+1)*SIZE, (y+1)*SIZE))), board[y][x].piece->image,
			0, board[y][x].piece->image->r.min);
	message("");
}

void cleanscreen(void){
	rectf(screen, screen->r, black);
	border(screen, screen->r, BORDER, medgreen, ZP);
}

void 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};
void menu2(Mouse *m){
	switch(emenuhit(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,
};

int confirm(int b){
	Mouse down, up;
	esetcursor(&confirmcursor);
	do down=emouse(); while(!down.buttons);
	do up=emouse(); while(up.buttons);
	esetcursor(0);
	return down.buttons==(1<<(b-1));
}
Menu m3={but3};

void menu3(Mouse *m){
	switch(emenuhit(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 mouse3(Mouse m){
	if(m.buttons==4)
		menu3(&m);
	return m;
}

void waitclick(void){
	Mouse down, up;
	do down=mouse3(emouse()); while(!down.buttons);
	do up=mouse3(emouse()); while(up.buttons);
}

void waitticks(int n, ulong timek)
{
	int i;
	ulong k;
	Event ev;
	
	i = 0;
	while(i < n) {
		k = eread(Emouse|timek, &ev);
		if (k == Emouse)
			mouse3(ev.mouse);
		if (k == timek)
			i++;
	}	
}

void main(int argc, char *argv[]){
	int x, y, doublecross, firstlevel;
	ulong timek, k;
	Event ev;
	Mouse oldm, m;
	char buf[100];
	srand(time(0));
	initdraw(0, 0, "plumb");
	einit(Emouse|Ekeyboard);
	timek = etimer(0, 1);
	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;
	black = allocimage(display, Rect(0,0,1,1), display->windows->chan, 1, DBlack);
	white = allocimage(display, Rect(0,0,1,1), display->windows->chan, 1, DWhite);
	red = allocimage(display, Rect(0,0,1,1), display->windows->chan, 1, DRed);
	paleyellow=allocimage(display, Rect(0, 0, 1, 1), display->windows->chan, 1, DPaleyellow);
	darkgreen=allocimage(display, Rect(0, 0, 1, 1), display->windows->chan, 1, DDarkgreen);
	palegreen=allocimage(display, Rect(0, 0, 1, 1), display->windows->chan, 1, DPalegreen);
	medgreen=allocimage(display, Rect(0, 0, 1, 1), display->windows->chan, 1, DMedgreen);
	darkblue = allocimage(display, Rect(0,0,1,1), display->windows->chan, 1, DDarkblue);
	darkgrey = allocimage(display, Rect(0,0,1,1), display->windows->chan, 1, DGreygreen);
	bgcolor = darkblue;
	whitemask = allocimage(display, Rect(0,0,1,1), CMAP8, 1, setalpha(DWhite, 0x1F));

	mkresdisks();
	m.buttons=0;
	eresized(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 */
			while(ecanmouse()) mouse3(emouse());
			do{
				k = eread(Emouse|timek, &ev);
				if(k == Emouse){
					oldm=m;
					m = mouse3(ev.mouse);
					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) {
				k = eread(Emouse|timek, &ev);
				if(k == Emouse)
					mouse3(ev.mouse);
				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) {
							k = eread(Emouse|timek, &ev);
							if(k == Emouse)
								mouse3(ev.mouse);
							fugit();
						}
						break;
					case 2:
						doublecross++;
						break;
					}
				}
			}
			// doublecross=doublecross/5*5; // too difficult for me -- Axel.
			if(doublecross){
				sprintf(buf, "Bonus for %d crosses", doublecross);
				message(buf);
				waitticks(200, timek);
				addscore(2000+1000*doublecross, 0);
			}
			while(ecanmouse()) mouse3(emouse());
			if(bonusdist) break;
			message("Click to continue");
			waitclick();
		}
		outscore();
		message("Game over [click]");
		waitclick();
		score=0;
		message("New game ...        ");
		waitticks(50, timek);
	}
}