path: root/appl/spree/clients/bounce.b

implement Clientmod;

# bouncing balls demo.  it uses tk and multiple processes to animate a
# number of balls bouncing around the screen.  each ball has its own
# process; CPU time is doled out fairly to each process by using
# a central monitor loop.

include "sys.m";
	sys: Sys;
include "draw.m";
	draw: Draw;
	Display, Point, Rect, Image: import draw;
include "tk.m";
	tk: Tk;
include "tkclient.m";
	tkclient: Tkclient;
include "math.m";
	math: Math;
include "rand.m";
include "../client.m";

BALLSIZE: con 5;
ZERO: con 1e-6;
π: con Math->Pi;
Maxδ: con π / 4.0;			# max bat angle deflection

Line: adt {
	p, v:		Realpoint;
	s:		real;
	new:			fn(p1, p2: Point): ref Line;
	hittest:		fn(l: self ref Line, p: Point): (Realpoint, real, real);
	intersection:	fn(b: self ref Line, p, v: Realpoint): (int, Realpoint, real, real);
	point:		fn(b: self ref Line, s: real): Point;
};

Realpoint: adt {
	x, y: real;
};

cliquecmds := array[] of {
"canvas .c -bg black",
"bind .c <ButtonRelease-1> {send mouse 0 1 %x %y}",
"bind .c <ButtonRelease-2> {send mouse 0 2 %x %y}",
"bind .c <Button-1> {send mouse 1 1 %x %y}",
"bind .c <Button-2> {send mouse 1 2 %x %y}",
"bind . <Key-b> {send ucmd newball}",
"bind . <ButtonRelease-1> {focus .}",
"bind .Wm_t <ButtonRelease-1> +{focus .}",
"focus .",
"bind .c <Key-b> {send ucmd newball}",
"bind .c <Key-u> {grab release .c}",
"frame .f",
"button .f.b -text {Start} -command {send ucmd start}",
"button .f.n -text {New ball} -command {send ucmd newball}",
"pack .f.b .f.n -side left",
"pack .f -fill x",
"pack .c -fill both -expand 1",
"update",
};

Ballstate: adt {
	owner: int;		# index into member array
	hitobs: ref Obstacle;
	t0: int;
	p, v: Realpoint;
	speed: real;
};

Queue: adt {
	h, t: list of T; 
	put: fn(q: self ref Queue, s: T);
	get: fn(q: self ref Queue): T;
};


Obstacle: adt {
	line: 		ref Line;
	id: 		int;
	isbat: 	int;
	s1, s2: 	real;
	srvid:	int;
	owner:	int;
	new: 	fn(id: int): ref Obstacle;
	config: 	fn(b: self ref Obstacle);
};

Object: adt {
	obstacle: ref Obstacle;
	ballctl: chan of ref Ballstate;
};


Member: adt {
	id: int;
	colour: string;
};

win: ref Tk->Toplevel;

lines: list of ref Obstacle;
lineversion := 0;
memberid: int;
myturn: int;
stderr: ref Sys->FD;
timeoffset := 0;

objects: array of ref Object;
srvobjects: array of ref Obstacle;	# all for lasthit...
members: array of ref Member;

CORNER: con 60;
INSET: con 20;
WIDTH: con 500;
HEIGHT: con 500;

bats: list of ref Obstacle;
mkball: chan of (int, chan of chan of ref Ballstate);
cliquefd: ref Sys->FD;
currentlydragging := -1;
Ballexit: ref Ballstate;
Noobs: ref Obstacle;

nomod(s: string)
{
	sys->fprint(stderr, "bounce: cannot load %s: %r\n", s);
	sys->raise("fail:bad module");
}

