package main
import (
"math/rand"
"testing"
)
// TestNewCombat_initialState verifies IV3: all hull values in range, timers zero,
// result ongoing.
func TestNewCombat_initialState(t *testing.T) {
c := NewCombat()
if c.Player.Hull != 20 || c.Player.MaxHull != 20 {
t.Errorf("Player Hull=%d MaxHull=%d, want 20/20", c.Player.Hull, c.Player.MaxHull)
}
if c.Player.ShieldLayers != 0 {
t.Errorf("Player.ShieldLayers=%d, want 0", c.Player.ShieldLayers)
}
if c.Enemy.Hull != 15 || c.Enemy.MaxHull != 15 {
t.Errorf("Enemy Hull=%d MaxHull=%d, want 15/15", c.Enemy.Hull, c.Enemy.MaxHull)
}
if c.PlayerWeaponT != 0 || c.EnemyFireT != 0 {
t.Errorf("timers non-zero: PlayerWeaponT=%f EnemyFireT=%f", c.PlayerWeaponT, c.EnemyFireT)
}
if c.Result != GameOngoing {
t.Errorf("Result=%v, want GameOngoing", c.Result)
}
}
// TestPlayerShieldMax_table covers the power 0..4 → 0,0,1,1,2 mapping.
func TestPlayerShieldMax_table(t *testing.T) {
cases := []struct {
power int
want int
}{
{0, 0},
{1, 0},
{2, 1},
{3, 1},
{4, 2},
}
for _, tc := range cases {
sys := NewStartingSystems()
sys[int(RoleShields)].PowerLevel = tc.power
got := playerShieldMax(sys)
if got != tc.want {
t.Errorf("power=%d: got %d, want %d", tc.power, got, tc.want)
}
}
}
// TestResolveIncoming_shieldsAbsorb verifies that a hit on a shielded side
// decrements layers but leaves hull untouched.
func TestResolveIncoming_shieldsAbsorb(t *testing.T) {
rng := rand.New(rand.NewSource(0))
side := CombatSide{Hull: 10, MaxHull: 10, ShieldLayers: 2}
resolveIncoming(&side, 0, rng) // evasion=0, always hits
if side.ShieldLayers != 1 {
t.Errorf("ShieldLayers=%d, want 1", side.ShieldLayers)
}
if side.Hull != 10 {
t.Errorf("Hull=%d after shield absorb, want 10", side.Hull)
}
if side.HitFlashT != 0 {
t.Errorf("HitFlashT=%f, want 0 when shield absorbed", side.HitFlashT)
}
}
// TestResolveIncoming_hullDamage verifies that a hit with no shields deals 1 hull
// and sets HitFlashT.
func TestResolveIncoming_hullDamage(t *testing.T) {
rng := rand.New(rand.NewSource(0))
side := CombatSide{Hull: 5, MaxHull: 10, ShieldLayers: 0}
resolveIncoming(&side, 0, rng)
if side.Hull != 4 {
t.Errorf("Hull=%d, want 4", side.Hull)
}
if side.HitFlashT != HitFlashDuration {
t.Errorf("HitFlashT=%f, want %f", side.HitFlashT, HitFlashDuration)
}
}
// TestResolveIncoming_hullClampsAtZero verifies IV3: hull never goes below 0.
func TestResolveIncoming_hullClampsAtZero(t *testing.T) {
rng := rand.New(rand.NewSource(0))
side := CombatSide{Hull: 0, MaxHull: 10, ShieldLayers: 0}
resolveIncoming(&side, 0, rng)
if side.Hull != 0 {
t.Errorf("Hull=%d after hit at 0, want 0", side.Hull)
}
}
// TestResolveIncoming_evasionMiss verifies that when the RNG rolls under the
// evasion threshold the hit is dodged and no state changes.
func TestResolveIncoming_evasionMiss(t *testing.T) {
// Use a source that produces a deterministic low value (< evasionPct).
// rand.New(rand.NewSource(7)).Intn(100) == 25 for the first call.
src := rand.NewSource(7)
rng := rand.New(src)
firstRoll := rand.New(rand.NewSource(7)).Intn(100)
if firstRoll >= 50 {
t.Skipf("seed 7 first roll=%d >= 50; pick a different seed", firstRoll)
}
side := CombatSide{Hull: 10, MaxHull: 10, ShieldLayers: 0}
resolveIncoming(&side, 50, rng) // 50% evasion, roll < 50 → miss
if side.Hull != 10 {
t.Errorf("Hull=%d after evasion miss, want 10", side.Hull)
}
if side.HitFlashT != 0 {
t.Errorf("HitFlashT=%f after evasion miss, want 0", side.HitFlashT)
}
}
// TestResolveIncoming_evasionHit verifies that when the RNG rolls at or above
// the evasion threshold the hit lands.
func TestResolveIncoming_evasionHit(t *testing.T) {
// Use seed 0 with a low evasion percentage so the first roll is guaranteed
// to be >= evasionPct (1%).
rng := rand.New(rand.NewSource(0))
side := CombatSide{Hull: 10, MaxHull: 10, ShieldLayers: 0}
resolveIncoming(&side, 1, rng) // 1% evasion — roll almost certainly >= 1
// We need to verify the hit landed; hull should decrease.
if side.Hull != 9 {
t.Errorf("Hull=%d, want 9 (hit landed)", side.Hull)
}
}
// TestUpdateCombat_postResultNoOp verifies IV5: state is frozen once a result is set.
func TestUpdateCombat_postResultNoOp(t *testing.T) {
rng := rand.New(rand.NewSource(42))
sys := NewStartingSystems()
sys[int(RoleWeapons)].PowerLevel = 4
c := NewCombat()
c.Result = GameVictory
c.Enemy.Hull = 5
c.Player.HitFlashT = 0.1
snap := c
updateCombat(&c, sys, 1.0, rng)
if c != snap {
t.Errorf("state mutated after GameVictory: got %+v, want %+v", c, snap)
}
}
// TestUpdateCombat_hitFlashTicksDown verifies that HitFlashT decrements and clamps at 0.
func TestUpdateCombat_hitFlashTicksDown(t *testing.T) {
rng := rand.New(rand.NewSource(42))
sys := NewStartingSystems() // all power 0 — no weapons, no enemy fire crosses interval
c := NewCombat()
c.Player.HitFlashT = 0.01
c.Enemy.HitFlashT = 0.15
updateCombat(&c, sys, 1.0/60.0, rng)
if c.Player.HitFlashT != 0 {
t.Errorf("Player.HitFlashT=%f, want 0 (clamped)", c.Player.HitFlashT)
}
if c.Enemy.HitFlashT <= 0 {
t.Errorf("Enemy.HitFlashT=%f, want >0 (partially ticked)", c.Enemy.HitFlashT)
}
}
// TestUpdateCombat_shieldRegen verifies shields regen when power=4 and
// ShieldRegenT crosses the threshold.
func TestUpdateCombat_shieldRegen(t *testing.T) {
rng := rand.New(rand.NewSource(42))
sys := NewStartingSystems()
sys[int(RoleShields)].PowerLevel = 4 // max=2 shields
c := NewCombat()
c.Player.ShieldLayers = 0
// Advance enough time to trigger one regen tick.
updateCombat(&c, sys, ShieldRegen+0.1, rng)
if c.Player.ShieldLayers != 1 {
t.Errorf("ShieldLayers=%d, want 1 after regen", c.Player.ShieldLayers)
}
}
// TestUpdateCombat_shieldsClampOnPowerDrop verifies IV4: layers clamp down when
// power is reduced below what current layers require.
func TestUpdateCombat_shieldsClampOnPowerDrop(t *testing.T) {
rng := rand.New(rand.NewSource(42))
sys := NewStartingSystems()
sys[int(RoleShields)].PowerLevel = 0 // power dropped to 0 → max=0
c := NewCombat()
c.Player.ShieldLayers = 2
updateCombat(&c, sys, 1.0/60.0, rng)
if c.Player.ShieldLayers != 0 {
t.Errorf("ShieldLayers=%d after power drop, want 0", c.Player.ShieldLayers)
}
}
// TestUpdateCombat_weaponChargeFires verifies that the weapon timer fires when it
// crosses WeaponChargeMax and deals 1 hull to the enemy.
func TestUpdateCombat_weaponChargeFires(t *testing.T) {
rng := rand.New(rand.NewSource(42))
sys := NewStartingSystems()
sys[int(RoleWeapons)].PowerLevel = 1
c := NewCombat()
c.PlayerWeaponT = WeaponChargeMax - 0.01 // just below threshold
enemyHullBefore := c.Enemy.Hull
updateCombat(&c, sys, 1.0, rng) // dt=1.0: 0.01 over threshold
if c.Enemy.Hull != enemyHullBefore-1 {
t.Errorf("Enemy.Hull=%d, want %d (one hit)", c.Enemy.Hull, enemyHullBefore-1)
}
if c.PlayerWeaponT != 0 {
t.Errorf("PlayerWeaponT=%f, want 0 after firing", c.PlayerWeaponT)
}
}
// TestUpdateCombat_weaponZeroPowerNoCharge verifies that zero weapons power means
// PlayerWeaponT does not advance.
func TestUpdateCombat_weaponZeroPowerNoCharge(t *testing.T) {
rng := rand.New(rand.NewSource(42))
sys := NewStartingSystems()
sys[int(RoleWeapons)].PowerLevel = 0
c := NewCombat()
c.PlayerWeaponT = 3.0
updateCombat(&c, sys, 1.0, rng)
if c.PlayerWeaponT != 3.0 {
t.Errorf("PlayerWeaponT=%f, want 3.0 (no change)", c.PlayerWeaponT)
}
}
// TestUpdateCombat_enemyFiresOnTimer verifies that the enemy fires when EnemyFireT
// crosses EnemyFireInterval and damages the player (no engines power → no evasion).
func TestUpdateCombat_enemyFiresOnTimer(t *testing.T) {
// Use a seed where the evasion roll at 0% always hits.
rng := rand.New(rand.NewSource(42))
sys := NewStartingSystems()
sys[int(RoleEngines)].PowerLevel = 0 // 0% evasion
c := NewCombat()
c.EnemyFireT = EnemyFireInterval - 0.01
playerHullBefore := c.Player.Hull
updateCombat(&c, sys, 1.0, rng)
if c.Player.Hull != playerHullBefore-1 {
t.Errorf("Player.Hull=%d, want %d (enemy hit)", c.Player.Hull, playerHullBefore-1)
}
if c.EnemyFireT != 0 {
t.Errorf("EnemyFireT=%f, want 0 after firing", c.EnemyFireT)
}
}
// TestUpdateCombat_victoryTransition verifies IV5: enemy reaches 0 hull → GameVictory.
func TestUpdateCombat_victoryTransition(t *testing.T) {
rng := rand.New(rand.NewSource(42))
sys := NewStartingSystems()
sys[int(RoleWeapons)].PowerLevel = 1
c := NewCombat()
c.Enemy.Hull = 1
c.PlayerWeaponT = WeaponChargeMax - 0.01
updateCombat(&c, sys, 1.0, rng)
if c.Result != GameVictory {
t.Errorf("Result=%v, want GameVictory", c.Result)
}
}
// TestUpdateCombat_defeatTransition verifies IV5: player reaches 0 hull → GameDefeat.
func TestUpdateCombat_defeatTransition(t *testing.T) {
// Need a seed that won't dodge (0% evasion, engines=0).
rng := rand.New(rand.NewSource(42))
sys := NewStartingSystems()
sys[int(RoleEngines)].PowerLevel = 0
sys[int(RoleShields)].PowerLevel = 0
c := NewCombat()
c.Player.Hull = 1
c.Player.ShieldLayers = 0
c.EnemyFireT = EnemyFireInterval - 0.01
updateCombat(&c, sys, 1.0, rng)
if c.Result != GameDefeat {
t.Errorf("Result=%v, want GameDefeat", c.Result)
}
}
// TestUpdateCombat_determinism verifies IV6: same seed + same inputs → identical
// state after N ticks.
func TestUpdateCombat_determinism(t *testing.T) {
sys := NewStartingSystems()
sys[int(RoleWeapons)].PowerLevel = 2
sys[int(RoleEngines)].PowerLevel = 1
sys[int(RoleShields)].PowerLevel = 2
run := func() Combat {
rng := rand.New(rand.NewSource(99))
c := NewCombat()
for i := 0; i < 500; i++ {
if c.Result != GameOngoing {
break
}
updateCombat(&c, sys, 1.0/60.0, rng)
}
return c
}
a := run()
b := run()
if a != b {
t.Errorf("non-deterministic: run1=%+v run2=%+v", a, b)
}
}