mirror of
https://github.com/AmanTahiliani/box-box.git
synced 2026-08-07 19:56:18 -04:00
feat: add replay track map scrubber
Spike: replay location fan-out is bounded with a semaphore at 4 concurrent GetLocation calls, covered by TestAssembleReplayFramesBoundsLocationFanOut. Adds /api/v1/replay/frames with 5s interval floor, 3000-frame cap, nearest-sample snapping, and empty-driver omission. Wires RaceStoryCanvas to lazy-load replay frames plus cached track outlines when the map panel opens, sharing the existing scrubber/playback state across chart and map. Tests: HOME=/private/tmp/box-box-home GOCACHE=/private/tmp/box-box-go-cache GOMODCACHE=/Users/aman/go/pkg/mod go test ./internal/web; go build ./... (same env, passed with read-only module stat-cache warning); npm run test; npx tsc --noEmit. Full go test ./... is blocked in this sandbox by existing network/listener-dependent internal/api and internal/news tests.
This commit is contained in:
259
internal/web/replay.go
Normal file
259
internal/web/replay.go
Normal file
@@ -0,0 +1,259 @@
|
||||
package web
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"math"
|
||||
"net/http"
|
||||
"sort"
|
||||
"strconv"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/AmanTahiliani/box-box/internal/models"
|
||||
)
|
||||
|
||||
const (
|
||||
defaultReplayIntervalMS = 5000
|
||||
maxReplayFrames = 3000
|
||||
replayFetchConcurrency = 4
|
||||
)
|
||||
|
||||
type replayDataClient interface {
|
||||
GetDriversForSession(sessionKey int) ([]models.Driver, error)
|
||||
GetLocation(sessionKey, driverNumber int) ([]models.Location, error)
|
||||
}
|
||||
|
||||
type replayFramesResponse struct {
|
||||
SessionKey int `json:"session_key"`
|
||||
Interval int `json:"interval_ms"`
|
||||
StartTime string `json:"start_time"`
|
||||
Frames []replayFrame `json:"frames"`
|
||||
}
|
||||
|
||||
type replayFrame struct {
|
||||
T int64 `json:"t"`
|
||||
Cars map[string]replayCar `json:"cars"`
|
||||
}
|
||||
|
||||
type replayCar struct {
|
||||
X float64 `json:"x"`
|
||||
Y float64 `json:"y"`
|
||||
}
|
||||
|
||||
func (s *Server) handleReplayFrames(w http.ResponseWriter, r *http.Request) {
|
||||
sessionKey, err := strconv.Atoi(r.URL.Query().Get("session_key"))
|
||||
if err != nil || sessionKey == 0 {
|
||||
http.Error(w, "session_key required", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
intervalMS := defaultReplayIntervalMS
|
||||
rawInterval := r.URL.Query().Get("interval_ms")
|
||||
if rawInterval != "" {
|
||||
parsed, err := strconv.Atoi(rawInterval)
|
||||
if err != nil {
|
||||
http.Error(w, "invalid interval_ms", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if parsed > intervalMS {
|
||||
intervalMS = parsed
|
||||
}
|
||||
}
|
||||
|
||||
resp, err := assembleReplayFrames(r.Context(), s.client, sessionKey, intervalMS)
|
||||
if err != nil {
|
||||
writeError(w, err, http.StatusInternalServerError, s.client.LastResponseWasStale())
|
||||
return
|
||||
}
|
||||
writeJSON(w, resp)
|
||||
}
|
||||
|
||||
func assembleReplayFrames(ctx context.Context, client replayDataClient, sessionKey, intervalMS int) (replayFramesResponse, error) {
|
||||
if intervalMS < defaultReplayIntervalMS {
|
||||
intervalMS = defaultReplayIntervalMS
|
||||
}
|
||||
|
||||
resp := replayFramesResponse{
|
||||
SessionKey: sessionKey,
|
||||
Interval: intervalMS,
|
||||
Frames: []replayFrame{},
|
||||
}
|
||||
|
||||
drivers, err := client.GetDriversForSession(sessionKey)
|
||||
if err != nil {
|
||||
return resp, err
|
||||
}
|
||||
|
||||
driverNumbers := uniqueDriverNumbers(drivers)
|
||||
if len(driverNumbers) == 0 {
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
series, err := fetchReplayLocationSeries(ctx, client, sessionKey, driverNumbers)
|
||||
if err != nil && len(series) == 0 {
|
||||
return resp, err
|
||||
}
|
||||
|
||||
start, ok := earliestReplayLocationTime(series)
|
||||
if !ok {
|
||||
return resp, nil
|
||||
}
|
||||
resp.StartTime = start.Format(time.RFC3339Nano)
|
||||
resp.Frames = snapReplayFrames(series, start, intervalMS)
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
func uniqueDriverNumbers(drivers []models.Driver) []int {
|
||||
seen := make(map[int]bool, len(drivers))
|
||||
numbers := make([]int, 0, len(drivers))
|
||||
for _, driver := range drivers {
|
||||
if driver.DriverNumber <= 0 || seen[driver.DriverNumber] {
|
||||
continue
|
||||
}
|
||||
seen[driver.DriverNumber] = true
|
||||
numbers = append(numbers, driver.DriverNumber)
|
||||
}
|
||||
sort.Ints(numbers)
|
||||
return numbers
|
||||
}
|
||||
|
||||
func fetchReplayLocationSeries(ctx context.Context, client replayDataClient, sessionKey int, driverNumbers []int) (map[int][]models.Location, error) {
|
||||
type result struct {
|
||||
driver int
|
||||
locs []models.Location
|
||||
err error
|
||||
}
|
||||
|
||||
sem := make(chan struct{}, replayFetchConcurrency)
|
||||
results := make(chan result, len(driverNumbers))
|
||||
var wg sync.WaitGroup
|
||||
|
||||
for _, driverNumber := range driverNumbers {
|
||||
driverNumber := driverNumber
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
select {
|
||||
case sem <- struct{}{}:
|
||||
defer func() { <-sem }()
|
||||
case <-ctx.Done():
|
||||
results <- result{driver: driverNumber, err: ctx.Err()}
|
||||
return
|
||||
}
|
||||
|
||||
locs, err := client.GetLocation(sessionKey, driverNumber)
|
||||
results <- result{driver: driverNumber, locs: locs, err: err}
|
||||
}()
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
close(results)
|
||||
|
||||
series := make(map[int][]models.Location, len(driverNumbers))
|
||||
var joined error
|
||||
for result := range results {
|
||||
if result.err != nil {
|
||||
joined = errors.Join(joined, result.err)
|
||||
continue
|
||||
}
|
||||
if len(result.locs) > 0 {
|
||||
series[result.driver] = result.locs
|
||||
}
|
||||
}
|
||||
return series, joined
|
||||
}
|
||||
|
||||
func earliestReplayLocationTime(series map[int][]models.Location) (time.Time, bool) {
|
||||
var start time.Time
|
||||
for _, locs := range series {
|
||||
for _, loc := range locs {
|
||||
t, err := time.Parse(time.RFC3339Nano, loc.Date)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
if start.IsZero() || t.Before(start) {
|
||||
start = t
|
||||
}
|
||||
}
|
||||
}
|
||||
if start.IsZero() {
|
||||
return time.Time{}, false
|
||||
}
|
||||
return start, true
|
||||
}
|
||||
|
||||
func snapReplayFrames(series map[int][]models.Location, start time.Time, intervalMS int) []replayFrame {
|
||||
type accumulator struct {
|
||||
t int64
|
||||
cars map[string]replayCar
|
||||
nearest map[string]int64
|
||||
}
|
||||
|
||||
interval := int64(intervalMS)
|
||||
framesByIndex := make(map[int]*accumulator)
|
||||
|
||||
for driverNumber, locs := range series {
|
||||
driverKey := strconv.Itoa(driverNumber)
|
||||
for _, loc := range locs {
|
||||
if !isFiniteFloat(loc.X) || !isFiniteFloat(loc.Y) {
|
||||
continue
|
||||
}
|
||||
t, err := time.Parse(time.RFC3339Nano, loc.Date)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
offset := t.Sub(start).Milliseconds()
|
||||
if offset < 0 {
|
||||
continue
|
||||
}
|
||||
index := int((offset + interval/2) / interval)
|
||||
if index < 0 || index >= maxReplayFrames {
|
||||
continue
|
||||
}
|
||||
frameT := int64(index) * interval
|
||||
distance := absInt64(offset - frameT)
|
||||
|
||||
acc, ok := framesByIndex[index]
|
||||
if !ok {
|
||||
acc = &accumulator{
|
||||
t: frameT,
|
||||
cars: make(map[string]replayCar),
|
||||
nearest: make(map[string]int64),
|
||||
}
|
||||
framesByIndex[index] = acc
|
||||
}
|
||||
if prev, ok := acc.nearest[driverKey]; ok && prev <= distance {
|
||||
continue
|
||||
}
|
||||
acc.nearest[driverKey] = distance
|
||||
acc.cars[driverKey] = replayCar{X: loc.X, Y: loc.Y}
|
||||
}
|
||||
}
|
||||
|
||||
indexes := make([]int, 0, len(framesByIndex))
|
||||
for index, acc := range framesByIndex {
|
||||
if len(acc.cars) > 0 {
|
||||
indexes = append(indexes, index)
|
||||
}
|
||||
}
|
||||
sort.Ints(indexes)
|
||||
|
||||
frames := make([]replayFrame, 0, len(indexes))
|
||||
for _, index := range indexes {
|
||||
acc := framesByIndex[index]
|
||||
frames = append(frames, replayFrame{T: acc.t, Cars: acc.cars})
|
||||
}
|
||||
return frames
|
||||
}
|
||||
|
||||
func absInt64(v int64) int64 {
|
||||
if v < 0 {
|
||||
return -v
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
func isFiniteFloat(v float64) bool {
|
||||
return !math.IsNaN(v) && !math.IsInf(v, 0)
|
||||
}
|
||||
Reference in New Issue
Block a user