#include <u.h>
#include <libc.h>
#include <draw.h>
#include <event.h>
#include <cursor.h>

#include "rushhour.h"

enum {
	LRestart,
	LWeird = 1,
	LBegin,
	LInter,
	LTInter,
	LAdv,
	LTAdv,
	LExpert,
	LTExpert,
	LMaster,
	LArgv,
	Lbeyond,
	LRegen = Lbeyond,
	LView,
	LExit,
};

int ttnrs[] = {
	LTInter,
	LTAdv,
	LTExpert
};

char *lvlfiles[] = {
[LWeird]	"/sys/games/lib/rushhour/levels/weird.slc",
[LBegin]	"/sys/games/lib/rushhour/levels/begin.slc",
[LInter]	"/sys/games/lib/rushhour/levels/inter.slc",
[LAdv]	"/sys/games/lib/rushhour/levels/adv.slc",
[LExpert]	"/sys/games/lib/rushhour/levels/expert.slc",
[LMaster]	"/sys/games/lib/rushhour/levels/master.slc",
[LTInter]	"/mnt/trafficfs/inter",
[LTAdv]	"/mnt/trafficfs/adv",
[LTExpert]	"/mnt/trafficfs/expert",
[LArgv]	"",
};

char *ctlfile = "/mnt/trafficfs/ctl";

char *gencommands[] = {
[LTInter]	"gen inter 20 30 200\n",
[LTAdv]	"gen adv 30 40 200\n",
[LTExpert]	"gen expert 40 55 200\n",
};

char *resetcommands[] = {
[LTInter]	"reset inter\n",
[LTAdv]	"reset adv\n",
[LTExpert]	"reset expert\n",
};


int LFaces;
char *imgdir;

char *buttons[] = 
{
	"restart",
	"weird",
	"beginner",
	"intermediate",
	"tt intermediate",
	"advanced",
	"tt advanced",
	"expert",
	"tt expert",
	"grand master",
	"(no input file)",
	"regenerate tt",
	"faces",
	"exit",
	0
};

char *facesorcars[] = {
	"faces",
	"cars",
};

char *nottbuttons[] = 
{
[LTInter]	"(no tt intermediate)",
[LTAdv]	"(no tt advanced)",
[LTExpert] "(no tt expert)",
};

char **levelnames;

Menu menu = 
{
	buttons,
};

Menu lmenu =
{
	levelnames,
};

Cursor whitearrow = {
	{0, 0},
	{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC, 
	 0xFF, 0xF0, 0xFF, 0xF0, 0xFF, 0xF8, 0xFF, 0xFC, 
	 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC, 
	 0xF3, 0xF8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, },
	{0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x06, 0xC0, 0x1C, 
	 0xC0, 0x30, 0xC0, 0x30, 0xC0, 0x38, 0xC0, 0x1C, 
	 0xC0, 0x0E, 0xC0, 0x07, 0xCE, 0x0E, 0xDF, 0x1C, 
	 0xD3, 0xB8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, }
};


static int
istt(int n)
{
	switch(n) {
	case LTInter:
	case LTAdv:
	case LTExpert:
		return 1;
	default:
		return 0;
	}
}

void*
erealloc(void *p, ulong sz)
{
	void *v;

	v = realloc(p, sz);
	if(v == nil)
		sysfatal("realloc %lud fails\n", sz);
	return v;
}

char *
estrdup(char *s)
{
	char *r;

	r = strdup(s);
	if(r == nil)
		sysfatal("strdup fails\n");
	return r;
}

Image *
eallocimage(Rectangle r, int repl, uint color)
{
	Image *tmp;

	tmp = allocimage(display, r, screen->chan, repl, color);
	if(tmp == nil)
		sysfatal("cannot allocate buffer image: %r");

	return tmp;
}

enum { 
	Facesize = 48
};

