cogames-agents 0.0.0.7__cp312-cp312-macosx_11_0_arm64.whl

cogames_agents/policy/scripted_agent/cogas/__init__.py

@@ -0,0 +1,5 @@
+"""Cogas policy - goal-tree scripted agent."""
+
+from .policy import CogasPolicy
+
+__all__ = ["CogasPolicy"]

cogames_agents/policy/scripted_agent/cogas/context.py

@@ -0,0 +1,68 @@
+"""Context and state snapshot for Cogas policy."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Optional
+
+if TYPE_CHECKING:
+    from .entity_map import EntityMap
+    from .navigator import Navigator
+    from .trace import TraceLog
+
+
+@dataclass
+class StateSnapshot:
+    """Rebuilt every tick from observation tokens. Observation is source of truth."""
+
+    position: tuple[int, int] = (0, 0)
+
+    # Inventory
+    carbon: int = 0
+    oxygen: int = 0
+    germanium: int = 0
+    silicon: int = 0
+    heart: int = 0
+    influence: int = 0
+    hp: int = 100
+    energy: int = 100
+
+    # Gear flags
+    miner_gear: bool = False
+    scout_gear: bool = False
+    aligner_gear: bool = False
+    scrambler_gear: bool = False
+
+    # Vibe
+    vibe: str = "default"
+
+    # Collective inventory
+    collective_carbon: int = 0
+    collective_oxygen: int = 0
+    collective_germanium: int = 0
+    collective_silicon: int = 0
+    collective_heart: int = 0
+    collective_influence: int = 0
+
+    @property
+    def cargo_total(self) -> int:
+        return self.carbon + self.oxygen + self.germanium + self.silicon
+
+    @property
+    def cargo_capacity(self) -> int:
+        return 40 if self.miner_gear else 4
+
+
+@dataclass
+class CogasContext:
+    """Passed to all goals, bundles everything needed for decision-making."""
+
+    state: StateSnapshot
+    map: EntityMap
+    blackboard: dict[str, Any]
+    navigator: Navigator
+    trace: Optional[TraceLog]
+    action_names: list[str]
+    agent_id: int
+    step: int
+    my_collective_id: Optional[int] = None

cogames_agents/policy/scripted_agent/cogas/entity_map.py

@@ -0,0 +1,152 @@
+"""Sparse entity map for Cogas policy."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class Entity:
+    """An object on the map."""
+
+    type: str  # e.g. "carbon_extractor", "miner_station", "wall", "agent"
+    properties: dict  # alignment, remaining_uses, inventory_amount, cooldown, etc.
+    last_seen: int = 0
+
+
+class EntityMap:
+    """Sparse map of entities. Only stores non-empty cells."""
+
+    def __init__(self) -> None:
+        self.entities: dict[tuple[int, int], Entity] = {}
+        self.explored: set[tuple[int, int]] = set()
+
+    def update_from_observation(
+        self,
+        agent_pos: tuple[int, int],
+        obs_half_height: int,
+        obs_half_width: int,
+        visible_entities: dict[tuple[int, int], Entity],
+        step: int,
+    ) -> None:
+        """Update map from current observation window.
+
+        All cells in the observation window are marked as explored.
+        Entities in the window are overwritten with fresh data.
+        Entities no longer visible in the window are removed.
+        """
+        # Mark all cells in observation window as explored
+        for obs_r in range(2 * obs_half_height + 1):
+            for obs_c in range(2 * obs_half_width + 1):
+                r = obs_r - obs_half_height + agent_pos[0]
+                c = obs_c - obs_half_width + agent_pos[1]
+                self.explored.add((r, c))
+
+        # Remove entities in observation window that are no longer visible
+        window_min_r = agent_pos[0] - obs_half_height
+        window_max_r = agent_pos[0] + obs_half_height
+        window_min_c = agent_pos[1] - obs_half_width
+        window_max_c = agent_pos[1] + obs_half_width
+
+        to_remove = []
+        for pos in self.entities:
+            if window_min_r <= pos[0] <= window_max_r and window_min_c <= pos[1] <= window_max_c:
+                if pos not in visible_entities:
+                    to_remove.append(pos)
+        for pos in to_remove:
+            del self.entities[pos]
+
+        # Add/update visible entities
+        for pos, entity in visible_entities.items():
+            entity.last_seen = step
+            self.entities[pos] = entity
+
+    def find(
+        self,
+        type: Optional[str] = None,
+        type_contains: Optional[str] = None,
+        property_filter: Optional[dict] = None,
+    ) -> list[tuple[tuple[int, int], Entity]]:
+        """Query entities by type and/or properties.
+
+        Args:
+            type: Exact type match
+            type_contains: Substring match on type
+            property_filter: Dict of property key-value pairs that must match
+        """
+        results = []
+        for pos, entity in self.entities.items():
+            if type is not None and entity.type != type:
+                continue
+            if type_contains is not None and type_contains not in entity.type:
+                continue
+            if property_filter is not None:
+                match = all(entity.properties.get(k) == v for k, v in property_filter.items())
+                if not match:
+                    continue
+            results.append((pos, entity))
+        return results
+
+    def find_nearest(
+        self,
+        from_pos: tuple[int, int],
+        type: Optional[str] = None,
+        type_contains: Optional[str] = None,
+        property_filter: Optional[dict] = None,
+        max_dist: Optional[int] = None,
+    ) -> Optional[tuple[tuple[int, int], Entity]]:
+        """Find nearest entity matching criteria."""
+        matches = self.find(type=type, type_contains=type_contains, property_filter=property_filter)
+        if not matches:
+            return None
+
+        best = None
+        best_dist = float("inf")
+        for pos, entity in matches:
+            dist = abs(pos[0] - from_pos[0]) + abs(pos[1] - from_pos[1])
+            if max_dist is not None and dist > max_dist:
+                continue
+            if dist < best_dist:
+                best = (pos, entity)
+                best_dist = dist
+        return best
+
+    def is_passable(self, pos: tuple[int, int]) -> bool:
+        """Check if a position is passable (explored and not a wall/obstacle)."""
+        if pos not in self.explored:
+            return False
+        entity = self.entities.get(pos)
+        if entity is None:
+            return True  # Explored empty cell
+        # Agents are temporary obstacles, everything else is permanent
+        if entity.type == "agent":
+            return False
+        # Walls are obstacles
+        if entity.type == "wall":
+            return False
+        # Structures are obstacles (stations, extractors, junctions, etc.)
+        # But we don't block pathfinding through them — goals that need adjacency
+        # handle that via reach_adjacent=True
+        return True  # Structures are passable for pathfinding
+
+    def is_wall(self, pos: tuple[int, int]) -> bool:
+        """Check if position is a wall."""
+        entity = self.entities.get(pos)
+        return entity is not None and entity.type == "wall"
+
+    def is_structure(self, pos: tuple[int, int]) -> bool:
+        """Check if position has a structure (non-wall, non-agent entity)."""
+        entity = self.entities.get(pos)
+        if entity is None:
+            return False
+        return entity.type not in ("wall", "agent")
+
+    def is_free(self, pos: tuple[int, int]) -> bool:
+        """Check if position is explored and has no entity."""
+        return pos in self.explored and pos not in self.entities
+
+    def has_agent(self, pos: tuple[int, int]) -> bool:
+        """Check if position has an agent."""
+        entity = self.entities.get(pos)
+        return entity is not None and entity.type == "agent"

