cogames-agents 0.0.0.7__cp312-cp312-macosx_11_0_arm64.whl

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

@@ -0,0 +1,174 @@
+"""Scrambler goals — neutralize enemy 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 GetScramblerGearGoal(GetGearGoal):
+    """Get scrambler gear (costs C1 O3 G1 S1 from collective)."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            gear_attr="scrambler_gear",
+            station_type="scrambler_station",
+            goal_name="GetScramblerGear",
+            gear_cost={"carbon": 1, "oxygen": 3, "germanium": 1, "silicon": 1},
+        )
+
+
+class ScrambleJunctionGoal(Goal):
+    """Find and scramble enemy (clips) junctions.
+
+    Tracks attempts per junction to avoid getting stuck.
+    """
+
+    name = "ScrambleJunction"
+    MAX_ATTEMPTS_PER_TARGET = 5
+    MAX_NAV_STEPS_PER_TARGET = 40  # Give up navigating to a target after this many steps
+    COOLDOWN_STEPS = 50
+
+    def is_satisfied(self, ctx: CogasContext) -> bool:
+        # Can't scramble without gear and a heart
+        if not ctx.state.scrambler_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]:
+        # Track navigation steps toward current target to detect stuck
+        nav_key = "_scramble_nav_steps"
+        nav_target_key = "_scramble_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
+
+        # If we've been navigating too long, mark target as failed
+        if nav_steps > self.MAX_NAV_STEPS_PER_TARGET:
+            failed_key = f"scramble_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"scramble_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"scramble_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}")
+                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"scramble_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 enemy junction to scramble, prioritized by blocking count."""
+        pos = ctx.state.position
+
+        def recently_failed(p: tuple[int, int]) -> bool:
+            failed_step = ctx.blackboard.get(f"scramble_failed_{p}", -9999)
+            return ctx.step - failed_step < self.COOLDOWN_STEPS
+
+        # Get clips junctions
+        enemy: list[tuple[tuple[int, int], dict]] = []
+        for jpos, e in ctx.map.find(type_contains="junction", property_filter={"alignment": "clips"}):
+            if not recently_failed(jpos):
+                enemy.append((jpos, e.properties))
+        for cpos, e in ctx.map.find(type_contains="junction", property_filter={"alignment": "clips"}):
+            if not recently_failed(cpos):
+                enemy.append((cpos, e.properties))
+
+        if not enemy:
+            return None
+
+        # Get neutral junctions for scoring
+        neutral_positions: list[tuple[int, int]] = []
+        for jpos, e in ctx.map.find(type_contains="junction"):
+            if e.properties.get("alignment") is None:
+                neutral_positions.append(jpos)
+        for cpos, e in ctx.map.find(type_contains="junction"):
+            if e.properties.get("alignment") is None:
+                neutral_positions.append(cpos)
+
+        # Score by: how many neutrals this enemy blocks, then by distance
+        scored: list[tuple[int, int, tuple[int, int]]] = []
+        for epos, _ in enemy:
+            blocked = sum(1 for np in neutral_positions if _manhattan(epos, np) <= JUNCTION_AOE_RANGE)
+            dist = _manhattan(pos, epos)
+            scored.append((-blocked, dist, epos))  # Negative blocked for descending sort
+
+        scored.sort()
+        return scored[0][2]
+
+
+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/cogas/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.cogas.goal import Goal
+from cogames_agents.policy.scripted_agent.cogas.navigator import _manhattan
+from mettagrid.simulator import Action
+
+if TYPE_CHECKING:
+    from cogames_agents.policy.scripted_agent.cogas.context import CogasContext
+
+
+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
+    # Reduced from 3 to 1 to allow earlier heart acquisition
+    RESOURCE_RESERVE = 1
+
+    def _collective_can_afford_heart(self, ctx: CogasContext) -> 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: CogasContext) -> 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: CogasContext) -> 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.
+
+    NEVER satisfied - always provides something to do rather than noop.
+    """
+
+    name = "FallbackMine"
+
+    def is_satisfied(self, ctx: CogasContext) -> bool:
+        # Never satisfied - always mine/explore as fallback to avoid noops
+        # This ensures aligners/scramblers always have productive work
+        return False
+
+    def execute(self, ctx: CogasContext) -> 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: "CogasContext") -> 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/cogas/goals/stem.py

@@ -0,0 +1,60 @@
+"""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.cogas.goal import Goal
+from mettagrid.simulator import Action
+
+if TYPE_CHECKING:
+    from cogames_agents.policy.scripted_agent.cogas.context import CogasContext
+
+
+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: CogasContext) -> bool:
+        return self._selected
+
+    def execute(self, ctx: CogasContext) -> 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 change_vibe action to immediately start the new role
+        return Action(name=f"change_vibe_{role}")
+
+    def _select_role(self, ctx: CogasContext) -> str:
+        """Distribute roles to match planky's defaults: 3 miners + 5 aligners.
+
+        For small teams, prioritize mining since resources are needed for hearts.
+        Uses planky's exact distribution pattern, tiled across agent IDs.
+        """
+        agent_id = ctx.agent_id
+
+        # Planky's default pattern: [miner, miner, miner, aligner, aligner, aligner, aligner, aligner]
+        # Index into this pattern based on agent_id
+        planky_pattern_size = 8  # 3 miners + 5 aligners
+        pattern_index = agent_id % planky_pattern_size
+
+        if pattern_index < 3:
+            return "miner"
+        return "aligner"

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

@@ -0,0 +1,100 @@
+"""SurviveGoal — retreat to safety when HP is critical."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from cogames_agents.policy.scripted_agent.cogas.goal import Goal
+from cogames_agents.policy.scripted_agent.cogas.navigator import _manhattan, _move_action
+from mettagrid.simulator import Action
+
+if TYPE_CHECKING:
+    from cogames_agents.policy.scripted_agent.cogas.context import CogasContext
+
+# 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: CogasContext) -> 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: CogasContext) -> 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
+        # Check dist to avoid navigator returning noop
+        dist = _manhattan(ctx.state.position, safe_pos)
+        if dist <= 1:
+            return _move_action(ctx.state.position, safe_pos)
+        return ctx.navigator.get_action(ctx.state.position, safe_pos, ctx.map, reach_adjacent=True)
+
+
+def _is_in_safe_zone(ctx: CogasContext) -> 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: CogasContext) -> 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: CogasContext) -> 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]