cogames-agents 0.0.0.7__cp312-cp312-macosx_11_0_arm64.whl

cogames_agents/policy/scripted_agent/planky/goals/shared.py

@@ -0,0 +1,160 @@
+"""Shared goals used by multiple roles."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from cogames_agents.policy.scripted_agent.planky.goal import Goal
+from cogames_agents.policy.scripted_agent.planky.navigator import _manhattan
+from mettagrid.simulator import Action
+
+if TYPE_CHECKING:
+    from cogames_agents.policy.scripted_agent.planky.context import PlankyContext
+
+
+class GetHeartsGoal(Goal):
+    """Navigate to a chest to acquire hearts.
+
+    Hearts cost 1 of each element from the collective. Skip if the
+    collective can't afford it to avoid wasting time at the chest.
+    """
+
+    name = "GetHearts"
+    # Cost per heart: 1 of each element
+    HEART_COST = {"carbon": 1, "oxygen": 1, "germanium": 1, "silicon": 1}
+
+    def __init__(self, min_hearts: int = 1) -> None:
+        self._min_hearts = min_hearts
+
+    # Minimum collective resource reserve — don't consume below this level
+    RESOURCE_RESERVE = 3
+
+    def _collective_can_afford_heart(self, ctx: PlankyContext) -> bool:
+        s = ctx.state
+        r = self.RESOURCE_RESERVE
+        return (
+            s.collective_carbon >= 1 + r
+            and s.collective_oxygen >= 1 + r
+            and s.collective_germanium >= 1 + r
+            and s.collective_silicon >= 1 + r
+        )
+
+    def is_satisfied(self, ctx: PlankyContext) -> bool:
+        if ctx.state.heart >= self._min_hearts:
+            return True
+        # Skip if collective can't afford a heart
+        if not self._collective_can_afford_heart(ctx):
+            if ctx.trace:
+                ctx.trace.skip(self.name, "collective lacks resources for heart")
+            return True
+        return False
+
+    def execute(self, ctx: PlankyContext) -> Action:
+        # Find own team's chest
+        pf = {"collective_id": ctx.my_collective_id} if ctx.my_collective_id is not None else None
+        result = ctx.map.find_nearest(ctx.state.position, type_contains="chest", property_filter=pf)
+        if result is None:
+            # Try hub as fallback
+            result = ctx.map.find_nearest(ctx.state.position, type_contains="hub", property_filter=pf)
+        if result is None:
+            return ctx.navigator.explore(ctx.state.position, ctx.map)
+
+        chest_pos, _ = result
+        if ctx.trace:
+            ctx.trace.nav_target = chest_pos
+
+        dist = _manhattan(ctx.state.position, chest_pos)
+        if dist <= 1:
+            return _move_toward(ctx.state.position, chest_pos)
+        return ctx.navigator.get_action(ctx.state.position, chest_pos, ctx.map, reach_adjacent=True)
+
+
+class FallbackMineGoal(Goal):
+    """Fallback: mine resources when combat roles can't act.
+
+    Used at the bottom of aligner/scrambler goal lists so they contribute
+    to the economy instead of idling when they lack gear or hearts.
+    """
+
+    name = "FallbackMine"
+
+    def is_satisfied(self, ctx: PlankyContext) -> bool:
+        from .miner import _collective_resources_sufficient
+
+        # Stop fallback mining when collective is well-stocked
+        if _collective_resources_sufficient(ctx) and ctx.state.cargo_total == 0:
+            return True
+        return False
+
+    def execute(self, ctx: PlankyContext) -> Action:
+        from .miner import RESOURCE_TYPES, _extractor_recently_failed
+
+        # If carrying resources, deposit first
+        if ctx.state.cargo_total > 0:
+            depot_pos = _find_deposit(ctx)
+            if depot_pos is not None:
+                if ctx.trace:
+                    ctx.trace.nav_target = depot_pos
+                dist = _manhattan(ctx.state.position, depot_pos)
+                if dist <= 1:
+                    return _move_toward(ctx.state.position, depot_pos)
+                return ctx.navigator.get_action(ctx.state.position, depot_pos, ctx.map, reach_adjacent=True)
+
+        # Find nearest usable extractor (any resource type)
+        best: tuple[int, tuple[int, int]] | None = None
+        for resource in RESOURCE_TYPES:
+            for pos, e in ctx.map.find(type=f"{resource}_extractor"):
+                if e.properties.get("remaining_uses", 999) <= 0:
+                    continue
+                if e.properties.get("inventory_amount", -1) == 0:
+                    continue
+                if _extractor_recently_failed(ctx, pos):
+                    continue
+                d = _manhattan(ctx.state.position, pos)
+                if best is None or d < best[0]:
+                    best = (d, pos)
+
+        if best is not None:
+            if ctx.trace:
+                ctx.trace.nav_target = best[1]
+            dist = best[0]
+            if dist <= 1:
+                return _move_toward(ctx.state.position, best[1])
+            return ctx.navigator.get_action(ctx.state.position, best[1], ctx.map, reach_adjacent=True)
+
+        # No extractors known — explore
+        return ctx.navigator.explore(
+            ctx.state.position,
+            ctx.map,
+            direction_bias=["north", "east", "south", "west"][ctx.agent_id % 4],
+        )
+
+
+def _find_deposit(ctx: "PlankyContext") -> tuple[int, int] | None:
+    """Find nearest cogs-aligned depot for depositing resources."""
+    pos = ctx.state.position
+    hub_filter = {"collective_id": ctx.my_collective_id} if ctx.my_collective_id is not None else None
+    candidates: list[tuple[int, tuple[int, int]]] = []
+    for apos, _ in ctx.map.find(type_contains="hub", property_filter=hub_filter):
+        candidates.append((_manhattan(pos, apos), apos))
+    for jpos, _ in ctx.map.find(type_contains="junction", property_filter={"alignment": "cogs"}):
+        candidates.append((_manhattan(pos, jpos), jpos))
+    if not candidates:
+        return None
+    candidates.sort()
+    return candidates[0][1]
+
+
+def _move_toward(current: tuple[int, int], target: tuple[int, int]) -> Action:
+    dr = target[0] - current[0]
+    dc = target[1] - current[1]
+    if abs(dr) >= abs(dc):
+        if dr > 0:
+            return Action(name="move_south")
+        elif dr < 0:
+            return Action(name="move_north")
+    if dc > 0:
+        return Action(name="move_east")
+    elif dc < 0:
+        return Action(name="move_west")
+    return Action(name="move_north")

cogames_agents/policy/scripted_agent/planky/goals/stem.py

@@ -0,0 +1,49 @@
+"""Stem goal — select a role based on map and collective state."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from cogames_agents.policy.scripted_agent.planky.goal import Goal
+from mettagrid.simulator import Action
+
+if TYPE_CHECKING:
+    from cogames_agents.policy.scripted_agent.planky.context import PlankyContext
+
+
+class SelectRoleGoal(Goal):
+    """Evaluate map + collective inventory to select a role.
+
+    Once a role is selected, the agent's goal list is replaced with
+    the selected role's goal list. This is a one-time decision.
+    """
+
+    name = "SelectRole"
+
+    def __init__(self, role_goal_lists: dict | None = None) -> None:
+        """
+        Args:
+            role_goal_lists: Deprecated, ignored. Roles are now vibe-driven.
+        """
+        self._selected = False
+
+    def is_satisfied(self, ctx: PlankyContext) -> bool:
+        return self._selected
+
+    def execute(self, ctx: PlankyContext) -> Action:
+        role = self._select_role(ctx)
+        ctx.blackboard["selected_role"] = role
+        ctx.blackboard["change_role"] = role
+        self._selected = True
+
+        if ctx.trace:
+            ctx.trace.activate(self.name, f"selected={role}")
+
+        return Action(name="noop")
+
+    def _select_role(self, ctx: PlankyContext) -> str:
+        """Distribute roles by agent_id: 5 miners, 5 aligners."""
+        agent_id = ctx.agent_id
+        if agent_id < 5:
+            return "miner"
+        return "aligner"