cogames_agents/policy/scripted_agent/cogas/goal.py

@@ -0,0 +1,115 @@
+"""Goal base class and evaluation logic for Cogas policy."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from mettagrid.simulator import Action
+
+if TYPE_CHECKING:
+    from .context import CogasContext
+
+
+class Goal:
+    """Base class for all goals in the goal tree.
+
+    Subclasses implement:
+    - is_satisfied(ctx) -> bool: whether this goal is already met
+    - preconditions() -> list[Goal]: sub-goals that must be satisfied first
+    - execute(ctx) -> Action | None: produce an action, or None to skip/defer
+    """
+
+    name: str = "Goal"
+
+    def is_satisfied(self, ctx: CogasContext) -> bool:
+        """Check if this goal is already satisfied."""
+        return False
+
+    def preconditions(self) -> list[Goal]:
+        """Return sub-goals that must be satisfied before this goal can execute."""
+        return []
+
+    def execute(self, ctx: CogasContext) -> Optional[Action]:
+        """Produce an action to work toward this goal, or None to skip."""
+        return Action(name="noop")
+
+
+def evaluate_goals(goals: list[Goal], ctx: CogasContext) -> Action:
+    """Evaluate a priority-ordered goal list and return an action.
+
+    Walks the list top-down. The first unsatisfied goal becomes active.
+    Recursively checks preconditions to find the deepest unsatisfied leaf.
+    That leaf's execute() produces the action.
+
+    If execute() returns None, the goal is skipped and evaluation continues
+    with the next goal (allows goals to voluntarily defer).
+    """
+    for goal in goals:
+        if goal.is_satisfied(ctx):
+            if ctx.trace:
+                ctx.trace.skip(goal.name, _satisfaction_detail(goal, ctx))
+            continue
+
+        # Found unsatisfied goal — recurse into preconditions
+        leaf = _deepest_unsatisfied(goal, ctx)
+        action = leaf.execute(ctx)
+
+        # None means "skip me for now" — continue to next goal
+        if action is None:
+            if ctx.trace:
+                ctx.trace.skip(leaf.name, "deferred")
+            continue
+
+        if ctx.trace:
+            ctx.trace.active_goal_chain = _build_chain(goal, leaf)
+            ctx.trace.action_name = action.name
+
+        return action
+
+    # All goals satisfied - explore as fallback instead of nooping
+    if ctx.trace:
+        ctx.trace.active_goal_chain = "AllGoalsSatisfied"
+    directions = ["north", "east", "south", "west"]
+    return ctx.navigator.explore(
+        ctx.state.position,
+        ctx.map,
+        direction_bias=directions[ctx.agent_id % 4],
+    )
+
+
+def _deepest_unsatisfied(goal: Goal, ctx: CogasContext) -> Goal:
+    """Find the deepest unsatisfied precondition in the goal tree."""
+    for pre in goal.preconditions():
+        if not pre.is_satisfied(ctx):
+            if ctx.trace:
+                ctx.trace.activate(pre.name)
+            return _deepest_unsatisfied(pre, ctx)
+    return goal
+
+
+def _build_chain(root: Goal, leaf: Goal) -> str:
+    """Build a display chain like 'MineCarbon>BeNearExtractor'."""
+    if root is leaf:
+        return root.name
+    # Walk preconditions to find the path
+    chain = [root.name]
+    _find_path(root, leaf, chain)
+    return ">".join(chain)
+
+
+def _find_path(current: Goal, target: Goal, chain: list[str]) -> bool:
+    """DFS to find path from current to target goal."""
+    for pre in current.preconditions():
+        if pre is target:
+            chain.append(pre.name)
+            return True
+        chain.append(pre.name)
+        if _find_path(pre, target, chain):
+            return True
+        chain.pop()
+    return False
+
+
+def _satisfaction_detail(goal: Goal, ctx: CogasContext) -> str:
+    """Generate a short detail string for why a goal is satisfied."""
+    return "ok"

cogames_agents/policy/scripted_agent/cogas/goals/__init__.py

@@ -0,0 +1,27 @@
+"""Goal classes for Cogas policy."""
+
+from .aligner import AlignJunctionGoal, GetAlignerGearGoal
+from .gear import GetGearGoal
+from .miner import DepositCargoGoal, GetMinerGearGoal, MineResourceGoal, PickResourceGoal
+from .scout import ExploreGoal, GetScoutGearGoal
+from .scrambler import GetScramblerGearGoal, ScrambleJunctionGoal
+from .shared import GetHeartsGoal
+from .stem import SelectRoleGoal
+from .survive import SurviveGoal
+
+__all__ = [
+    "SurviveGoal",
+    "GetGearGoal",
+    "GetAlignerGearGoal",
+    "GetMinerGearGoal",
+    "GetScoutGearGoal",
+    "GetScramblerGearGoal",
+    "GetHeartsGoal",
+    "PickResourceGoal",
+    "DepositCargoGoal",
+    "MineResourceGoal",
+    "ExploreGoal",
+    "AlignJunctionGoal",
+    "ScrambleJunctionGoal",
+    "SelectRoleGoal",
+]

cogames_agents/policy/scripted_agent/cogas/goals/aligner.py

@@ -0,0 +1,160 @@
+"""Aligner goals — align neutral junctions."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from cogames_agents.policy.scripted_agent.cogas.goal import Goal
+from cogames_agents.policy.scripted_agent.cogas.navigator import _manhattan
+from mettagrid.simulator import Action
+
+from .gear import GetGearGoal
+
+if TYPE_CHECKING:
+    from cogames_agents.policy.scripted_agent.cogas.context import CogasContext
+
+JUNCTION_AOE_RANGE = 10
+
+
+class GetAlignerGearGoal(GetGearGoal):
+    """Get aligner gear (costs C3 O1 G1 S1 from collective)."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            gear_attr="aligner_gear",
+            station_type="aligner_station",
+            goal_name="GetAlignerGear",
+            gear_cost={"carbon": 3, "oxygen": 1, "germanium": 1, "silicon": 1},
+        )
+
+
+class AlignJunctionGoal(Goal):
+    """Find and align a neutral junction to cogs.
+
+    Tracks attempts per junction to avoid getting stuck on one that
+    can't be captured (e.g., already aligned but map hasn't updated).
+    """
+
+    name = "AlignJunction"
+    MAX_ATTEMPTS_PER_TARGET = 15  # Increased from 5 - 55% move fail needs more attempts
+    MAX_NAV_STEPS_PER_TARGET = 80  # Increased from 40 - give more time to navigate
+    COOLDOWN_STEPS = 30  # Reduced from 50 - try junctions again sooner
+
+    def is_satisfied(self, ctx: CogasContext) -> bool:
+        # Can't align without gear and a heart
+        if not ctx.state.aligner_gear:
+            if ctx.trace:
+                ctx.trace.skip(self.name, "no gear")
+            return True
+        if ctx.state.heart < 1:
+            if ctx.trace:
+                ctx.trace.skip(self.name, "no heart")
+            return True
+        return False
+
+    def execute(self, ctx: CogasContext) -> Optional[Action]:
+        nav_key = "_align_nav_steps"
+        nav_target_key = "_align_nav_target"
+        nav_steps = ctx.blackboard.get(nav_key, 0) + 1
+        ctx.blackboard[nav_key] = nav_steps
+
+        target = self._find_best_target(ctx)
+        if target is None:
+            ctx.blackboard[nav_key] = 0
+            return ctx.navigator.explore(
+                ctx.state.position,
+                ctx.map,
+                direction_bias=["north", "east", "south", "west"][ctx.agent_id % 4],
+            )
+
+        # Reset nav counter if target changed
+        prev_target = ctx.blackboard.get(nav_target_key)
+        if prev_target != target:
+            ctx.blackboard[nav_key] = 0
+            nav_steps = 0
+        ctx.blackboard[nav_target_key] = target
+
+        # Nav timeout — mark target as failed
+        if nav_steps > self.MAX_NAV_STEPS_PER_TARGET:
+            failed_key = f"align_failed_{target}"
+            ctx.blackboard[failed_key] = ctx.step
+            ctx.blackboard[nav_key] = 0
+            if ctx.trace:
+                ctx.trace.activate(self.name, f"nav timeout on {target}")
+            return ctx.navigator.explore(
+                ctx.state.position,
+                ctx.map,
+                direction_bias=["north", "east", "south", "west"][ctx.agent_id % 4],
+            )
+
+        if ctx.trace:
+            ctx.trace.nav_target = target
+
+        dist = _manhattan(ctx.state.position, target)
+        if dist <= 1:
+            # Track attempts on this specific junction
+            attempts_key = f"align_attempts_{target}"
+            attempts = ctx.blackboard.get(attempts_key, 0) + 1
+            ctx.blackboard[attempts_key] = attempts
+
+            if attempts > self.MAX_ATTEMPTS_PER_TARGET:
+                # Mark this junction as failed temporarily
+                failed_key = f"align_failed_{target}"
+                ctx.blackboard[failed_key] = ctx.step
+                ctx.blackboard[attempts_key] = 0
+                if ctx.trace:
+                    ctx.trace.activate(self.name, f"giving up on {target}")
+                # Clear and try a different junction next tick
+                return ctx.navigator.explore(
+                    ctx.state.position,
+                    ctx.map,
+                    direction_bias=["north", "east", "south", "west"][ctx.agent_id % 4],
+                )
+
+            if ctx.trace:
+                ctx.trace.activate(self.name, f"bump {attempts}/{self.MAX_ATTEMPTS_PER_TARGET}")
+            return _move_toward(ctx.state.position, target)
+
+        # Not adjacent - reset attempts for this target
+        attempts_key = f"align_attempts_{target}"
+        ctx.blackboard[attempts_key] = 0
+        return ctx.navigator.get_action(ctx.state.position, target, ctx.map, reach_adjacent=True)
+
+    def _find_best_target(self, ctx: CogasContext) -> tuple[int, int] | None:
+        """Find nearest neutral junction, including contested ones."""
+        pos = ctx.state.position
+
+        def recently_failed(p: tuple[int, int]) -> bool:
+            failed_step = ctx.blackboard.get(f"align_failed_{p}", -9999)
+            return ctx.step - failed_step < self.COOLDOWN_STEPS
+
+        # Find neutral junctions (no AOE filter — aligners go where needed)
+        candidates: list[tuple[int, tuple[int, int]]] = []
+
+        for jpos, e in ctx.map.find(type_contains="junction"):
+            alignment = e.properties.get("alignment")
+            if alignment is not None:
+                continue  # Not neutral
+            if recently_failed(jpos):
+                continue
+            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")