sim

type Binding interface {
	HasScript(name string) bool
	Start(name string, args ...int)
	// Restart spawns the named script after cancelling any live instance of it,
	// so a per-tick re-driven thread (a weapon aim loop) supersedes rather than
	// stacks. It mirrors the COB START opcode's same-name supersede.
	Restart(name string, args ...int)
	// Pieces returns the current piece transforms for the render snapshot.
	Pieces() []frame.PieceState
}

type Blast struct {
	Damage fixed.Fixed
	AoE    fixed.Fixed
	Edge   fixed.Fixed
}

type CobController interface {
	KillAllThreads()
	KillThread(id int32)
	ResetState()
}

type CobDebugger interface {
	StepThread(id int32)
	SetThreadPC(id int32, pc int)
	SetThreadLocal(id int32, idx int, v int32)
	SetStatic(idx int, v int32)
	AddBreakpoint(scriptIdx int, offset uint32)
	RemoveBreakpoint(scriptIdx int, offset uint32)
	ClearBreakpoints()
	ClearBreakpointHits()
	Coverage() map[int][]uint32
}

type CobInspector interface {
	CobState() frame.CobUnitState
}

type CobPorts interface {
	SetUnitValuePort(port int, v int32)
	UnitValuePort(port int) int32
}

type CobScripts interface {
	HasScript(name string) bool
	Start(name string, args ...int)
	Restart(name string, args ...int)
	KillThreadsByName(name string)
	ScriptNames() []string
}

type Config struct {
	Seed    uint32
	Gravity fixed.Fixed
	Spawn   SpawnFunc
}

type RestoredProjectile struct {
	ID        uint32
	OwnerID   uint32
	TargetID  uint32
	Slot      int
	Mode      uint8
	Phase     uint8
	Model     string
	Weapon    string
	Pos       fixed.Vec3
	Vel       fixed.Vec3
	Origin    fixed.Vec3
	Target    fixed.Vec3
	LaunchY   fixed.Fixed
	Speed     fixed.Fixed
	VMax      fixed.Fixed
	Accel     fixed.Fixed
	TurnAng   int32
	HomingR   fixed.Fixed
	Gravity   fixed.Fixed
	AoE       fixed.Fixed
	Damage    fixed.Fixed
	AgeSec    fixed.Fixed
	LifeSec   fixed.Fixed
	LastDist  fixed.Fixed
	Closing   bool
	Heading   int32
	Pitch     int32
	FromPiece int
}

type RestoredQueued struct {
	Kind       uint8
	Target     fixed.Vec2
	TargetUnit uint32
	Name       string
}

type RestoredUnit struct {
	ID         uint32
	Name       string
	Side       int
	Pos        fixed.Vec3
	Heading    fixed.Fixed // raw fractional TA-angle
	Speed      fixed.Fixed
	HasMove    bool
	MoveTarget fixed.Vec2
	Health     fixed.Fixed
	Dead       bool
	// Combat state so a late joiner's prediction re-engages weapons that were
	// firing / aiming on the authority. Without it a restored unit re-runs only
	// its Create script and renders at its base pose, so a weapon caught
	// mid-recoil snaps back to rest on the joining client.
	HasAttack    bool
	AttackTarget uint32
	// Queue carries the unit's shift-queued follow-up orders so a joiner's
	// world advances through the same waypoint chain as the authority.
	Queue   []RestoredQueued
	Weapons [3]RestoredWeapon
	// BuildPercent carries construction progress (a buildee below 100% stays
	// inert on the joiner too); the Build* fields carry a builder's live job
	// so the joiner keeps raising the same buildee; ProdQueue a factory's
	// pending production run.
	BuildPercent  fixed.Fixed
	BuildState    uint8
	BuildName     string
	BuildSite     fixed.Vec2
	BuildTargetID uint32
	BuildGateMs   int64
	ProdQueue     []string
	// Standing orders + their working state, so a joiner's units keep the
	// same stances, posts and patrol/auto-engage status.
	MoveMode    uint8
	FireMode    uint8
	HomePos     fixed.Vec2
	AutoEngaged bool
	CurIsPatrol bool
	SelfDAtMs   int64
	// Transport links: who carries this unit, who it carries, and any
	// in-flight pickup / drop job.
	CarriedBy  uint32
	Carrying   []uint32
	LoadTarget uint32
	StallTicks uint16
	AvoidFlip  bool
	ProgressX  fixed.Fixed
	ProgressZ  fixed.Fixed
	HasUnload  bool
	UnloadAt   fixed.Vec2
	// Cob carries the unit's full live script VM state (piece animators, threads,
	// statics, visibility) when the binding can export it. With it the joiner
	// resumes the exact piece poses the authority holds — a turret's aim angle, a
	// half-played recoil — instead of re-deriving them by replaying Create and
	// StartMoving, which only ever reproduces a rest pose. Nil when the binding
	// has no script or cannot export, in which case Restore falls back to replay.
	Cob *frame.CobSnapshot
}