static Image*
readbit(int fd, ulong chan, char *path)
{
	char buf[4096], hx[4], *p;
	uchar data[Facesize*Facesize];	/* more than enough */
	int nhx, i, n, ndata, nbit;
	Image *img;

	n = readn(fd, buf, sizeof buf);
	if(n <= 0)
		return nil;
	if(n >= sizeof buf)
		n = sizeof(buf)-1;
	buf[n] = '\0';

	n = 0;
	nhx = 0;
	nbit = chantodepth(chan);
	ndata = (Facesize*Facesize*nbit)/8;
	p = buf;
	while(n < ndata) {
		p = strpbrk(p+1, "0123456789abcdefABCDEF");
		if(p == nil)
			break;
		if(p[0] == '0' && p[1] == 'x')
			continue;

		hx[nhx] = *p;
		if(++nhx == 2) {
			hx[nhx] = 0;
			i = strtoul(hx, 0, 16);
			data[n++] = ~i;
			nhx = 0;
		}
	}
	if(n < ndata)
		sysfatal("short face %s", path);

	img = allocimage(display, Rect(0,0,Facesize,Facesize), chan, 0, 0);
	if(img == nil)
		return nil;

	loadimage(img, img->r, data, ndata);
	return img;
}

static Image*
resample(Image *src)
{
	int p[2], q[2], kid, pid;
	Image *img;

	if(pipe(p) < 0 || pipe(q) < 0)
		sysfatal("can't make a pipe: %r");
	kid = fork();
	switch(kid){
	case -1:
		sysfatal("can't fork: %r");
	default:
		close(p[0]);
		close(q[1]);
		if (writeimage(p[1], src, 0) < 0)
			fprint(2, "error writeimage\n");
		close(p[1]);
		img = readimage(display, q[0], 0);
		close(q[0]);
		/*
		 * we may have unknown children forked by a previous
		 * program (e.g., rc) that then execed us.
		 */
		while ((pid = waitpid()) != kid && pid != -1)
			continue;
 		return img;
	case 0:
		close(p[1]);
		close(q[0]);
		dup(p[0], 0);
		dup(q[1], 1);
		execl("/bin/resample", "resample", "-x50%", (char *)nil);
		sysfatal("can't exec resample: %r");
	}
	return nil;
}

Image *
openimage(char *dir, char *file)
{
	Image *img;
	int fd;
	char path[1024];

	if (dir != nil)
		sprint(path, "%s/%s", dir, file);
	else
		strcpy(path, file);

	fd = open(path, OREAD);
	if(fd < 0)
		sysfatal("open %s: %r", path);
	img = readimage(display, fd, 0);
	if(img == nil)
		sysfatal("readimage %s: %r", path);
	close(fd);

	return img;
}

Image*
openface(char *path)
{
	char *p;
	int fd, n;
	Image *tmp, *img;

	p = strstr(path, "48x48x");
	if(p == nil)
		img = openimage(nil, path);
	else {
		n = atoi(p+6);
		if(n < 4){
			if((fd = open(path, OREAD)) < 0)
				sysfatal("open %s: %r", path);
			img =  readbit(fd, n==1 ? GREY1 : GREY2, path);
		} else
			img =  openimage(nil, path);
	}
	if (tinyflag) {
		tmp = resample(img);
		if (tmp != nil)
			return tmp;
		return img;
	}
	
	return img;
}