cogames_agents/policy/scripted_agent/planky/goals/survive.py

@@ -0,0 +1,96 @@
+"""SurviveGoal — retreat to safety when HP is critical."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from cogames_agents.policy.scripted_agent.planky.goal import Goal
+from cogames_agents.policy.scripted_agent.planky.navigator import _manhattan
+from mettagrid.simulator import Action
+
+if TYPE_CHECKING:
+    from cogames_agents.policy.scripted_agent.planky.context import PlankyContext
+
+# Game constants
+JUNCTION_AOE_RANGE = 10
+HP_SAFETY_MARGIN = 10
+
+
+class SurviveGoal(Goal):
+    """Retreat to nearest safe zone when HP is low."""
+
+    name = "Survive"
+
+    def __init__(self, hp_threshold: int = 30) -> None:
+        self._hp_threshold = hp_threshold
+
+    def is_satisfied(self, ctx: PlankyContext) -> bool:
+        # If we're in a safe zone, we're fine
+        if _is_in_safe_zone(ctx):
+            return True
+        # If HP is above threshold, we're fine
+        safe_pos = _nearest_safe_zone(ctx)
+        if safe_pos is None:
+            return ctx.state.hp > 20  # No known safe zone, be conservative
+        steps_to_safety = max(0, _manhattan(ctx.state.position, safe_pos) - JUNCTION_AOE_RANGE)
+        hp_needed = steps_to_safety + HP_SAFETY_MARGIN
+        return ctx.state.hp > hp_needed
+
+    def execute(self, ctx: PlankyContext) -> Action:
+        safe_pos = _nearest_safe_zone(ctx)
+        if safe_pos is None:
+            return ctx.navigator.explore(ctx.state.position, ctx.map)
+        if ctx.trace:
+            ctx.trace.nav_target = safe_pos
+        return ctx.navigator.get_action(ctx.state.position, safe_pos, ctx.map, reach_adjacent=True)
+
+
+def _is_in_safe_zone(ctx: PlankyContext) -> bool:
+    """Check if agent is within AOE of any cogs structure."""
+    pos = ctx.state.position
+    # Check hub
+    hubs = ctx.map.find(type="hub")
+    for apos, _ in hubs:
+        if _manhattan(pos, apos) <= JUNCTION_AOE_RANGE:
+            return True
+    # Check cogs junctions
+    junctions = ctx.map.find(type_contains="junction", property_filter={"alignment": "cogs"})
+    for jpos, _ in junctions:
+        if _manhattan(pos, jpos) <= JUNCTION_AOE_RANGE:
+            return True
+    # Check cogs junctions
+    junctions = ctx.map.find(type_contains="junction", property_filter={"alignment": "cogs"})
+    for cpos, _ in junctions:
+        if _manhattan(pos, cpos) <= JUNCTION_AOE_RANGE:
+            return True
+    return False
+
+
+def _is_in_enemy_aoe(ctx: PlankyContext) -> bool:
+    """Check if agent is within AOE of any clips structure."""
+    pos = ctx.state.position
+    for jpos, _ in ctx.map.find(type_contains="junction", property_filter={"alignment": "clips"}):
+        if _manhattan(pos, jpos) <= JUNCTION_AOE_RANGE:
+            return True
+    for cpos, _ in ctx.map.find(type_contains="junction", property_filter={"alignment": "clips"}):
+        if _manhattan(pos, cpos) <= JUNCTION_AOE_RANGE:
+            return True
+    return False
+
+
+def _nearest_safe_zone(ctx: PlankyContext) -> tuple[int, int] | None:
+    """Find nearest cogs-aligned structure."""
+    pos = ctx.state.position
+    candidates: list[tuple[int, tuple[int, int]]] = []
+
+    for apos, _ in ctx.map.find(type="hub"):
+        candidates.append((_manhattan(pos, apos), apos))
+    for jpos, _ in ctx.map.find(type_contains="junction", property_filter={"alignment": "cogs"}):
+        candidates.append((_manhattan(pos, jpos), jpos))
+    for cpos, _ in ctx.map.find(type_contains="junction", property_filter={"alignment": "cogs"}):
+        candidates.append((_manhattan(pos, cpos), cpos))
+
+    if not candidates:
+        return None
+    candidates.sort()
+    return candidates[0][1]

cogames_agents/policy/scripted_agent/planky/navigator.py

@@ -0,0 +1,388 @@
+"""A* navigator for Planky policy."""
+
+from __future__ import annotations
+
+import heapq
+import random
+from typing import TYPE_CHECKING, Optional
+
+from mettagrid.simulator import Action
+
+if TYPE_CHECKING:
+    from .entity_map import EntityMap
+
+MOVE_DELTAS: dict[str, tuple[int, int]] = {
+    "north": (-1, 0),
+    "south": (1, 0),
+    "east": (0, 1),
+    "west": (0, -1),
+}
+
+DIRECTIONS = ["north", "south", "east", "west"]
+
+
+class Navigator:
+    """A* pathfinding over the entity map."""
+
+    def __init__(self) -> None:
+        self._cached_path: Optional[list[tuple[int, int]]] = None
+        self._cached_target: Optional[tuple[int, int]] = None
+        self._cached_reach_adjacent: bool = False
+        self._position_history: list[tuple[int, int]] = []
+
+    def get_action(
+        self,
+        current: tuple[int, int],
+        target: tuple[int, int],
+        map: EntityMap,
+        reach_adjacent: bool = False,
+    ) -> Action:
+        """Navigate from current to target using A*.
+
+        Args:
+            current: Current position
+            target: Target position
+            map: Entity map for pathfinding
+            reach_adjacent: If True, stop adjacent to target
+        """
+        # Track position history for stuck detection
+        self._position_history.append(current)
+        if len(self._position_history) > 30:
+            self._position_history.pop(0)
+
+        # Stuck detection
+        if self._is_stuck():
+            action = self._break_stuck(current, map)
+            if action:
+                return action
+
+        if current == target and not reach_adjacent:
+            return Action(name="noop")
+
+        # Check if adjacent to target (for reach_adjacent mode)
+        if reach_adjacent and _manhattan(current, target) == 1:
+            return Action(name="noop")
+
+        # Get or compute path
+        path = self._get_path(current, target, map, reach_adjacent)
+
+        if not path:
+            # No path found — try exploring toward target
+            return self._move_toward_greedy(current, target, map)
+
+        next_pos = path[0]
+
+        # Check if next position is blocked by agent
+        if map.has_agent(next_pos):
+            sidestep = self._find_sidestep(current, next_pos, target, map)
+            if sidestep:
+                self._cached_path = None
+                return _move_action(current, sidestep)
+            return Action(name="noop")  # Wait for agent to move
+
+        # Advance path
+        self._cached_path = path[1:] if len(path) > 1 else None
+        return _move_action(current, next_pos)
+
+    def explore(
+        self,
+        current: tuple[int, int],
+        map: EntityMap,
+        direction_bias: Optional[str] = None,
+    ) -> Action:
+        """Navigate toward unexplored frontier cells."""
+        self._position_history.append(current)
+        if len(self._position_history) > 30:
+            self._position_history.pop(0)
+
+        if self._is_stuck():
+            action = self._break_stuck(current, map)
+            if action:
+                return action
+
+        frontier = self._find_frontier(current, map, direction_bias)
+        if frontier:
+            return self.get_action(current, frontier, map)
+
+        # No frontier — random walk
+        return self._random_move(current, map)
+
+    def _get_path(
+        self,
+        start: tuple[int, int],
+        target: tuple[int, int],
+        map: EntityMap,
+        reach_adjacent: bool,
+    ) -> Optional[list[tuple[int, int]]]:
+        """Get cached path or compute new one."""
+        if self._cached_path and self._cached_target == target and self._cached_reach_adjacent == reach_adjacent:
+            # Verify path is still valid
+            for pos in self._cached_path:
+                if map.has_agent(pos):
+                    break
+            else:
+                return self._cached_path
+
+        # Compute new path
+        goal_cells = self._compute_goals(target, map, reach_adjacent)
+        if not goal_cells:
+            return None
+
+        # Try known terrain first
+        path = self._astar(start, goal_cells, map, allow_unknown=False)
+        if not path:
+            # Allow unknown cells
+            path = self._astar(start, goal_cells, map, allow_unknown=True)
+
+        self._cached_path = path.copy() if path else None
+        self._cached_target = target
+        self._cached_reach_adjacent = reach_adjacent
+        return path
+
+    def _compute_goals(
+        self,
+        target: tuple[int, int],
+        map: EntityMap,
+        reach_adjacent: bool,
+    ) -> list[tuple[int, int]]:
+        if not reach_adjacent:
+            return [target]
+        goals = []
+        for dr, dc in MOVE_DELTAS.values():
+            nr, nc = target[0] + dr, target[1] + dc
+            pos = (nr, nc)
+            if self._is_traversable(pos, map, allow_unknown=True):
+                goals.append(pos)
+        return goals
+
+    def _astar(
+        self,
+        start: tuple[int, int],
+        goals: list[tuple[int, int]],
+        map: EntityMap,
+        allow_unknown: bool,
+    ) -> list[tuple[int, int]]:
+        """A* pathfinding with iteration limit to prevent hanging."""
+        goal_set = set(goals)
+        if not goals:
+            return []
+
+        def h(pos: tuple[int, int]) -> int:
+            return min(_manhattan(pos, g) for g in goals)
+
+        tie = 0
+        iterations = 0
+        max_iterations = 5000  # Prevent infinite search on large unknown maps
+
+        open_set: list[tuple[int, int, tuple[int, int]]] = [(h(start), tie, start)]
+        came_from: dict[tuple[int, int], Optional[tuple[int, int]]] = {start: None}
+        g_score: dict[tuple[int, int], int] = {start: 0}
+
+        while open_set and iterations < max_iterations:
+            iterations += 1
+            _, _, current = heapq.heappop(open_set)
+
+            if current in goal_set:
+                return self._reconstruct(came_from, current)
+
+            current_g = g_score.get(current, float("inf"))
+            if isinstance(current_g, float):
+                continue
+
+            for dr, dc in MOVE_DELTAS.values():
+                neighbor = (current[0] + dr, current[1] + dc)
+                is_goal = neighbor in goal_set
+                if not is_goal and not self._is_traversable(neighbor, map, allow_unknown):
+                    continue
+
+                tentative_g = current_g + 1
+                if tentative_g < g_score.get(neighbor, float("inf")):
+                    came_from[neighbor] = current
+                    g_score[neighbor] = tentative_g
+                    f = tentative_g + h(neighbor)
+                    tie += 1
+                    heapq.heappush(open_set, (f, tie, neighbor))
+
+        return []
+
+    def _reconstruct(
+        self,
+        came_from: dict[tuple[int, int], Optional[tuple[int, int]]],
+        current: tuple[int, int],
+    ) -> list[tuple[int, int]]:
+        path = []
+        while came_from[current] is not None:
+            path.append(current)
+            prev = came_from[current]
+            assert prev is not None
+            current = prev
+        path.reverse()
+        return path
+
+    def _is_traversable(
+        self,
+        pos: tuple[int, int],
+        map: EntityMap,
+        allow_unknown: bool = False,
+    ) -> bool:
+        """Check if a cell can be walked through."""
+        if map.is_wall(pos) or map.is_structure(pos):
+            return False
+        if map.has_agent(pos):
+            return False
+        if pos in map.explored:
+            return pos not in map.entities or map.entities[pos].type == "agent"
+        # Unknown cell
+        return allow_unknown
+
+    def _find_frontier(
+        self,
+        from_pos: tuple[int, int],
+        map: EntityMap,
+        direction_bias: Optional[str] = None,
+    ) -> Optional[tuple[int, int]]:
+        """BFS to find nearest unexplored cell adjacent to explored free cell."""
+        from collections import deque
+
+        if direction_bias == "north":
+            deltas = [(-1, 0), (0, -1), (0, 1), (1, 0)]
+        elif direction_bias == "south":
+            deltas = [(1, 0), (0, -1), (0, 1), (-1, 0)]
+        elif direction_bias == "east":
+            deltas = [(0, 1), (-1, 0), (1, 0), (0, -1)]
+        elif direction_bias == "west":
+            deltas = [(0, -1), (-1, 0), (1, 0), (0, 1)]
+        else:
+            deltas = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+
+        visited: set[tuple[int, int]] = {from_pos}
+        queue: deque[tuple[int, int, int]] = deque([(from_pos[0], from_pos[1], 0)])
+
+        while queue:
+            r, c, dist = queue.popleft()
+            if dist > 50:
+                continue
+
+            for dr, dc in deltas:
+                nr, nc = r + dr, c + dc
+                pos = (nr, nc)
+                if pos in visited:
+                    continue
+                visited.add(pos)
+
+                if pos not in map.explored:
+                    # Check if any neighbor is explored and free
+                    for dr2, dc2 in deltas:
+                        adj = (nr + dr2, nc + dc2)
+                        if adj in map.explored and map.is_free(adj):
+                            return pos
+                    continue
+
+                if map.is_free(pos):
+                    queue.append((nr, nc, dist + 1))
+
+        return None
+
+    def _find_sidestep(
+        self,
+        current: tuple[int, int],
+        blocked: tuple[int, int],
+        target: tuple[int, int],
+        map: EntityMap,
+    ) -> Optional[tuple[int, int]]:
+        """Find sidestep around blocking agent."""
+        current_dist = _manhattan(current, target)
+        candidates = []
+        for d in DIRECTIONS:
+            dr, dc = MOVE_DELTAS[d]
+            pos = (current[0] + dr, current[1] + dc)
+            if pos == blocked:
+                continue
+            if not self._is_traversable(pos, map, allow_unknown=True):
+                continue
+            new_dist = _manhattan(pos, target)
+            score = new_dist - current_dist
+            candidates.append((score, pos))
+
+        if not candidates:
+            return None
+        candidates.sort()
+        if candidates[0][0] <= 2:
+            return candidates[0][1]
+        return None
+
+    def _is_stuck(self) -> bool:
+        history = self._position_history
+        if len(history) < 6:
+            return False
+        recent = history[-6:]
+        if len(set(recent)) <= 2:
+            return True
+        if len(history) >= 20:
+            current = history[-1]
+            earlier = history[:-10]
+            if earlier.count(current) >= 2:
+                return True
+        return False
+
+    def _break_stuck(self, current: tuple[int, int], map: EntityMap) -> Optional[Action]:
+        self._cached_path = None
+        self._cached_target = None
+        self._position_history.clear()
+        return self._random_move(current, map)
+
+    def _random_move(self, current: tuple[int, int], map: EntityMap) -> Action:
+        dirs = list(DIRECTIONS)
+        random.shuffle(dirs)
+        for d in dirs:
+            dr, dc = MOVE_DELTAS[d]
+            pos = (current[0] + dr, current[1] + dc)
+            if pos in map.explored and not map.is_wall(pos) and not map.is_structure(pos):
+                return Action(name=f"move_{d}")
+        # Try unknown cells
+        for d in dirs:
+            dr, dc = MOVE_DELTAS[d]
+            pos = (current[0] + dr, current[1] + dc)
+            if not map.is_wall(pos):
+                return Action(name=f"move_{d}")
+        return Action(name="noop")
+
+    def _move_toward_greedy(self, current: tuple[int, int], target: tuple[int, int], map: EntityMap) -> Action:
+        """Move greedily toward target without pathfinding."""
+        dr = target[0] - current[0]
+        dc = target[1] - current[1]
+
+        # Try primary direction
+        if abs(dr) >= abs(dc):
+            primary = "south" if dr > 0 else "north"
+            secondary = "east" if dc > 0 else "west"
+        else:
+            primary = "east" if dc > 0 else "west"
+            secondary = "south" if dr > 0 else "north"
+
+        for d in [primary, secondary]:
+            ddr, ddc = MOVE_DELTAS[d]
+            pos = (current[0] + ddr, current[1] + ddc)
+            if not map.is_wall(pos) and not map.is_structure(pos) and not map.has_agent(pos):
+                return Action(name=f"move_{d}")
+
+        return self._random_move(current, map)
+
+
+def _manhattan(a: tuple[int, int], b: tuple[int, int]) -> int:
+    return abs(a[0] - b[0]) + abs(a[1] - b[1])
+
+
+def _move_action(current: tuple[int, int], target: tuple[int, int]) -> Action:
+    """Return move action from current to adjacent target."""
+    dr = target[0] - current[0]
+    dc = target[1] - current[1]
+    if dr == -1 and dc == 0:
+        return Action(name="move_north")
+    if dr == 1 and dc == 0:
+        return Action(name="move_south")
+    if dr == 0 and dc == 1:
+        return Action(name="move_east")
+    if dr == 0 and dc == -1:
+        return Action(name="move_west")
+    return Action(name="noop")