type RestoredWeapon struct {
	HasTarget  bool
	TargetUnit uint32
	TargetPt   fixed.Vec3
	Source     string
	LastFireMs int64
}

type Runtime interface {
	Tick(ms int64)
}

type SpawnFunc func(name string) (*UnitMeta, Binding)

type Terrain struct {
	W, H        int         // cells
	CellWU      fixed.Fixed // world units per cell (16 for TNT attr grid)
	HeightScale fixed.Fixed // world Y per height unit (TA renders at 1/2)
	SeaLevel    int         // height units; cells below it are underwater
	Data        []uint8     // row-major heights, len = W*H
	// Void marks cells the map carves out entirely (the TNT 0xFFFC
	// sentinel): nothing stands, walks or builds there. Optional —
	// nil means no voids.
	Void []uint8
	// SlopeScalePct scales a unit's declared MaxSlope onto THIS heightmap's
	// per-cell delta scale, as a percentage (0 → defaultSlopeScalePct). TA's
	// coarse attribute grid inflates per-cell deltas ~2.5x relative to the
	// MaxSlope authoring scale, so TA maps use 40 (the 2/5 calibration that
	// makes KOTH's spiral ramps the only way up). TA:Kingdoms maps carry a
	// native heightmap whose deltas sit on the MaxSlope scale directly and run
	// far steeper (Athri-Cay island edges hit ~30 vs KOTH's ~11), so they use
	// 100 — otherwise GROUND2 units (MaxSlope 30 → 12) can't climb any island.
	SlopeScalePct int
}

type Unit struct {
	ID   uint32
	Name string
	Side int
	Meta *UnitMeta

	PosY   fixed.Fixed
	Health fixed.Fixed // 0..100

	Dead         bool
	BuildPercent fixed.Fixed

	IsMoving bool
	// contains filtered or unexported fields
}