client(ctxt: ref Draw->Context, argv: list of string, nil: int)
{
	sys = load Sys Sys->PATH;
	stderr = sys->fildes(2);
	draw = load Draw Draw->PATH;
	math = load Math Math->PATH;
	tk = load Tk Tk->PATH;
	tkclient = load Tkclient Tkclient->PATH;
	if (tkclient == nil)
		nomod(Tkclient->PATH);
	tkclient->init();
	cliquefd = sys->fildes(0);
	Ballexit = ref Ballstate;
	Noobs = Obstacle.new(-1);
	lines = tl lines;		# XXX ahem.

	if (len argv >= 3)		# argv: modname mnt dir ...
		membername = readfile(hd tl argv + "/name");

	sys->pctl(Sys->NEWPGRP, nil);
	wmctl: chan of string;
	(win, wmctl) = tkclient->toplevel(ctxt.screen, nil, "Bounce", 0);
	ucmd := chan of string;
	tk->namechan(win, ucmd, "ucmd");
	mouse := chan of string;
	tk->namechan(win, mouse, "mouse");
	for (i := 0; i < len cliquecmds; i++)
		cmd(win, cliquecmds[i]);
	cmd(win, ".c configure -width 500 -height 500");
	cmd(win, ".c configure -width [.c cget -actwidth] -height [.c cget -actheight]");
	imageinit();

	mch := chan of (int, Point);

	spawn mouseproc(mch);
	mkball = chan of (int, chan of chan of ref Ballstate);
	spawn monitor(mkball);
	balls: list of chan of ref Ballstate;

	spawn updateproc();
	sys->sleep(500);		# wait for things to calm down a little
	cliquecmd("time " + string sys->millisec());

	buts := 0;
	for (;;) alt {
	c := <-wmctl =>
		if (c == "exit")
			sys->write(cliquefd, array[0] of byte, 0);
		tkclient->wmctl(win, c);
	c := <-mouse =>
		(nil, toks) := sys->tokenize(c, " ");
		if ((hd toks)[0] == '1')
			buts |= int hd tl toks;
		else
			buts &= ~int hd tl toks;
		mch <-= (buts, Point(int hd tl tl toks, int hd tl tl tl toks));
	c := <-ucmd =>
		cliquecmd(c);
	}
}

cliquecmd(s: string): int
{
	if (sys->fprint(cliquefd, "%s\n", s) == -1) {
		err := sys->sprint("%r");
		notify(err);
		sys->print("bounce: cmd error on '%s': %s\n", s, err);
		return 0;
	}
	return 1;
}

updateproc()
{
	wfd := sys->open("/prog/" + string sys->pctl(0, nil) + "/wait", Sys->OREAD);
	spawn updateproc1();
	buf := array[Sys->ATOMICIO] of byte;
	n := sys->read(wfd, buf, len buf);
	sys->print("updateproc process exited: %s\n", string buf[0:n]);
}

updateproc1()
{
	buf := array[Sys->ATOMICIO] of byte;
	while ((n := sys->read(cliquefd, buf, len buf)) > 0) {
		(nil, lines) := sys->tokenize(string buf[0:n], "\n");
		for (; lines != nil; lines = tl lines)
			applyupdate(hd lines);
		cmd(win, "update");
	}
	if (n < 0)
		sys->fprint(stderr, "bounce: error reading updates: %r\n");
	sys->fprint(stderr, "bounce: updateproc exiting\n");
}

UNKNOWN, BALL, OBSTACLE: con iota;

