""" AutoPOE2 - Unit Test for Closed-Loop Map Runner Waystone Row 1 Farm (Doc 48) Verifies: 1. Coordinate transform math between 1080p reference and 1440p real screen. 2. Exact center points for Slots 0..4 in Row 1 matching Ground-Truth. 3. Optical classification logic distinguishing Waystone (AvgRGB > 50) vs Empty (AvgRGB < 15). 4. FSM State transitions for 8-state closed loop and mission completion. 5. Invariant enforcement: INV-TOWN-PORTAL-KEY uses '.' (VK 0xBE), INV-UI-MAP-DEVICE delay. """ import sys import unittest from enum import Enum, auto from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) class MapFarmState(Enum): CHECK_INVENTORY_ROW1 = auto() OPEN_MAP_DEVICE = auto() INSERT_WAYSTONE = auto() ACTIVATE_MAP = auto() ENTER_PORTAL = auto() AUTONOMOUS_CLEAR_MAP = auto() TOWN_PORTAL_RETURN = auto() TRANSITION_TO_HIDEOUT = auto() COMPLETED = auto() class ClosedLoopMapRunnerFSM: """Mock FSM simulating the 8-state autonomous map farming loop (Doc 48).""" def __init__(self, initial_waystone_slots): self.state = MapFarmState.CHECK_INVENTORY_ROW1 self.inventory_row1 = list(initial_waystone_slots) self.current_target_slot = -1 self.maps_completed = 0 def step(self): if self.state == MapFarmState.CHECK_INVENTORY_ROW1: waystones = [i for i, has_w in enumerate(self.inventory_row1) if has_w] if not waystones: self.state = MapFarmState.COMPLETED return "COMPLETED" self.current_target_slot = waystones[0] self.state = MapFarmState.OPEN_MAP_DEVICE return f"FOUND_WAYSTONE_SLOT_{self.current_target_slot}" elif self.state == MapFarmState.OPEN_MAP_DEVICE: self.state = MapFarmState.INSERT_WAYSTONE return "MAP_DEVICE_OPENED" elif self.state == MapFarmState.INSERT_WAYSTONE: # Remove waystone from inventory slot self.inventory_row1[self.current_target_slot] = False self.state = MapFarmState.ACTIVATE_MAP return f"INSERTED_SLOT_{self.current_target_slot}" elif self.state == MapFarmState.ACTIVATE_MAP: self.state = MapFarmState.ENTER_PORTAL return "MAP_ACTIVATED_WAIT_2500MS" elif self.state == MapFarmState.ENTER_PORTAL: self.state = MapFarmState.AUTONOMOUS_CLEAR_MAP return "ENTERED_MAP_INSTANCE" elif self.state == MapFarmState.AUTONOMOUS_CLEAR_MAP: self.state = MapFarmState.TOWN_PORTAL_RETURN return "MAP_CLEARED" elif self.state == MapFarmState.TOWN_PORTAL_RETURN: self.state = MapFarmState.TRANSITION_TO_HIDEOUT return "PORTAL_KEY_DOT_PRESSED" elif self.state == MapFarmState.TRANSITION_TO_HIDEOUT: self.maps_completed += 1 self.state = MapFarmState.CHECK_INVENTORY_ROW1 return f"RETURNED_TO_HIDEOUT_TOTAL_{self.maps_completed}" return "IDLE" class TestWaystoneRow1Farm(unittest.TestCase): def setUp(self): # 1080p Reference parameters (SSoT) self.ref_w = 1920 self.ref_h = 1080 self.inv_origin_x_1080 = 1272.0 self.inv_origin_y_1080 = 590.0 self.inv_cell_w_1080 = 52.5 self.inv_cell_h_1080 = 52.5 self.cols = 12 def test_coordinate_scaling_to_1440p(self): """Verify 1080p reference coordinates scale exactly to 1440p ground-truth.""" scale_x = 2560.0 / 1920.0 # 4/3 = 1.3333333333333333 scale_y = 1440.0 / 1080.0 # 4/3 = 1.3333333333333333 origin_x_1440 = self.inv_origin_x_1080 * scale_x origin_y_1440 = self.inv_origin_y_1080 * scale_y cell_w_1440 = self.inv_cell_w_1080 * scale_x cell_h_1440 = self.inv_cell_h_1080 * scale_y self.assertAlmostEqual(origin_x_1440, 1696.0, places=2) self.assertAlmostEqual(origin_y_1440, 786.6666666666666, places=1) self.assertEqual(round(origin_y_1440), 787) self.assertAlmostEqual(cell_w_1440, 70.0, places=2) self.assertAlmostEqual(cell_h_1440, 70.0, places=2) # Verify exact slot center coordinates for slots 0..4 expected_centers = [ (0, 1731, 822), (1, 1801, 822), (2, 1871, 822), (3, 1941, 822), (4, 2011, 822), ] for col, exp_x, exp_y in expected_centers: cx = origin_x_1440 + col * cell_w_1440 + (cell_w_1440 * 0.5) cy = origin_y_1440 + 0 * cell_h_1440 + (cell_h_1440 * 0.5) self.assertEqual(int(round(cx)), exp_x, f"Slot {col} X mismatch") self.assertEqual(int(round(cy)), exp_y, f"Slot {col} Y mismatch") def test_map_device_coordinates_1440p(self): """Verify Map Device in Shoreline Hideout scales correctly to (1018, 203).""" scale_x = 2560.0 / 1920.0 scale_y = 1440.0 / 1080.0 ref_x = 763.5 ref_y = 152.25 x_1440 = round(ref_x * scale_x) y_1440 = round(ref_y * scale_y) self.assertEqual(x_1440, 1018) self.assertEqual(y_1440, 203) def test_town_portal_key_invariant(self): """Verify INV-TOWN-PORTAL-KEY requires key '.' (VK 0xBE), never 'T'.""" VK_DOT = 0xBE VK_T = 0x54 portal_key = VK_DOT self.assertEqual(portal_key, 0xBE) self.assertNotEqual(portal_key, VK_T, "Portal key must NOT be 'T' (Warcry conflict)!") def test_optical_classification_threshold(self): """Verify optical classification logic distinguishes Waystones (AvgRGB > 50) vs Empty (AvgRGB < 15).""" threshold = 50.0 ground_truth_samples = [ (0, 104.2, True), # Waystone (1, 101.4, True), # Waystone (2, 108.7, True), # Waystone (3, 103.1, True), # Waystone (4, 102.6, True), # Waystone (5, 8.3, False), # Empty (6, 8.1, False), # Empty (7, 8.5, False), # Empty (8, 7.9, False), # Empty (9, 8.2, False), # Empty (10, 8.4, False), # Empty (11, 8.0, False), # Empty ] for slot_idx, avg_rgb, expected_present in ground_truth_samples: is_present = avg_rgb > threshold self.assertEqual(is_present, expected_present, f"Slot {slot_idx} classification mismatch") def test_closed_loop_fsm_execution_all_5_waystones(self): """Verify full 8-step FSM iterates through all 5 waystones and terminates gracefully.""" # 5 waystones in slots 0..4, slots 5..11 empty initial_slots = [True] * 5 + [False] * 7 fsm = ClosedLoopMapRunnerFSM(initial_slots) # Run FSM until completion steps_run = 0 max_steps = 100 while fsm.state != MapFarmState.COMPLETED and steps_run < max_steps: fsm.step() steps_run += 1 self.assertEqual(fsm.state, MapFarmState.COMPLETED) self.assertEqual(fsm.maps_completed, 5) # All slots must now be empty self.assertFalse(any(fsm.inventory_row1)) if __name__ == "__main__": unittest.main()