cogames-agents 0.0.0.7__cp312-cp312-macosx_11_0_arm64.whl

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

@@ -0,0 +1,197 @@
+"""GetGearGoal — navigate to a station to acquire gear."""
+
+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
+
+if TYPE_CHECKING:
+    from cogames_agents.policy.scripted_agent.cogas.context import CogasContext
+
+
+class GetGearGoal(Goal):
+    """Navigate to a station to acquire gear for a role.
+
+    If the team lacks resources to produce gear, the station won't give any.
+    Checks collective resources before attempting, to avoid wasting time bumping
+    a station that can't dispense gear.
+    """
+
+    # How many bump attempts at dist=1 before exploring for another route
+    MAX_BUMPS_AT_STATION = 5
+    # How many total steps trying to get gear before giving up temporarily
+    MAX_TOTAL_ATTEMPTS = 80
+    # How many steps to wait before trying again
+    RETRY_INTERVAL = 150
+
+    def __init__(
+        self,
+        gear_attr: str,
+        station_type: str,
+        goal_name: str,
+        gear_cost: dict[str, int] | None = None,
+    ) -> None:
+        self.name = goal_name
+        self._gear_attr = gear_attr  # e.g. "miner_gear"
+        self._station_type = station_type  # e.g. "miner_station"
+        self._gear_cost = gear_cost or {}
+        self._bb_attempts_key = f"{goal_name}_total_attempts"
+        self._bb_giveup_step_key = f"{goal_name}_giveup_step"
+        self._bb_bump_count_key = f"{goal_name}_bump_count"
+        self._bb_last_dist_key = f"{goal_name}_last_dist"
+
+    # Minimum collective resource reserve — don't consume below this level
+    # Reduced from 3 to 1 for faster gear acquisition
+    RESOURCE_RESERVE = 1
+
+    def _collective_can_afford(self, ctx: CogasContext) -> bool:
+        """Check if the collective can afford gear while maintaining reserves."""
+        if not self._gear_cost:
+            return True
+        s = ctx.state
+        collective = {
+            "carbon": s.collective_carbon,
+            "oxygen": s.collective_oxygen,
+            "germanium": s.collective_germanium,
+            "silicon": s.collective_silicon,
+        }
+        # Must have cost + reserve for each resource
+        return all(collective.get(res, 0) >= amt + self.RESOURCE_RESERVE for res, amt in self._gear_cost.items())
+
+    def _get_hub_center(self, ctx: CogasContext) -> tuple[int, int]:
+        """Find hub center from observations, falling back to current position."""
+        # Check if we already cached the hub position
+        cached_hub = ctx.blackboard.get("_hub_center")
+        if cached_hub is not None:
+            return cached_hub
+
+        # Try to find hub from entity map
+        pf = {"collective_id": ctx.my_collective_id} if ctx.my_collective_id is not None else None
+        hub = ctx.map.find_nearest(ctx.state.position, type_contains="hub", property_filter=pf)
+        if hub is not None:
+            hub_pos, _ = hub
+            ctx.blackboard["_hub_center"] = hub_pos
+            return hub_pos
+
+        # Fall back to current position if hub not visible yet
+        return ctx.state.position
+
+    def is_satisfied(self, ctx: CogasContext) -> bool:
+        # Satisfied if we have the gear
+        if getattr(ctx.state, self._gear_attr, False):
+            # Got gear - reset attempts for next time
+            ctx.blackboard[self._bb_attempts_key] = 0
+            ctx.blackboard[self._bb_bump_count_key] = 0
+            return True
+        # Also "satisfied" (skip) if we gave up recently
+        giveup_step = ctx.blackboard.get(self._bb_giveup_step_key, -9999)
+        if ctx.step - giveup_step < self.RETRY_INTERVAL:
+            return True
+        # Skip if collective can't afford this gear
+        if not self._collective_can_afford(ctx):
+            if ctx.trace:
+                ctx.trace.skip(self.name, "collective lacks resources")
+            return True
+        return False
+
+    def execute(self, ctx: CogasContext) -> Optional[Action]:
+        # Track total attempts regardless of distance
+        attempts = ctx.blackboard.get(self._bb_attempts_key, 0) + 1
+        ctx.blackboard[self._bb_attempts_key] = attempts
+
+        if attempts > self.MAX_TOTAL_ATTEMPTS:
+            # Give up - team probably lacks resources or station unreachable
+            ctx.blackboard[self._bb_giveup_step_key] = ctx.step
+            ctx.blackboard[self._bb_attempts_key] = 0
+            ctx.blackboard[self._bb_bump_count_key] = 0
+            if ctx.trace:
+                ctx.trace.activate(self.name, "giving up after max attempts")
+            return None  # Skip to next goal
+
+        # Find station by type (filter to own team if known)
+        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=self._station_type, property_filter=pf)
+        if result is None:
+            # Station not discovered yet — navigate toward hub where stations are
+            hub_pos = self._get_hub_center(ctx)
+            hub_dist = _manhattan(ctx.state.position, hub_pos)
+            if ctx.trace:
+                ctx.trace.activate(self.name, f"exploring for {self._station_type} (hub dist={hub_dist})")
+            if hub_dist > 3:
+                # Navigate toward hub
+                return ctx.navigator.get_action(ctx.state.position, hub_pos, ctx.map, reach_adjacent=True)
+            # At hub — explore nearby to find the station
+            return ctx.navigator.explore(ctx.state.position, ctx.map)
+
+        station_pos, _ = result
+        dist = _manhattan(ctx.state.position, station_pos)
+
+        if ctx.trace:
+            ctx.trace.nav_target = station_pos
+
+        # Track if we're making progress toward the station
+        last_dist = ctx.blackboard.get(self._bb_last_dist_key, 999)
+        ctx.blackboard[self._bb_last_dist_key] = dist
+
+        if dist <= 1:
+            # Adjacent to station — try to bump into it
+            bump_count = ctx.blackboard.get(self._bb_bump_count_key, 0) + 1
+            ctx.blackboard[self._bb_bump_count_key] = bump_count
+
+            if bump_count > self.MAX_BUMPS_AT_STATION:
+                # Stuck at dist=1 - explore to find another path
+                ctx.blackboard[self._bb_bump_count_key] = 0
+                if ctx.trace:
+                    ctx.trace.activate(self.name, "stuck at dist=1, exploring")
+                # Clear navigator cache and explore a random direction
+                ctx.navigator._cached_path = None
+                ctx.navigator._cached_target = None
+                return ctx.navigator.explore(ctx.state.position, ctx.map)
+
+            if ctx.trace:
+                ctx.trace.activate(self.name, f"bump {bump_count}/{self.MAX_BUMPS_AT_STATION}")
+            return _move_toward(ctx.state.position, station_pos)
+
+        # Not adjacent yet - navigate toward station
+        ctx.blackboard[self._bb_bump_count_key] = 0
+
+        # If we're not making progress (dist not decreasing), clear cache and try fresh path
+        if dist >= last_dist and attempts > 10:
+            ctx.navigator._cached_path = None
+            ctx.navigator._cached_target = None
+
+        return ctx.navigator.get_action(ctx.state.position, station_pos, ctx.map, reach_adjacent=True)
+
+
+def _move_toward(current: tuple[int, int], target: tuple[int, int]) -> Action:
+    """Move one step toward target, trying the most direct direction."""
+    dr = target[0] - current[0]
+    dc = target[1] - current[1]
+
+    # When exactly adjacent (dist=1), we want to bump INTO the target
+    # Return the direction that would move us onto the target
+    if dr == 1 and dc == 0:
+        return Action(name="move_south")
+    if dr == -1 and dc == 0:
+        return Action(name="move_north")
+    if dr == 0 and dc == 1:
+        return Action(name="move_east")
+    if dr == 0 and dc == -1:
+        return Action(name="move_west")
+
+    # For larger distances, prefer the longer axis
+    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")
+
+    # On target — shouldn't happen, but bump north as fallback
+    return Action(name="move_north")

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

