game

type Camera struct {
	Position        *util.Vector2D
	FOV             float64
	ShipsSeen       map[uint64]bool
	ProjectilesSeen map[uint64]bool
}

type Candidate struct {
	Ship *Ship
	Dist float64
}

type CircularCollisionPlugin struct {
	GenericObject
	AABB *util.AABB
}

type CollidableObject interface {
	util.Identifiable
	GetAABB() *util.AABB
	Insert()
	Collide()
}

type Control struct {
	Game                *Game
	Body                *Ship
	Goal, PrimaryTarget *util.Vector2D
}

type Faction struct {
	ID               uint64
	Name             string
	Color            color.RGBA
	ShipsSpatialHash *util.SpatialHash[*Ship]
}

type Game struct {
	Factions   map[uint64]*Faction
	FactionsMu sync.RWMutex
	Ships      *util.SafeStorage[*Ship]
	Planes     *util.SafeStorage[*Plane]

	ShipCache                      map[uint64]*ShipCache
	ProjectileCache                map[uint64]*GenericObjectCache
	ShipCacheMu, ProjectileCacheMu sync.RWMutex
	Players                        map[int]*Player
	PlayersMu                      sync.RWMutex
	// contains filtered or unexported fields
}

type GenericObject struct {
	ID                                             uint64
	Game                                           *Game
	Position, Velocity                             *util.Vector2D
	Size, Rotation, Friction, Density, Pushability float64
	Faction                                        *Faction
}

type GenericObjectCache struct {
	AsOf                                int // Corresponds with Game.time
	New, Old                            *protocol.Writer
	ID                                  uint64
	X, Y, Size, Rotation                float64
	PosChanged, SizeChanged, RotChanged bool
}

type HealthComponent struct {
	Health, MaxHealth float64
	CanBeRepaired     bool
}

type Plane struct {
	CircularCollisionPlugin
}

type Player struct {
	Socket       *web.Socket
	Body         *Ship
	Camera       *Camera
	InputFlags   uint8
	LastFireTick int
	InputMu      sync.RWMutex
	Faction      *Faction
}

type PolygonalCollisionPlugin struct {
	GenericObject
	Polygon *util.Polygon
}

type Ship struct {
	PolygonalCollisionPlugin
	Name    string
	Cfg     *definitions.Ship
	Health  *HealthComponent
	Control *Control
}

type ShipAI struct {
	Ship   *Ship
	Target *Ship
}

type ShipCache struct {
	GenericObjectCache
	Health                                                        float64
	Shields                                                       [][2]float64 // [][hardpoint health ratio, shield health ratio]
	Engines                                                       []float64    // []engine health ratio
	Turrets                                                       [][2]float64 // [][hardpoint health ratio, turret facing (absolute)]
	HealthChanged, ShieldsChanged, EnginesChanged, TurretsChanged bool
}