applyupdate(s: string)
{
#	sys->print("bounce: got update %s\n", s);
	(nt, toks) := sys->tokenize(s, " ");
	case hd toks {
	"create" =>
		# create id parentid vis type
		id := int hd tl toks;
		if (id >= len objects) {
			newobjects := array[id + 10] of ref Object;
			newobjects[0:] = objects;
			objects = newobjects;
		}
		objects[id] = ref Object;
	"del" =>
		# del parent start end objid...
		for (toks = tl tl tl tl toks; toks != nil; toks = tl toks) {
			id := int hd toks;
			if (objects[id].obstacle != nil)
				sys->fprint(stderr, "bounce: cannot delete obstructions yet\n");
			else
				objects[id].ballctl <-= Ballexit;
			objects[id] = nil;
		}
	"set" =>
		# set obj attr val
		id := int hd tl toks;
		attr := hd tl tl toks;
		val := tl tl tl toks;
		case attr {
		"state" =>
			# state lasthit owner p.x p.y v.x v.y s time
			state := ref Ballstate;
			(state.hitobs, val) = (srvobj(int hd val), tl val);
			(state.owner, val) = (int hd val, tl val);
			(state.p.x, val) = (real hd val, tl val);
			(state.p.y, val) = (real hd val, tl val);
			(state.v.x, val) = (real hd val, tl val);
			(state.v.y, val) = (real hd val, tl val);
			(state.speed, val) = (real hd val, tl val);
			(state.t0, val) = (int hd val, tl val);
			if (objects[id].ballctl == nil)
				objects[id].ballctl = makeball(id, state);
			else
				objects[id].ballctl <-= state;
		"pos" or "coords" or "owner" or "id" =>
			if (objects[id].obstacle == nil)
				objects[id].obstacle = Obstacle.new(id);
			o := objects[id].obstacle;
			case attr {
			"pos" =>
				(o.s1, val) = (real hd val, tl val);
				(o.s2, val) = (real hd val, tl val);
				o.isbat = 1;
			"coords" =>
				p1, p2: Point;
				(p1.x, val) = (int hd val, tl val);
				(p1.y, val) = (int hd val, tl val);
				(p2.x, val) = (int hd val, tl val);
				(p2.y, val) = (int hd val, tl val);
				o.line = Line.new(p1, p2);
			"owner" =>
				o.owner = hd val;
				if (o.owner == membername)
					bats = o :: bats;
			"id" =>
				o.srvid = int hd val;
				if (o.srvid >= len srvobjects) {
					newobjects := array[id + 10] of ref Obstacle;
					newobjects[0:] = srvobjects;
					srvobjects = newobjects;
				}
				srvobjects[o.srvid] = o;
			}
			if (currentlydragging != id)
				o.config();
		"arenasize" =>
			# arenasize w h
			cmd(win, ".c configure -width " + hd val + " -height " + hd tl val);
		* =>
			if (len attr > 5 && attr[0:5] == "score") {
				# scoreN val
				n := int attr[5:];
				w := ".f." + string n;
				if (!tkexists(w)) {
					cmd(win, "label " + w + "l -text '" + attr);
					cmd(win, "label " + w + " -relief sunken -bd 5 -width 5w");
					cmd(win, "pack " +w + "l " + w + " -side left");
				}
				cmd(win, w + " configure -text {" + hd val + "}");
			} else if (len attr > 6 && attr[0:6] == "member") {
				# memberN id colour
				n := int attr[6:];
				if (n >= len members) {
					newmembers := array[n + 1] of ref Member;
					newmembers[0:] = members;
					members = newmembers;
				}
				p := members[n] = ref Member(int hd val, hd tl val);
				cmd(win, ".c itemconfigure o" + string p.id + " -fill " + p.colour);
				if (p.id == memberid)
					myturn = n;
			}
			else
				sys->fprint(stderr, "bounce: unknown attr '%s'\n", attr);
		}
	"time" =>
		# time offset orig
		now := sys->millisec();
		time := int hd tl tl toks;
		transit := now - time;
		timeoffset = int hd tl toks - transit / 2;
		sys->print("transit time %d, timeoffset: %d\n", transit, timeoffset);
	* =>
		sys->fprint(stderr, "chat: unknown update message '%s'\n", s);
	}
}

tkexists(w: string): int
{
	return tk->cmd(win, w + " cget -bd")[0] != '!';
}

srvobj(id: int): ref Obstacle
{
	if (id < 0 || id >= len srvobjects || srvobjects[id] == nil)
		return Noobs;
	return srvobjects[id];
}