static void
allocimages(void)
{
	int i;
	Rectangle one = Rect(0, 0, 1, 1);
	
	bg		= eallocimage(one, 1, 0xAAAAAAFF);//0xEEEEEEFF
	text 		= eallocimage(one, 1, DBluegreen);
	black 	= eallocimage(one, 1, DBlack);

	wall = openimage(imgdir, "wall.bit");
	empty = openimage(imgdir, "empty.bit");
	empty->repl = 1;
	win = openimage(imgdir, "win.bit");

	col[CarX]		= eallocimage(one, 1, 0xFF0000FF);
	col[CarY]		= eallocimage(one, 1, 0xFF0000FF);
	col[CarZ]		= eallocimage(one, 1, 0xFF0000FF);
	col[CarA]		= eallocimage(one, 1, 0x00FF55FF);
	col[CarB]		= eallocimage(one, 1, 0xCC8800FF);
	col[CarC]		= eallocimage(one, 1, 0x00AAFFFF);
	col[CarD]		= eallocimage(one, 1, 0xFF00FFFF);
	col[CarE]		= eallocimage(one, 1, 0x770077FF);
	col[CarF]		= eallocimage(one, 1, 0x008844FF);
	col[CarG]		= eallocimage(one, 1, 0x333333FF); //0x222222FF
	col[CarH]		= eallocimage(one, 1, 0xBBBB5DFF); //0xCCCC88FF
	col[CarI]		= eallocimage(one, 1, 0xFFFF00FF);
	col[CarJ]		= eallocimage(one, 1, 0x884400FF);
	col[CarK]		= eallocimage(one, 1, 0x555500FF);
	for(i=CarL; i <= CarN; i++)
		col[i]	= col[CarA-CarL+i];
	col[TruckO]	= eallocimage(one, 1, 0xFFAA00FF);
	col[TruckP]	= eallocimage(one, 1, 0xBB5DBBFF);
	col[TruckQ]	= eallocimage(one, 1, 0x0000FFFF);
	col[TruckR]	= eallocimage(one, 1, 0x00BB5DFF);
	for(i=TruckS; i <= TruckV; i++)
		col[i]	= col[TruckO-TruckS+i];

	face[CarX]		= openface("/lib/face/48x48x4/g/glenda.1");
	face[CarY]		= face[CarX];
	face[CarZ]		= face[CarX];
	face[CarA]		= openface("/lib/face/48x48x2/k/ken.1");
	face[CarB]		= openface("/lib/face/48x48x4/b/bobf.1");
	face[CarC]		= openface("/lib/face/48x48x4/p/philw.1");
	face[CarD]		= openface("/lib/face/48x48x4/p/presotto.1");
	face[CarE]		= openface("/lib/face/48x48x4/r/rob.1");
	face[CarF]		= openface("/lib/face/48x48x4/s/sean.1");
	face[CarG]		= openface("/lib/face/48x48x4/b/bwk.1");
	face[CarH]		= openface("/lib/face/48x48x4/c/cyoung.1");
	face[CarI]		= openface("/lib/face/48x48x4/d/dmr.1");
	face[CarJ]		= openface("/lib/face/48x48x4/d/doug.1");
	face[CarK]		= openface("/lib/face/48x48x4/h/howard.1");
	for(i=CarL; i <= CarN; i++)
		face[i]	= face[CarA-CarL+i];
	face[TruckO]	= openface("/lib/face/48x48x4/j/jmk.1");
	face[TruckP]	= openface("/lib/face/48x48x4/s/sape.1");
	face[TruckQ]	= openface("/lib/face/48x48x4/s/seanq.1");
	face[TruckR]	= openface("/lib/face/48x48x4/t/td.1");
	for(i=TruckS; i <= TruckV; i++)
		face[i]	= face[TruckO-TruckS+i];

	face[Wall]		= openface("/lib/face/48x48x2/p/pjw+9ball.2");

	car[CarX][OHoriz]	= openimage(imgdir, "redcarEW.bit");
	car[CarX][OVert]	= openimage(imgdir, "redcarNS.bit");
	car[CarY][OHoriz]	= openimage(imgdir, "limoEW.bit");
	car[CarY][OVert]	= openimage(imgdir, "limoNS.bit");
	car[CarZ][OHoriz]	= car[CarX][OHoriz];
	car[CarZ][OVert]	= car[CarX][OVert];
	car[CarA][OHoriz]	= openimage(imgdir, "AcarEW.bit");
	car[CarA][OVert]	= openimage(imgdir, "AcarNS.bit");
	car[CarB][OHoriz]	= openimage(imgdir, "BcarEW.bit");
	car[CarB][OVert]	= openimage(imgdir, "BcarNS.bit");
	car[CarC][OHoriz]	= openimage(imgdir, "CcarEW.bit");
	car[CarC][OVert]	= openimage(imgdir, "CcarNS.bit");
	car[CarD][OHoriz]	= openimage(imgdir, "DcarEW.bit");
	car[CarD][OVert]	= openimage(imgdir, "DcarNS.bit");
	car[CarE][OHoriz]	= openimage(imgdir, "EcarEW.bit");
	car[CarE][OVert]	= openimage(imgdir, "EcarNS.bit");
	car[CarF][OHoriz]	= openimage(imgdir, "FcarEW.bit");
	car[CarF][OVert]	= openimage(imgdir, "FcarNS.bit");
	car[CarG][OHoriz]	= openimage(imgdir, "GcarEW.bit");
	car[CarG][OVert]	= openimage(imgdir, "GcarNS.bit");
	car[CarH][OHoriz]	= openimage(imgdir, "HcarEW.bit");
	car[CarH][OVert]	= openimage(imgdir, "HcarNS.bit");
	car[CarI][OHoriz]	= openimage(imgdir, "IcarEW.bit");
	car[CarI][OVert]		= openimage(imgdir, "IcarNS.bit");
	car[CarJ][OHoriz]	= openimage(imgdir, "JcarEW.bit");
	car[CarJ][OVert]		= openimage(imgdir, "JcarNS.bit");
	car[CarK][OHoriz]	= openimage(imgdir, "KcarEW.bit");
	car[CarK][OVert]	= openimage(imgdir, "KcarNS.bit");
	for(i=CarL; i <= CarN; i++) {
		car[i][OHoriz]	= car[CarA-CarL+i][OHoriz];
		car[i][OVert]	= car[CarA-CarL+i][OVert];
	}
	car[TruckO][OHoriz]	= openimage(imgdir, "OlorryEW.bit");
	car[TruckO][OVert]	= openimage(imgdir, "OlorryNS.bit");
	car[TruckP][OHoriz]	= openimage(imgdir, "PlorryEW.bit");
	car[TruckP][OVert]	= openimage(imgdir, "PlorryNS.bit");
	car[TruckQ][OHoriz]	= openimage(imgdir, "QlorryEW.bit");
	car[TruckQ][OVert]	= openimage(imgdir, "QlorryNS.bit");
	car[TruckR][OHoriz]	= openimage(imgdir, "RlorryEW.bit");
	car[TruckR][OVert]	= openimage(imgdir, "RlorryNS.bit");
	for(i=TruckS; i <= TruckV; i++) {
		car[i][OHoriz]	= car[TruckO-TruckS+i][OHoriz];
		car[i][OVert]	= car[TruckO-TruckS+i][OVert];
	}

	msk[CarX][OHoriz]	= openimage(imgdir, "redcarEW-msk.bit");
	msk[CarX][OVert]	= openimage(imgdir, "redcarNS-msk.bit");
	msk[CarY][OHoriz]	= openimage(imgdir, "limoEW-msk.bit");
	msk[CarY][OVert]	= openimage(imgdir, "limoNS-msk.bit");
	msk[CarZ][OHoriz]	= msk[CarX][OHoriz];
	msk[CarZ][OVert]	= msk[CarX][OVert];
	msk[CarA][OHoriz]	= openimage(imgdir, "AcarEW-msk.bit");
	msk[CarA][OVert]	= openimage(imgdir, "AcarNS-msk.bit");
	for(i=CarB; i <= CarN; i++) {
		msk[i][OHoriz]	= msk[CarA][OHoriz];
		msk[i][OVert]	= msk[CarA][OVert];
	}
	msk[TruckO][OHoriz]	= openimage(imgdir, "OlorryEW-msk.bit");
	msk[TruckO][OVert]	= openimage(imgdir, "OlorryNS-msk.bit");
	for(i=TruckP; i <= TruckV; i++) {
		msk[i][OHoriz]	= msk[TruckO][OHoriz];
		msk[i][OVert]	= msk[TruckO][OVert];
	}
}

