physics source pure

1const (
2	RollSpeed = 1.8
3	RollDrag  = 0.08
4	keepBonus = 0.05
5	maxKeep   = 0.98
6)

 1const (
 2	// WallFriction is the Coulomb µ between the ball and a wall or post:
 3	// the tangential impulse is at most µ times the normal one.
 4	WallFriction = 0.05
 5	// TangentMass caps the tangential impulse, per unit mass and speed:
 6	// 2/7 is what stops a solid ball's contact point from slipping.
 7	TangentMass = 2.0 / 7
 8	// RestSpeed is the speed into a surface, per substep, under which a
 9	// contact is resting: no restitution, no bounce counted. At least what
10	// the steepest hill adds in a substep, so a ball a hill presses into a
11	// rail slides along it instead of jittering.
12	RestSpeed = 0.35
13	// MaxBounce is the most restitution a passive piece plays: a Bounce
14	// above it is played at it.
15	MaxBounce = 0.75
16	// MaxKick is the most restitution a bumper (a Bounce above 1 on a skin
17	// that Kicks) plays, and the most course.Decode accepts. The ball stays
18	// under SpeedCap.
19	MaxKick = 1.5
20)

 1const (
 2	// CrestRadius is the radius of a hill's lip, in board units: a ball
 3	// needs sqrt(G·CrestRadius), 0.71 per substep, to take off.
 4	CrestRadius = 0.5
 5	// MinRamp is the gentlest hill (|Vec|) that launches.
 6	MinRamp = 0.12
 7	// GroundBounce is the restitution of the ground when a ball lands.
 8	GroundBounce = 0.4
 9	// LandFriction is the Coulomb µ between a landing ball and the ground.
10	LandFriction = 0.3
11	// HopSpeed is the vertical speed, per substep, under which a landing
12	// ball stays down.
13	HopSpeed = 0.25
14	// MaxSin is the steepest grade a hill plays, sin θ (about 72°), so tan θ
15	// and a flight stay bounded; course.Decode holds |Vec| to G·MaxSin.
16	MaxSin = 0.95
17)

1const G = 1.0

1const JumpRun = 0.5

1const LoopKeep = 0.8

1const MaxMove = 1.5

1const MaxRollOn = 120

1const MaxWork = 1000000

1const MaxWorkStep = 225000

1const SpeedCap = 8

 1const (
 2	Surface ZoneKind = iota // Scale sets the rolling resistance (Rolling): sand holds, ice frees
 3	Slope                   // a hill: Vec, gravity along it, is added to velocity each substep
 4	Tunnel                  // the ball is moved to Vec, keeping its velocity
 5	Hazard                  // the ball goes back where the stroke was played from: water, a pit, the void
 6	// Loop is a tube's mouth (Min..Max): a ball heading in within 25° at
 7	// Scale or faster comes out at Vec, else it falls back or off the side.
 8	// The mouth must be at least MaxMove deep, or a fast ball steps over it.
 9	Loop
10)

1func Kicks(skin string) bool

1func Lengths(s Segment, r float64) (l, lp, lm float64)

1func Prepare(f *Field)

1func PrepareWith(f *Field, lens []float64)

1func Prepared(f *Field) []float64

1func Rolling(friction, scale float64) float64

1func There(i, every, on, phase int) bool

1func WithTick(f *Field, tick int) *Field

1func FromPolar(angle, r float64) Vec2

1func UnstickIn(ball Vec2, walls []Wall, posts []Post, r float64, stays []Wall) Vec2

1func V(x, y float64) Vec2

1type Circle struct {
2	C Vec2
3	R float64
4}

 1type Field struct {
 2	Walls    []Wall
 3	Posts    []Post
 4	Zones    []Zone
 5	Friction float64 // the green's rolling resistance, as Rolling maps it: 0.87 is Crr 0.224
 6	Bounce   float64 // default restitution of barriers
 7	// Radius of the ball (0 plays it as a point).
 8	Radius float64
 9	// Tick is where the stroke starts on the clock of timed walls and zones.
10	Tick int
11	// Cap, above 0 and under MaxWork, replaces MaxWork for this stroke.
12	Cap int
13	// prep is the walls' offsets, worked out once (Prepare).
14	prep []float64
15}

1type Post struct {
2	Circle
3	Bounce float64 // 0 = use the field default; played at MaxBounce at most; above 1 a bumper, if Kicks(Skin)
4	Mark   rune
5	Skin   string
6}

1type Segment struct{ A, B Vec2 }

 1type Shot struct {
 2	Path    []Vec2
 3	Bounces int
 4	// Air marks the path points where the ball is off the ground (no zone
 5	// acts, no cup takes it). Same length as Path.
 6	Air []bool
 7	// Cause says, per path point, what most acted on the ball in the substep
 8	// that ended there: 'b' a bounce, 's' a hill, 'w' wind or a gust, 'i' a
 9	// slippery surface, '-' nothing but friction. Same length as Path.
10	Cause []byte
11	why   byte // this substep's cause so far
12	// Work is what the stroke cost, in MaxWork's units.
13	Work int
14	// start is where the stroke was played from, where a hazard sends it.
15	start Vec2
16}

1type Vec2 struct{ X, Y float64 }

1type Wall struct {
2	Seg    Segment
3	Bounce float64 // 0 = use the field default
4	Mark   rune
5	Skin   string
6	// Every > 0 times the wall within a stroke: it stands in substep i only
7	// when (i+Tick+Phase) mod Every is below On.
8	Every, On, Phase int
9}

 1type Zone struct {
 2	Kind     ZoneKind
 3	Min, Max Vec2
 4	Vec      Vec2    // Slope: acceleration (G·sin θ downhill). Tunnel: destination. Loop: where it comes down. Hazard: unused.
 5	Scale    float64 // Surface: its rolling resistance (Rolling). Loop: the speed to go round.
 6	Mark     rune
 7	Skin     string
 8	// Round makes the zone the ellipse inscribed in Min..Max.
 9	Round bool
10	// Poly (3 points or more) makes the zone that polygon, within Min..Max;
11	// Outside makes it everything in Min..Max but the polygon.
12	Poly    []Vec2
13	Outside bool
14	// Every, On, Phase time the zone within a stroke, as for a Wall.
15	Every, On, Phase int
16	// Air makes a Slope moving air: it pushes the ball but is no hill, and
17	// hides none under it. Capped air never speeds the ball up.
18	Air, Capped bool
19}

1type ZoneKind int