shithub: sce

Info  •  Files  •  Log

major refactoring: use path node coordinates everywhere

this avoids a lot of stupid errors, previously 3 different
coordinates were saved and it was never clear which ones a
function is supposed to use.

also:
- use Points more
- main map is node map, not tilemap
- mobj as first argument where applicable to homogenize usage
- assume node width and height are the same (will always be the case)
- com: don't send mobj coordinates, these will often be stale
- com: use constants to avoid problems between send/recv functions
- com: additional checks to avoid moving in place
- drw: use vectors for vis and drawlists
- map: coordinate conversion functions, try to isolate map code here
- path: switch to plain a∗ to debug pathing and movement

there are A LOT of bugs there, some new, many old

--- a/bmap.c

+++ b/bmap.c

@@ -69,60 +69,60 @@

 }

 u64int *

-baddr(int x, int y)

+baddr(Point p)

 {

-	x >>= Bshift;

-	x += Npad;

-	y += Npad;

-	return bmap + y * bmapwidth + x;

+	p.x >>= Bshift;

+	p.x += Npad;

+	p.y += Npad;

+	return bmap + p.y * bmapwidth + p.x;

 }

 u64int *

-rbaddr(int y, int x)

+rbaddr(Point p)

 {

-	x >>= Bshift;

-	x += Npad;

-	y += Npad;

-	return rbmap + y * rbmapwidth + x;

+	p.x >>= Bshift;

+	p.x += Npad;

+	p.y += Npad;

+	return rbmap + p.y * rbmapwidth + p.x;

 }

 static u64int *

-breduce(u64int *p, int Δp, int ofs, int w, int h, int Δw, int Δh, int left)