static Point
point2pos(Point p)
{
	p.x /= BoardX;
	p.x += Off;
	p.y /= BoardY;
	p.y += Off;

	return p;
}

static Point
mouse2point(Mouse m)
{
	Point p;

	p = subpt(m.xy, screen->r.min);

	return p;
}

static Point
point2mouse(Point mp)
{
	Point p;

	p = addpt(mp, screen->r.min);

	return p;
}

static Point
project(Point p, Point dir)
{
	if (dir.x == 0)
		p.x = 0;
	if (dir.y == 0)
		p.y = 0;
	return p;
}

static int
writectl(char *s)
{
	int ctlfd;

	ctlfd = open(ctlfile, OWRITE);
	if (ctlfd < 0) {
		fprint(2, "cannot open trafficfs ctl: %r\n");
		return 0;
	} else {
		fprint(ctlfd, "%s", s);
		close(ctlfd);
		return 1;
	}
}

static void
initttlevels(void)
{
	int i, n;

	if (access(ctlfile,0) == 0)
		for (i=0; i < nelem(ttnrs); i++) {
			n = ttnrs[i];
			if (access(lvlfiles[n],0) < 0 && ! writectl(gencommands[n])) {
				lvlfiles[n] = "";
				buttons[n] = nottbuttons[n];
			}
		}
	else
		for (i=0; i < nelem(ttnrs); i++) {
			n = ttnrs[i];
			lvlfiles[n] = "";
			buttons[n] = nottbuttons[n];
		}
}

