cogames 0.3.65__py3-none-any.whl → 0.3.68__py3-none-any.whl

cogames/cogs_vs_clips/cogsguard_curriculum.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Sequence
+
+from cogames.cogs_vs_clips.mission import CvCMission
+from cogames.cogs_vs_clips.reward_variants import AVAILABLE_REWARD_VARIANTS
+from cogames.cogs_vs_clips.variants import HIDDEN_VARIANTS, VARIANTS
+from cogames.core import CoGameMissionVariant
+
+
+@dataclass(frozen=True)
+class EventProfile:
+    name: str
+    clips_overrides: dict[str, object]
+    weather_overrides: dict[str, object]
+
+
+COGSGUARD_FIXED_MAPS: list[str] = [
+    "machina_100_stations.map",
+    "machina_200_stations.map",
+    "cave_base_50.map",
+    "vanilla_large.map",
+]
+
+DEFAULT_EVENT_PROFILE = EventProfile("events_baseline", {}, {})
+COGSGUARD_EVENT_PROFILES: list[EventProfile] = [
+    DEFAULT_EVENT_PROFILE,
+    EventProfile(
+        "events_fast_clips_short_day",
+        {
+            "initial_clips_start": 5,
+            "initial_clips_spots": 2,
+            "scramble_start": 25,
+            "scramble_interval": 50,
+            "scramble_radius": 35,
+            "align_start": 50,
+            "align_interval": 50,
+            "align_radius": 35,
+        },
+        {"day_length": 100},
+    ),
+    EventProfile(
+        "events_slow_clips_long_day",
+        {
+            "initial_clips_start": 50,
+            "initial_clips_spots": 1,
+            "scramble_start": 200,
+            "scramble_interval": 200,
+            "scramble_radius": 15,
+            "align_start": 300,
+            "align_interval": 200,
+            "align_radius": 15,
+        },
+        {"day_length": 400},
+    ),
+    EventProfile(
+        "events_no_clips",
+        {"disabled": True},
+        {"day_length": 200},
+    ),
+]
+
+
+def normalize_variant_names(variants: str | Sequence[str] | None) -> list[str]:
+    if variants is None:
+        return []
+    if isinstance(variants, str):
+        if variants.startswith("["):
+            parsed = json.loads(variants)
+            if isinstance(parsed, list):
+                return [str(name) for name in parsed]
+        return [variants]
+    return list(variants)
+
+
+def split_variants(
+    variants: str | Sequence[str] | None,
+) -> tuple[list[CoGameMissionVariant], list[str]]:
+    if variants is None:
+        names: list[str] = []
+    else:
+        names = normalize_variant_names(variants)
+    all_variants = {variant.name: variant for variant in [*VARIANTS, *HIDDEN_VARIANTS]}
+    reward_variants = set(AVAILABLE_REWARD_VARIANTS)
+
+    resolved: list[CoGameMissionVariant] = []
+    resolved_rewards: list[str] = []
+    unknown: list[str] = []
+    for name in names:
+        if name in reward_variants:
+            resolved_rewards.append(name)
+            continue
+        variant = all_variants.get(name)
+        if variant is None:
+            unknown.append(name)
+            continue
+        resolved.append(variant)
+
+    if unknown:
+        available_mission = ", ".join(v.name for v in VARIANTS)
+        available_reward = ", ".join(AVAILABLE_REWARD_VARIANTS)
+        missing = ", ".join(unknown)
+        raise ValueError(
+            f"Unknown variant(s): {missing}. Mission variants: {available_mission}. "
+            f"Reward variants: {available_reward}."
+        )
+
+    return resolved, resolved_rewards
+
+
+def resolve_event_profiles(event_profiles: Sequence[EventProfile] | None) -> list[EventProfile]:
+    if event_profiles is None:
+        return [DEFAULT_EVENT_PROFILE]
+    return list(event_profiles)
+
+
+def filter_compatible_variants(
+    mission: CvCMission, variants: Sequence[CoGameMissionVariant]
+) -> list[CoGameMissionVariant]:
+    return [variant for variant in variants if variant.compat(mission)]