mouseproc(mch: chan of (int, Point))
{
	procname("mouse");
	for (;;) {
		hitbat: ref Obstacle = nil;
		minperp, hitdist: real;
		(buts, p) := <-mch;
		for (bl := bats; bl != nil; bl = tl bl) {
			b := hd bl;
			(normal, perp, dist) := b.line.hittest(p);
			perp = abs(perp);
			
			if ((hitbat == nil || perp < minperp) && (dist >= b.s1 && dist <= b.s2))
				(hitbat, minperp, hitdist) = (b, perp, dist);
		}
		if (hitbat == nil || minperp > 30.0) {
			while ((<-mch).t0)
				;
			continue;
		}
		offset := hitdist - hitbat.s1;
		if (buts & 2)
			(buts, p) = aim(mch, hitbat, p);
		if (buts & 1)
			drag(mch, hitbat, offset);
	}
}


drag(mch: chan of (int, Point), hitbat: ref Obstacle, offset: real)
{
	realtosrv := chan of string;
	dummytosrv := chan of string;
	tosrv := dummytosrv;
	currevent := "";

	currentlydragging = hitbat.id;

	line := hitbat.line;
	batlen := hitbat.s2 - hitbat.s1;

	cvsorigin := Point(int cmd(win, ".c cget -actx"), int cmd(win, ".c cget -acty"));
	spawn sendproc(realtosrv);

	cmd(win, "grab set .c");
	cmd(win, "focus .");
loop:	for (;;) alt {
	tosrv <-= currevent =>
		tosrv = dummytosrv;

	(buts, p) := <-mch =>
		if (buts & 2)
			(buts, p) = aim(mch, hitbat, p);
		(v, perp, dist) := line.hittest(p);
		dist -= offset;
		# constrain bat and mouse positions
		if (dist < 0.0 || dist + batlen > line.s) {
			if (dist < 0.0) {
				p = line.point(offset);
				dist = 1.0;
			} else {
				p = line.point(line.s - batlen + offset);
				dist = line.s - batlen;
			}
			p.x -= int (v.x * perp);
			p.y -= int (v.y * perp);
			win.image.display.cursorset(p.add(cvsorigin));
		}
		(hitbat.s1, hitbat.s2) = (dist, dist + batlen);
		hitbat.config();
		cmd(win, "update");
		currevent = "bat " + string hitbat.s1;
		tosrv = realtosrv;
		if (!buts)
			break loop;
	}
	cmd(win, "grab release .c");
	realtosrv <-= nil;
	currentlydragging = -1;
}

CHARGETIME: con 1000.0;
MAXCHARGE: con 50.0;

α: con 0.999;		# decay in one millisecond
D: con 5;
aim(mch: chan of (int, Point), hitbat: ref Obstacle, p: Point): (int, Point)
{
	cvsorigin := Point(int cmd(win, ".c cget -actx"), int cmd(win, ".c cget -acty"));
	startms := ms := sys->millisec();
	δ := Realpoint(0.0, 0.0);
	line := hitbat.line;
	charge := 0.0;
	pivot := line.point((hitbat.s1 + hitbat.s2) / 2.0);
	s1 := p2s(line.point(hitbat.s1));
	s2 := p2s(line.point(hitbat.s2));
	cmd(win, ".c create line 0 0 0 0 -tags wire -fill yellow");
	ballid := makeballitem(-1, myturn);
	bp, p2: Point;
	buts := 2;
	for (;;) {
		v := makeunit(δ);
		bp = pivot.add((int (v.x * charge), int (v.y * charge)));
		cmd(win, ".c coords wire "+s1+" "+p2s(bp)+" "+s2);
		ballmove(ballid, bp);
		cmd(win, "update");
		if ((buts & 2) == 0)
			break;
		(buts, p2) = <-mch;
		now := sys->millisec();
		fade := math->pow(α, real (now - ms));
		charge = real (now - startms) * (MAXCHARGE / CHARGETIME);
		if (charge > MAXCHARGE)
			charge = MAXCHARGE;
		ms = now;
		dp := p2.sub(p);
		δ.x = δ.x * fade + real dp.x;
		δ.y = δ.y * fade + real dp.y;
		mag := δ.x * δ.x + δ.y * δ.y;
		if (dp.x != 0 || dp.y != 0)
			win.image.display.cursorset(p.add(cvsorigin));
	}
	cmd(win, ".c delete wire " + ballid);
	cmd(win, "update");
	(δ.x, δ.y) = (-δ.x, -δ.y);
	cliquecmd("newball " + string hitbat.id + " " +
		p2s(bp) + " " + rp2s(makeunit(δ)) + " " + string (charge / 100.0));
	return (buts, p2);
}