char *
genlevels(int i)
{
	char *s;

	if(i >= numlevels)
		return 0;

	if (levels[i].name == nil)
		s = smprint("level %d", i+1);
	else
		s = smprint("level %d (%s)", i+1, levels[i].name);

	return s;
}

static void
buildmenu(void)
{
	int i;

	if (levelnames != nil) {
		for(i=0; levelnames[i] != 0; i++)
			free(levelnames[i]);
	}
	levelnames = erealloc(levelnames, sizeof(char*)*(numlevels+1));
	for(i=0; i < numlevels; i++)
		levelnames[i] = genlevels(i);
	levelnames[numlevels] = 0;
	lmenu.item = levelnames;
}

static void
doloadlevels(int n)
{
	int r;

	r = loadlevels(lvlfiles[n]);
	if (! istt(n))
		return;

	if (r < 0 && access(ctlfile,0) < 0) {
		lvlfiles[n] = "";
		buttons[n] = nottbuttons[n];
	} else if (numlevels == 0 && access(ctlfile,0) == 0) {
		writectl(resetcommands[n]);
		writectl(gencommands[n]);
		loadlevels(lvlfiles[n]);
	}
}

static void
activatelevel(Level l, Point *topleft)
{
	*topleft = Pt(-1,-1);
	level = l;
	drawlevel();
	drawscreen();
}

static void
uselevels(int l, int *lvlindex, Point *topleft)
{
	if (strcmp(lvlfiles[l], "") != 0) {
		*lvlindex = l;
		doloadlevels(*lvlindex);
		buildmenu();
		activatelevel(levels[0], topleft);
	}
}

static void
nextlevel(int *lvlindex, Point *topleft)
{
	if(level.index < numlevels - 1)
		activatelevel(levels[++level.index], topleft);
	else if (*lvlindex < Lbeyond -1 &&
	            strcmp(lvlfiles[(*lvlindex)+1], "") != 0) {
		doloadlevels(++(*lvlindex));
		buildmenu();
		activatelevel(levels[0], topleft);
	} else
		*topleft = Pt(-1,-1);
}

static void
prevlevel(int *lvlindex, Point *topleft)
{
	if(level.index > 0)
		activatelevel(levels[--level.index], topleft);
	else if (*lvlindex > 1) {
		doloadlevels(--(*lvlindex));
		buildmenu();
		activatelevel(levels[numlevels-1], topleft);
	} else
		*topleft = Pt(-1,-1);
}

static void
regenlevels(int lvlindex, Point *topleft)
{
	if (istt(lvlindex) && access(ctlfile,0) == 0) {
		writectl(gencommands[lvlindex]);
		doloadlevels(lvlindex);
		buildmenu();
		activatelevel(levels[0], topleft);
	}
}

static void
toggleview(void)
{
	if (usefaces)
		usefaces = 0;
	else
		usefaces = 1;
	buttons[LFaces] = facesorcars[usefaces];
	drawlevel();
	drawscreen();
}

