ref: 3866717cbb020199d58171c1c0cdd7382a74ee82
dir: /appl/spree/other/tstboing.b/
implement Tst;
include "sys.m";
sys: Sys;
include "draw.m";
draw: Draw;
Point, Rect: import draw;
include "sh.m";
sh: Sh;
Context: import Sh;
include "math.m";
math: Math;
ZERO: con 1e-6;
stderr: ref Sys->FD;
Tst: module {
init: fn(nil: ref Draw->Context, argv: list of string);
};
π: con Math->Pi;
Maxδ: con π / 4.0;
init(nil: ref Draw->Context, argv: list of string)
{
sys = load Sys Sys->PATH;
stderr = sys->fildes(2);
math = load Math Math->PATH;
if (len argv != 9) {
sys->fprint(stderr, "args?\n");
exit;
}
ar := argv2r(tl argv);
br := argv2r(tl tl tl tl tl argv);
a := Line.new(ar.min, ar.max); # ball
b := Line.new(br.min, br.max); # bat
(hit, hitp, s, t) := b.intersection(a.p, a.v);
if (hit) {
nv := boing(a.v, b);
rl := ref Line(hitp, nv, 50.0);
ballθ := a.θ();
batθ := b.θ();
φ := ballθ - batθ;
δ: real;
if (math->sin(φ) > 0.0)
δ = (t / b.s) * Maxδ * 2.0 - Maxδ;
else
δ = (t / b.s) * -Maxδ * 2.0 + Maxδ;
nl := Line.newpolar(rl.p, rl.θ() + δ, rl.s);
sys->print("%s %s %s\n", p2s(rl.point(0.0)), p2s(rl.point(rl.s)), p2s(nl.point(nl.s)));
} else
sys->fprint(stderr, "no hit\n");
}
argv2r(v: list of string): Rect
{
r: Rect;
(r.min.x, v) = (int hd v, tl v);
(r.min.y, v) = (int hd v, tl v);
(r.max.x, v) = (int hd v, tl v);
(r.max.y, v) = (int hd v, tl v);
return r;
}
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;
θ: fn(b: self ref Line): real;
newpolar: fn(p: Realpoint, θ: real, s: real): ref Line;
};
Realpoint: adt {
x, y: real;
};
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;
}
Line.newpolar(p: Realpoint, θ: real, s: real): ref Line
{
l := ref Line;
l.p = p;
l.s = s;
l.v = (math->cos(θ), math->sin(θ));
return l;
}
Line.θ(l: self ref Line): real
{
return math->atan2(l.v.y, l.v.x);
}
# 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);
}
# bounce ball travelling in direction av off line b.
# return the new unit vector.
boing(av: Realpoint, b: ref Line): Realpoint
{
d := math->atan2(real b.v.y, real b.v.x) * 2.0 - math->atan2(av.y, av.x);
return (math->cos(d), math->sin(d));
}
p2s(p: Point): string
{
return string p.x + " " + string p.y;
}