makeunit(v: Realpoint): Realpoint
{
	mag := math->sqrt(v.x * v.x + v.y * v.y);
	if (mag < ZERO)
		return (1.0, 0.0);
	return (v.x / mag, v.y / mag);
}

sendproc(tosrv: chan of string)
{
	procname("send");
	while ((ev := <-tosrv) != nil)
		cliquecmd(ev);
}

makeball(id: int, state: ref Ballstate): chan of ref Ballstate
{
	mkballreply := chan of chan of ref Ballstate;
	mkball <-= (id, mkballreply);
	ballctl := <-mkballreply;
	ballctl <-= state;
	return ballctl;
}

blankobstacle: Obstacle;
Obstacle.new(id: int): ref Obstacle
{
	cmd(win, ".c create line 0 0 0 0 -width 3 -fill #aaaaaa" + " -tags l" + string id);
	o := ref blankobstacle;
	o.line = Line.new((0, 0), (0, 0));
	o.id = id;
	o.owner = -1;
	o.srvid = -1;
	lineversion++;
	lines = o :: lines;
	return o;
}

Obstacle.config(o: self ref Obstacle)
{
	if (o.isbat) {
		cmd(win, ".c coords l" + string o.id + " " +
			p2s(o.line.point(o.s1)) + " " + p2s(o.line.point(o.s2)));
		if (o.owner == memberid)
			cmd(win, ".c itemconfigure l" + string o.id + " -fill red");
		else
			cmd(win, ".c itemconfigure l" + string o.id + " -fill white");
	} else {
		cmd(win, ".c coords l" + string o.id + " " +
			p2s(o.line.point(0.0)) + " " + p2s(o.line.point(o.line.s)));
	}
}
	
# make sure cpu time is handed to all ball processes fairly
# by passing a "token" around to each process in turn.
# each process does its work when it *hasn't* got its
# token but it can't go through two iterations without
# waiting its turn.
#
# new processes are created by sending on mkball.
# the channel sent back can be used to control the position
# and velocity of the ball and to destroy it.
monitor(mkball: chan of (int, chan of chan of ref Ballstate))
{
	procname("mon");
	procl, proc: list of (chan of ref Ballstate, chan of int);
	rc := dummyrc := chan of int;
	for (;;) {
		alt {
		(id, ch) := <-mkball =>
			(newc, newrc) := (chan of ref Ballstate, chan of int);
			procl = (newc, newrc) :: procl;
			spawn animproc(id, newc, newrc);
			ch <-= newc;
			if (tl procl == nil) {		# first ball
				newc <-= nil;
				rc = newrc;
				proc = procl;
			}
		alive := <-rc =>					# got token.
			if (!alive) {
				# ball has exited: remove from list
				newprocl: list of (chan of ref Ballstate, chan of int);
				for (; procl != nil; procl = tl procl)
					if ((hd procl).t1 != rc)
						newprocl = hd procl :: newprocl;
				procl = newprocl;
			}
			if ((proc = tl proc) == nil)
				proc = procl;
			if (proc == nil) {
				rc = dummyrc;
			} else {
				c: chan of ref Ballstate;
				(c, rc) = hd proc;
				c <-= nil;				# hand token to next process.
			}
		}
	}
}