static int
finished(void)
{
	int x, y;

	for(x = 0; x < MazeX; x++)
		for(y = 0; y < MazeY; y++)
			if(level.board[x][y] == level.us)
				return 0;

	return 1;
}

void
eresized(int new)
{
	Point p;

	if(new && getwindow(display, Refnone) < 0)
		sysfatal("can't reattach to window");
	
	p = Pt(Dx(screen->r), Dy(screen->r));

	if(!new || !eqpt(p, boardsize(subpt(level.max,Pt(Off,Off))))) {
		drawlevel();
	}
	drawscreen();
}

static char*
mklabel(char *s)
{
	char *p, *e, c;

	p = strrchr(s, '/');
	if (p != nil)
		p++;
	else
		p = s;
	e = strchr(p, '.');
	if (e != nil) {
		c = *e;
		*e = '\0';
		p = estrdup(p);
		*e = c;
	} else
		p = estrdup(p);
	return p;
}

static Point
key2dir(int kbdc)
{
	switch(kbdc){
	case 61454: /*Up*/
		return Pt(0,-1);
	case 63488: /*Down*/
		return Pt(0,1);
	case 61457: /*Left*/
		return Pt(-1,0);
	case 61458: /*Right*/
		return Pt(1,0);
	default:
		return Pt(0,0);
	}
}