type UnitMeta struct {
	Name string

	CanMove     bool
	MaxVelocity fixed.Fixed // world-units per frame (30 Hz)
	TurnRate    fixed.Fixed // TA-angle per frame
	Accel       fixed.Fixed // world-units per frame^2
	BrakeRate   fixed.Fixed // world-units per frame^2

	IsAircraft     bool
	IsHover        bool
	IsShip         bool
	IsSub          bool
	IsHovercraft   bool
	CruiseAltitude fixed.Fixed

	// Terrain limits (FBI maxslope / maxwaterdepth / minwaterdepth, in
	// height units): the steepest cell delta the unit climbs, the deepest
	// water a surface unit wades, the shallowest water a ship needs.
	MaxSlope      int
	MaxWaterDepth int
	MinWaterDepth int

	IsBuilder bool
	OnOffable bool
	// ActivateWhenBuilt — the unit's Activate script runs the moment its
	// construction completes (FBI activatewhenbuilt; ARM Solar's panels).
	ActivateWhenBuilt bool

	// Construction stats. BuildTime is the unit's own build-effort points
	// (FBI buildtime — how long IT takes to construct); WorkerTime is the
	// builder's effort output per second (FBI workertime); BuildDistance is
	// how close (wu) a mobile builder must stand to its construction site.
	BuildTime     fixed.Fixed
	WorkerTime    int
	BuildDistance fixed.Fixed

	// FootprintX/Z are the FBI footprint in map squares; collisionRadius
	// derives the body circle the collision/avoidance passes use.
	FootprintX int
	FootprintZ int

	// TransportSlots — how many units this transport carries (0 = not a
	// transport).
	TransportSlots int

	// Yard is the parsed YardMap occupancy grid (row-major FootprintZ rows ×
	// FootprintX cols). Nil means the whole footprint is solid. Only standing
	// structures collide by yard; mobile units stay on the circle model.
	Yard []yardCell

	// Resource prices, drained over the unit's build (TA metal+energy,
	// TA:K mana). Pools are infinite in the sandbox; the drain feeds the
	// per-side usage stats only.
	CostMetal  fixed.Fixed
	CostEnergy fixed.Fixed
	CostMana   fixed.Fixed

	// Default standing orders the unit spawns with (FBI standingmoveorder /
	// standingfireorder, already resolved to the game defaults — Maneuver /
	// Fire at Will — when the FBI is silent).
	StandMove uint8
	StandFire uint8

	// Death blasts: the resolved explodeas weapon (ordinary death) and
	// selfdestructas weapon (Ctrl+D). Damage is absolute per-shot, AoE the
	// blast diameter in world units, Edge the damage fraction left at the
	// rim. A zero-damage blast deals no splash (visual only).
	Explode Blast
	SelfD   Blast

	// Economy contributions per second while the unit stands (generation)
	// and the storage capacity it adds to its side's pools. The sandbox
	// never gates on stock — these feed the economy bar's accounting only.
	MakeMetal   fixed.Fixed
	MakeEnergy  fixed.Fixed
	MakeMana    fixed.Fixed
	StoreMetal  fixed.Fixed
	StoreEnergy fixed.Fixed
	StoreMana   fixed.Fixed

	// MaxHealth is the unit's absolute hit points (FBI maxdamage). The sim's
	// health bar stays on a 0..100 scale; ApplyDamage divides each weapon's
	// absolute damage by this to land TDF-faithful percentage hits. Zero
	// means unknown — damage then applies at face value, the legacy scale.
	MaxHealth fixed.Fixed

	Weapons [3]WeaponMeta
}

type WeaponMeta struct {
	Name     string
	Range    fixed.Fixed // world units
	ReloadMs int         // milliseconds between shots
	Burst    int         // shots per burst (>=1)
	Damage   fixed.Fixed // per shot
	Present  bool
	// CommandFire weapons (the D-gun) discharge only on an explicit fire
	// order — one shot per order, never as part of a standing attack.
	CommandFire bool
	// Per-shot economy drain (TDF energypershot / metalpershot).
	EnergyShot fixed.Fixed
	MetalShot  fixed.Fixed

	// Tolerance is the weapon's firing arc in TA-angle units (65536 = full
	// turn); 0 = no arc constraint. Aircraft aim by pointing the whole airframe
	// (no rotating turret), so the body heading must be within tolerance of the
	// target bearing before the weapon may open fire.
	Tolerance int32

	// Ballistic / projectile fields. Every weapon except an instant-hit beam
	// flies a tracked projectile through the subsystem and applies its damage on
	// detonation — a missile/rocket/bomb carries a 3DO mesh, while a cannon shell
	// or EMG bolt flies the same flight path with no model. Tracking the
	// model-less shots is what lets a late joiner restore in-flight cannon/EMG
	// fire, not just missiles. All rates derive from the weapon TDF.
	Model           string      // 3DO projectile model; empty = model-less shot
	BeamWeapon      bool        // instant-hit beam (lasers): never flies
	VelocityWU      fixed.Fixed // top speed, world units/sec
	StartVelocityWU fixed.Fixed // launch speed; 0 = top speed (no ramp)
	AccelerationWU  fixed.Fixed // ramp to top speed, wu/s^2; 0 = instant
	TurnRateAng     int32       // homing turn rate, TA-angle/sec; 0 = unguided
	FlightTimeSec   fixed.Fixed // self-destruct timer; 0 = derive from range/vel
	AreaOfEffectWU  fixed.Fixed // blast diameter for detonation damage
	Dropped         bool        // gravity bomb: released with no thrust
	VLaunch         bool        // vertical launch: climbs then homes
	Tracks          bool        // guided: homes on the target
	SelfProp        bool        // self-propelled (with Tracks + turn rate, homes)
	Ballistic       bool        // unpowered arc under gravity
}

type World struct {
	// contains filtered or unexported fields
}