"""Project 02, Step 1: one battle. Each rule pinned to a number from data.py worked out by hand.""" import random import unittest from p02 import data as D from p02 import tactics as T class Rolls: """randint returns the next listed value (then the last one forever); the rest is seeded.""" def __init__(self, *values): self.values, self.inner = list(values), random.Random(1) def randint(self, a, b): v = self.values.pop(0) if len(self.values) > 1 else self.values[0] return max(a, min(b, v)) def __getattr__(self, name): return getattr(self.inner, name) def field(obst=None, squad=(("rifleman", 2, 10),), enemies=(("militiaman", 12, 10),), awake=True): """A hand-made battle: an empty field (plus obst), units where you put them.""" units = [T.soldier(f"S{i}", c, x, y) for i, (c, x, y) in enumerate(squad)] units += [T.enemy(k, x, y, i) for i, (k, x, y) in enumerate(enemies)] for u in units: u.awake = awake if u.side == "enemy" else True b = T.Battle(random.Random(0), dict(obst or {}), units) b.start_turn() return b def who(b, kind): return next(u for u in b.units if u.kind == kind) class TheTown(unittest.TestCase): def test_every_open_cell_can_be_walked_to(self): for seed in range(40): obst = T.make_town(random.Random(seed)) reach = T._reachable(obst, (1, D.GRID_H - 2)) sealed = [(x, y) for x in range(D.GRID_W) for y in range(D.GRID_H) if (x, y) not in obst and (x, y) not in reach] self.assertEqual(sealed, [], seed) def test_the_landing_zone_is_clear_and_pods_sleep(self): b = T.Battle.new(7) squad = [u for u in b.units if u.side == "squad"] self.assertEqual([u.kind for u in squad], D.SQUAD) self.assertTrue(all(u.x < 5 and u.y >= D.GRID_H - 5 for u in squad)) foes = [u for u in b.units if u.side == "enemy"] self.assertEqual(len(foes), sum(len(p) for p in D.PODS)) self.assertTrue(all(not u.awake for u in foes if u not in b.visible("squad"))) class Sight(unittest.TestCase): def test_high_walls_block_low_dont(self): b = field({(7, 10): "high"}) self.assertFalse(b.los((2, 10), (12, 10))) b.obst[(7, 10)] = "low" self.assertTrue(b.los((2, 10), (12, 10))) def test_sight_range(self): b = field(enemies=(("militiaman", 2 + D.SIGHT + 1, 10),)) self.assertEqual(b.visible("squad"), []) class Cover(unittest.TestCase): def test_half_full_flanked_hunkered(self): b = field({(11, 10): "low"}) # a wreck between them, by the sentry me, it = who(b, "rifleman"), who(b, "militiaman") self.assertEqual(b.cover(it, 12, 10, me.x, me.y), D.COVER["low"]) b.obst[(11, 10)] = "high" self.assertEqual(b.cover(it, 12, 10, me.x, me.y), D.COVER["high"]) self.assertEqual(b.cover(it, 12, 10, 12, 2), 0) # shot from above: flanked b.obst[(11, 10)] = "low" it.hunkered = True hit, _ = b.odds(me, it) self.assertEqual(hit, me.aim + D.WEAPONS[D.weapon_key("rifle")]["range"][1] - it.defense - D.HUNKER * D.COVER["low"]) def test_odds(self): b = field() me, it = who(b, "rifleman"), who(b, "militiaman") # 10 cells: mid range, no cover hit, crit = b.odds(me, it) self.assertEqual(hit, 65 + 0 - it.defense) self.assertEqual(crit, D.WEAPONS[D.weapon_key("rifle")]["crit"] + D.FLANK_CRIT) it.x = 5 # 3 cells: close self.assertEqual(b.odds(me, it)[0], 65 + 10 - it.defense) it.x = 2 + 12 # 12 cells: long self.assertEqual(b.odds(me, it)[0], 65 - 10 - it.defense) self.assertEqual(b.odds(me, it, reaction=True)[0], 65 - 10 - it.defense + D.OVERWATCH_AIM) me.aim = 300 self.assertEqual(b.odds(me, it)[0], 100) class Moving(unittest.TestCase): def test_a_move_and_a_dash(self): b = field() me = who(b, "rifleman") self.assertEqual(b.move(me, 2 + D.CLASSES["rifleman"]["mobility"], 10), 1) self.assertEqual(me.actions, 1) b = field() me = who(b, "rifleman") self.assertEqual(b.move(me, 2 + D.CLASSES["rifleman"]["mobility"] + 1, 10), 2) self.assertEqual(me.actions, 0) with self.assertRaises(ValueError): b.move(me, 3, 10) def test_diagonals_cost_more_and_no_corner_cutting(self): b = field() me = who(b, "rifleman") cells = b.reach(me, 1) self.assertEqual(cells[(3, 11)], D.DIAGONAL) self.assertNotIn((2 + 5, 10 + 5), cells) # 5 diagonals = 7.5 > 6 b.obst[(3, 10)] = "high" # a wall right beside you self.assertEqual(b.reach(me, 1)[(3, 9)], 2) # not 1.5: no cutting its corner def test_overwatch_fires_once_at_a_mover(self): b = field() me, it = who(b, "rifleman"), who(b, "militiaman") b.side = "enemy" b.start_turn() b.overwatch(it) b.side = "squad" b.start_turn() b.rng = Rolls(1, 3, 100) # hit, 3 damage, no crit b.move(me, 4, 10) self.assertEqual(me.hp, D.CLASSES["rifleman"]["hp"] - 3) self.assertFalse(it.overwatch) self.assertTrue(any("overwatch" in l for l in b.log)) class Shooting(unittest.TestCase): def test_a_shot_ends_the_turn_and_spends_ammo(self): b = field() me, it = who(b, "rifleman"), who(b, "militiaman") b.rng = Rolls(1, 5, 100) b.shoot(me, it) self.assertEqual((me.actions, me.ammo, it.hp), (0, D.WEAPONS[D.weapon_key("rifle")]["clip"] - 1, D.ENEMIES["militiaman"]["hp"] - 5)) with self.assertRaises(ValueError): b.shoot(me, it) def test_how_it_went_down_is_kept_for_the_record(self): b = field(enemies=(("militiaman", 4, 10),)) me, it = who(b, "rifleman"), who(b, "militiaman") b.side = "enemy" b.start_turn() me.hp = 2 b.rng = Rolls(1, 5, 1) # hit, 5 damage, crit b.shoot(it, me) self.assertFalse(me.alive) self.assertEqual(me.downed, f"shot by a militiaman with {it.weapon} (a critical hit), turn {b.turn}") b = field(squad=(("rifleman", 2, 10), ("medic", 3, 10)), enemies=(("raider", 12, 10),)) me, doc = who(b, "rifleman"), who(b, "medic") doc.hp = 1 me.x = 8 b.grenade(me, 3, 10) # a bad throw self.assertEqual(doc.downed, f"caught in a grenade blast thrown by {me.name}, turn 1") self.assertEqual(me.kills, 0) # no kill for downing your own b = field() self.assertEqual(who(b, "rifleman").downed, "") # standing: nothing on the record def test_armor_and_crits(self): b = field(enemies=(("bruiser", 12, 10),)) me, it = who(b, "rifleman"), who(b, "bruiser") b.rng = Rolls(1, 3, 1) # hit, 3 damage, crit b.shoot(me, it) self.assertEqual(it.hp, D.ENEMIES["bruiser"]["hp"] - 3) # (3 - 1 armor) x 1.5 = 3 def test_no_shot_through_a_wall_or_without_ammo(self): b = field({(7, 10): "high", (7, 9): "high", (7, 11): "high"}) me, it = who(b, "rifleman"), who(b, "militiaman") self.assertFalse(b.can_shoot(me, it)) b = field() me, it = who(b, "rifleman"), who(b, "militiaman") me.ammo = 0 self.assertFalse(b.can_shoot(me, it)) b.reload(me) self.assertEqual(me.ammo, D.WEAPONS[D.weapon_key("rifle")]["clip"]) def test_claws_reach_only_next_door(self): b = field(enemies=(("raider", 4, 10),)) b.side = "enemy" b.start_turn() h, me = who(b, "raider"), who(b, "rifleman") self.assertFalse(b.can_shoot(h, me)) h.x = 3 self.assertTrue(b.can_shoot(h, me)) self.assertEqual(b.odds(h, me)[0], 100) class Kit(unittest.TestCase): def test_grenade(self): b = field({(11, 9): "low"}, enemies=(("militiaman", 12, 10), ("raider", 11, 11))) me = who(b, "rifleman") me.x = 4 b.grenade(me, 12, 10) self.assertEqual(who(b, "militiaman").hp, D.ENEMIES["militiaman"]["hp"] - D.GRENADE["damage"]) self.assertFalse(who(b, "raider").alive) self.assertNotIn((11, 9), b.obst, "low cover blown away") self.assertEqual((me.grenades, me.actions), (0, 1)) with self.assertRaises(ValueError): b.grenade(me, 12, 10) # none left def test_grenade_range(self): b = field() me = who(b, "rifleman") with self.assertRaises(ValueError): b.grenade(me, 2 + D.GRENADE["range"] + 1, 10) def test_medkit(self): b = field(squad=(("medic", 2, 10), ("rifleman", 3, 10))) med, rif = who(b, "medic"), who(b, "rifleman") rif.hp = 1 b.medkit(med, rif) self.assertEqual(rif.hp, 1 + D.MEDKIT_HEAL) rif.hp = rif.max_hp - 1 b.medkit(med, rif) self.assertEqual(rif.hp, rif.max_hp, "never past full") rif.x = 6 with self.assertRaises(ValueError): b.medkit(med, rif) class Pods(unittest.TestCase): def test_a_pod_sleeps_until_seen_then_scrambles(self): b = field({(10, 9): "low"}, enemies=(("militiaman", 18, 10),), awake=False) me, it = who(b, "rifleman"), who(b, "militiaman") b.end_turn() self.assertEqual((it.x, it.y), (18, 10), "asleep: it didn't move") self.assertFalse(it.awake) b.move(me, 2 + 6, 10) # now within sight self.assertTrue(it.awake) self.assertTrue(any("spotted" in l for l in b.log)) class Endings(unittest.TestCase): def test_won_and_lost(self): b = field() who(b, "militiaman").hp = 0 b.check() self.assertEqual(b.outcome, "won") b = field() who(b, "rifleman").hp = 0 b.check() self.assertEqual(b.outcome, "lost") def test_ai_battles_finish_and_the_squad_usually_wins(self): # Measured 2026-11-10 over 100 seeds: won 68, lost 31, 1 ran out of turns. outcomes = [T.auto_battle(s).outcome for s in range(30)] self.assertGreaterEqual(sum(o is not None for o in outcomes), 28) self.assertGreaterEqual(outcomes.count("won"), 15) if __name__ == "__main__": unittest.main() class TheLanding(unittest.TestCase): """Step 3b: a unit of 16 lands; every enemy is placed, none near your soldiers.""" def test_every_fighter_placed_and_none_on_top_of_you(self): import math import random for seed in range(60): rg = random.Random(seed) group = rg.choice(D.REGIONS[rg.choice(sorted(D.REGIONS))]["groups"]) pods = [list(rg.choice(group["pods"])) for _ in range(5)] unit = [(f"S{i}", "rifleman", None, 1 + i // D.SQUAD_SIZE) for i in range(16)] b = T.Battle.new(seed, squad=unit, pods=pods) mine = [u for u in b.units if u.side == "squad"] theirs = [u for u in b.units if u.side == "enemy"] self.assertEqual(sorted(u.kind for u in theirs), sorted(k for p in pods for k in p), seed) self.assertGreater(min(math.dist((a.x, a.y), (e.x, e.y)) for a in mine for e in theirs), D.POD_CLEAR, seed) self.assertEqual(len({(u.x, u.y) for u in b.units}), len(b.units), seed)