void 
main(int argc, char **argv)
{
	Mouse m, mprev;
	Event ev;
	int e, start, up, lvlindex, l, cursoronly, mouseinitialized;
	Point p, d, off, dir, prevdir, topleft, vacant, dst, winoff, tl, tdir;
	char *fontfile, **bp;
	Rectangle *drp, *srp;

	imgdir = "/sys/games/lib/rushhour/images/normal";
	fontfile = nil;
	BoardX = 48;
	BoardY = 48;
	winoff = Pt(6,6);
	OutlineWidth = 2;

	LFaces = LView;
	lvlindex = LBegin;
	levelnames = nil;
	start = 1;
	up = 0;
	topleft = Pt(-1,-1);
	cursoronly = 0;
	mouseinitialized = 0;

	ARGBEGIN{
	case 'b':
		boutflag = 1;
		break;
	case 'f':
		usefaces = 1;
		buttons[LFaces] = facesorcars[usefaces];
		break;
	case 't':
		tinyflag = 1;
		imgdir = "/sys/games/lib/rushhour/images/small";
		fontfile = "/lib/font/bit/lucidasans/unicode.6.font";
		BoardX = 24;
		BoardY = 24;
		winoff = Pt(3,3);
		OutlineWidth = 1;
		break;
	default:
		fprint(2, "Usage: %s [-f] [-t] [levelfile]\n", argv0);
		exits("usage");
	}ARGEND

	switch(argc) {
	case 1: 
		lvlindex = LArgv;
		lvlfiles[LArgv] = argv[0];
		buttons[LArgv] = mklabel(argv[0]);
		break;
	case 0: 
		buttons[LArgv] = "";
		/* remove empty LArgv buttons menu entry */
		bp = &buttons[LArgv];
		memmove(bp, bp+1, sizeof(char*)*(nelem(buttons)-LArgv-1));
		LFaces--;
		break;
	default:
		fprint(2, "Usage: %s [-f] [-t] [levelfile]\n", argv0);
		exits("usage");
	}

	if(loadlevels(lvlfiles[lvlindex]) < 0) {
		fprint(2, "Usage: %s [-f] [-t] [levelfile]\n", argv0);
		exits("usage");
	}

	initttlevels();
	buildmenu();

	if(initdraw(nil, fontfile, "rushhour") < 0)
		sysfatal("initdraw failed: %r");
	einit(Emouse|Ekeyboard);

	SizeX = MazeX*BoardX+10,	
	SizeY = MazeY*BoardY+10,

	allocimages();
	eresized(0);

	for(;;) {
		e = event(&ev);
		switch(e) {
		case Emouse:
			m = ev.mouse;
			if (start) {
				mprev = m;
				start = 0;
			}
			if(m.buttons&1) {
				 /* setting up here instead of in next else branch
				  * did make a difference in the version with
				  * explicit selection making. should not matter here?
				  */
				up = 1;
				if (! mprev.buttons&1) {
					d = mouse2point(m);
					topleft = gettopleft(point2pos(d));
					prevdir = ZP;
				} else {
					/* up = 1;  moved upwards */
					if (! eqpt(topleft, Pt(-1,-1)) && isvehicle(item(topleft))) {
						p = mouse2point(m);
						off = subpt(p, d);
						dir = getdir(topleft, off);
						if (!eqpt(prevdir, ZP) && !eqpt(prevdir, dir)) {
							dst = destof(topleft, prevdir);
							drawboard(dst, 0, ZP);
						}
						prevdir = dir;
						off = project(off, dir);
						while(canmove(topleft,dir) && !intile(off, dir)) {
							/*
							 * superflous:
							 * dst = destof(tl, dir);
							 * drawboard(dst, 0, ZP);
							 */
							onestep(topleft, dir, &vacant);
							topleft = addpt(topleft, dir);
							drawboard(vacant, 0, ZP);
							off = subtile(off, dir);
							d = addtile(d, dir);
						}
						if (!canmove(topleft, dir))
							off = ZP;
						dst = destof(topleft, dir);
						drawboard(dst, 0, ZP);
						drawboard(topleft, 0, off);
						drawscreen();
					}
				}
			} else if (up) {
				up = 0;
				if (!eqpt(topleft, Pt(-1,-1)) && isvehicle(item(topleft))){
					p = mouse2point(m);
					dir = getdir(topleft, off);
					if (canmove(topleft, dir) && !inhalftile(off, dir)) {
						onestep(topleft, dir, &vacant);
						topleft = addpt(topleft, dir);
						drawboard(vacant, 0, ZP);
					} else {
						dst = destof(topleft, dir);
						drawboard(dst, 0, ZP);
					}
					drawboard(topleft, 0, ZP);
					drawscreen();
				}
				/*
				 * superflous; does clean up if we messed up
				 * which we don't, of course
				 * drawlevel();
				 * drawscreen();
				 */
			} else {
				if(m.buttons&2) {
					lmenu.lasthit = level.index;
					l = emenuhit(2, &m, &lmenu);
					if (l >= 0)
						activatelevel(levels[l], &topleft);
				}
				if(m.buttons&4) {
					menu.lasthit = lvlindex;
					l = emenuhit(3, &m, &menu);
					/* deal with removed empty LArgv menu entry */
					if (l >= LArgv && strcmp(lvlfiles[LArgv], "") == 0)
						l += 1;
					switch(l) {
					case LRestart:
						activatelevel(levels[level.index], &topleft);
						break;
					case LWeird:
					case LBegin:
					case LInter:
					case LTInter:
					case LAdv:
					case LTAdv:
					case LExpert:
					case LTExpert:
					case LMaster:
					case LArgv:
						uselevels(l, &lvlindex, &topleft);
						break;
					case LRegen:
						regenlevels(lvlindex, &topleft);
						break;
					case LView:
						toggleview();
						break;
					case LExit:
						exits(nil);
					}
				}
			}
			mprev = m;
			break;

		case Ekeyboard:
			switch(ev.kbdc) {
			case 127:
			case 'q':
			case 'Q':
				exits(nil);
			case 'n':
			case 'N':
				nextlevel(&lvlindex, &topleft);
				break;
			case 'p':
			case 'P':
				prevlevel(&lvlindex, &topleft);
				break;
			case 'r':
			case 'R':
				activatelevel(levels[level.index], &topleft);
				break;
			case 27: /*Esc*/
			case ' ':
				if (cursoronly) {
					cursoronly = 0;
					esetcursor(nil);
				} else {
					Point m0, p0, p1,p2;
					drp = &display->image->r;
					srp = &screen->r;
					cursoronly = 1;
					esetcursor(&whitearrow);
					if (!ptinrect(m.xy, *srp)) {
						//fprint(2, "m0 %R %P", *srp, m.xy);
						if (eqpt(m.xy, Pt(0,0)) && !mouseinitialized)
							m.xy = addpt(srp->min, Pt(Dx(*srp)/2, Dy(*srp)/2));
						else if (ptinrect(m.xy, Rect(srp->min.x, drp->min.y, srp->max.x, srp->min.y)))
							m.xy.y = srp->min.y + 1; /*above game window*/
						else if (ptinrect(m.xy, Rect(srp->max.x, srp->min.y, drp->max.x, srp->max.y)))
							m.xy.x = srp->max.x - 1; /*to right of game window*/
						else if (ptinrect(m.xy, Rect(srp->min.x, srp->max.y, srp->max.x, drp->max.y)))
							m.xy.y = srp->max.y - 1; /*below game window*/
						else if (ptinrect(m.xy, Rect(drp->min.x,drp->min.y, srp->min.x, srp->max.y)))
							m.xy.x = srp->max.x + 1; /*left of game window*/
						//fprint(2, " m1 %P\n", m.xy);
					}
					mouseinitialized = 1;
					m0 = mouse2point(m);
					p0 = point2pos(m0);
					p1 = subpt(p0, Pt(Off,Off));
					p2 = addpt(Pt(p1.x*BoardX,p1.y*BoardY), divpt(Pt(BoardX,BoardY),2));
					m.xy = point2mouse(p2);
					//fprint(2, "m0%P p0%P p1%P p2%P m1%P\n", m0, p0, p1, p2, m.xy);
					emoveto(m.xy);
				}
				break;
			case 61454: /*Up*/
			case 63488: /*Down*/
			case 61457: /*Left*/
			case 61458: /*Right*/
				if (cursoronly) {
					Point m1;
					tdir = key2dir(ev.kbdc);
					m1 = addpt(m.xy, Pt(tdir.x*BoardX,tdir.y*BoardY));
					if (ptinrect(m1, screen->r)){
						m.xy = m1;
						emoveto(m.xy);
					}
				} else {
					/* avoid updating global variables: topleft, d (dir?)
					 * unless condition in this case holds
					 * (if they are updated, they interfere with the
					 *  handling of mouse-button1-move events
					 * if cursor keys are used while at the same time
					 * mouse button 1 is continuiously pressed,
					 * and the mouse is occasionally moved).
					 * currently there is minor interference if
					 * we B1press and move with mouse tiny bits
					 * back and forth, while one side is blocked.
					 * e.g. right side blocked, we move 1/4 tile left,
					 * then 1/8 back right, back left a bit, etc.,
					 * and then start pressing cursor keys:
					 * nothhing happens, until we mouse-move
					 * the car to the next tile grid border.
					 */
					tl = gettopleft(point2pos(mouse2point(m)));
					tdir = getdir(tl, key2dir(ev.kbdc));
					if (! eqpt(tl, Pt(-1,-1)) &&
					     isvehicle(item(tl)) &&
					     canmove(tl,tdir)) {
					     	topleft = tl;
					     	dir = tdir;
						if (!eqpt(prevdir, ZP) && !eqpt(prevdir, dir)) {
							dst = destof(topleft, prevdir);
							drawboard(dst, 0, ZP);
						}
						prevdir = ZP;
						onestep(topleft, dir, &vacant);
						topleft = addpt(topleft, dir);
						dst = destof(topleft, dir);
						m.xy = addpt(m.xy, Pt(dir.x*BoardX,dir.y*BoardY));
						d = mouse2point(m);
						emoveto(m.xy);
						drawboard(dst, 0, ZP);
						drawboard(vacant, 0, ZP);
						drawboard(topleft, 0, ZP);
						drawscreen();
					}
				}	
				break;
			default:
				// fprint(2, "key: %d\n", ev.kbdc);
				break;
			}
			break;

		default:
			break;
		}

		if(finished() && ! level.done) {
			level.done = 1;
			level.win = vacant; /* set tile of 'you win' msg */
			drawwin(winoff);
			drawscreen();
			sleep(3000);
			nextlevel(&lvlindex, &topleft);
		}
	}
}