root
270 lines
8.3 KiB
Go
270 lines
8.3 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"math"
|
|
"net/http"
|
|
"strconv"
|
|
"sync"
|
|
|
|
"halcyon/config"
|
|
"halcyon/fixed"
|
|
"halcyon/runner"
|
|
"halcyon/sim"
|
|
"halcyon/world"
|
|
)
|
|
|
|
// The admin map shows the world as it stood when the last daily run ended: every
|
|
// asteroid (placed from its orbit at that moment), every launched ship with its
|
|
// velocity, the station and any containers left drifting. Units are kilometres
|
|
// and kilometres per second, in the ecliptic frame centred on the Star.
|
|
|
|
// mapCache holds the last response, valid while the world stays on the same day.
|
|
type mapCache struct {
|
|
mu sync.Mutex
|
|
day string
|
|
body []byte
|
|
}
|
|
|
|
func (s *Server) adminMap(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
day, _, err := s.st.GetMeta(ctx, runner.MetaDay)
|
|
if err != nil {
|
|
fail(w, err)
|
|
return
|
|
}
|
|
s.mapCache.mu.Lock()
|
|
defer s.mapCache.mu.Unlock()
|
|
if s.mapCache.body == nil || s.mapCache.day != day {
|
|
body, err := s.buildMap(r)
|
|
if err != nil {
|
|
fail(w, err)
|
|
return
|
|
}
|
|
s.mapCache.day, s.mapCache.body = day, body
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Write(s.mapCache.body)
|
|
}
|
|
|
|
func (s *Server) buildMap(r *http.Request) ([]byte, error) {
|
|
st, err := s.st.LoadState(r.Context())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if st == nil { // nothing has run yet: show the world as it will begin
|
|
st = sim.NewState(s.cfg)
|
|
}
|
|
names := map[int64]string{}
|
|
accounts, err := s.st.ListAccounts(r.Context())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, a := range accounts {
|
|
names[a.ID] = a.Name
|
|
}
|
|
|
|
t := st.Day * config.SecondsPerDay
|
|
type asteroid struct {
|
|
ID int64 `json:"id"`
|
|
X float64 `json:"x"`
|
|
Y float64 `json:"y"`
|
|
Z float64 `json:"z"`
|
|
Ore []int64 `json:"ore"`
|
|
Total int64 `json:"total"`
|
|
Radius float64 `json:"orbit_radius"`
|
|
Period int64 `json:"period"`
|
|
Inc float64 `json:"inclination"`
|
|
}
|
|
asts := make([]asteroid, 0, len(st.Asteroids))
|
|
for i := range st.Asteroids {
|
|
a := &st.Asteroids[i]
|
|
p, _ := a.Orbit.State(t)
|
|
ore := make([]int64, world.NumOre)
|
|
copy(ore, a.Ore[:])
|
|
asts = append(asts, asteroid{a.ID, p.X.Float64(), p.Y.Float64(), p.Z.Float64(), ore, a.TotalOre(), a.Orbit.A.Float64(), a.Orbit.Period, a.Orbit.Inc.Float64()})
|
|
}
|
|
|
|
towCount := map[int64]int{}
|
|
towOre := map[int64]int64{}
|
|
type container struct {
|
|
ID int64 `json:"id"`
|
|
X float64 `json:"x"`
|
|
Y float64 `json:"y"`
|
|
Z float64 `json:"z"`
|
|
Ore int64 `json:"ore"`
|
|
Expires int64 `json:"expires_at"`
|
|
}
|
|
drifting := []container{}
|
|
for _, c := range st.Containers {
|
|
if c.Towed != 0 {
|
|
towCount[c.Towed]++
|
|
towOre[c.Towed] += c.OreTotal()
|
|
continue
|
|
}
|
|
drifting = append(drifting, container{c.ID, c.Pos.X.Float64(), c.Pos.Y.Float64(), c.Pos.Z.Float64(), c.OreTotal(), c.ExpiresAt})
|
|
}
|
|
|
|
type ship struct {
|
|
ID int64 `json:"id"`
|
|
Owner int64 `json:"owner"`
|
|
Name string `json:"name"`
|
|
Alive bool `json:"alive"`
|
|
X float64 `json:"x"`
|
|
Y float64 `json:"y"`
|
|
Z float64 `json:"z"`
|
|
VX float64 `json:"vx"`
|
|
VY float64 `json:"vy"`
|
|
VZ float64 `json:"vz"`
|
|
Fuel float64 `json:"fuel"`
|
|
Throttle int32 `json:"throttle"`
|
|
Mining bool `json:"mining"`
|
|
Earned int64 `json:"earned"`
|
|
Towing int `json:"containers_in_tow"`
|
|
TowOre int64 `json:"ore_in_tow"`
|
|
}
|
|
ships := make([]ship, 0, len(st.Ships))
|
|
for _, sh := range st.Ships {
|
|
ships = append(ships, ship{sh.ID, sh.Owner, names[sh.Owner], sh.Alive,
|
|
sh.Pos.X.Float64(), sh.Pos.Y.Float64(), sh.Pos.Z.Float64(), sh.Vel.X.Float64(), sh.Vel.Y.Float64(), sh.Vel.Z.Float64(),
|
|
sh.Fuel.Float64(), sh.Throttle, sh.Mining, sh.Earned, towCount[sh.ID], towOre[sh.ID]})
|
|
}
|
|
|
|
sp, sv := st.Station.Orbit.State(t)
|
|
oreNames := make([]string, world.NumOre)
|
|
for o := range oreNames {
|
|
oreNames[o] = world.Ore(o).String()
|
|
}
|
|
return json.Marshal(map[string]any{
|
|
"day": st.Day,
|
|
"time": t,
|
|
"star": map[string]any{"radius": sim.StarRadiusKm},
|
|
"belt": map[string]any{"inner": s.cfg.BeltInner.Float64(), "outer": s.cfg.BeltOuter.Float64()},
|
|
"ranges": map[string]any{"mining": sim.MineRangeKm, "docking": sim.DockRangeKm, "container": sim.ContainerRangeKm},
|
|
"station": map[string]any{
|
|
"x": sp.X.Float64(), "y": sp.Y.Float64(), "z": sp.Z.Float64(),
|
|
"vx": sv.X.Float64(), "vy": sv.Y.Float64(), "vz": sv.Z.Float64(), "orbit_radius": st.Station.Orbit.A.Float64(),
|
|
},
|
|
"ores": oreNames,
|
|
"asteroids": asts,
|
|
"ships": ships,
|
|
"containers": drifting,
|
|
})
|
|
}
|
|
|
|
// adminMapOrbit predicts the path a ship would coast along from its current
|
|
// position and velocity, with the engine off from here on. It is what the map
|
|
// draws when a ship is clicked.
|
|
func (s *Server) adminMapOrbit(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
id, err := strconv.ParseInt(r.URL.Query().Get("ship"), 10, 64)
|
|
if err != nil || id <= 0 {
|
|
httpError(w, http.StatusBadRequest, "ship must be a positive integer")
|
|
return
|
|
}
|
|
st, err := s.st.LoadState(ctx)
|
|
if err != nil {
|
|
fail(w, err)
|
|
return
|
|
}
|
|
if st == nil {
|
|
st = sim.NewState(s.cfg)
|
|
}
|
|
var sh *sim.Ship
|
|
for _, x := range st.Ships {
|
|
if x.ID == id {
|
|
sh = x
|
|
break
|
|
}
|
|
}
|
|
if sh == nil || !sh.Alive {
|
|
httpError(w, http.StatusNotFound, "no such ship in the belt")
|
|
return
|
|
}
|
|
points, closed, hitStar := predictOrbit(s.cfg, sh.Pos, sh.Vel)
|
|
writeJSON(w, http.StatusOK, map[string]any{"ship": id, "points": points, "closed": closed, "hit_star": hitStar})
|
|
}
|
|
|
|
// predictOrbit integrates a ballistic (engine-off) path under the belt's
|
|
// simplified gravity (a pull of OrbitSpeed^2/r toward the Star, the same as
|
|
// sim.physics applies), starting from pos and vel. That pull is always
|
|
// radial, so angular momentum -- and with it the orbital plane -- never
|
|
// changes: "one turn around the Star" is therefore well defined even though,
|
|
// unlike real gravity, this force does not in general trace a closed ellipse.
|
|
// The path is sampled until it has swept a full turn in that plane, falls
|
|
// into the Star, flies far outside the belt, or a time cap is reached
|
|
// (whichever comes first), in plain float64: this is a display aid, not part
|
|
// of the deterministic simulation.
|
|
func predictOrbit(cfg config.Config, pos, vel fixed.Vec) (points [][3]float64, closed, hitStar bool) {
|
|
px, py, pz := pos.X.Float64(), pos.Y.Float64(), pos.Z.Float64()
|
|
vx, vy, vz := vel.X.Float64(), vel.Y.Float64(), vel.Z.Float64()
|
|
orbitSpeed := cfg.OrbitSpeed.Float64()
|
|
dt := float64(cfg.TickSeconds())
|
|
r0 := math.Sqrt(px*px + py*py + pz*pz)
|
|
starR := float64(sim.StarRadiusKm)
|
|
if r0 < starR || orbitSpeed <= 0 {
|
|
return nil, false, r0 < starR
|
|
}
|
|
|
|
// Plane normal (direction of pos x vel, i.e. of angular momentum), unit length.
|
|
nx, ny, nz := py*vz-pz*vy, pz*vx-px*vz, px*vy-py*vx
|
|
nlen := math.Sqrt(nx*nx + ny*ny + nz*nz)
|
|
planar := nlen > 1e-9
|
|
if planar {
|
|
nx, ny, nz = nx/nlen, ny/nlen, nz/nlen
|
|
}
|
|
|
|
// A ship on a circular orbit at the belt's own speed takes tens of days to
|
|
// come around, so the tick-by-tick budget has to be generous; the actual
|
|
// game tick length is used as the step so this matches sim.physics exactly.
|
|
const maxTicks = 300_000 // a hard safety cap (~208 sim days), for a wild escape
|
|
const targetPoints = 400
|
|
periodTicks := int(2 * math.Pi * r0 / orbitSpeed / dt)
|
|
capTicks := periodTicks * 3
|
|
if capTicks <= 0 || capTicks > maxTicks {
|
|
capTicks = maxTicks
|
|
}
|
|
recordEvery := capTicks / targetPoints
|
|
if recordEvery < 1 {
|
|
recordEvery = 1
|
|
}
|
|
escapeR := math.Max(5*r0, 5*cfg.BeltOuter.Float64())
|
|
|
|
points = [][3]float64{{px, py, pz}}
|
|
prevX, prevY, prevZ := px, py, pz
|
|
swept := 0.0
|
|
for i := 1; i <= capTicks; i++ {
|
|
r := math.Sqrt(px*px + py*py + pz*pz)
|
|
g := orbitSpeed * orbitSpeed * dt / r
|
|
vx -= px / r * g
|
|
vy -= py / r * g
|
|
vz -= pz / r * g
|
|
px += vx * dt
|
|
py += vy * dt
|
|
pz += vz * dt
|
|
|
|
if planar {
|
|
cx, cy, cz := prevY*pz-prevZ*py, prevZ*px-prevX*pz, prevX*py-prevY*px
|
|
sin := cx*nx + cy*ny + cz*nz
|
|
cos := prevX*px + prevY*py + prevZ*pz
|
|
swept += math.Atan2(sin, cos)
|
|
}
|
|
prevX, prevY, prevZ = px, py, pz
|
|
|
|
last := i == capTicks
|
|
if i%recordEvery == 0 || last {
|
|
points = append(points, [3]float64{px, py, pz})
|
|
}
|
|
if r := math.Sqrt(px*px + py*py + pz*pz); r < starR {
|
|
points = append(points, [3]float64{px, py, pz})
|
|
return points, false, true
|
|
} else if r > escapeR {
|
|
return points, false, false
|
|
}
|
|
if planar && math.Abs(swept) >= 2*math.Pi {
|
|
return points, true, false
|
|
}
|
|
}
|
|
return points, false, false
|
|
}
|