# buffer ball state commands, so at least balls we handle
# locally appear glitch free.
bufferproc(cmdch: chan of string)
{
	procname("buffer");
	buffer := ref Queue;
	bufhd: string;
	dummytosrv := chan of string;
	realtosrv := chan of string;
	spawn sendproc(realtosrv);
	tosrv := dummytosrv;
	for (;;) alt {
	tosrv <-= bufhd =>
		if ((bufhd = buffer.get()) == nil)
			tosrv = dummytosrv;
	s := <-cmdch =>
		if (s == nil) {
			# ignore other queued requests, as they're
			# only state changes for a ball that's now been deleted.
			realtosrv <-= nil;
			exit;
		}
		buffer.put(s);
		if (tosrv == dummytosrv) {
			tosrv = realtosrv;
			bufhd = buffer.get();
		}
	}
}
start: int;
# animate one ball. initial position and unit-velocity are
# given by p and v.
animproc(id: int, c: chan of ref Ballstate, rc: chan of int)
{
	procname("anim");
	while ((newstate := <-c) == nil)
		rc <-= 1;
	state := *newstate;
	totaldist := 0.0;		# distance ball has travelled from reference point to last intersection
	ballid := makeballitem(id, state.owner);
	smallcount := 0;
	version := lineversion;
	tosrv := chan of string;
	start := sys->millisec();
	spawn bufferproc(tosrv);
loop:	for (;;) {
		hitp: Realpoint;

		dist := 1000000.0;
		oldobs := state.hitobs;
		hitt: real;
		for (l := lines; l != nil; l = tl l) {
			obs := hd l;
			(ok, hp, hdist, t) := obs.line.intersection(state.p, state.v);
			if (ok && hdist < dist && obs != oldobs && (smallcount < 10 || hdist > 1.5)) {
				(hitp, state.hitobs, dist, hitt) = (hp, obs, hdist, t);
			}
		}
		if (dist > 10000.0) {
			sys->print("no intersection!\n");
			state = ballexit(1, ballid, tosrv, c, rc);
			totaldist = 0.0;
			continue loop;
		}
		if (dist < 0.0001)
			smallcount++;
		else
			smallcount = 0;
		t0 := int (totaldist / state.speed) + state.t0 - timeoffset;
		et := t0 + int (dist / state.speed);
		t := sys->millisec() - t0;
		dt := et - t0;
		do {
			s := real t * state.speed;
			currp := Realpoint(state.p.x + s * state.v.x,  state.p.y + s * state.v.y);
			ballmove(ballid, (int currp.x, int currp.y));
			cmd(win, "update");
			if (lineversion > version) {
				(state.p, state.hitobs, version) = (currp, oldobs, lineversion);
				totaldist += s;
				continue loop;
			}
			if ((newstate := <-c) != nil) {
				if (newstate == Ballexit)
					ballexit(0, ballid, tosrv, c, rc);
				state = *newstate;
				totaldist = 0.0;
				continue loop;
			}
			rc <-= 1;
			t = sys->millisec() - t0;
		} while (t < dt);
		totaldist += dist;
		state.p = hitp;
		hitobs := state.hitobs;
		if (hitobs.isbat) {
			if (hitobs.owner == memberid) {
				if (hitt >= hitobs.s1 && hitt <= hitobs.s2)
					state.v = batboing(hitobs, hitt, state.v);
				tosrv <-= "state " + 
					string id + 
					" " + string hitobs.srvid +
					" " + string state.owner +
					" " + rp2s(state.p) + " " + rp2s(state.v) +
					" " + string state.speed +
					" " + string (sys->millisec() + timeoffset);
			} else {
				# wait for enlightenment
				while ((newstate := <-c) == nil)
					rc <-= 1;
				if (newstate == Ballexit)
					ballexit(0, ballid, tosrv, c, rc);
				state = *newstate;
				totaldist = 0.0;
			}
		} else if (hitobs.owner == memberid) {
			# if line has an owner but isn't a bat, then it's
			# a terminating line, so we inform server.
			cliquecmd("lost " + string id);
			state = ballexit(1, ballid, tosrv, c, rc);
			totaldist = 0.0;
		} else
			state.v = boing(state.v, hitobs.line);
	}
}