cogames/cogs_vs_clips/cogsguard_tutorial.py

@@ -18,11 +18,11 @@ def make_cogsguard_tutorial_site() -> CoGameSite:
         hub_height=15,
         outer_clearance=2,
         stations=[
-            "aligner_station",
-            "scrambler_station",
-            "miner_station",
-            "scout_station",
-            "chest",
+            "c:aligner",
+            "c:scrambler",
+            "c:miner",
+            "c:scout",
+            "c:chest",
         ],
     )
     map_builder = MapGen.Config(

cogames/cogs_vs_clips/config.py

@@ -32,7 +32,7 @@ CvCConfig = SimpleNamespace(
         "miner": "⛏️",
         "scout": "🔭",
     },
-    RESOURCES=["energy", "heart", "hp", "influence", *_ELEMENTS, *_GEAR],
+    RESOURCES=["energy", "heart", "hp", "influence", "solar", *_ELEMENTS, *_GEAR],
     VIBES=_VIBES,
     VIBE_NAMES=[vibe.name for vibe in _VIBES],
 )

cogames/cogs_vs_clips/docs/cogs_vs_clips_mapgen.md

@@ -341,11 +341,10 @@ Included missions and variants:
 Usage example:
 
 ```bash
-uv run python packages/cogames/scripts/run_evaluation.py \
-  --policy thinky \
+uv run cogames diagnose thinky \
   --mission-set integrated_evals \
   --cogs 4 \
-  --repeats 2
+  --episodes 2
 ```
 
 Recommendation: When designing new scorable baselines, combine one "shaping" variant (e.g., `HeartChorusVariant`,

cogames/cogs_vs_clips/evals/README.md

@@ -193,49 +193,25 @@ uv run cogames play --mission hello_world.single_use_swarm --cogs 4 -p baseline
 
 ## Programmatic Evaluation
 
-### Using run_evaluation.py
+### Using cogames diagnose / cogames run
 
 For systematic evaluation across multiple missions and configurations:
 
 ```bash
 # Evaluate on integrated eval suite
-uv run python packages/cogames/scripts/run_evaluation.py \
-  --policy thinky \
+uv run cogames diagnose thinky \
   --mission-set integrated_evals \
   --cogs 4 \
-  --repeats 2
+  --episodes 2
 
-# Evaluate specific agent
-uv run python packages/cogames/scripts/run_evaluation.py \
+# Evaluate specific agent with structured output
+uv run cogames run \
+  --mission-set integrated_evals \
   --policy baseline \
-  --steps 1000 \
-  --output eval_baseline.json
+  --episodes 10 \
+  --format json
 ```
 
-### Using in Curriculum Training
-
-Both diagnostic and integrated missions can be used in curriculum training via `mission_variant_curriculum.py`:
-
-```python
-from recipes.experiment.cvc import mission_variant_curriculum
-
-# Train on diagnostic missions
-mission_variant_curriculum.train(
-    base_missions=["diagnostic_missions"],
-    num_cogs=4,
-    variants="all"
-)
-
-# Train on specific integrated missions
-mission_variant_curriculum.train(
-    base_missions=["oxygen_bottleneck", "energy_starved"],
-    num_cogs=4,
-    variants=["pack_rat", "energized"]
-)
-```
-
----
-
 ## Design Philosophy
 
 ### Diagnostic Missions

cogames/cogs_vs_clips/evals/diagnostic_evals.py

@@ -26,7 +26,6 @@ _GENEROUS_COG = CogConfig(
     cargo_limit=255,
     initial_energy=255,
     initial_hp=100,
-    energy_regen=255,
     hp_regen=0,
     influence_regen=0,
 )

cogames/cogs_vs_clips/evals/difficulty_variants.py

@@ -37,11 +37,8 @@ class DifficultyLevel(CoGameMissionVariant):
     name: str = Field(description="Difficulty name (easy, medium, hard, brutal, etc.)")
     description: str = Field(description="What makes this difficulty challenging", default="")
 
-    # Energy regen multiplier (relative to mission baseline)
-    energy_regen_mult: float = Field(default=1.0)
-
-    # Absolute overrides (if set, ignore multipliers)
-    energy_regen_override: int | None = Field(default=None)
+    # Solar override (if set, overrides weather day/night deltas)
+    solar_override: int | None = Field(default=None)
     move_energy_cost_override: int | None = Field(default=None)
     energy_capacity_override: int | None = Field(default=None)
     cargo_capacity_override: int | None = Field(default=None)
@@ -70,20 +67,20 @@ STANDARD = DifficultyLevel(
 HARD = DifficultyLevel(
     name="hard",
     description="Minimal passive regen and higher move cost",
-    energy_regen_override=1,  # Minimal regen prevents deadlock
+    solar_override=1,  # Minimal regen prevents deadlock
     move_energy_cost_override=2,
 )
 
 SINGLE_USE = DifficultyLevel(
     name="single_use",
     description="Minimal regen - no second chances",
-    energy_regen_override=1,
+    solar_override=1,
 )
 
 SPEED_RUN = DifficultyLevel(
     name="speed_run",
     description="Short clock, cheap movement",
-    energy_regen_override=2,
+    solar_override=2,
     move_energy_cost_override=1,
     max_steps_override=600,
 )
@@ -91,7 +88,7 @@ SPEED_RUN = DifficultyLevel(
 ENERGY_CRISIS = DifficultyLevel(
     name="energy_crisis",
     description="Minimal passive regen - plan every move",
-    energy_regen_override=1,  # Minimal regen prevents deadlock
+    solar_override=1,  # Minimal regen prevents deadlock
 )
 
 # Export variants for use with --variant CLI flag.
@@ -116,7 +113,7 @@ def list_difficulties() -> None:
     print("=" * 80)
     for diff in DIFFICULTY_VARIANTS:
         print(f"\n{diff.name.upper()}: {diff.description}")
-        print(f"  Energy regen mult: {diff.energy_regen_mult}")
+        print(f"  Solar override: {diff.solar_override}")
 
 
 if __name__ == "__main__":

cogames/cogs_vs_clips/mission.py

@@ -15,6 +15,7 @@ from cogames.cogs_vs_clips.stations import (
 )
 from cogames.cogs_vs_clips.team import CogTeam
 from cogames.cogs_vs_clips.variants import NumCogsVariant
+from cogames.cogs_vs_clips.weather import WeatherConfig
 from cogames.core import (
     MAP_MISSION_DELIMITER,
     CoGameMission,
@@ -28,7 +29,7 @@ from mettagrid.config.action_config import (
     NoopActionConfig,
 )
 from mettagrid.config.game_value import inv
-from mettagrid.config.mettagrid_config import GameConfig, MettaGridConfig
+from mettagrid.config.mettagrid_config import CollectiveConfig, GameConfig, MettaGridConfig
 from mettagrid.config.obs_config import GlobalObsConfig, ObsConfig
 from mettagrid.map_builder.map_builder import AnyMapBuilderConfig
 
@@ -46,6 +47,7 @@ class CvCMission(CoGameMission):
     """Mission configuration for CogsGuard game mode."""
 
     max_steps: int = Field(default=10000)
+    total_junctions: int = Field(default=118, description="Total junctions on the map (for curriculum scaling)")
 
     cog: CogConfig = Field(default_factory=lambda: CogConfig())
     teams: dict[str, CogTeam] = Field(
@@ -55,6 +57,7 @@ class CvCMission(CoGameMission):
     )
 
     clips: ClipsConfig = Field(default_factory=lambda: ClipsConfig())
+    weather: WeatherConfig = Field(default_factory=lambda: WeatherConfig())
 
     @property
     def num_agents(self) -> int:
@@ -74,7 +77,7 @@ class CvCMission(CoGameMission):
         Returns:
             MettaGridConfig ready for environment creation
         """
-
+        team_objs = list(self.teams.values())
         game = GameConfig(
             map_builder=self.map_builder(),
             max_steps=self.max_steps,
@@ -91,24 +94,40 @@ class CvCMission(CoGameMission):
                 noop=NoopActionConfig(),
                 change_vibe=ChangeVibeActionConfig(vibes=CvCConfig.VIBES),
             ),
-            agent=self.cog.agent_config(team="cogs", max_steps=self.max_steps),
-            agents=[self.cog.agent_config(team="cogs", max_steps=self.max_steps) for _ in range(self.num_agents)],
+            agents=[
+                self.cog.agent_config(team=t.name, max_steps=self.max_steps)
+                for t in team_objs
+                for _ in range(t.num_agents)
+            ],
             objects={
                 "wall": CvCWallConfig().station_cfg(),
-                "hub": CvCHubConfig().station_cfg(team="cogs"),
                 "junction": CvCJunctionConfig().station_cfg(),
-                "chest": CvCChestConfig().station_cfg(team="cogs"),
                 **{
                     f"{resource}_extractor": CvCExtractorConfig(resource=resource).station_cfg()
                     for resource in CvCConfig.ELEMENTS
                 },
-                **{f"{g}_station": CvCGearStationConfig(gear_type=g).station_cfg(team="cogs") for g in CvCConfig.GEAR},
+                **{
+                    f"{t.short_name}:hub": CvCHubConfig().station_cfg(team=t.short_name, collective=t.name)
+                    for t in team_objs
+                },
+                **{
+                    f"{t.short_name}:chest": CvCChestConfig().station_cfg(team=t.short_name, collective=t.name)
+                    for t in team_objs
+                },
+                **{
+                    f"{t.short_name}:{g}": CvCGearStationConfig(gear_type=g).station_cfg(
+                        team=t.short_name, collective=t.name
+                    )
+                    for t in team_objs
+                    for g in CvCConfig.GEAR
+                },
             },
             collectives={
-                **{team.name: team.collective_config() for team in self.teams.values()},
-                "clips": self.clips.collective_config(),
+                **{t.name: t.collective_config() for t in team_objs},
+                **self.clips.collectives(),
+                "neutral": CollectiveConfig(name="neutral"),
             },
-            events=self.clips.events(max_steps=self.max_steps),
+            events=self._merge_events(),
         )
 
         env = MettaGridConfig(game=game)
@@ -122,3 +141,12 @@ class CvCMission(CoGameMission):
             env.label += f".{variant.name}"
 
         return env
+
+    def _merge_events(self) -> dict:
+        """Merge clips and weather events, raising on key conflicts."""
+        clips_events = self.clips.events(max_steps=self.max_steps)
+        weather_events = self.weather.events(max_steps=self.max_steps)
+        overlap = set(clips_events) & set(weather_events)
+        if overlap:
+            raise ValueError(f"Overlapping event keys between clips and weather: {overlap}")
+        return {**clips_events, **weather_events}

cogames/cogs_vs_clips/missions.py

@@ -50,7 +50,7 @@ def get_core_missions() -> list[CvCMission]:
 
 
 def _build_eval_missions() -> list[CvCMission]:
-    from cogames.cogs_vs_clips.evals.integrated_evals import EVAL_MISSIONS as INTEGRATED_EVAL_MISSIONS
+    from cogames.cogs_vs_clips.evals.integrated_evals import EVAL_MISSIONS as INTEGRATED_EVAL_MISSIONS  # noqa: PLC0415
 
     return [
         *INTEGRATED_EVAL_MISSIONS,

cogames/cogs_vs_clips/reward_variants.py

@@ -0,0 +1,173 @@
+"""Reward preset wiring for the CogsGuard (Cogs vs Clips) mission.
+
+The mission has a single "true" objective signal, plus optional shaping variants.
+Reward variants are stackable; each one adds additional shaping signals on top of the
+mission's default objective rewards.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Literal, Sequence, cast
+
+from mettagrid.config.game_value import stat
+from mettagrid.config.mettagrid_config import MettaGridConfig
+from mettagrid.config.reward_config import AgentReward, reward
+
+CogsGuardRewardVariant = Literal[
+    "credit",
+    "milestones",
+    "no_objective",
+    "penalize_vibe_change",
+    "objective",
+]
+
+AVAILABLE_REWARD_VARIANTS: tuple[CogsGuardRewardVariant, ...] = (
+    "objective",
+    "no_objective",
+    "milestones",
+    "credit",
+    "penalize_vibe_change",
+)
+
+_OBJECTIVE_STAT_KEY = "aligned_junction_held"
+
+
+def _apply_milestones(rewards: dict[str, AgentReward], *, max_junctions: int = 100) -> None:
+    """Add milestone shaping rewards onto an existing baseline.
+
+    Args:
+        rewards: Rewards dict to modify in-place.
+        max_junctions: Maximum expected number of junctions for capping rewards.
+            Defaults to 100 as a reasonable upper bound for most maps.
+    """
+    w_junction_aligned = 1.0
+    w_scramble_act = 0.5
+    w_align_act = 1.0
+
+    # Max caps based on expected junction counts
+    max_junction_aligned = w_junction_aligned * max_junctions
+    max_scramble = w_scramble_act * max_junctions
+    max_align = w_align_act * max_junctions
+
+    rewards["aligned_junctions"] = reward(
+        stat("collective.junction"),
+        weight=w_junction_aligned,
+        max=max_junction_aligned,
+    )
+
+    rewards["junction_scrambled_by_agent"] = reward(
+        stat("junction.scrambled_by_agent"),
+        weight=w_scramble_act,
+        max=max_scramble,
+    )
+    rewards["junction_aligned_by_agent"] = reward(
+        stat("junction.aligned_by_agent"),
+        weight=w_align_act,
+        max=max_align,
+    )
+
+
+def _apply_penalize_vibe_change(rewards: dict[str, AgentReward]) -> None:
+    """Add penalty for vibe changes to discourage spamming."""
+    w_vibe_change = -0.01
+    rewards["vibe_change_penalty"] = reward(stat("action.change_vibe.success"), weight=w_vibe_change)
+
+
+def _apply_credit(rewards: dict[str, AgentReward]) -> None:
+    """Add dense precursor shaping rewards onto an existing baseline."""
+    w_heart = 0.05
+    cap_heart = 0.5
+    w_align_gear = 0.2
+    cap_align_gear = 0.4
+    w_scramble_gear = 0.2
+    cap_scramble_gear = 0.4
+    w_element_gain = 0.001
+    cap_element_gain = 0.1
+
+    # Stats rewards for gains as a single map
+    gain_rewards: dict[str, AgentReward] = {
+        "heart_gained": reward(stat("heart.gained"), weight=w_heart, max=cap_heart),
+        "aligner_gained": reward(stat("aligner.gained"), weight=w_align_gear, max=cap_align_gear),
+        "aligner_lost": reward(stat("aligner.lost"), weight=-w_align_gear, max=-cap_align_gear),
+        "scrambler_gained": reward(stat("scrambler.gained"), weight=w_scramble_gear, max=cap_scramble_gear),
+        "scrambler_lost": reward(stat("scrambler.lost"), weight=-w_scramble_gear, max=-cap_scramble_gear),
+        "carbon_gained": reward(stat("carbon.gained"), weight=w_element_gain, max=cap_element_gain),
+        "oxygen_gained": reward(stat("oxygen.gained"), weight=w_element_gain, max=cap_element_gain),
+        "germanium_gained": reward(stat("germanium.gained"), weight=w_element_gain, max=cap_element_gain),
+        "silicon_gained": reward(stat("silicon.gained"), weight=w_element_gain, max=cap_element_gain),
+    }
+    rewards.update(gain_rewards)
+
+    # Collective deposit rewards
+    w_deposit = 0.002
+    cap_deposit = 0.2
+    deposit_rewards: dict[str, AgentReward] = {
+        f"collective_{element}_deposited": reward(
+            stat(f"collective.{element}.deposited"), weight=w_deposit, max=cap_deposit
+        )
+        for element in ["carbon", "oxygen", "germanium", "silicon"]
+    }
+    rewards.update(deposit_rewards)
+
+
+def apply_reward_variants(env: MettaGridConfig, *, variants: str | Sequence[str] | None = None) -> None:
+    """Apply CogsGuard reward variants to `env`.
+
+    Variants are stackable:
+    - `objective`: no-op marker; keeps the mission's default objective reward wiring.
+    - `no_objective`: disables the objective stat reward (`junction.held`).
+    - `milestones`: adds shaped rewards for aligning/scrambling junctions and holding more junctions.
+    - `credit`: adds additional dense shaping for precursor behaviors (resources/gear/deposits).
+    - `penalize_vibe_change`: adds a penalty for vibe changes to discourage spamming.
+    """
+    if not variants:
+        return
+
+    # Parse JSON-encoded list strings (e.g., '["milestones"]' from sweeps)
+    if isinstance(variants, str):
+        if variants.startswith("["):
+            try:
+                parsed = json.loads(variants)
+                variant_names = list(parsed) if isinstance(parsed, list) else [variants]
+            except json.JSONDecodeError:
+                variant_names = [variants]
+        else:
+            variant_names = [variants]
+    else:
+        variant_names = list(variants)
+
+    reward_variants: list[CogsGuardRewardVariant] = []
+    for variant_name in variant_names:
+        if variant_name not in AVAILABLE_REWARD_VARIANTS:
+            available = ", ".join(AVAILABLE_REWARD_VARIANTS)
+            raise ValueError(f"Unknown Cogsguard reward variant '{variant_name}'. Available: {available}")
+        variant = cast(CogsGuardRewardVariant, variant_name)
+        if variant in reward_variants:
+            continue
+        reward_variants.append(variant)
+
+    enabled = set(reward_variants)
+    if enabled <= {"objective"}:
+        return
+
+    # Start from the mission's existing objective baseline to preserve its scaling.
+    rewards = dict(env.game.agent.rewards)
+
+    if "no_objective" in enabled:
+        rewards.pop(_OBJECTIVE_STAT_KEY, None)
+    if "milestones" in enabled:
+        _apply_milestones(rewards)
+    if "credit" in enabled:
+        _apply_credit(rewards)
+    if "penalize_vibe_change" in enabled:
+        _apply_penalize_vibe_change(rewards)
+
+    env.game.agent.rewards = rewards
+
+    # Deterministic label suffix order (exclude "objective").
+    for variant in AVAILABLE_REWARD_VARIANTS:
+        if variant == "objective":
+            continue
+        if variant in enabled:
+            env.label += f".{variant}"

cogames/cogs_vs_clips/sites.py

@@ -72,16 +72,17 @@ MACHINA_1 = CoGameSite(
 
 def _cogsguard_hub_config() -> BaseHubConfig:
     return BaseHubConfig(
+        hub_object="c:hub",
         corner_bundle="extractors",
         cross_bundle="none",
         cross_distance=7,
         junction_object="junction",
+        heart_chest_object="c:chest",
         stations=[
-            "aligner_station",
-            "scrambler_station",
-            "miner_station",
-            "scout_station",
-            "chest",
+            "c:aligner",
+            "c:scrambler",
+            "c:miner",
+            "c:scout",
         ],
     )
 

cogames/cogs_vs_clips/stations.py

@@ -82,6 +82,7 @@ class CvCJunctionConfig(CvCStationConfig):
     def station_cfg(self, team: Optional[str] = None) -> GridObjectConfig:
         return GridObjectConfig(
             name="junction",
+            render_name="junction",
             render_symbol="📦",
             collective=team,
             aoes={
@@ -121,11 +122,12 @@ class CvCHubConfig(CvCStationConfig):
     attack_deltas: dict[str, int] = Field(default_factory=lambda: {"hp": -1, "influence": -100})
     elements: list[str] = Field(default_factory=lambda: CvCConfig.ELEMENTS)
 
-    def station_cfg(self, team: str) -> GridObjectConfig:
+    def station_cfg(self, team: str, collective: str | None = None) -> GridObjectConfig:
         return GridObjectConfig(
-            name="hub",
+            name=f"{team}:hub",
+            render_name="hub",
             render_symbol="📦",
-            collective=team,
+            collective=collective or team,
             aoes={
                 "influence": AOEConfig(
                     radius=self.aoe_range,
@@ -152,11 +154,12 @@ class CvCChestConfig(CvCStationConfig):
 
     heart_cost: dict[str, int] = Field(default_factory=lambda: CvCConfig.HEART_COST)
 
-    def station_cfg(self, team: str) -> GridObjectConfig:
+    def station_cfg(self, team: str, collective: str | None = None) -> GridObjectConfig:
         return GridObjectConfig(
-            name="chest",
+            name=f"{team}:chest",
+            render_name="chest",
             render_symbol="📦",
-            collective=team,
+            collective=collective or team,
             on_use_handlers={
                 "get_heart": Handler(
                     filters=[isAlignedToActor(), targetCollectiveHas({"heart": 1})],
@@ -180,12 +183,13 @@ class CvCGearStationConfig(CvCStationConfig):
     gear_costs: dict[str, dict[str, int]] = Field(default_factory=lambda: CvCConfig.GEAR_COSTS)
     gear_symbols: dict[str, str] = Field(default_factory=lambda: CvCConfig.GEAR_SYMBOLS)
 
-    def station_cfg(self, team: str) -> GridObjectConfig:
+    def station_cfg(self, team: str, collective: str | None = None) -> GridObjectConfig:
         cost = self.gear_costs.get(self.gear_type, {})
         return GridObjectConfig(
-            name=f"{self.gear_type}_station",
+            name=f"{team}:{self.gear_type}",
+            render_name=f"{self.gear_type}_station",
             render_symbol=self.gear_symbols[self.gear_type],
-            collective=team,
+            collective=collective or team,
             on_use_handlers={
                 "keep_gear": Handler(
                     filters=[isAlignedToActor(), actorHas({self.gear_type: 1})],

cogames/cogs_vs_clips/team.py

@@ -17,7 +17,8 @@ from mettagrid.config.mettagrid_config import (
 class CogTeam(Config):
     """Configuration for a cogs team."""
 
-    name: str = Field(default="cogs", description="Team name")
+    name: str = Field(default="cogs", description="Team name used for collectives and alignment")
+    short_name: str = Field(default="c", description="Short prefix used for map object names")
     wealth: int = Field(default=1, description="Wealth multiplier for initial resources")
     num_agents: int = Field(default=8, ge=1, description="Number of agents in the team")
 
@@ -28,6 +29,7 @@ class CogTeam(Config):
             CollectiveConfig with resource limits and initial inventory.
         """
         return CollectiveConfig(
+            name=self.name,
             inventory=InventoryConfig(
                 limits={
                     "resources": ResourceLimitsConfig(min=10000, resources=CvCConfig.ELEMENTS),