@@ -0,0 +1,441 @@
+"""Miner goals — pick resource, mine, deposit."""
+
+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
+
+
+class GetMinerGearGoal(GetGearGoal):
+    """Get miner gear (costs C1 O1 G3 S1 from collective).
+
+    Miners always get gear regardless of reserves — they produce resources.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(
+            gear_attr="miner_gear",
+            station_type="miner_station",
+            goal_name="GetMinerGear",
+            gear_cost={"carbon": 1, "oxygen": 1, "germanium": 3, "silicon": 1},
+        )
+
+    def _collective_can_afford(self, ctx: "CogasContext") -> bool:
+        """Miners always get gear — they're the resource producers.
+
+        But skip if collective is already well-stocked (no need to mine).
+        """
+        if _collective_resources_sufficient(ctx):
+            return False
+        if not self._gear_cost:
+            return True
+        s = ctx.state
+        collective = {
+            "carbon": s.collective_carbon,
+            "oxygen": s.collective_oxygen,
+            "germanium": s.collective_germanium,
+            "silicon": s.collective_silicon,
+        }
+        # No reserve requirement for miners — just need the cost
+        return all(collective.get(res, 0) >= amt for res, amt in self._gear_cost.items())
+
+
+# Resource types that can be mined
+RESOURCE_TYPES = ["carbon", "oxygen", "germanium", "silicon"]
+
+# When the collective has more than this amount of every resource, stop mining.
+COLLECTIVE_SUFFICIENT_THRESHOLD = 100
+
+
+def _collective_resources_sufficient(ctx: "CogasContext") -> bool:
+    """Return True when the collective has >COLLECTIVE_SUFFICIENT_THRESHOLD of every resource."""
+    s = ctx.state
+    return (
+        s.collective_carbon > COLLECTIVE_SUFFICIENT_THRESHOLD
+        and s.collective_oxygen > COLLECTIVE_SUFFICIENT_THRESHOLD
+        and s.collective_germanium > COLLECTIVE_SUFFICIENT_THRESHOLD
+        and s.collective_silicon > COLLECTIVE_SUFFICIENT_THRESHOLD
+    )
+
+
+class ExploreHubGoal(Goal):
+    """Explore the hub to discover all 4 extractors before mining.
+
+    Finds the actual hub from observations (not hardcoded position) and
+    explores nearby corners to discover extractors.
+    """
+
+    name = "ExploreHub"
+    # Hub corner offsets from hub center — extractors at these positions
+    HUB_OFFSETS = [(-5, -5), (-5, 5), (5, 5), (5, -5)]
+
+    def is_satisfied(self, ctx: CogasContext) -> bool:
+        found = sum(1 for r in RESOURCE_TYPES if ctx.map.find(type=f"{r}_extractor"))
+        if found >= 4:
+            return True
+        # Time limit: don't explore forever, but give more time (30 steps)
+        if ctx.step > 30:
+            return True
+        return False
+
+    def execute(self, ctx: CogasContext) -> Optional[Action]:
+        # Find actual hub position from observations
+        hub_center = self._get_hub_center(ctx)
+
+        corner_idx = ctx.blackboard.get("_hub_corner_idx", ctx.agent_id % 4)
+        offsets = self.HUB_OFFSETS
+        target = (hub_center[0] + offsets[corner_idx][0], hub_center[1] + offsets[corner_idx][1])
+
+        dist = _manhattan(ctx.state.position, target)
+        if dist <= 2:
+            corner_idx = (corner_idx + 1) % 4
+            ctx.blackboard["_hub_corner_idx"] = corner_idx
+            target = (hub_center[0] + offsets[corner_idx][0], hub_center[1] + offsets[corner_idx][1])
+
+        if ctx.trace:
+            ctx.trace.nav_target = target
+            found = sum(1 for r in RESOURCE_TYPES if ctx.map.find(type=f"{r}_extractor"))
+            ctx.trace.activate(self.name, f"corner={corner_idx} found={found}/4 hub={hub_center}")
+
+        # Check dist to avoid navigator returning noop
+        new_dist = _manhattan(ctx.state.position, target)
+        if new_dist <= 1:
+            return _move_toward(ctx.state.position, target)
+        return ctx.navigator.get_action(ctx.state.position, target, ctx.map, reach_adjacent=True)
+
+    def _get_hub_center(self, ctx: CogasContext) -> tuple[int, int]:
+        """Find hub center from observations, falling back to current position."""
+        # Check if we already cached the hub position
+        cached_hub = ctx.blackboard.get("_hub_center")
+        if cached_hub is not None:
+            return cached_hub
+
+        # Try to find hub from entity map
+        pf = {"collective_id": ctx.my_collective_id} if ctx.my_collective_id is not None else None
+        hub = ctx.map.find_nearest(ctx.state.position, type_contains="hub", property_filter=pf)
+        if hub is not None:
+            hub_pos, _ = hub
+            ctx.blackboard["_hub_center"] = hub_pos
+            return hub_pos
+
+        # Fall back to current position if hub not visible yet
+        # (agent will explore from where it spawned)
+        return ctx.state.position
+
+
+class PickResourceGoal(Goal):
+    """Select a target resource based on collective needs.
+
+    Prioritizes the resource that the collective has the least of,
+    ensuring balanced gathering for heart production.
+    Re-evaluates every 50 steps to adapt to changing needs.
+    """
+
+    name = "PickResource"
+    REEVALUATE_INTERVAL = 50
+
+    def is_satisfied(self, ctx: CogasContext) -> bool:
+        # Don't bother picking a resource if collective is well-stocked
+        if _collective_resources_sufficient(ctx):
+            return True
+
+        if "target_resource" not in ctx.blackboard:
+            return False
+
+        # Re-evaluate periodically to ensure we're mining what's needed
+        last_pick = ctx.blackboard.get("_target_resource_step", 0)
+        if ctx.step - last_pick >= self.REEVALUATE_INTERVAL:
+            # Clear to force re-evaluation
+            ctx.blackboard.pop("target_resource", None)
+            return False
+
+        return True
+
+    def execute(self, ctx: CogasContext) -> Optional[Action]:
+        # Get collective resource levels
+        collective = {
+            "carbon": ctx.state.collective_carbon,
+            "oxygen": ctx.state.collective_oxygen,
+            "germanium": ctx.state.collective_germanium,
+            "silicon": ctx.state.collective_silicon,
+        }
+
+        # Find resources with available extractors
+        available_resources: list[tuple[int, str]] = []
+        for resource in RESOURCE_TYPES:
+            extractors = ctx.map.find(type=f"{resource}_extractor")
+            usable = [
+                (pos, e)
+                for pos, e in extractors
+                if e.properties.get("remaining_uses", 999) > 0
+                and e.properties.get("inventory_amount", -1) != 0
+                and not _extractor_recently_failed(ctx, pos)
+            ]
+            if usable:
+                # Score by collective amount (lower = higher priority)
+                available_resources.append((collective.get(resource, 0), resource))
+
+        if not available_resources:
+            # No extractors known — pick carbon as default, MineResource will explore
+            ctx.blackboard["target_resource"] = "carbon"
+            ctx.blackboard["_target_resource_step"] = ctx.step
+            if ctx.trace:
+                ctx.trace.activate(self.name, "no extractors known, defaulting to carbon")
+            # Return None to immediately continue to MineResource goal
+            return None
+
+        # Pick the resource the collective has least of (that we can mine)
+        available_resources.sort()
+        best_resource = available_resources[0][1]
+
+        if ctx.trace:
+            ctx.trace.activate(self.name, f"need={best_resource} coll={collective}")
+
+        ctx.blackboard["target_resource"] = best_resource
+        ctx.blackboard["_target_resource_step"] = ctx.step
+        # Return None to immediately continue to next goal (mining)
+        return None
+
+
+def _extractor_recently_failed(ctx: CogasContext, pos: tuple[int, int]) -> bool:
+    """Check if we recently failed to mine from this extractor."""
+    failed_step = ctx.blackboard.get(f"mine_failed_{pos}", -9999)
+    return ctx.step - failed_step < 100  # 100 step cooldown - extractors may refill
+
+
+class DepositCargoGoal(Goal):
+    """Deposit resources at nearest cogs-aligned building when cargo is reasonably full.
+
+    Triggers when cargo is >= 50% full (or >= 10 resources for small capacity).
+    Once triggered, keeps depositing until cargo is EMPTY.
+    Tracks attempts and marks depots as failed if cargo doesn't decrease.
+    """
+
+    name = "DepositCargo"
+    MAX_ATTEMPTS_PER_DEPOT = 5
+
+    def is_satisfied(self, ctx: CogasContext) -> bool:
+        cargo = ctx.state.cargo_total
+
+        # If we're currently depositing (flag set), keep going until empty
+        if ctx.blackboard.get("_depositing", False):
+            if cargo == 0:
+                ctx.blackboard["_depositing"] = False
+                return True
+            return False  # Keep depositing until empty
+
+        # Not currently depositing - check if we should start
+        # Deposit when at least 50% full (but always deposit if cargo == capacity)
+        capacity = ctx.state.cargo_capacity
+        threshold = max(2, capacity // 2)
+
+        if cargo >= threshold:
+            ctx.blackboard["_depositing"] = True
+            return False  # Start depositing
+
+        return True  # Don't need to deposit yet
+
+    def execute(self, ctx: CogasContext) -> Optional[Action]:
+        # Track cargo to detect successful deposit
+        prev_cargo = ctx.blackboard.get("prev_deposit_cargo", ctx.state.cargo_total)
+        current_cargo = ctx.state.cargo_total
+        ctx.blackboard["prev_deposit_cargo"] = current_cargo
+
+        # Find nearest cogs depot
+        depot_pos = _find_cogs_depot(ctx)
+        if depot_pos is None:
+            return ctx.navigator.explore(ctx.state.position, ctx.map)
+
+        if ctx.trace:
+            ctx.trace.nav_target = depot_pos
+
+        dist = _manhattan(ctx.state.position, depot_pos)
+        if dist <= 1:
+            if ctx.trace:
+                hub_dbg_filter = {"collective_id": ctx.my_collective_id} if ctx.my_collective_id is not None else None
+                hubs = ctx.map.find(type_contains="hub", property_filter=hub_dbg_filter)
+                depot_entity = ctx.map.entities.get(depot_pos)
+                print(
+                    f"[deposit-debug] agent={ctx.agent_id} t={ctx.step} pos={ctx.state.position}"
+                    f" depot={depot_pos} depot_type={depot_entity.type if depot_entity else 'NONE'}"
+                    f" depot_align={depot_entity.properties.get('alignment') if depot_entity else 'N/A'}"
+                    f" cargo={current_cargo} prev={prev_cargo}"
+                    f" hubs={[(p, e.properties.get('alignment')) for p, e in hubs]}"
+                )
+            # Adjacent to depot - track attempts
+            attempts_key = f"deposit_attempts_{depot_pos}"
+            attempts = ctx.blackboard.get(attempts_key, 0) + 1
+
+            # Reset if cargo decreased (deposit succeeded)
+            if current_cargo < prev_cargo:
+                ctx.blackboard[attempts_key] = 0
+            else:
+                ctx.blackboard[attempts_key] = attempts
+
+                if attempts > self.MAX_ATTEMPTS_PER_DEPOT:
+                    # Mark as failed temporarily
+                    ctx.blackboard[f"deposit_failed_{depot_pos}"] = ctx.step
+                    ctx.blackboard[attempts_key] = 0
+                    if ctx.trace:
+                        ctx.trace.activate(self.name, f"giving up on {depot_pos}")
+                    return ctx.navigator.explore(ctx.state.position, ctx.map)
+
+            return _move_toward(ctx.state.position, depot_pos)
+
+        # Not adjacent - reset attempts
+        ctx.blackboard[f"deposit_attempts_{depot_pos}"] = 0
+        return ctx.navigator.get_action(ctx.state.position, depot_pos, ctx.map, reach_adjacent=True)
+
+
+class MineResourceGoal(Goal):
+    """Navigate to extractor for target_resource and bump it.
+
+    Tracks attempts at each extractor and marks them as failed if
+    cargo doesn't increase after several bumps (extractor empty/broken).
+
+    NEVER satisfied - miners should always mine or explore, never noop.
+    """
+
+    name = "MineResource"
+    MAX_ATTEMPTS_PER_EXTRACTOR = 3  # Reduced from 5 - fail faster
+
+    def is_satisfied(self, ctx: CogasContext) -> bool:
+        # Never satisfied - always mine or explore to avoid noops
+        # Even when collective is well-stocked, keep contributing
+        return False
+
+    def execute(self, ctx: CogasContext) -> Optional[Action]:
+        target_resource = ctx.blackboard.get("target_resource", "carbon")
+
+        # Track cargo to detect successful mining
+        prev_cargo = ctx.blackboard.get("prev_cargo", 0)
+        current_cargo = ctx.state.cargo_total
+        ctx.blackboard["prev_cargo"] = current_cargo
+
+        # Find nearest usable extractor for this resource
+        target_pos = self._find_extractor(ctx, target_resource)
+
+        if target_pos is None:
+            # Try any resource type
+            for resource in RESOURCE_TYPES:
+                if resource == target_resource:
+                    continue
+                target_pos = self._find_extractor(ctx, resource)
+                if target_pos:
+                    ctx.blackboard["target_resource"] = resource
+                    ctx.blackboard["_target_resource_step"] = ctx.step
+                    break
+
+        if target_pos is None:
+            # No extractors found — explore in agent-specific direction to discover them
+            ctx.blackboard.pop("target_resource", None)
+            directions = ["north", "east", "south", "west"]
+            return ctx.navigator.explore(
+                ctx.state.position,
+                ctx.map,
+                direction_bias=directions[ctx.agent_id % 4],
+            )
+
+        if ctx.trace:
+            ctx.trace.nav_target = target_pos
+
+        dist = _manhattan(ctx.state.position, target_pos)
+        if dist <= 1:
+            # Adjacent to extractor — track attempts
+            attempts_key = f"mine_attempts_{target_pos}"
+            attempts = ctx.blackboard.get(attempts_key, 0) + 1
+
+            # Reset attempts if cargo increased (mining succeeded)
+            if current_cargo > prev_cargo:
+                ctx.blackboard[attempts_key] = 0
+            else:
+                ctx.blackboard[attempts_key] = attempts
+
+                if attempts > self.MAX_ATTEMPTS_PER_EXTRACTOR:
+                    # Mark as failed permanently for this episode
+                    ctx.blackboard[f"mine_failed_{target_pos}"] = ctx.step
+                    ctx.blackboard[attempts_key] = 0
+                    # Also clear target resource to force re-evaluation
+                    ctx.blackboard.pop("target_resource", None)
+                    if ctx.trace:
+                        ctx.trace.activate(self.name, f"giving up on {target_pos}")
+                    return ctx.navigator.explore(
+                        ctx.state.position,
+                        ctx.map,
+                        direction_bias=["north", "east", "south", "west"][ctx.agent_id % 4],
+                    )
+
+            return _move_toward(ctx.state.position, target_pos)
+
+        # Don't reset attempts when moving away - only reset on successful mine
+        return ctx.navigator.get_action(ctx.state.position, target_pos, ctx.map, reach_adjacent=True)
+
+    def _find_extractor(self, ctx: CogasContext, resource: str) -> Optional[tuple[int, int]]:
+        """Find nearest usable extractor."""
+        extractors = ctx.map.find(type=f"{resource}_extractor")
+        usable = [
+            (pos, e)
+            for pos, e in extractors
+            if e.properties.get("remaining_uses", 999) > 0
+            and e.properties.get("inventory_amount", -1) != 0
+            and not _extractor_recently_failed(ctx, pos)
+        ]
+
+        if not usable:
+            return None
+
+        # Sort by distance to agent
+        usable.sort(key=lambda x: _manhattan(ctx.state.position, x[0]))
+        return usable[0][0]
+
+
+def _find_cogs_depot(ctx: CogasContext) -> tuple[int, int] | None:
+    """Find nearest cogs-aligned depot, prioritizing hub."""
+    from cogames_agents.policy.scripted_agent.cogas.policy import SPAWN_POS
+
+    pos = ctx.state.position
+
+    def recently_failed(p: tuple[int, int]) -> bool:
+        failed_step = ctx.blackboard.get(f"deposit_failed_{p}", -9999)
+        return ctx.step - failed_step < 100
+
+    # Prioritize own team's hub
+    hub_filter = {"collective_id": ctx.my_collective_id} if ctx.my_collective_id is not None else None
+    for apos, _ in ctx.map.find(type_contains="hub", property_filter=hub_filter):
+        if not recently_failed(apos):
+            return apos
+
+    # Fallback: nearest cogs junction near hub
+    candidates: list[tuple[int, tuple[int, int]]] = []
+    for jpos, _ in ctx.map.find(type_contains="junction", property_filter={"alignment": "cogs"}):
+        if not recently_failed(jpos) and _manhattan(jpos, SPAWN_POS) <= 15:
+            candidates.append((_manhattan(pos, jpos), jpos))
+
+    if not candidates:
+        # Last resort: navigate to hub area
+        return SPAWN_POS
+    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/scout.py

@@ -0,0 +1,40 @@
+"""Scout goals — explore the map."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from cogames_agents.policy.scripted_agent.cogas.goal import Goal
+from mettagrid.simulator import Action
+
+from .gear import GetGearGoal
+
+if TYPE_CHECKING:
+    from cogames_agents.policy.scripted_agent.cogas.context import CogasContext
+
+
+class GetScoutGearGoal(GetGearGoal):
+    """Get scout gear (costs C1 O1 G1 S3 from collective)."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            gear_attr="scout_gear",
+            station_type="scout_station",
+            goal_name="GetScoutGear",
+            gear_cost={"carbon": 1, "oxygen": 1, "germanium": 1, "silicon": 3},
+        )
+
+
+class ExploreGoal(Goal):
+    """Explore the map by navigating to frontier cells."""
+
+    name = "Explore"
+
+    def is_satisfied(self, ctx: CogasContext) -> bool:
+        # Never satisfied — always explore
+        return False
+
+    def execute(self, ctx: CogasContext) -> Action:
+        directions = ["north", "east", "south", "west"]
+        direction_bias = directions[ctx.agent_id % 4]
+        return ctx.navigator.explore(ctx.state.position, ctx.map, direction_bias=direction_bias)