#ballmask: ref Image;
imageinit()
{
#	displ := win.image.display;
#	ballmask = displ.newimage(((0, 0), (BALLSIZE+1, BALLSIZE+1)), 0, 0, Draw->White);
#	ballmask.draw(ballmask.r, displ.zeros, displ.ones, (0, 0));
#	ballmask.fillellipse((BALLSIZE/2, BALLSIZE/2), BALLSIZE/2, BALLSIZE/2, displ.ones,  (0, 0));
#	End: con Draw->Endsquare;
#	n := 5;
#	θ := 0.0;
#	δ := (2.0 * π) / real n;
#	c := Point(BALLSIZE / 2, BALLSIZE / 2).sub((1, 1));
#	r := real (BALLSIZE / 2);
#	for (i := 0; i < n; i++) {
#		p2 := Point(int (r * math->cos(θ)), int (r * math->sin(θ)));
#		sys->print("drawing from %s to %s\n", p2s(c), p2s(p2.add(c)));
#		ballmask.line(c, c.add(p2), End, End, 1, displ.ones, (0, 0));
#		θ += δ;
#	}
}

makeballitem(id, owner: int): string
{
	displ := win.image.display;
	return cmd(win, ".c create oval 0 0 1 1 -fill " + members[owner].colour +
			" -tags o" + string owner);
}

ballmove(ballid: string, p: Point)
{
	cmd(win, ".c coords " + ballid +
		" " + string (p.x - BALLSIZE) +
		" " + string (p.y - BALLSIZE) +
		" " + string (p.x + BALLSIZE) +
		" " + string (p.y + BALLSIZE));
}

ballexit(wait: int, ballid: string, tosrv: chan of string, c: chan of ref Ballstate, rc: chan of int): Ballstate
{
	if (wait) {
		while ((s := <-c) != Ballexit)
			if (s == nil)
				rc <-= 1;
			else
				return *s;			# maybe we're not exiting, after all...
	}
	cmd(win, ".c delete " + ballid + ";update");
#	cmd(win, "image delete " + ballid);
	tosrv <-= nil;
	<-c;
	rc <-= 0;		# inform monitor that we've gone
	exit;
}

# thread-safe access to the Rand module
randgenproc(ch: chan of int)
{
	procname("rand");
	rand := load Rand Rand->PATH;
	for (;;)
		ch <-= rand->rand(16r7fffffff);
}

abs(x: real): real
{
	if (x < 0.0)
		return -x;
	return x;
}

# bounce ball travelling in direction av off line b.
# return the new unit vector.
boing(av: Realpoint, b: ref Line): Realpoint
{
	d := math->atan2(b.v.y, b.v.x) * 2.0 - math->atan2(av.y, av.x);
	return (math->cos(d), math->sin(d));
}

# calculate how a bounce vector should be modified when
# hitting a bat. t gives the intersection point on the bat;
# ballv is the ball's vector.
batboing(bat: ref Obstacle, t: real, ballv: Realpoint): Realpoint
{
	ballθ := math->atan2(ballv.y, ballv.x);
	batθ := math->atan2(bat.line.v.y, bat.line.v.x);
	φ := ballθ - batθ;
	δ: real;
	t -= bat.s1;
	batlen := bat.s2 - bat.s1;
	if (math->sin(φ) > 0.0)
		δ = (t / batlen) * Maxδ * 2.0 - Maxδ;
	else
		δ = (t / batlen) * -Maxδ * 2.0 + Maxδ;
	θ := math->atan2(bat.line.v.y, bat.line.v.x) * 2.0 - ballθ;	# boing
	θ += δ;
	return (math->cos(θ), math->sin(θ));
}

Line.new(p1, p2: Point): ref Line
{
	ln := ref Line;
	ln.p = (real p1.x, real p1.y);
	v := Realpoint(real (p2.x - p1.x), real (p2.y - p1.y));
	ln.s =  math->sqrt(v.x * v.x + v.y * v.y);
	if (ln.s > ZERO)
		ln.v = (v.x / ln.s, v.y / ln.s);
	else
		ln.v = (1.0, 0.0);
	return ln;
}