+breduce(u64int *b, int Δb, int ofs, Point sz, Point Δsz, int left)

 {

 	static u64int row[Nmaxsize+2];

 	int i, j;

 	u64int u, m;

-	m = (1 << w - 1) - 1;

+	m = (1 << sz.x - 1) - 1;

 	if(left){

-		ofs = 64 - w - Δw - ofs;

-		m <<= 63 - w + 1;

+		ofs = 64 - sz.x - Δsz.x - ofs;

+		m <<= 63 - sz.x + 1;

 	}

 	m = ~m;

-	for(i=0; i<h+Δh; i++, p+=Δp){

-		u = p[0];

+	for(i=0; i<sz.y+Δsz.y; i++, b+=Δb){

+		u = b[0];

 		if(ofs > 0){

 			if(left){

 				u >>= ofs;

-				u |= p[-1] << 64 - ofs;

+				u |= b[-1] << 64 - ofs;

 			}else{

 				u <<= ofs;

-				u |= p[1] >> 64 - ofs;

+				u |= b[1] >> 64 - ofs;

 			}

 		}

 		if(left)

-			switch(w){

+			switch(sz.x){

 			case 4: u |= u >> 1 | u >> 2 | u >> 3; break;

 			case 2: u |= u >> 1; break;

 			}

 		else

-			switch(w){

+			switch(sz.x){

 			case 4: u |= u << 1 | u << 2 | u << 3; break;

 			case 2: u |= u << 1; break;

 			}

 		u &= m;

 		row[i] = u;

-		for(j=max(i-h+1, 0); j<i; j++)

+		for(j=max(i-sz.y+1, 0); j<i; j++)

 			row[j] |= u;

 	}

 	return row;

@@ -129,50 +129,50 @@

 }

 u64int *

-bload(int x, int y, int w, int h, int Δw, int Δh, int left, int rot)

+bload(Point p, Point sz, Point Δsz, int left, int rot)

 {

-	int ofs, Δp;

-	u64int *p;

+	int ofs, Δb;

+	u64int *b;

 	if(rot){

-		p = rbaddr(x, y);

-		Δp = rbmapwidth;

-		ofs = y & Bmask;

+		b = rbaddr(p);

+		Δb = rbmapwidth;

+		ofs = p.y & Bmask;

 	}else{

-		p = baddr(x, y);

-		Δp = bmapwidth;

-		ofs = x & Bmask;

+		b = baddr(p);

+		Δb = bmapwidth;

+		ofs = p.x & Bmask;

 	}

-	return breduce(p, Δp, ofs, w, h, Δw, Δh, left);

+	return breduce(b, Δb, ofs, sz, Δsz, left);

 }

 void

-bset(int x, int y, int w, int h, int set)

+bset(Point p, Point sz, int set)

 {

 	int i, Δ, n;

-	u64int *p, m, m´;

+	u64int *b, m, m´;

-	p = baddr(x, y);

-	n = x & Bmask;

-	m = (1ULL << w) - 1 << 64 - w;

+	b = baddr(p);

+	n = p.x & Bmask;

+	m = (1ULL << sz.x) - 1 << 64 - sz.x;

 	m >>= n;

-	Δ = n + w - 64;

+	Δ = n + sz.x - 64;

 	m´ = (1ULL << Δ) - 1 << 64 - Δ;

-	for(i=0; i<h; i++, p+=bmapwidth){

-		p[0] = set ? p[0] | m : p[0] & ~m;

+	for(i=0; i<sz.y; i++, b+=bmapwidth){

+		b[0] = set ? b[0] | m : b[0] & ~m;

 		if(Δ > 0)

-			p[1] = set ? p[1] | m´ : p[1] & ~m´;

+			b[1] = set ? b[1] | m´ : b[1] & ~m´;

 	}

-	p = rbaddr(x, y);

-	n = y & Bmask;

-	m = (1ULL << h) - 1 << 64 - h;

+	b = rbaddr(p);

+	n = p.y & Bmask;

+	m = (1ULL << sz.y) - 1 << 64 - sz.y;

 	m >>= n;

-	Δ = n + h - 64;

+	Δ = n + sz.y - 64;

 	m´ = (1ULL << Δ) - 1 << 64 - Δ;

-	for(i=0; i<w; i++, p+=rbmapwidth){

-		p[0] = set ? p[0] | m : p[0] & ~m;

+	for(i=0; i<sz.x; i++, b+=rbmapwidth){

+		b[0] = set ? b[0] | m : b[0] & ~m;

 		if(Δ > 0)

-			p[1] = set ? p[1] | m´ : p[1] & ~m´;

+			b[1] = set ? b[1] | m´ : b[1] & ~m´;

 	}

 }

@@ -192,14 +192,14 @@

 {

 	int i;

-	bmapwidth = (nodemapwidth >> Bshift) + 2 * Npad;

-	bmapheight = nodemapheight + 2 * Npad;

-	rbmapwidth = (nodemapheight >> Bshift) + 2 * Npad;

-	rbmapheight = nodemapwidth + 2 * Npad;

+	bmapwidth = (mapwidth >> Bshift) + 2 * Npad;

+	bmapheight = mapheight + 2 * Npad;

+	rbmapwidth = (mapheight >> Bshift) + 2 * Npad;

+	rbmapheight = mapwidth + 2 * Npad;

 	bmap = emalloc(bmapwidth * bmapheight * sizeof *bmap);

 	rbmap = emalloc(rbmapwidth * rbmapheight * sizeof *rbmap);

 	for(i=0; i<Npad; i++){

-		memset(bmap + i * nodemapwidth, 0xff, bmapwidth * sizeof *bmap);

+		memset(bmap + i * mapwidth, 0xff, bmapwidth * sizeof *bmap);

 		memset(bmap + (bmapheight - i - 1) * bmapwidth, 0xff,

 			bmapwidth * sizeof *bmap);

 		memset(rbmap + i * rbmapwidth, 0xff, rbmapwidth * sizeof *rbmap);

--- a/com.c

+++ b/com.c

@@ -13,6 +13,11 @@

 	ushort size;

 };

+#define	MGATHER		"dl dl"

+#define	MMOVENEAR	"dl dl"

+#define MMOVE		"dl dd"

+#define MSTOP		"dl"

+

 static int

 vunpack(uchar *p, uchar *e, char *fmt, va_list a)

 {

@@ -74,9 +79,7 @@

 	int n;

 	Mobj reqm, reqt, *mo, *tgt;

-	if((n = unpack(p, e, "dldd dldd",

-	&reqm.idx, &reqm.uuid, &reqm.x, &reqm.y,

-	&reqt.idx, &reqt.uuid, &reqt.x, &reqt.y)) < 0)

+	if((n = unpack(p, e, MGATHER, &reqm.idx, &reqm.uuid, &reqt.idx, &reqt.uuid)) < 0)

 		return -1;

 	if((mo = mobjfromreq(&reqm)) == nil)

 		return -1;

@@ -90,6 +93,10 @@

 	}

 	if((tgt = mobjfromreq(&reqt)) == nil)

 		return -1;

+	if(mo == tgt){

+		werrstr("reqgather: object %M targeting itself", mo);

+		return -1;

+	}

 	if((tgt->o->f & Fresource) == 0){

 		werrstr("reqgather: target %M not a resource", tgt);

 		return -1;

@@ -103,18 +110,10 @@

 reqmovenear(uchar *p, uchar *e)

 {

 	int n;

-	Point click;

 	Mobj reqm, reqt, *mo, *tgt;

-	if((n = unpack(p, e, "dldd dd dldd",

-	&reqm.idx, &reqm.uuid, &reqm.x, &reqm.y,

-	&click.x, &click.y,

-	&reqt.idx, &reqt.uuid, &reqt.x, &reqt.y)) < 0)

+	if((n = unpack(p, e, MMOVENEAR, &reqm.idx, &reqm.uuid, &reqt.idx, &reqt.uuid)) < 0)

 		return -1;

-	if(eqpt(reqm.Point, reqt.Point) || eqpt(reqm.Point, click)){

-		dprint("reqmovenear: %P [%#ux,%ld] → %P [%#ux,%ld] (%P), not moving to itself\n", reqm.Point, reqm.idx, reqm.uuid, reqt.Point, reqt.idx, reqt.uuid, click);

-		return n;

-	}

 	if((mo = mobjfromreq(&reqm)) == nil)

 		return -1;

 	if((mo->o->f & Fimmutable) || mo->o->speed == 0.0){

@@ -123,11 +122,11 @@

 	}

 	if((tgt = mobjfromreq(&reqt)) == nil)

 		return -1;

-	if(click.x >= nodemapwidth || click.y >= nodemapheight){

-		werrstr("reqmovenear: invalid location %d,%d", click.x, click.y);

+	if(mo == tgt){

+		werrstr("reqmovenear: object %M targeting itself", mo);

 		return -1;

 	}

-	if(pushmovecommand(click, mo, tgt) < 0)

+	if(pushmovecommand(mo, tgt->Point, tgt) < 0)

 		return -1;

 	return n;

 }

@@ -139,26 +138,24 @@

 	Point tgt;

 	Mobj reqm, *mo;

-	if((n = unpack(p, e, "dldd dd",

-	&reqm.idx, &reqm.uuid, &reqm.x, &reqm.y,

-	&tgt.x, &tgt.y)) < 0)

+	if((n = unpack(p, e, MMOVE, &reqm.idx, &reqm.uuid, &tgt.x, &tgt.y)) < 0)

 		return -1;

-	if(eqpt(reqm.Point, tgt)){

-		dprint("reqmove: %P [%#ux,%ld] → %P, not moving to itself\n", reqm.Point, reqm.idx, reqm.uuid, tgt);

-		return n;

+	if(!ptinrect(tgt, Rect(0,0,mapwidth,mapheight))){

+		werrstr("reqmove: invalid target %P", tgt);

+		return -1;

 	}

 	if((mo = mobjfromreq(&reqm)) == nil)

 		return -1;

+	if(eqpt(mo->Point, tgt)){

+		werrstr("reqmove: object %M targeting itself", mo);

+		return -1;

+	}

 	if((mo->o->f & Fimmutable) || mo->o->speed == 0.0){

 		werrstr("reqmove: object %M can't move", mo);

 		return -1;

 	}

-	if(tgt.x >= nodemapwidth || tgt.y >= nodemapheight){

-		werrstr("reqmove: invalid target %d,%d", tgt.x, tgt.y);

+	if(pushmovecommand(mo, tgt, nil) < 0)

 		return -1;

-	}

-	if(pushmovecommand(tgt, mo, nil) < 0)

-		return -1;

 	return n;

 }

@@ -168,8 +165,7 @@

 	int n;

 	Mobj reqm, *mo;

-	if((n = unpack(p, e, "dldd",

-	&reqm.idx, &reqm.uuid, &reqm.x, &reqm.y)) < 0)

+	if((n = unpack(p, e, MSTOP, &reqm.idx, &reqm.uuid)) < 0)

 		return -1;

 	if((mo = mobjfromreq(&reqm)) == nil)

 		return -1;

@@ -307,9 +303,7 @@

 	Msg *m;

 	m = getclbuf();

-	if(packmsg(m, "h dldd dldd", CTgather,

-	mo->idx, mo->uuid, mo->x, mo->y,

-	tgt->idx, tgt->uuid, tgt->x, tgt->y) < 0){

+	if(packmsg(m, "h" MGATHER, CTgather, mo->idx, mo->uuid, tgt->idx, tgt->uuid) < 0){

 		fprint(2, "sendgather: %r\n");

 		return -1;

 	}

@@ -317,15 +311,12 @@

 }

 int

-sendmovenear(Mobj *mo, Point click, Mobj *tgt)

+sendmovenear(Mobj *mo, Mobj *tgt)

 {

 	Msg *m;

 	m = getclbuf();

-	if(packmsg(m, "h dldd dd dldd", CTmovenear,

-	mo->idx, mo->uuid, mo->x, mo->y,

-	click.x, click.y,

-	tgt->idx, tgt->uuid, tgt->x, tgt->y) < 0){

+	if(packmsg(m, "h" MMOVENEAR, CTmovenear, mo->idx, mo->uuid, tgt->idx, tgt->uuid) < 0){

 		fprint(2, "sendmovenear: %r\n");

 		return -1;

 	}

@@ -338,9 +329,7 @@

 	Msg *m;

 	m = getclbuf();

-	if(packmsg(m, "h dldd dd", CTmove,

-	mo->idx, mo->uuid, mo->x, mo->y,

-	tgt.x, tgt.y) < 0){

+	if(packmsg(m, "h" MMOVE, CTmove, mo->idx, mo->uuid, tgt.x, tgt.y) < 0){

 		fprint(2, "sendmove: %r\n");

 		return -1;

 	}

@@ -353,8 +342,7 @@

 	Msg *m;

 	m = getclbuf();

-	if(packmsg(m, "h dldd", CTstop,

-	mo->idx, mo->uuid, mo->x, mo->y) < 0){

+	if(packmsg(m, "h" MSTOP, CTstop, mo->idx, mo->uuid) < 0){

 		fprint(2, "sendstop: %r\n");

 		return -1;

 	}

--- a/dat.h

+++ b/dat.h

@@ -1,6 +1,7 @@

 typedef struct Node Node;

 typedef struct Pairheap Pairheap;

 typedef struct Attack Attack;

+typedef struct Size Size;

 typedef struct Pic Pic;

 typedef struct Pics Pics;

 typedef struct Obj Obj;

@@ -10,8 +11,8 @@

 typedef struct Mresource Mresource;

 typedef struct Mobj Mobj;

 typedef struct Mobjl Mobjl;

+typedef struct Tilepic Tilepic;

 typedef struct Tile Tile;

-typedef struct Map Map;

 typedef struct Resource Resource;

 typedef struct Team Team;

 typedef struct Cbuf Cbuf;

@@ -28,13 +29,12 @@

 	Nteam = 1 << Nteambits,

 	Teamshift = 32 - Nteambits,

 	Teamidxmask = ~(Nteam - 1 << Teamshift),

-	Tilewidth = 32,

-	Tileheight = Tilewidth,

+	Tilesz = 32,

 	Node2Tile = 4,

-	Nodewidth = Tilewidth / Node2Tile,

-	Nodeheight = Tileheight / Node2Tile,

-	Subpxshift = 16,

-	Subpxmask = (1 << Subpxshift) - 1,

+	Nodesz = Tilesz / Node2Tile,

+	Subshift = 16,

+	Submask = (1 << Subshift) - 1,

+	Pixelshift = 16 - 3,

 };

 struct Vector{

@@ -70,16 +70,18 @@

 	Node *from;

 	Pairheap *p;

 };

-extern Node *nodemap;

-extern int nodemapwidth, nodemapheight;

+extern Node *map;

+extern int mapwidth, mapheight;

-struct Pic{

-	u32int *p;

+struct Size{

 	int w;

 	int h;

-	int dx;

-	int dy;

 };

+struct Pic{

+	u32int *p;

+	Size;

+	Point Δ;

+};

 struct Pics{

 	Pic **pic;

 	int teamcol;

@@ -152,9 +154,8 @@

 };

 struct Obj{

 	char *name;

+	Size;

 	Pics pics[OSend][PTend];

-	int w;

-	int h;

 	int f;

 	Attack *atk[2];

 	int hp;

@@ -215,10 +216,7 @@

 	Command cmds[Ncmd];

 	int ctail;

 	Point;

-	int px;

-	int py;

-	int subpx;

-	int subpy;

+	Point sub;

 	Munit;

 	Mresource;

 };

@@ -229,15 +227,15 @@

 };

 extern char *statename[OSend];

-struct Tile{

+struct Tilepic{

 	Pic *p;

 };

-struct Map{

-	Tile *t;

+struct Tile{

+	Tilepic *t;

 	Mobjl ml;

 };

-extern Map *map;

-extern int mapwidth, mapheight;

+extern Tile *tilemap;

+extern int tilemapwidth, tilemapheight;

 enum{

 	Ngatheramount = 8,

--- a/drw.c

+++ b/drw.c

@@ -15,8 +15,7 @@

 static Rectangle selr;

 static Point panmax;

 static Mobj *selected[Nselect];

-static Mobj **visbuf;

-static int nvisbuf, nvis;

+static Vector vis;

 enum{

 	DLgndshad,

@@ -29,10 +28,8 @@

 };

 typedef struct Drawlist Drawlist;

 struct Drawlist{

-	Mobj **mo;

-	Pic **pics;

-	int n;

-	int sz;

+	Vector mobj;

+	Vector pics;

 	int noalpha;

 };

 static Drawlist drawlist[DLend] = {

@@ -55,51 +52,57 @@

 		pan.y = panmax.y;

 }

-void

-doselect(Point p)

+static Mobj *

+vismobj(Point p)

 {

 	int i;

+	Mobj **mp;

+	if((i = fbvis[p.y * fbw + p.x]) < 0)

+		return nil;

+	mp = vis.p;

+	assert(i < vis.n);

+	return mp[i];

+}

+

+void

+doselect(Point p)

+{

 	if(!ptinrect(p, selr))

 		return;

 	p = divpt(subpt(p, selr.min), scale);

-	i = fbvis[p.y * fbw + p.x];

-	selected[0] = i == -1 ? nil : visbuf[i];

+	selected[0] = vismobj(p);

 }

 void

 doaction(Point p, int clearcmds)

 {

-	int i;

-	Point vp;

-	Mobj *mo, *it;

+	Mobj *mo, *tgt;

-	it = selected[0];

-	if(it == nil || it->o->f & Fimmutable || !ptinrect(p, selr))

+	mo = selected[0];

+	if(mo == nil || mo->o->f & Fimmutable || !ptinrect(p, selr))

 		return;

-	vp = divpt(subpt(p, selr.min), scale);

-	i = fbvis[vp.y * fbw + vp.x];

-	mo = i == -1 ? nil : visbuf[i];

-	p = divpt(addpt(subpt(p, selr.min), pan), scale);

-	p.x /= Nodewidth;

-	p.y /= Nodeheight;

-	if(nodemapwidth - p.x < it->o->w || nodemapheight - p.y < it->o->h){

-		dprint("doaction: %M destination beyond map edge\n", it);

+	p = subpt(p, selr.min);

+	tgt = vismobj(divpt(p, scale));

+	p = divpt(addpt(p, pan), scale);

+	p = divpt(p, Nodesz);

+	if(p.x + mo->o->w > mapwidth || p.y + mo->o->h > mapheight){

+		dprint("doaction: %M target %P beyond map edge\n", mo, p);

 		return;

 	}

-	if(mo == it || eqpt(it->Point, p)){

-		dprint("doaction: %M targeting itself\n", it);

+	if(tgt == mo || eqpt(mo->Point, p)){

+		dprint("doaction: %M targeting moself\n", mo);

 		return;

 	}

 	if(clearcmds)

-		sendstop(it);

-	if(mo != nil){

-		if((mo->o->f & Fresource) && (it->o->f & Fgather))

-			sendgather(it, mo);

+		sendstop(mo);

+	if(tgt != nil){

+		if((tgt->o->f & Fresource) && (mo->o->f & Fgather))

+			sendgather(mo, tgt);

 		else

-			sendmovenear(it, p, mo);

+			sendmovenear(mo, tgt);

 	}else

-		sendmove(it, p);

+		sendmove(mo, p);

 }

 static void

@@ -136,62 +139,57 @@

 	string(screen, p, display->white, ZP, font, s);

 }

-static int

-addvis(Mobj *mo)

+static void

+clearvis(void)

 {

-	int i;

-

-	if((i = nvis++) >= nvisbuf){

-		visbuf = erealloc(visbuf, (nvisbuf + 16) * sizeof *visbuf,

-			nvisbuf * sizeof *visbuf);

-		nvisbuf += 16;

-	}

-	visbuf[i] = mo;

-	return i;

+	clearvec(&vis, sizeof(Mobj*));

 }

-static void

-clearvis(void)

+static int

+addvis(Mobj *mo)

 {

-	if(visbuf != nil)

-		memset(visbuf, 0, nvisbuf * sizeof *visbuf);

-	nvis = 0;

+	pushvec(&vis, &mo, sizeof mo);

+	return vis.n - 1;

 }

 static int

-boundpic(Rectangle *r, u32int **q)

+boundpic(Rectangle *rp, Point o, u32int **q)

 {

 	int w;

+	Rectangle r;

-	r->min.x -= pan.x / scale;

-	r->min.y -= pan.y / scale;

-	if(r->min.x + r->max.x < 0 || r->min.x >= fbw

-	|| r->min.y + r->max.y < 0 || r->min.y >= fbh)

+	r = *rp;

+	r.min = addpt(r.min, o);

+	r.min.x -= pan.x / scale;

+	r.min.y -= pan.y / scale;

+	if(r.min.x + r.max.x < 0 || r.min.x >= fbw

+	|| r.min.y + r.max.y < 0 || r.min.y >= fbh)

 		return -1;

-	w = r->max.x;

-	if(r->min.x < 0){

+	w = r.max.x;

+	if(r.min.x < 0){

 		if(q != nil)

-			*q -= r->min.x;

-		r->max.x += r->min.x;

-		r->min.x = 0;

+			*q -= r.min.x;

+		r.max.x += r.min.x;

+		r.min.x = 0;

 	}

-	if(r->min.x + r->max.x > fbw)

-		r->max.x -= r->min.x + r->max.x - fbw;

-	if(r->min.y < 0){

+	if(r.min.x + r.max.x > fbw)

+		r.max.x -= r.min.x + r.max.x - fbw;

+	if(r.min.y < 0){

 		if(q != nil)

-			*q -= w * r->min.y;

-		r->max.y += r->min.y;

-		r->min.y = 0;

+			*q -= w * r.min.y;

+		r.max.y += r.min.y;

+		r.min.y = 0;

 	}

-	if(r->min.y + r->max.y > fbh)

-		r->max.y -= r->min.y + r->max.y - fbh;

-	r->min.x *= scale;

-	r->max.x *= scale;

+	if(r.min.y + r.max.y > fbh)

+		r.max.y -= r.min.y + r.max.y - fbh;

+	r.min.x *= scale;

+	r.max.x *= scale;

+	*rp = r;

 	return 0;

 }

 static void

-drawpic(int x, int y, Pic *pic, int ivis)

+drawpic(Point o, Pic *pic, int ivis)

 {

 	int n, Δp, Δsp, Δq;

 	u32int v, *p, *e, *sp, *q;

@@ -200,8 +198,8 @@

 	if(pic->p == nil)

 		sysfatal("drawpic: empty pic");

 	q = pic->p;

-	r = Rect(x + pic->dx, y + pic->dy, pic->w, pic->h);

-	if(boundpic(&r, &q) < 0)

+	r = Rect(pic->Δ.x, pic->Δ.y, pic->w, pic->h);

+	if(boundpic(&r, o, &q) < 0)

 		return;

 	Δq = pic->w - r.max.x / scale;

 	p = fb + r.min.y * fbws + r.min.x;

@@ -226,18 +224,18 @@

 }

 static void

-drawpicalpha(int x, int y, Pic *pic)

+drawpicalpha(Point o, Pic *pic)

 {

 	int n, Δp, Δq;

 	u8int k, a, b;

-	u32int o, A, B, *p, *e, *q;

+	u32int f, A, B, *p, *e, *q;

 	Rectangle r;

 	if(pic->p == nil)

-		sysfatal("drawpic: empty pic");

+		sysfatal("drawpicalpha: empty pic");

 	q = pic->p;

-	r = Rect(x + pic->dx, y + pic->dy, pic->w, pic->h);

-	if(boundpic(&r, &q) < 0)

+	r = Rect(pic->Δ.x, pic->Δ.y, pic->w, pic->h);

+	if(boundpic(&r, o, &q) < 0)

 		return;

 	Δq = pic->w - r.max.x / scale;

 	p = fb + r.min.y * fbws + r.min.x;

@@ -251,9 +249,9 @@

 			for(n=0; n<24; n+=8){

 				a = A >> n;

 				b = B >> n;

-				o = k * (a - b);

-				o = (o + 1 + (o >> 8)) >> 8;

-				B = B & ~(0xff << n) | (o + b & 0xff) << n;

+				f = k * (a - b);

+				f = (f + 1 + (f >> 8)) >> 8;

+				B = B & ~(0xff << n) | (f + b & 0xff) << n;

 			}

 			for(n=0; n<scale; n++)

 				*p++ = B;

@@ -264,14 +262,14 @@

 }

 void

-compose(int x, int y, u32int c)

+compose(Point o, u32int c)

 {

 	int n, Δp;

 	u32int v, *p, *e;

 	Rectangle r;

-	r = Rect(x * Nodewidth, y * Nodeheight, Nodewidth, Nodeheight);

-	if(boundpic(&r, nil) < 0)

+	r = Rpt(ZP, Pt(Nodesz, Nodesz));

+	if(boundpic(&r, o, nil) < 0)

 		return;

 	p = fb + r.min.y * fbws + r.min.x;

 	Δp = fbws - r.max.x;

@@ -329,54 +327,31 @@

 {

 	Drawlist *dl;

-	for(dl=drawlist; dl<drawlist+DLend; dl++)

-		dl->n = 0;

+	for(dl=drawlist; dl<drawlist+DLend; dl++){

+		clearvec(&dl->mobj, sizeof(Mobj*));

+		clearvec(&dl->pics, sizeof(Pic*));

+	}

 }

 static void

-drawmobjs(void)

-{

-	int n;

-	Mobj *mo;

-	Drawlist *dl;

-

-	for(dl=drawlist; dl<drawlist+DLend; dl++)

-		for(n=0; n<dl->n; n++){

-			mo = dl->mo[n];

-			if(dl->noalpha)

-				drawpic(mo->px, mo->py, dl->pics[n], addvis(mo));

-			else

-				drawpicalpha(mo->px, mo->py, dl->pics[n]);

-		}

-}

-

-static void

 addpic(Drawlist *dl, Mobj *mo, int type)

 {

-	int n;

 	Pic *p;

 	if((p = frm(mo, type)) == nil)

 		return;

-	if(dl->n >= dl->sz){

-		n = dl->sz * sizeof *dl->pics;

-		dl->pics = erealloc(dl->pics, n + 16 * sizeof *dl->pics, n);

-		dl->mo = erealloc(dl->mo, n + 16 * sizeof *dl->mo, n);

-		dl->sz += 16;

-	}

-	n = dl->n++;

-	dl->pics[n] = p;

-	dl->mo[n] = mo;

+	pushvec(&dl->mobj, &mo, sizeof mo);

+	pushvec(&dl->pics, &p, sizeof p);

 }

 static void

-addmobjs(Map *m)

+addmobjs(Tile *t)

 {

 	int air;

 	Mobj *mo;

 	Mobjl *ml;

-	for(ml=m->ml.l; ml!=&m->ml; ml=ml->l){

+	for(ml=t->ml.l; ml!=&t->ml; ml=ml->l){

 		mo = ml->mo;

 		air = mo->o->f & Fair;

 		addpic(drawlist + (air ? DLairshad : DLgndshad), mo, PTshadow);

@@ -386,44 +361,65 @@

 	}

 }

-static Rectangle

-setdrawrect(void)

+static void

+drawmobjs(void)

 {

+	int n;

+	Mobj *mo, **mp;

+	Pic **pp;

+	Drawlist *dl;

+

+	for(dl=drawlist; dl<drawlist+DLend; dl++)

+		for(mp=dl->mobj.p, pp=dl->pics.p, n=0; n<dl->mobj.n; n++, mp++, pp++){

+			mo = *mp;

+			if(dl->noalpha)

+				drawpic(Pt(mo->sub.x >> Pixelshift,

+					mo->sub.y >> Pixelshift), *pp, addvis(mo));

+			else

+				drawpicalpha(Pt(mo->sub.x >> Pixelshift,

+					mo->sub.y >> Pixelshift), *pp);

+		}

+}

+

+static void

+mapdrawrect(Rectangle *rp)

+{

 	Rectangle r;

-	r.min.x = pan.x / scale / Tilewidth;

-	r.min.y = pan.y / scale / Tileheight;

-	r.max.x = r.min.x + (pan.x / scale % Tilewidth != 0);

-	r.max.x += fbw / Tilewidth + (fbw % Tilewidth != 0);

-	if(r.max.x > mapwidth)

-		r.max.x = mapwidth;

-	r.max.y = r.min.y + (pan.y / scale % Tileheight != 0);

-	r.max.y += fbh / Tileheight + (fbh % Tilewidth != 0);

-	if(r.max.y > mapheight)

-		r.max.y = mapheight;

+	r.min = divpt(pan, scale);

+	r.min = divpt(r.min, Tilesz);

+	r.max.x = r.min.x + (pan.x / scale % Tilesz != 0);

+	r.max.x += fbw / Tilesz + (fbw % Tilesz != 0);

+	if(r.max.x > tilemapwidth)

+		r.max.x = tilemapwidth;

+	r.max.y = r.min.y + (pan.y / scale % Tilesz != 0);

+	r.max.y += fbh / Tilesz + (fbh % Tilesz != 0);

+	if(r.max.y > tilemapheight)

+		r.max.y = tilemapheight;

 	/* enlarge window to capture units overlapping multiple tiles;

 	 * seems like the easiest way to take this into account */

 	r.min.x = max(r.min.x - 4, 0);

 	r.min.y = max(r.min.y - 4, 0);

-	return r;

+	*rp = r;

 }

 void

 redraw(void)

 {

-	int x, y;

+	Point p;

 	Rectangle r;

-	Map *m;

+	Tile *t;

 	clearvis();

 	clearlists();

-	r = setdrawrect();

-	for(y=r.min.y, m=map+y*mapwidth+r.min.x; y<r.max.y; y++){

-		for(x=r.min.x; x<r.max.x; x++, m++){

-			drawpic(x*Tilewidth, y*Tileheight, m->t->p, -1);

-			addmobjs(m);

+	mapdrawrect(&r);

+	t = tilemap + p.y * tilemapwidth + r.min.x;

+	for(p.y=r.min.y; p.y<r.max.y; p.y++){

+		for(p.x=r.min.x; p.x<r.max.x; p.x++, t++){

+			drawpic(mulpt(p, Tilesz), t->t->p, -1);

+			addmobjs(t);

 		}

-		m += mapwidth - (r.max.x - r.min.x);

+		t += tilemapwidth - (r.max.x - r.min.x);

 	}

 	drawmobjs();

 	if(debugmap)

@@ -443,13 +439,13 @@

 void

 resetfb(void)

 {

-	fbws = min(nodemapwidth * Nodewidth * scale, Dx(screen->r));

-	fbh = min(nodemapheight * Nodeheight * scale, Dy(screen->r));

+	fbws = min(mapwidth * Nodesz * scale, Dx(screen->r));

+	fbh = min(mapheight * Nodesz * scale, Dy(screen->r));

 	selr = Rpt(screen->r.min, addpt(screen->r.min, Pt(fbws, fbh)));

 	p0 = Pt(screen->r.min.x + 8, screen->r.max.y - 3 * font->height);

 	p0.y -= (p0.y - screen->r.min.y) % scale;

-	panmax.x = max(Nodewidth * nodemapwidth * scale - Dx(screen->r), 0);

-	panmax.y = max(Nodeheight * nodemapheight * scale - Dy(screen->r), 0);

+	panmax.x = max(Nodesz * mapwidth * scale - Dx(screen->r), 0);

+	panmax.y = max(Nodesz * mapheight * scale - Dy(screen->r), 0);

 	if(p0.y < selr.max.y){

 		panmax.y += selr.max.y - p0.y;

 		fbh -= selr.max.y - p0.y;

--- a/fns.h

+++ b/fns.h

@@ -4,17 +4,21 @@

 int	parsemsg(Msg*);

 void	endmsg(Msg*);

 int	sendgather(Mobj*, Mobj*);

-int	sendmovenear(Mobj*, Point, Mobj*);

+int	sendmovenear(Mobj*, Mobj*);

 int	sendstop(Mobj*);

 int	sendmove(Mobj*, Point);

 int	sendpause(void);

 void	stepsnd(void);

 void	initsnd(void);

+void	setpos(Mobj*, Point);

+void	setsubpos(Mobj*, Point);

+void	snaptomapgrid(Mobj*);

+Tile*	tilepos(Point);

 void	linktomap(Mobj*);

 int	pushreturncommand(Mobj*, Mobj*);

 int	pushgathercommand(Mobj*, Mobj*);

 int	pushmove(Mobj*);

-int	pushmovecommand(Point, Mobj*, Mobj*);

+int	pushmovecommand(Mobj*, Point, Mobj*);

 void	resourcestate(Mobj*);

 void	depleteresource(Mobj*, int);

 void	freezefrm(Mobj*, int);

@@ -36,7 +40,7 @@

 void	dopan(Point);

 void	doselect(Point);

 void	doaction(Point, int);

-void	compose(int, int, u32int);

+void	compose(Point, u32int);

 void	redraw(void);

 void	updatefb(void);

 void	resetfb(void);

@@ -43,19 +47,20 @@

 void	drawfb(void);

 void	initimg(void);

 void	initfs(void);

+double	eucdist(Point, Point);

 double	octdist(Point, Point);

-void	setgoal(Point*, Mobj*, Mobj*);

-Mobj*	unitat(int, int);

+void	setgoal(Mobj*, Point*, Mobj*);

+Mobj*	unitat(Point);

 int	isblocked(Point, Obj*);

 void	markmobj(Mobj*, int);

 int	isnextto(Mobj*, Mobj*);

-int	findpath(Point, Mobj*);

+int	findpath(Mobj*, Point);

 void	drawnodemap(Rectangle, Mobj*);

-Mobj*	mapspawn(Point, Obj*);

+Mobj*	mapspawn(Obj*, Point);

 void	initmap(void);

 Mobj*	derefmobj(int, long);

-int	spawnunit(Point, Obj*, int);

-int	spawnresource(Point, Obj*, int);

+int	spawnunit(Obj*, Point, int);

+int	spawnresource(Obj*, Point, int);

 void	nukequeue(Pairheap**);

 Pairheap*	popqueue(Pairheap**);

 void	decreasekey(Pairheap*, double, Pairheap**);

@@ -62,10 +67,10 @@

 void	pushqueue(Node*, Pairheap**);

 int	lsb(uvlong);

 int	msb(uvlong);

-u64int*	baddr(int, int);

-u64int*	rbaddr(int, int);

-u64int*	bload(int, int, int, int, int, int, int, int);

-void	bset(int, int, int, int, int);

+u64int*	baddr(Point);

+u64int*	rbaddr(Point);

+u64int*	bload(Point, Point, Point, int, int);

+void	bset(Point, Point, int);

 void	initbmap(void);

 int	mobjfmt(Fmt*);

 void	dprint(char *, ...);

--- a/fs.c

+++ b/fs.c

@@ -39,7 +39,7 @@

 };

 struct Tilel{

 	int id;

-	Tile *t;

+	Tilepic *t;

 	Tilel *l;

 };

 static Tilel tilel0 = {.l = &tilel0}, *tilel = &tilel0;

@@ -80,8 +80,8 @@

 	pic->p = p;

 	pic->w = dx;

 	pic->h = dy;

-	pic->dx = i->r.min.x;

-	pic->dy = i->r.min.y;

+	pic->Δ.x = i->r.min.x;

+	pic->Δ.y = i->r.min.y;

 	m = i->depth / 8;

 	freeimage(i);

 	s = b;

@@ -215,7 +215,7 @@

 	return pl->p;

 }

-static Tile *

+static Tilepic *

 pushtile(int id)

 {

 	Tilel *tl;

@@ -248,6 +248,7 @@

 		switch(*fmt++){

 		default: sysfatal("unknown format %c", fmt[-1]);

 		case 0: return;

+		case ' ': break;

 		case 'd':

 			if((n = strtol(*fld++, nil, 0)) < 0)

 				sysfatal("vunpack: illegal positive integer %d", n);

@@ -301,7 +302,7 @@

 				sysfatal("vunpack: empty tile");

 			if((n = strtol(s, nil, 0)) <= 0)

 				sysfatal("vunpack: illegal tile index %d", n);

-			*va_arg(a, Tile**) = pushtile(n);

+			*va_arg(a, Tilepic**) = pushtile(n);

 			break;

 		}

 	}

@@ -323,7 +324,7 @@

 	Obj *o, **os;

 	Resource *r;

-	unpack(fld, "ro", &r, &o);

+	unpack(fld, "r o", &r, &o);

 	if(o->res != nil && o->res != r)

 		sysfatal("readgather %s: obj %s already assigned to %s",

 			r->name, o->name, o->res->name);

@@ -362,16 +363,16 @@

 readmap(char **fld, int n, Table *tab)

 {

 	int x;

-	Map *m;

+	Tile *t;

 	if(tab->row == 0){

 		tab->ncol = n;

-		mapwidth = n;

-		map = emalloc(mapheight * n * sizeof *map);

+		tilemapwidth = n;

+		tilemap = emalloc(tilemapheight * n * sizeof *tilemap);

 	}

-	m = map + tab->row * mapwidth;

-	for(x=0; x<n; x++, m++)

-		unpack(fld++, "t", &m->t);

+	t = tilemap + tab->row * tilemapwidth;

+	for(x=0; x<n; x++, t++)

+		unpack(fld++, "t", &t->t);

 }

 static void

@@ -383,7 +384,8 @@

 	if(objp == nil)

 		objp = emalloc(nobjp * sizeof *objp);

 	op = objp + tab->row;

-	unpack(fld, "oddd", &op->o, &op->x, &op->y, &arg);

+	unpack(fld, "o dd d", &op->o, &op->x, &op->y, &arg);

+	op->Point = mulpt(op->Point, Node2Tile);

 	if(op->o->f & Fresource){

 		op->team = 0;

 		op->resource = 1;

@@ -443,10 +445,11 @@

 		obj = emalloc(nobj * sizeof *obj);

 	o = obj + tab->row;

 	o->name = estrdup(*fld++);

-	unpack(fld, "ddddddddddaaffff", &o->f, &o->w, &o->h,

+	unpack(fld, "d dd ddd dddd aa ffff", &o->f, &o->w, &o->h,

 		&o->hp, &o->def, &o->vis,

 		o->cost, o->cost+1, o->cost+2, &o->time,

-		o->atk, o->atk+1, &o->speed, &o->accel, &o->halt, &o->turn);

+		o->atk, o->atk+1,

+		&o->speed, &o->accel, &o->halt, &o->turn);

 	if(o->f & Fresource)

 		o->f |= Fimmutable;

 	else{

@@ -453,9 +456,9 @@

 		o->accel /= 256.0;

 		o->halt /= 256.0;

 		/* halting distance in path node units */

-		o->halt /= Nodewidth;

+		o->halt /= Nodesz;

 	}

-	if(o->w < 1 || o->h < 1)

+	if(o->w < 1 || o->h < 1 || o->w > 4 * Node2Tile || o->h > 4 * Node2Tile)

 		sysfatal("readobj: %s invalid dimensions %d,%d", o->name, o->w, o->h);

 }

@@ -469,7 +472,7 @@

 	if(n < 4)

 		sysfatal("readspr %s: %d fields < 4 mandatory columns", o->name, n);

-	unpack(fld, "odd", &o, &type, &nr);

+	unpack(fld, "o dd", &o, &type, &nr);

 	fld += 3;

 	n -= 3;

 	state = type & PFstatemask;

@@ -519,7 +522,7 @@

 	[TBresource] {"resource", readresource, -1, &nresource},

 	[TBspawn] {"spawn", readspawn, -1, nil},

 	[TBtileset] {"tileset", readtileset, 1, nil},

-	[TBmap] {"map", readmap, -1, &mapheight},

+	[TBmap] {"map", readmap, -1, &tilemapheight},

 	[TBspr] {"spr", readspr, -1, nil},

 	[TBgather] {"gather", readgather, -1, nil},

 };

@@ -605,17 +608,15 @@

 initmapobj(void)

 {

 	Objp *op;

-	Map *m;

-	Point p;

+	Tile *t;

-	for(m=map; m<map+mapwidth*mapheight; m++)

-		m->ml.l = m->ml.lp = &m->ml;

+	for(t=tilemap; t<tilemap+tilemapwidth*tilemapheight; t++)

+		t->ml.l = t->ml.lp = &t->ml;

 	for(op=objp; op<objp+nobjp; op++){

-		p = mulpt(op->Point, Node2Tile);

 		if(op->resource){

-			if(spawnresource(p, op->o, op->amount) < 0)

+			if(spawnresource(op->o, op->Point, op->amount) < 0)

 				sysfatal("initmapobj: %s at %P: %r", op->o->name, op->Point);

-		}else if(spawnunit(p, op->o, op->team) < 0)

+		}else if(spawnunit(op->o, op->Point, op->team) < 0)

 			sysfatal("initmapobj: %s team %d at %P: %r", op->o->name, op->team, op->Point);

 	}

 	free(objp);

@@ -649,9 +650,10 @@

 		sysfatal("checkdb: no tileset defined");

 	if(nresource != Nresource)

 		sysfatal("checkdb: incomplete resource specification");

-	if(mapwidth % 16 != 0 || mapheight % 16 != 0 || mapwidth * mapheight == 0)

+	if(tilemapwidth % 16 != 0 || tilemapheight % 16 != 0

+	|| tilemapwidth * tilemapheight <= 0)

 		sysfatal("checkdb: map size %d,%d not in multiples of 16",

-			mapwidth, mapheight);

+			tilemapwidth, tilemapheight);

 	if(nteam < 2)

 		sysfatal("checkdb: not enough teams");

 }

--- a/map.c

+++ b/map.c

@@ -4,11 +4,52 @@

 #include "dat.h"

 #include "fns.h"

-Map *map;

+Tile *tilemap;

+int tilemapwidth, tilemapheight;

+Node *map;

 int mapwidth, mapheight;

-Node *nodemap;

-int nodemapwidth, nodemapheight;

+void

+setpos(Mobj *mo, Point p)

+{

+	assert(p.x < mapwidth && p.y < mapheight);

+	mo->Point = p;

+	mo->sub.x = mo->x << Subshift;

+	mo->sub.y = mo->y << Subshift;

+}

+

+void

+setsubpos(Mobj *mo, Point p)

+{

+	mo->sub = p;

+	mo->x = p.x >> Subshift;

+	mo->y = p.y >> Subshift;

+}

+

+void

+snaptomapgrid(Mobj *mo)

+{

+	markmobj(mo, 0);

+	setpos(mo, mo->Point);

+	markmobj(mo, 1);

+}

+

+Tile *

+tilepos(Point p)

+{

+	p = divpt(p, Node2Tile);

+	return tilemap + p.y * tilemapwidth + p.x;

+}

+

+void

+linktomap(Mobj *mo)

+{

+	Tile *t;

+

+	t = tilepos(mo->Point);

+	mo->mapl = linkmobj(mo->o->f & Fair ? t->ml.lp : &t->ml, mo, mo->mapl);

+}

+

 static void

 updatemap(Mobj *mo)

 {

@@ -15,7 +56,7 @@

 	Mobj *bmo;

 	if(isblocked(mo->Point, mo->o)){

-		bmo = unitat(mo->x, mo->y);

+		bmo = unitat(mo->Point);

 		sysfatal("markmobj: attempt to place %s at %P, non-free block having %s at %P",

 			mo->o->name, mo->Point, bmo->o->name, bmo->Point);

 	}

@@ -26,24 +67,24 @@

 static int

 findspawn(Point *pp, int ofs, Obj *o, Obj *spawn)

 {

-	int minx, miny, maxx, maxy;

+	Rectangle r;

 	Point p;

 	p = *pp;

-	minx = p.x - (ofs+1) * o->w;

-	miny = p.y - (ofs+1) * o->h;

-	maxx = p.x + spawn->w + ofs * o->w;

-	maxy = p.y + spawn->h + ofs * o->h;

-	for(p.x=minx+o->w, p.y=maxy; p.x<maxx; p.x++)

+	r.min.x = p.x - (ofs+1) * o->w;

+	r.min.y = p.y - (ofs+1) * o->h;

+	r.max.x = p.x + spawn->w + ofs * o->w;

+	r.max.y = p.y + spawn->h + ofs * o->h;

+	for(p.x=r.min.x+o->w, p.y=r.max.y; p.x<r.max.x; p.x++)

 		if(!isblocked(p, o))

 			goto found;

-	for(p.x=maxx, p.y=maxy; p.y>miny; p.y--)

+	for(p.x=r.max.x, p.y=r.max.y; p.y>r.min.y; p.y--)

 		if(!isblocked(p, o))

 			goto found;

-	for(p.x=maxx, p.y=miny; p.x>minx; p.x--)

+	for(p.x=r.max.x, p.y=r.min.y; p.x>r.min.x; p.x--)

 		if(!isblocked(p, o))

 			goto found;

-	for(p.x=minx, p.y=miny; p.y<=maxy; p.y++)

+	for(p.x=r.min.x, p.y=r.min.y; p.y<=r.max.y; p.y++)

 		if(!isblocked(p, o))

 			goto found;

 	return -1;

@@ -57,7 +98,7 @@

 {

 	int n;

 	Point p;

-	Map *m;

+	Tile *t;

 	Mobjl *ml;

 	Mobj *mo;

 	Obj **os;

@@ -64,13 +105,17 @@

 	p = *pp;

 	if(o->f & (Fbuild|Fimmutable)){

+		if((p.x & Node2Tile - 1) || (p.y & Node2Tile - 1)){

+			werrstr("getspawn: unaligned building placement %P", p);

+			return -1;

+		}

 		if(isblocked(p, o)){

 			werrstr("getspawn: building placement at %P blocked", p);

 			return -1;

 		}

 	}else{

-		m = map + p.y / Node2Tile * mapwidth + p.x / Node2Tile;

-		for(mo=nil, ml=m->ml.l; ml!=&m->ml; ml=ml->l){

+		t = tilepos(p);

+		for(mo=nil, ml=t->ml.l; ml!=&t->ml; ml=ml->l){

 			mo = ml->mo;

 			for(os=mo->o->spawn, n=mo->o->nspawn; n>0; n--, os++)

 				if(*os == o)

@@ -78,7 +123,7 @@

 			if(n > 0)

 				break;

 		}

-		if(ml == &m->ml){

+		if(ml == &t->ml){

 			werrstr("getspawn: no spawn object at %P", p);

 			return -1;

 		}

@@ -96,23 +141,15 @@

 }

 Mobj *

-mapspawn(Point p, Obj *o)

+mapspawn(Obj *o, Point p)

 {

 	Mobj *mo;

-	if(o->f & (Fbuild|Fimmutable) && (p.x & Node2Tile-1 || p.y & Node2Tile-1)){

-		werrstr("mapspawn: building spawn %P not aligned to tile map", p);

-		return nil;

-	}

 	if(getspawn(&p, o) < 0)

 		return nil;

 	mo = emalloc(sizeof *mo);

 	mo->uuid = lrand();

-	mo->Point = p;

-	mo->px = p.x * Nodewidth;

-	mo->py = p.y * Nodeheight;

-	mo->subpx = mo->px << Subpxshift;

-	mo->subpy = mo->py << Subpxshift;

+	setpos(mo, p);

 	mo->o = o;

 	updatemap(mo);

 	return mo;

@@ -121,8 +158,8 @@

 void

 initmap(void)

 {

-	nodemapwidth = mapwidth * Node2Tile;

-	nodemapheight = mapheight * Node2Tile;

-	nodemap = emalloc(nodemapwidth * nodemapheight * sizeof *nodemap);

+	mapwidth = tilemapwidth * Node2Tile;

+	mapheight = tilemapheight * Node2Tile;

+	map = emalloc(mapwidth * mapheight * sizeof *map);

 	initbmap();

 }

--- a/path.c

+++ b/path.c

@@ -61,39 +61,38 @@

 void

 drawnodemap(Rectangle r, Mobj *sel)

 {

-	int x, y;

 	u64int *row, v, m;

-	Point *p;

-	Path *pp;

+	Point p, *pp;

+	Path *path;

 	Node *n;

 	r = Rpt(mulpt(r.min, Node2Tile), mulpt(r.max, Node2Tile));

-	for(y=r.min.y, n=nodemap+y*nodemapwidth+r.min.x; y<r.max.y; y++){

-		x = r.min.x;

-		row = baddr(x, y);

+	for(p.y=r.min.y, n=map+p.y*mapwidth+r.min.x; p.y<r.max.y; p.y++){

+		p.x = r.min.x;

+		row = baddr(p);

 		v = *row++;

-		m = 1ULL << 63 - (x & Bmask);

-		for(; x<r.max.x; x++, n++, m>>=1){

+		m = 1ULL << 63 - (p.x & Bmask);

+		for(; p.x<r.max.x; p.x++, n++, m>>=1){

 			if(m == 0){

 				v = *row++;

 				m = 1ULL << 63;

 			}

 			if(v & m)

-				compose(x, y, 0xff0000);

+				compose(mulpt(p, Nodesz), 0xff0000);

 			if(n->closed)

-				compose(x, y, 0x000077);

+				compose(mulpt(p, Nodesz), 0x000077);

 			else if(n->open)

-				compose(x, y, 0x007777);

+				compose(mulpt(p, Nodesz), 0x007777);

 		}

-		n += nodemapwidth - (r.max.x - r.min.x);

+		n += mapwidth - (r.max.x - r.min.x);

 	}

 	if(sel != nil){

-		pp = &sel->path;

-		if(pp->step == nil)

+		path = &sel->path;

+		if(path->step == nil)

 			return;

-		for(p=pp->step; p>=pp->moves.p; p--)

-			compose(p->x / Nodewidth, p->y / Nodeheight, 0x00ff00);

-		compose(pp->target.x, pp->target.y, 0x00ff77);

+		for(pp=path->step; pp>=path->moves.p; pp--)

+			compose(mulpt(*pp, Nodesz), 0x00ff00);

+		compose(mulpt(path->target, Nodesz), 0x00ff77);

 	}

 }

@@ -101,7 +100,7 @@

 clearpath(void)

 {

 	nukequeue(&queue);

-	memset(nodemap, 0, nodemapwidth * nodemapheight * sizeof *nodemap);

+	memset(map, 0, mapwidth * mapheight * sizeof *map);

 	nearest = nil;

 }

@@ -112,34 +111,32 @@

 	if(o->f & Fair)

 		return 0;

-	row = bload(p.x, p.y, o->w, o->h, 0, 0, 0, 0);

+	row = bload(p, Pt(o->w, o->h), ZP, 0, 0);

 	return (*row & 1ULL << 63) != 0;

 }

 Mobj *

-unitat(int px, int py)

+unitat(Point p)

 {

-	int x, y;

+	Point mp;

 	Rectangle r, mr;

-	Map *m;

+	Tile *t;

 	Mobjl *ml;

 	Mobj *mo;

-	x = px / Node2Tile;

-	y = py / Node2Tile;

-	r = Rect(x-4, y-4, x, y);

-	for(; y>=r.min.y; y--)

-		for(x=r.max.x, m=map+y*mapwidth+x; x>=r.min.x; x--)

-			for(ml=m->ml.l; ml!=&m->ml; ml=ml->l){

+	mp = divpt(p, Node2Tile);

+	r = Rpt(subpt(mp, Pt(4, 4)), mp);

+	for(; mp.y>=r.min.y; mp.y--){

+		mp.x = r.max.x;

+		t = tilemap + mp.y * tilemapwidth + mp.x;

+		for(; mp.x>=r.min.x; mp.x--, t--)

+			for(ml=t->ml.l; ml!=&t->ml; ml=ml->l){

 				mo = ml->mo;

-				mr.min.x = mo->x;

-				mr.min.y = mo->y;

-				mr.max.x = mr.min.x + mo->o->w;

-				mr.max.y = mr.min.y + mo->o->h;

-				if(px >= mo->x && px <= mo->x + mo->o->w

-				&& py >= mo->y && py <= mo->y + mo->o->h)

+				mr = Rect(mo->x, mo->y, mo->x+mo->o->w, mo->y+mo->o->h);

+				if(ptinrect(p, mr))

 					return mo;

 			}

+	}

 	return nil;

 }

@@ -146,26 +143,29 @@

 void

 markmobj(Mobj *mo, int set)

 {

-	int w, h;

+	Point sz;

 	if(mo->o->f & Fair)

 		return;

-	w = mo->o->w;

-	if((mo->subpx & Subpxmask) != 0 && mo->x != (mo->px + 1) / Nodewidth)

-		w++;

-	h = mo->o->h;

-	if((mo->subpy & Subpxmask) != 0 && mo->y != (mo->py + 1) / Nodewidth)

-		h++;

-	bset(mo->x, mo->y, w, h, set);

+	sz = Pt(mo->o->w, mo->o->h);

+/*

+	if((mo->sub.x & Submask) != 0 && mo->x != ((mo->sub.x>>Pixelshift) + 1) / Nodesz)

+		sz.x++;

+	if((mo->sub.y & Submask) != 0 && mo->y != ((mo->sub.y>>Pixelshift) + 1) / Nodesz)

+		sz.y++;

+*/

+	sz.x += (mo->sub.x & Submask) != 0 && mo->x != mo->sub.x + (1<<Pixelshift) >> Subshift;

+	sz.y += (mo->sub.y & Submask) != 0 && mo->y != mo->sub.y + (1<<Pixelshift) >> Subshift;

+	bset(mo->Point, sz, set);

 }

-static double

-eucdist(Node *a, Node *b)

+double

+eucdist(Point a, Point b)

 {

-	double dx, dy;

+	int dx, dy;

-	dx = a->x - b->x;

-	dy = a->y - b->y;

+	dx = a.x - b.x;

+	dy = a.y - b.y;

 	return sqrt(dx * dx + dy * dy);

 }

@@ -203,7 +203,7 @@

 	ss = left ? -1 : 1;

 	(*v)--;

 	for(;;){

-		row = bload(x, y, w, h, 0, 2, left, rot);

+		row = bload(Pt(x, y), Pt(w, h), Pt(0, 2), left, rot);

 		bs = row[1];

 		if(left){

 			bs |= row[0] << 1 & ~row[0];

@@ -240,8 +240,8 @@

 	}

 	if(end)

 		return nil;

-	assert(x < nodemapwidth && y < nodemapheight);

-	n = nodemap + y * nodemapwidth + x;

+	assert(x < mapwidth && y < mapheight);

+	n = map + y * mapwidth + x;

 	n->x = x;

 	n->y = y;

 	n->Δg = steps;

@@ -267,7 +267,7 @@

 		steps++;

 		x += Δx;

 		y += Δy;

-		if(*bload(x, y, w, h, 0, 0, 0, 0) & 1ULL << 63)

+		if(*bload(Pt(x, y), Pt(w, h), ZP, 0, 0) & 1ULL << 63)

 			return nil;

 		if(jumpeast(x, y, w, h, b, &ofs1, left1, 1) != nil

 		|| jumpeast(x, y, w, h, b, &ofs2, left2, 0) != nil)

@@ -275,8 +275,8 @@

 		if(ofs1 == 0 || ofs2 == 0)

 			return nil;

 	}

-	assert(x < nodemapwidth && y < nodemapheight);

-	n = nodemap + y * nodemapwidth + x;

+	assert(x < mapwidth && y < mapheight);

+	n = map + y * mapwidth + x;

 	n->x = x;

 	n->y = y;

 	n->Δg = steps;

@@ -367,12 +367,12 @@

 {

 	u64int *row;

-	row = bload(x-1, y-1, w, h, 2, 2, 1, 0);

+	row = bload(Pt(x-1,y-1), Pt(w,h), Pt(2,2), 1, 0);

 	return (row[2] & 7) << 6 | (row[1] & 7) << 3 | row[0] & 7;

 }

 static Node **

-successors(Node *n, int w, int h, Node *b)

+jpssuccessors(Node *n, Size sz, Node *b)

 {

 	static Node *dir[8+1];

 	static dtab[2*(nelem(dir)-1)]={

@@ -382,13 +382,13 @@

 	int i, ns;

 	Node *s, **p;

-	ns = neighbors(n->x, n->y, w, h);

+	ns = neighbors(n->x, n->y, sz.w, sz.h);

 	ns = prune(ns, n->dir);

 	memset(dir, 0, sizeof dir);

 	for(i=0, p=dir; i<nelem(dtab); i+=2){

 		if(ns & dtab[i])

 			continue;

-		if((s = jump(n->x, n->y, w, h, b, dtab[i+1])) != nil){

+		if((s = jump(n->x, n->y, sz.w, sz.h, b, dtab[i+1])) != nil){

 			s->dir = dtab[i+1];

 			*p++ = s;

 		}

@@ -396,8 +396,33 @@

 	return dir;

 }

+static Node **

+successors(Node *n, Size, Node *)

+{

+	static Node *dir[8+1];

+	static dtab[2*(nelem(dir)-1)]={

+		-1,-1, 0,-1, 1,-1,

+		-1,0, 0,1,

+		-1,1, 0,1, 1,1,

+	};

+	int i;

+	Node *s, **p;

+

+	memset(dir, 0, sizeof dir);

+	for(i=0, p=dir; i<nelem(dtab); i+=2){

+		s = n + dtab[i+1] * mapwidth + dtab[i];

+		if(s >= map && s < map + mapwidth * mapheight){

+			s->Point = addpt(n->Point, Pt(dtab[i], dtab[i+1]));

+			s->Δg = 1;

+			s->Δlen = dtab[i] != 0 && dtab[i+1] != 0 ? SQRT2 : 1;

+			*p++ = s;

+		}

+	}

+	return dir;

+}

+

 static Node *

-a∗(Node *a, Node *b, Mobj *mo)

+a∗(Mobj *mo, Node *a, Node *b)

 {

 	double g, Δg;

 	Node *x, *n, **dp;

@@ -416,10 +441,12 @@

 		if(x == b)

 			break;

 		x->closed = 1;

-		dp = successors(x, mo->o->w, mo->o->h, b);

+		dp = successors(x, mo->o->Size, b);

 		for(n=*dp++; n!=nil; n=*dp++){

 			if(n->closed)

 				continue;

+			if(isblocked(n->Point, mo->o))

+				continue;

 			g = x->g + n->Δg;

 			Δg = n->g - g;

 			if(!n->open){

@@ -445,33 +472,28 @@

 }

 static void

-directpath(Node *a, Node *g, Mobj *mo)

+directpath(Mobj *mo, Node *a, Node *g)

 {

-	Point p;

 	Path *pp;

 	pp = &mo->path;

-	pp->dist = eucdist(a, g);

-	clearvec(&pp->moves, sizeof p);

-	p = Pt(g->x * Nodewidth, g->y * Nodeheight);

-	pushvec(&pp->moves, &p, sizeof p);

+	pp->dist = eucdist(a->Point, g->Point);

+	clearvec(&pp->moves, sizeof g->Point);

+	pushvec(&pp->moves, &g->Point, sizeof g->Point);

 	pp->step = (Point *)pp->moves.p + pp->moves.n - 1;

 }

 static void

-backtrack(Node *n, Node *a, Mobj *mo)

+backtrack(Mobj *mo, Node *n, Node *a)

 {

-	Point p;

 	Path *pp;

 	pp = &mo->path;

 	assert(n != a && n->step > 0);

 	pp->dist = n->len;

-	clearvec(&pp->moves, sizeof p);

-	for(; n!=a; n=n->from){

-		p = Pt(n->x * Nodewidth, n->y * Nodeheight);

-		pushvec(&pp->moves, &p, sizeof p);

-	}

+	clearvec(&pp->moves, sizeof n->Point);

+	for(; n!=a; n=n->from)

+		pushvec(&pp->moves, &n->Point, sizeof n->Point);

 	pp->step = (Point *)pp->moves.p + pp->moves.n - 1;

 }

@@ -491,7 +513,7 @@

 /* FIXME: completely broken */

 static Node *

-nearestnonjump(Node *n, Node *b, Mobj *mo)

+nearestnonjump(Mobj *mo, Node *n, Node *b)

 {

 	static Point dirtab[] = {

 		{0,-1},

@@ -499,23 +521,21 @@

 		{0,1},

 		{-1,0},

 	};

-	int i, x, y;

+	int i;

+	Point p;

 	Node *m, *min;

 	min = n;

 	for(i=0; i<nelem(dirtab); i++){

-		x = n->x + dirtab[i].x;

-		y = n->y + dirtab[i].y;

-		while(!isblocked(Pt(x, y), mo->o)){

-			m = nodemap + y * nodemapwidth + x;

-			m->x = x;

-			m->y = y;

+		p = addpt(n->Point, dirtab[i]);

+		while(!isblocked(p, mo->o)){

+			m = map + p.y * mapwidth + p.x;

+			m->Point = p;

 			m->h = octdist(m->Point, b->Point);

 			if(min->h < m->h)

 				break;

 			min = m;

-			x += dirtab[i].x;

-			y += dirtab[i].y;

+			p = addpt(p, dirtab[i]);

 		}

 	}

 	if(min != n){

@@ -528,92 +548,82 @@

 /* FIXME: completely broken */

 void

-setgoal(Point *p, Mobj *mo, Mobj *block)

+setgoal(Mobj *mo, Point *gp, Mobj *block)

 {

-	int x, y, e;

+	int e;

 	double Δ, Δ´;

-	Node *n1, *n2, *pm;

+	Point p, g;

+	Node *n1, *n2, *gn;

 	if(mo->o->f & Fair || block == nil){

 		mo->path.blocked = 0;

 		return;

 	}

+	g = *gp;

 	mo->path.blocked = 1;

-	dprint("%M setgoal: moving goal %d,%d in block %#p ", mo, p->x, p->y, block);

-	pm = nodemap + p->y * nodemapwidth + p->x;

-	pm->x = p->x;

-	pm->y = p->y;

+	dprint("%M setgoal: moving goal %P in block %#p ", mo, g, block);

+	gn = map + g.y * mapwidth + g.x;

+	gn->Point = g;

 	Δ = 0x7ffffff;

-	x = block->x;

-	y = block->y;

-	n1 = nodemap + y * nodemapwidth + x;

-	n2 = n1 + (block->o->h - 1) * nodemapwidth;

-	for(e=x+block->o->w; x<e; x++, n1++, n2++){

-		n1->x = x;

-		n1->y = y;

-		Δ´ = octdist(pm->Point, n1->Point);

+	p = block->Point;

+	n1 = map + p.y * mapwidth + p.x;

+	n2 = n1 + (block->o->h - 1) * mapwidth;

+	for(e=p.x+block->o->w; p.x<e; p.x++, n1++, n2++){

+		n1->Point = p;

+		Δ´ = octdist(gn->Point, n1->Point);

 		if(Δ´ < Δ){

 			Δ = Δ´;

-			p->x = x;

-			p->y = y;

+			g = p;

 		}

-		n2->x = x;

-		n2->y = y + block->o->h - 1;

-		Δ´ = octdist(pm->Point, n2->Point);

+		n2->Point = addpt(p, Pt(0, block->o->h-1));

+		Δ´ = octdist(gn->Point, n2->Point);

 		if(Δ´ < Δ){

 			Δ = Δ´;

-			p->x = x;

-			p->y = y + block->o->h - 1;

+			g = n2->Point;

 		}

 	}

-	x = block->x;

-	y = block->y + 1;

-	n1 = nodemap + y * nodemapwidth + x;

+	p = addpt(block->Point, Pt(0,1));

+	n1 = map + p.y * mapwidth + p.x;

 	n2 = n1 + block->o->w - 1;

-	for(e=y+block->o->h-2; y<e; y++, n1+=nodemapwidth, n2+=nodemapwidth){

-		n1->x = x;

-		n1->y = y;

-		Δ´ = octdist(pm->Point, n1->Point);

+	for(e=p.y+block->o->h-2; p.y<e; p.y++, n1+=mapwidth, n2+=mapwidth){

+		n1->Point = p;

+		Δ´ = octdist(gn->Point, n1->Point);

 		if(Δ´ < Δ){

 			Δ = Δ´;

-			p->x = x;

-			p->y = y;

+			g = p;

 		}

-		n2->x = x + block->o->w - 1;

-		n2->y = y;

-		Δ´ = octdist(pm->Point, n2->Point);

+		n2->Point = addpt(p, Pt(block->o->w-1, 0));

+		Δ´ = octdist(gn->Point, n2->Point);

 		if(Δ´ < Δ){

 			Δ = Δ´;

-			p->x = x + block->o->w - 1;

-			p->y = y;

+			g = n2->Point;

 		}

 	}

-	dprint("to %d,%d\n", p->x, p->y);

+	dprint("to %P\n", g);

+	*gp = g;

 }

 int

-findpath(Point p, Mobj *mo)

+findpath(Mobj *mo, Point p)

 {

 	Node *a, *b, *n;

-	dprint("%M findpath to %P\n", mo, p);

 	if(eqpt(p, mo->Point)){

 		werrstr("not moving to itself");

 		return -1;

 	}

 	clearpath();

-	a = nodemap + mo->y * nodemapwidth + mo->x;

-	a->x = mo->x;

-	a->y = mo->y;

-	b = nodemap + p.y * nodemapwidth + p.x;

-	b->x = p.x;

-	b->y = p.y;

+	a = map + mo->y * mapwidth + mo->x;

+	a->Point = mo->Point;

+	b = map + p.y * mapwidth + p.x;

+	b->Point = p;

+	dprint("%M findpath from %P to %P dist %f\n", mo, a->Point, b->Point, octdist(a->Point, b->Point));

 	if(mo->o->f & Fair){

-		directpath(a, b, mo);

+		directpath(mo, a, b);

 		return 0;

 	}

 	markmobj(mo, 0);

-	n = a∗(a, b, mo);

+	n = a∗(mo, a, b);

 	if(n != b){

 		dprint("%M findpath: goal unreachable\n", mo);

 		if((n = nearest) == a || n == nil || a->h < n->h){

@@ -621,8 +631,15 @@

 			markmobj(mo, 1);

 			return -1;

 		}

-		dprint("%M nearest: %#p %P dist %f\n", mo, n, n->Point, n->h);

-		b = nearestnonjump(n, b, mo);

+		dprint("%M findpath: nearest is %#p %P dist %f\n", mo, n, n->Point, n->h);

+		n = nearest;

+		if(n == a){

+			werrstr("a∗: really can't move");

+			markmobj(mo, 1);

+			return -1;

+		}

+		/*

+		b = nearestnonjump(mo, n, b);

 		if(b == a){

 			werrstr("a∗: really can't move");

 			markmobj(mo, 1);

@@ -629,16 +646,16 @@

 			return -1;

 		}

 		clearpath();

-		a->x = mo->x;

-		a->y = mo->y;

-		b->x = (b - nodemap) % nodemapwidth;

-		b->y = (b - nodemap) / nodemapwidth;

-		if((n = a∗(a, b, mo)) != b){

+		a->Point = mo->Point;

+		b->Point = Pt((b - map) % mapwidth, (b - map) / mapwidth);

+		if((n = a∗(mo, a, b)) != b){

 			werrstr("bug: failed to find path to nearest non-jump point");

 			return -1;

 		}

+		*/

 	}

+	dprint("%M found %#p at %P dist %f\n", mo, n, n->Point, n->h);

 	markmobj(mo, 1);

-	backtrack(n, a, mo);

+	backtrack(mo, n, a);

 	return 0;

 }

--- a/pheap.c

+++ b/pheap.c

@@ -58,6 +58,7 @@

 	if(p == nil)

 		return nil;

 	*queue = mergepairs(p->left);

+	dprint("pop %#p %P g %f sum %f\n", p->n, p->n->Point, p->n->g, p->sum);

 	return p;

 }

@@ -66,6 +67,7 @@

 {

 	p->sum -= Δ;

 	p->n->g -= Δ;

+	dprint("decrease %#p %P g %f sum %f\n", p->n, p->n->Point, p->n->g, p->sum);

 	if(p->parent != nil && p->sum < p->parent->sum){

 		p->parent->left = nil;

 		p->parent = nil;

@@ -82,5 +84,6 @@

 	p->n = n;

 	p->sum = n->h + n->g;

 	n->p = p;

+	dprint("push %#p %P g %f sum %f\n", p->n, p->n->Point, p->n->g, p->sum);

 	*queue = mergequeue(p, *queue);

 }

--- a/sim.move.c

+++ b/sim.move.c

@@ -4,32 +4,14 @@

 #include "dat.h"

 #include "fns.h"

-void

-linktomap(Mobj *mo)

-{

-	Map *m;

-

-	m = map + mo->y / Node2Tile * mapwidth + mo->x / Node2Tile;

-	mo->mapl = linkmobj(mo->o->f & Fair ? m->ml.lp : &m->ml, mo, mo->mapl);

-}

-

-static void

-resetcoords(Mobj *mo)

-{

-	markmobj(mo, 0);

-	mo->subpx = mo->px << Subpxshift;

-	mo->subpy = mo->py << Subpxshift;

-	markmobj(mo, 1);

-}

-

 static double

-facegoal(Point p, Mobj *mo)

+facegoal(Mobj *mo, Point p)

 {

 	int dx, dy;

 	double vx, vy, d, θ, θ256, Δθ;

-	dx = p.x - mo->px;

-	dy = p.y - mo->py;

+	dx = p.x - mo->x;

+	dy = p.y - mo->y;

 	d = sqrt(dx * dx + dy * dy);

 	if(d == 0.0)

 		sysfatal("facegoal: %M → %P: moving in place, shouldn't happen", mo, p);

@@ -60,22 +42,21 @@

 {

 	Point p;

-	p.x = tgt->px + tgt->o->w * Nodewidth / 2;

-	p.y = tgt->py + tgt->o->h * Nodeheight / 2;

-	return facegoal(p, mo);

+	p = addpt(tgt->Point, Pt(tgt->o->w / 2, tgt->o->h / 2));

+	return facegoal(mo, p);

 }

 static void

 nextpathnode(Mobj *mo)

 {

-	resetcoords(mo);

-	facegoal(*mo->path.step, mo);

+	snaptomapgrid(mo);

+	facegoal(mo, *mo->path.step);

 }

 static void

 clearpath(Mobj *mo)

 {

-	resetcoords(mo);

+	snaptomapgrid(mo);

 	mo->speed = 0.0;

 	mo->path.step = nil;

 	clearvec(&mo->path.moves, sizeof *mo->path.step);

@@ -85,7 +66,7 @@

 cleanup(Mobj *mo)

 {

 	clearpath(mo);

-	mo->path.target = (Point){0,0};

+	mo->path.target = ZP;

 	mo->path.blocked = 0;

 	mo->path.dist = 0.0;

 	mo->path.nerr = 0;

@@ -122,15 +103,13 @@

 	abortcommands(mo);

 }

-/* FIXME: kind of weird to mix up argument order,

- * mo should be first like elsewhere */

 static int

-repath(Point p, Mobj *mo)

+repath(Mobj *mo, Point p)

 {

 	clearpath(mo);

 	mo->path.target = p;

-	if(findpath(p, mo) < 0){

-		mo->θ = facegoal(p, mo);

+	if(findpath(mo, p) < 0){

+		mo->θ = facegoal(mo, p);

 		return -1;

 	}

 	nextpathnode(mo);

@@ -149,28 +128,26 @@

 		if(mo->speed > mo->o->speed)

 			mo->speed = mo->o->speed;

 	}

+	mo->speed /= 8;

 }

 static int

 trymove(Mobj *mo)

 {

-	int px, py, sx, sy, Δx, Δy, Δu, Δv, Δrx, Δry, Δpx, Δpy;

-	double dx, dy;

-	Point p;

+	int Δx, Δy, Δu, Δv, Δrx, Δry, Δpx, Δpy;

+	Point p, from, sub;

 	markmobj(mo, 0);

-	px = mo->px;

-	py = mo->py;

-	sx = mo->subpx;

-	sy = mo->subpy;

-	Δu = mo->u * (1 << Subpxshift);

-	Δv = mo->v * (1 << Subpxshift);

+	from = mo->Point;

+	sub = mo->sub;

+	Δu = mo->u * (1 << Subshift);

+	Δv = mo->v * (1 << Subshift);

 	Δx = abs(Δu);

 	Δy = abs(Δv);

-	Δrx = fabs(mo->u * mo->speed) * (1 << Subpxshift);

-	Δry = fabs(mo->v * mo->speed) * (1 << Subpxshift);

-	Δpx = abs((mo->path.step->x << Subpxshift) - sx);

-	Δpy = abs((mo->path.step->y << Subpxshift) - sy);

+	Δrx = fabs(mo->u * mo->speed) * (1 << Subshift);

+	Δry = fabs(mo->v * mo->speed) * (1 << Subshift);

+	Δpx = abs((mo->path.step->x << Subshift) - sub.x);

+	Δpy = abs((mo->path.step->y << Subshift) - sub.y);

 	if(Δpx < Δrx)

 		Δrx = Δpx;

 	if(Δpy < Δry)

@@ -178,20 +155,18 @@

 	while(Δrx > 0 || Δry > 0){

 		p = mo->Point;

 		if(Δrx > 0){

-			sx += Δu;

+			sub.x += Δu;

 			Δrx -= Δx;

 			if(Δrx < 0)

-				sx += mo->u < 0 ? -Δrx : Δrx;

-			p.x = (sx >> Subpxshift) + ((sx & Subpxmask) != 0);

-			p.x /= Nodewidth;

+				sub.x += mo->u < 0 ? -Δrx : Δrx;

+			p.x = (sub.x >> Subshift) + ((sub.x & Submask) != 0);

 		}

 		if(Δry > 0){

-			sy += Δv;

+			sub.y += Δv;

 			Δry -= Δy;

 			if(Δry < 0)

-				sy += mo->v < 0 ? -Δry : Δry;

-			p.y = (sy >> Subpxshift) + ((sy & Subpxmask) != 0);

-			p.y /= Nodewidth;

+				sub.y += mo->v < 0 ? -Δry : Δry;

+			p.y = (sub.y >> Subshift) + ((sub.y & Submask) != 0);

 		}

 		if(isblocked(p, mo->o))

 			goto end;

@@ -202,30 +177,16 @@

 			dprint("%M detected corner coasting at %P\n", mo, p);

 			goto end;

 		}

-		mo->subpx = sx;

-		mo->subpy = sy;

-		mo->px = sx >> Subpxshift;

-		mo->py = sy >> Subpxshift;

-		mo->x = mo->px / Nodewidth;

-		mo->y = mo->py / Nodeheight;

+		setsubpos(mo, sub);

 	}

 	markmobj(mo, 1);

-	dx = mo->px - px;

-	dx *= dx;

-	dy = mo->py - py;

-	dy *= dy;

-	mo->path.dist -= sqrt(dx + dy) / Nodewidth;

+	mo->path.dist -= eucdist(mo->Point, from);

 	return 0;

 end:

 	werrstr("trymove: can't move to %P", p);

-	mo->subpx = mo->px << Subpxshift;

-	mo->subpy = mo->py << Subpxshift;

+	setpos(mo, mo->Point);

 	markmobj(mo, 1);

-	dx = mo->px - px;

-	dx *= dx;

-	dy = mo->py - py;

-	dy *= dy;

-	mo->path.dist -= sqrt(dx + dy) / Nodewidth;

+	mo->path.dist -= eucdist(mo->Point, from);

 	return -1;

 }

@@ -272,7 +233,7 @@

 static int

 nodereached(Mobj *mo)

 {

-	return mo->px == mo->path.step->x && mo->py == mo->path.step->y;

+	return eqpt(mo->Point, *mo->path.step);

 }

 static void

@@ -289,9 +250,9 @@

 			fprint(2, "%M stepmove: bug: infinite loop!\n", mo);

 			return;

 		}

-		dprint("%M stepmove: failed moving from %d,%d to %P: %r\n",

-			mo, mo->px, mo->py, *mo->path.step);

-		if(repath(mo->path.target, mo) < 0){

+		dprint("%M stepmove: failed moving from %P to %P: %r\n",

+			mo, mo->Point, *mo->path.step);

+		if(repath(mo, mo->path.target) < 0){

 			dprint("%M stepmove: failed moving towards target: %r\n", mo);

 			abortcommands(mo);

 			return;

@@ -322,7 +283,7 @@

 		return;

 	}

 	dprint("%M stepmove: trying again\n", mo);

-	if(mo->path.nerr++ > 1 || repath(mo->path.target, mo) < 0){

+	if(mo->path.nerr++ > 1 || repath(mo, mo->path.target) < 0){

 		dprint("%M stepmove: still can't reach target: %r\n", mo);

 		abortmove(mo);

 		return;

@@ -338,10 +299,10 @@

 	c = mo->cmds;

 	c->cleanupfn = cleanup;

 	goal = c->goal;

-	setgoal(&goal, mo, c->target1);

-	if(repath(goal, mo) < 0)

+	setgoal(mo, &goal, c->target1);

+	if(repath(mo, goal) < 0)

 		return -1;

-	if(eqpt(goal, mo->Point)){

+	if(eqpt(mo->Point, goal)){

 		mo->state = OSskymaybe;

 		return 0;

 	}

@@ -351,7 +312,7 @@

 }

 int

-pushmovecommand(Point goal, Mobj *mo, Mobj *target)

+pushmovecommand(Mobj *mo, Point goal, Mobj *target)

 {

 	Command *c;

--- a/sim.return.c

+++ b/sim.return.c

@@ -55,7 +55,7 @@

 		werrstr("no drops");

 		return nil;

 	}

-	d = nodemapwidth * nodemapheight;

+	d = mapwidth * mapheight;

 	for(wp=t->drops.p, we=wp+t->drops.n, wo=nil; wp<we; wp++){

 		w = *wp;

 		d´ = octdist(mo->Point, w->Point);

--- a/sim.spawn.c

+++ b/sim.spawn.c

@@ -31,11 +31,11 @@

 }

 int

-spawnunit(Point p, Obj *o, int team)

+spawnunit(Obj *o, Point p, int team)

 {

 	Mobj *mo;

-	if((mo = mapspawn(p, o)) == nil)

+	if((mo = mapspawn(o, p)) == nil)

 		return -1;

 	mo->team = team;

 	mo->θ = frand() * 256;

@@ -46,7 +46,7 @@

 }

 int

-spawnresource(Point p, Obj *o, int amount)

+spawnresource(Obj *o, Point p, int amount)

 {

 	Mobj *mo;

@@ -54,7 +54,7 @@

 		werrstr("spawnresource: invalid amount");

 		return -1;

 	}

-	if((mo = mapspawn(p, o)) == nil)

+	if((mo = mapspawn(o, p)) == nil)

 		return -1;

 	mo->team = 0;

 	mo->amount = amount;