root
125 lines
3.2 KiB
Go
125 lines
3.2 KiB
Go
package examples_test
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"math"
|
|
"os"
|
|
"testing"
|
|
|
|
"wh/config"
|
|
"wh/fixed"
|
|
"wh/sim"
|
|
"wh/vm"
|
|
)
|
|
|
|
func asm(t *testing.T, name string) []byte {
|
|
t.Helper()
|
|
src, err := os.ReadFile("programs/" + name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
p, err := vm.Assemble(string(src))
|
|
if err != nil {
|
|
t.Fatalf("%s: %v", name, err)
|
|
}
|
|
return p
|
|
}
|
|
|
|
func cfg() config.Config {
|
|
c := config.Default()
|
|
c.AsteroidCount = 50
|
|
return c
|
|
}
|
|
|
|
func launch(t *testing.T, c config.Config, prog []byte, uplink []byte) (*sim.State, sim.DayResult) {
|
|
t.Helper()
|
|
s := sim.NewState(c)
|
|
in := sim.DayInput{Launches: []sim.Launch{{ShipID: 1, Owner: 1, Program: prog}}}
|
|
if uplink != nil {
|
|
in.Uplinks = []sim.Uplink{{ShipID: 1, Data: uplink}}
|
|
}
|
|
res, err := s.RunDay(c, in)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return s, res
|
|
}
|
|
|
|
func TestEcho(t *testing.T) {
|
|
msg := make([]byte, 300)
|
|
for i := range msg {
|
|
msg[i] = byte(i*7 + 1)
|
|
}
|
|
_, res := launch(t, cfg(), asm(t, "echo.s"), msg)
|
|
got := res.Downlinks[0].Data
|
|
for i := range msg {
|
|
if got[i] != msg[i] {
|
|
t.Fatalf("byte %d: got %d want %d", i, got[i], msg[i])
|
|
}
|
|
}
|
|
if got[300] != 0 {
|
|
t.Fatal("echoed too much")
|
|
}
|
|
}
|
|
|
|
func TestTelemetry(t *testing.T) {
|
|
c := cfg()
|
|
s, res := launch(t, c, asm(t, "telemetry.s"), nil)
|
|
d := res.Downlinks[0].Data
|
|
w := func(i int) int32 { return int32(binary.LittleEndian.Uint32(d[i*4:])) }
|
|
if w(0) != int32(c.TicksPerDay-1) || w(1) != 4000 {
|
|
t.Fatalf("tick=%d fuel=%d", w(0), w(1))
|
|
}
|
|
// The last report was taken one tick (<= ~180 km) before the final state.
|
|
end := s.Ships[0].Pos
|
|
for i, got := range []int32{w(2), w(3), w(4)} {
|
|
want := []fixed.F{end.X, end.Y, end.Z}[i].Floor()
|
|
if math.Abs(float64(int64(got)-want)) > 200 {
|
|
t.Fatalf("axis %d: reported %d, ship at %d", i, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPursueAims(t *testing.T) {
|
|
c := cfg()
|
|
c.TicksPerDay = 1 // one long tick: the program aims once, from t=0 state
|
|
s := sim.NewState(c)
|
|
stPos, _ := s.Station.Orbit.State(0)
|
|
|
|
// Expected: nearest asteroid, and the bearing to it in whole km.
|
|
best, bestD := 0, fixed.Max
|
|
for i, a := range s.Asteroids {
|
|
p, _ := a.Orbit.State(0)
|
|
if d := p.Sub(stPos).Len(); d < bestD {
|
|
best, bestD = i, d
|
|
}
|
|
}
|
|
tp, _ := s.Asteroids[best].Orbit.State(0)
|
|
rel := tp.Sub(stPos)
|
|
dx, dy, dz := float64(rel.X.Floor()), float64(rel.Y.Floor()), float64(rel.Z.Floor())
|
|
wantAz := math.Atan2(dy, dx) * 1000
|
|
wantEl := math.Atan2(dz, math.Hypot(dx, dy)) * 1000
|
|
|
|
if _, err := s.RunDay(c, sim.DayInput{Launches: []sim.Launch{{ShipID: 1, Owner: 1, Program: asm(t, "pursue.s")}}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sh := s.Ships[0]
|
|
if sh.Target != int64(best+1) || sh.Throttle != 1000 {
|
|
t.Fatalf("target=%d (want %d) throttle=%d", sh.Target, best+1, sh.Throttle)
|
|
}
|
|
if math.Abs(float64(sh.Azimuth)-wantAz) > 3 || math.Abs(float64(sh.Pitch)-wantEl) > 3 {
|
|
t.Fatalf("aim az=%d el=%d, want %.0f %.0f", sh.Azimuth, sh.Pitch, wantAz, wantEl)
|
|
}
|
|
}
|
|
|
|
func TestPortsEquatesAssemble(t *testing.T) {
|
|
// The standard equate file must assemble and be usable alongside code.
|
|
src, err := os.ReadFile("programs/ports.s")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := vm.Assemble(string(src) + "\n in r1, P_UPNEW\n out P_THROTTLE, r1\n halt\n"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|