# return normal from line, perpendicular distance from line and distance down line
Line.hittest(l: self ref Line, ip: Point): (Realpoint, real, real)
{
	p := Realpoint(real ip.x, real ip.y);
	v := Realpoint(-l.v.y, l.v.x);
	(nil, nil, perp, ldist) := l.intersection(p, v);
	return (v, perp, ldist);
}

Line.point(l: self ref Line, s: real): Point
{
	return (int (l.p.x + s * l.v.x), int (l.p.y + s * l.v.y));
}

# compute the intersection of lines a and b.
# b is assumed to be fixed, and a is indefinitely long
# but doesn't extend backwards from its starting point.
# a is defined by the starting point p and the unit vector v.
# return whether it hit, the point at which it hit if so,
# the distance of the intersection point from p,
# and the distance of the intersection point from b.p.
Line.intersection(b: self ref Line, p, v: Realpoint): (int, Realpoint, real, real)
{
	det := b.v.x * v.y - v.x * b.v.y;
	if (det > -ZERO && det < ZERO)
		return (0, (0.0, 0.0), 0.0, 0.0);

	y21 := b.p.y - p.y;
	x21 := b.p.x - p.x;
	s := (b.v.x * y21 - b.v.y * x21) / det;
	t := (v.x * y21 - v.y * x21) / det;
	if (s < 0.0)
		return (0, (0.0, 0.0), s, t);
	hit := t >= 0.0 && t <= b.s;
	hp: Realpoint;
	if (hit)
		hp = (p.x+v.x*s, p.y+v.y*s);
	return (hit, hp, s, t);
}

cmd(top: ref Tk->Toplevel, s: string): string
{
	e := tk->cmd(top, s);
	if (e != nil && e[0] == '!')
		sys->print("tk error %s on '%s'\n", e, s);
	return e;
}

state2s(s: ref Ballstate): string
{
	return sys->sprint("[hitobs:%d(id %d), t0: %d, p: %g %g; v: %g %g; s: %g",
		s.hitobs.srvid, s.hitobs.id, s.t0, s.p.x, s.p.y, s.v.x, s.v.y, s.speed);
}

l2s(l: ref Line): string
{
	return p2s(l.point(0.0)) + " " + p2s(l.point(l.s));
}

rp2s(rp: Realpoint): string
{
	return string rp.x + " " + string rp.y;
}


p2s(p: Point): string
{
	return string p.x + " " + string p.y;
}

notifypid := -1;
notify(s: string)
{
	kill(notifypid);
	sync := chan of int;
	spawn notifyproc(s, sync);
	notifypid = <-sync;
}

notifyproc(s: string, sync: chan of int)
{
	procname("notify");
	sync <-= sys->pctl(0, nil);
	cmd(win, ".c delete notify");
	id := cmd(win, ".c create text 0 0 -anchor nw -fill red -tags notify -text '" + s);
	bbox := cmd(win, ".c bbox " + id);
	cmd(win, ".c create rectangle " + bbox + " -fill #ffffaa -tags notify");
	cmd(win, ".c raise " + id);
	cmd(win, "update");
	sys->sleep(750);
	cmd(win, ".c delete notify");
	cmd(win, "update");
	notifypid = -1;
}

kill(pid: int)
{
	if ((fd := sys->open("/prog/"+string pid+"/ctl", Sys->OWRITE)) != nil)
		sys->write(fd, array of byte "kill", 4);
}

T: type string;

Queue.put(q: self ref Queue, s: T)
{
	q.t = s :: q.t;
}

Queue.get(q: self ref Queue): T
{
	s: T;
	if(q.h == nil){
		q.h = revlist(q.t);
		q.t = nil;
	}
	if(q.h != nil){
		s = hd q.h;
		q.h = tl q.h;
	}
	return s;
}

revlist(ls: list of T) : list of T
{
	rs: list of T;
	for (; ls != nil; ls = tl ls)
		rs = hd ls :: rs;
	return rs;
}

procname(s: string)
{
#	sys->procname(sys->procname(nil) + " " + s);
}