cogames 0.3.49__py3-none-any.whl → 0.3.64__py3-none-any.whl

cogames/cogs_vs_clips/procedural.py

@@ -52,7 +52,7 @@ class MachinaArenaConfig(SceneConfig):
     #### Building placement ####
 
     # How much of the map is covered by buildings
-    building_coverage: float = 0.0175
+    building_coverage: float = 0.05
     # Resource placement (building-based API)
     # Defines the set of buildings that can be placed on the map
     building_names: list[str] | None = None
@@ -113,8 +113,8 @@ class MachinaArena(Scene[MachinaArenaConfig]):
         # Building weights
         default_building_weights = {
             "chest": 0.0,
-            "charger": 0.6,
-            "germanium_extractor": 0.5,
+            "junction": 0.7,
+            "germanium_extractor": 0.3,
             "silicon_extractor": 0.3,
             "oxygen_extractor": 0.3,
             "carbon_extractor": 0.3,
@@ -372,11 +372,11 @@ class SequentialMachinaArena(Scene[SequentialMachinaArenaConfig]):
         base_cfg: SceneConfig = BaseCfgModel.model_validate(cfg.base_biome_config or {})
         default_building_weights = {
             "chest": 0.0,
-            "charger": 0.6,
-            "germanium_extractor": 0.5,
-            "silicon_extractor": 0.3,
-            "oxygen_extractor": 0.3,
-            "carbon_extractor": 0.3,
+            "junction": 0.6,
+            "germanium_extractor": 0.2,
+            "silicon_extractor": 0.2,
+            "oxygen_extractor": 0.2,
+            "carbon_extractor": 0.2,
         }
         weights_dict: dict[str, float] = {str(k): v for k, v in (cfg.building_weights or {}).items()}
         if not weights_dict:

cogames/cogs_vs_clips/sites.py

@@ -1,10 +1,12 @@
 """Central site definitions shared across mission modules."""
 
+from typing import cast
+
 from cogames.cogs_vs_clips.mission import Site
 from cogames.cogs_vs_clips.mission_utils import get_map
 from cogames.cogs_vs_clips.procedural import MachinaArena, RandomTransform, SequentialMachinaArena
-from mettagrid.mapgen.mapgen import MapGen
-from mettagrid.mapgen.scenes.base_hub import BaseHub
+from mettagrid.mapgen.mapgen import MapGen, MapGenConfig
+from mettagrid.mapgen.scenes.base_hub import BaseHub, BaseHubConfig
 
 TRAINING_FACILITY = Site(
     name="training_facility",
@@ -46,6 +48,22 @@ MACHINA_1 = Site(
     max_cogs=20,
 )
 
+
+def _cogsguard_hub_config() -> BaseHubConfig:
+    return BaseHubConfig(
+        corner_bundle="extractors",
+        cross_bundle="none",
+        cross_distance=7,
+        stations=[
+            "aligner_station",
+            "scrambler_station",
+            "miner_station",
+            "scout_station",
+            "chest",
+        ],
+    )
+
+
 # Evals site used by diagnostic evaluation missions
 # Note: Individual diagnostic missions override this with their own specific maps
 EVALS = Site(
@@ -56,9 +74,95 @@ EVALS = Site(
     max_cogs=8,
 )
 
-SITES = [
+
+def make_cogsguard_arena_site(num_agents: int = 10) -> Site:
+    """Create a CogsGuard arena site with configurable agent count."""
+    map_builder = MapGen.Config(
+        width=50,
+        height=50,
+        instance=MachinaArena.Config(
+            spawn_count=num_agents,
+            building_coverage=0.1,
+            hub=_cogsguard_hub_config(),
+        ),
+    )
+    return Site(
+        name="cogsguard_arena",
+        description="CogsGuard arena map",
+        map_builder=map_builder,
+        min_cogs=num_agents,
+        max_cogs=num_agents,
+    )
+
+
+def _build_cogsguard_machina1_map_builder(spawn_count: int) -> MapGenConfig:
+    map_builder = cast(MapGenConfig, MACHINA_1.map_builder).model_copy(deep=True)
+    instance = map_builder.instance
+    assert instance is not None
+    return map_builder.model_copy(
+        update={
+            "instance": instance.model_copy(
+                update={
+                    "spawn_count": spawn_count,
+                    "hub": _cogsguard_hub_config(),
+                }
+            ),
+        }
+    )
+
+
+def make_cogsguard_machina1_site(num_agents: int = 10) -> Site:
+    """Create a CogsGuard Machina1 site with configurable agent count."""
+    return Site(
+        name="cogsguard_machina_1",
+        description="CogsGuard Machina1 layout with gear stations.",
+        map_builder=_build_cogsguard_machina1_map_builder(num_agents),
+        min_cogs=num_agents,
+        max_cogs=num_agents,
+    )
+
+
+# Default CogsGuard Machina1 site with flexible agent count
+COGSGUARD_MACHINA_1 = Site(
+    name="cogsguard_machina_1",
+    description="CogsGuard Machina1 layout with gear stations.",
+    map_builder=_build_cogsguard_machina1_map_builder(20),
+    min_cogs=1,
+    max_cogs=20,
+)
+
+# Default CogsGuard arena site with flexible agent count
+COGSGUARD_ARENA = Site(
+    name="cogsguard_arena",
+    description="CogsGuard arena - compact training map with gear stations.",
+    map_builder=MapGen.Config(
+        width=50,
+        height=50,
+        instance=MachinaArena.Config(
+            spawn_count=20,
+            building_coverage=0.1,
+            hub=_cogsguard_hub_config(),
+        ),
+    ),
+    min_cogs=1,
+    max_cogs=20,
+)
+
+
+# Feature flag: Set to True to include legacy (pre-CogsGuard) sites in the CLI.
+# To enable, add TRAINING_FACILITY, HELLO_WORLD, MACHINA_1 to SITES below.
+# Also set _INCLUDE_LEGACY_MISSIONS = True in missions.py.
+_INCLUDE_LEGACY_SITES = False
+
+_LEGACY_SITES = [
     TRAINING_FACILITY,
     HELLO_WORLD,
     MACHINA_1,
+]
+
+SITES = [
+    COGSGUARD_MACHINA_1,
+    COGSGUARD_ARENA,
     EVALS,
+    *(_LEGACY_SITES if _INCLUDE_LEGACY_SITES else []),
 ]

cogames/cogs_vs_clips/stations.py

@@ -1,13 +1,33 @@
+from typing import Optional
+
 from pydantic import Field
 
 from mettagrid.base_config import Config
 from mettagrid.config import vibes
+from mettagrid.config.handler_config import (
+    AOEConfig,
+    ClearInventoryMutation,
+    EntityTarget,
+    Handler,
+    actorCollectiveHas,
+    actorHas,
+    alignToActor,
+    collectiveDeposit,
+    collectiveWithdraw,
+    isAlignedToActor,
+    isEnemy,
+    isNeutral,
+    removeAlignment,
+    targetCollectiveHas,
+    updateActor,
+    updateTarget,
+    updateTargetCollective,
+    withdraw,
+)
 from mettagrid.config.mettagrid_config import (
-    AssemblerConfig,
     ChestConfig,
     GridObjectConfig,
     InventoryConfig,
-    ProtocolConfig,
     WallConfig,
 )
 
@@ -24,11 +44,35 @@ resources = [
     "scrambler",
 ]
 
+# CogsGuard constants
+GEAR = ["aligner", "scrambler", "miner", "scout"]
+ELEMENTS = ["oxygen", "carbon", "germanium", "silicon"]
 
-class CvCStationConfig(Config):
-    start_clipped: bool = Field(default=False)
-    clip_immune: bool = Field(default=False)
 
+HEART_COST = {e: 10 for e in ELEMENTS}
+COGSGUARD_ALIGN_COST = {"heart": 1}
+COGSGUARD_SCRAMBLE_COST = {"heart": 1}
+
+GEAR_COSTS = {
+    "aligner": {"carbon": 3, "oxygen": 1, "germanium": 1, "silicon": 1},
+    "scrambler": {"carbon": 1, "oxygen": 3, "germanium": 1, "silicon": 1},
+    "miner": {"carbon": 1, "oxygen": 1, "germanium": 3, "silicon": 1},
+    "scout": {"carbon": 1, "oxygen": 1, "germanium": 1, "silicon": 3},
+}
+
+GEAR_SYMBOLS = {
+    "aligner": "🔗",
+    "scrambler": "🌀",
+    "miner": "⛏️",
+    "scout": "🔭",
+}
+
+
+def _neg(recipe: dict[str, int]) -> dict[str, int]:
+    return {k: -v for k, v in recipe.items()}
+
+
+class CvCStationConfig(Config):
     def station_cfg(self) -> GridObjectConfig:
         raise NotImplementedError("Subclasses must implement this method")
 
@@ -38,203 +82,171 @@ class CvCWallConfig(CvCStationConfig):
         return WallConfig(name="wall", render_symbol=vibes.VIBE_BY_NAME["wall"].symbol)
 
 
-class ExtractorConfig(CvCStationConfig):
-    """Base class for all extractor configs."""
-
-    # How much this extractor produces relative to its default.
-    # Efficiency outside of this range won't technically break things, but they'll be far enough from the
-    # expectations that we don't want to go beyond them without some thought.
-    efficiency: int = Field(ge=20, le=500, default=100)
-    # How much additional agents increase production.
-    # Scaled so 0 means none and 100 means some version of "twice as much".
-    synergy: int = Field(default=0)
-    max_uses: int = Field()
-
-
-class ChargerConfig(ExtractorConfig):
-    max_uses: int = 0  # unlimited uses
-
-    def station_cfg(self) -> AssemblerConfig:
-        output = 50 * self.efficiency // 100
-        return AssemblerConfig(
-            name="charger",
-            render_symbol=vibes.VIBE_BY_NAME["charger"].symbol,
-            # Protocols
-            allow_partial_usage=True,  # can use it while its on cooldown
-            max_uses=self.max_uses,
-            protocols=[
-                ProtocolConfig(
-                    min_agents=(additional_agents + 1) if additional_agents >= 1 else 0,
-                    output_resources={"energy": output * (100 + additional_agents * self.synergy) // 100},
-                    cooldown=10,
-                )
-                for additional_agents in range(4)
-            ],
-            # Clipping
-            start_clipped=self.start_clipped,
-            clip_immune=self.clip_immune,
-        )
+# ==============================================================================
+# CogsGuard Station Configs
+# ==============================================================================
 
 
-# Time consuming but easy to mine.
-class CarbonExtractorConfig(ExtractorConfig):
-    max_uses: int = Field(default=25)
-
-    def station_cfg(self) -> AssemblerConfig:
-        output = 2 * self.efficiency // 100
-        return AssemblerConfig(
-            name="carbon_extractor",
-            render_symbol=vibes.VIBE_BY_NAME["carbon_a"].symbol,
-            max_uses=self.max_uses,
-            protocols=[
-                ProtocolConfig(
-                    min_agents=(additional_agents + 1) if additional_agents >= 1 else 0,
-                    output_resources={"carbon": output * (100 + additional_agents * self.synergy) // 100},
-                    cooldown=0,
-                )
-                for additional_agents in range(4)
-            ],
-            # Clipping
-            start_clipped=self.start_clipped,
-            clip_immune=self.clip_immune,
-        )
+class SimpleExtractorConfig(CvCStationConfig):
+    """Simple resource extractor with inventory that transfers resources to actors."""
 
+    resource: str = Field(description="The resource to extract")
+    initial_amount: int = Field(default=100, description="Initial amount of resource in extractor")
+    small_amount: int = Field(default=1, description="Amount extracted without mining equipment")
+    large_amount: int = Field(default=10, description="Amount extracted with mining equipment")
 
-# Accumulates over time.
-class OxygenExtractorConfig(ExtractorConfig):
-    max_uses: int = Field(default=5)
-
-    def station_cfg(self) -> AssemblerConfig:
-        # efficiency impacts cooldown, not output
-        output = 10
-        return AssemblerConfig(
-            name="oxygen_extractor",
-            render_symbol=vibes.VIBE_BY_NAME["oxygen_a"].symbol,
-            max_uses=self.max_uses,
-            allow_partial_usage=True,  # can use it while its on cooldown
-            protocols=[
-                ProtocolConfig(
-                    min_agents=(additional_agents + 1) if additional_agents >= 1 else 0,
-                    output_resources={"oxygen": output * (100 + additional_agents * self.synergy) // 100},
-                    cooldown=int(10_000 / self.efficiency),
-                )
-                for additional_agents in range(4)
-            ],
-            # Clipping
-            start_clipped=self.start_clipped,
-            clip_immune=self.clip_immune,
+    def station_cfg(self) -> ChestConfig:
+        return ChestConfig(
+            name=f"{self.resource}_extractor",
+            map_name=f"{self.resource}_extractor",
+            render_symbol="📦",
+            on_use_handlers={
+                # Order matters: miner first so agents with miner gear get the bonus
+                "miner": Handler(
+                    filters=[actorHas({"miner": 1})],
+                    mutations=[withdraw({self.resource: self.large_amount}, remove_when_empty=True)],
+                ),
+                "extract": Handler(
+                    filters=[],
+                    mutations=[withdraw({self.resource: self.small_amount}, remove_when_empty=True)],
+                ),
+            },
+            inventory=InventoryConfig(initial={self.resource: self.initial_amount}),
         )
 
 
-# Rare regenerates slowly. More cogs increase the amount extracted.
-class GermaniumExtractorConfig(ExtractorConfig):
-    max_uses: int = Field(default=5)
-    synergy: int = 50
-
-    def station_cfg(self) -> AssemblerConfig:
-        # efficiency impacts cooldown, not output
-        output = 2
-        return AssemblerConfig(
-            name="germanium_extractor",
-            render_symbol=vibes.VIBE_BY_NAME["germanium_a"].symbol,
-            max_uses=self.max_uses,
-            protocols=[
-                ProtocolConfig(
-                    min_agents=(additional_agents + 1) if additional_agents >= 1 else 0,
-                    output_resources={"germanium": output * (100 + additional_agents * self.synergy) // 100},
-                    cooldown=int(20_000 / self.efficiency),
-                )
-                for additional_agents in range(4)
-            ],
-            # Clipping
-            start_clipped=self.start_clipped,
-            clip_immune=self.clip_immune,
+class JunctionConfig(CvCStationConfig):
+    """Supply depot that receives element resources via default vibe into collective."""
+
+    map_name: str = Field(description="Map name for this junction")
+    team: Optional[str] = Field(default=None, description="Team/collective this junction belongs to")
+    aoe_range: int = Field(default=10, description="Range for AOE effects")
+    influence_deltas: dict[str, int] = Field(default_factory=lambda: {"influence": 10, "energy": 100, "hp": 100})
+    attack_deltas: dict[str, int] = Field(default_factory=lambda: {"hp": -1, "influence": -100})
+    elements: list[str] = Field(default_factory=lambda: ELEMENTS)
+    align_cost: dict[str, int] = Field(default_factory=lambda: COGSGUARD_ALIGN_COST)
+    scramble_cost: dict[str, int] = Field(default_factory=lambda: COGSGUARD_SCRAMBLE_COST)
+
+    def station_cfg(self) -> GridObjectConfig:
+        return GridObjectConfig(
+            name="junction",
+            map_name=self.map_name,
+            render_symbol="📦",
+            collective=self.team,
+            aoes={
+                "influence": AOEConfig(
+                    radius=self.aoe_range,
+                    filters=[isAlignedToActor()],
+                    mutations=[updateTarget(self.influence_deltas)],
+                ),
+                "attack": AOEConfig(
+                    radius=self.aoe_range,
+                    filters=[isEnemy()],
+                    mutations=[updateTarget(self.attack_deltas)],
+                ),
+            },
+            on_use_handlers={
+                "deposit": Handler(
+                    filters=[isAlignedToActor()],
+                    mutations=[collectiveDeposit({resource: 100 for resource in self.elements})],
+                ),
+                "align": Handler(
+                    filters=[isNeutral(), actorHas({"aligner": 1, "influence": 1, **self.align_cost})],
+                    mutations=[updateActor(_neg(self.align_cost)), alignToActor()],
+                ),
+                "scramble": Handler(
+                    filters=[isEnemy(), actorHas({"scrambler": 1, **self.scramble_cost})],
+                    mutations=[removeAlignment(), updateActor(_neg(self.scramble_cost))],
+                ),
+            },
         )
 
 
-# Bulky and energy intensive.
-class SiliconExtractorConfig(ExtractorConfig):
-    max_uses: int = Field(default=10)
-
-    def station_cfg(self) -> AssemblerConfig:
-        output = 15 * self.efficiency // 100
-        return AssemblerConfig(
-            name="silicon_extractor",
-            render_symbol=vibes.VIBE_BY_NAME["silicon_a"].symbol,
-            max_uses=self.max_uses,
-            protocols=[
-                ProtocolConfig(
-                    min_agents=(additional_agents + 1) if additional_agents >= 1 else 0,
-                    input_resources={"energy": 20},
-                    output_resources={"silicon": output * (100 + additional_agents * self.synergy) // 100},
-                )
-                for additional_agents in range(4)
-            ],
-            # Clipping
-            start_clipped=self.start_clipped,
-            clip_immune=self.clip_immune,
+class HubConfig(JunctionConfig):
+    """Main hub with influence AOE effect. A junction without align/scramble handlers."""
+
+    def station_cfg(self) -> GridObjectConfig:
+        return GridObjectConfig(
+            name="hub",
+            map_name=self.map_name,
+            render_name="hub",
+            render_symbol="📦",
+            collective=self.team,
+            aoes={
+                "influence": AOEConfig(
+                    radius=self.aoe_range,
+                    filters=[isAlignedToActor()],
+                    mutations=[updateTarget(self.influence_deltas)],
+                ),
+                "attack": AOEConfig(
+                    radius=self.aoe_range,
+                    filters=[isEnemy()],
+                    mutations=[updateTarget(self.attack_deltas)],
+                ),
+            },
+            on_use_handlers={
+                "deposit": Handler(
+                    filters=[isAlignedToActor()],
+                    mutations=[collectiveDeposit({resource: 100 for resource in self.elements})],
+                ),
+            },
         )
 
 
-class CvCChestConfig(CvCStationConfig):
-    initial_inventory: dict[str, int] = Field(default={}, description="Initial inventory for each resource type")
+class CogsGuardChestConfig(CvCStationConfig):
+    """Chest for heart management in CogsGuard."""
 
-    def station_cfg(self) -> ChestConfig:
-        # Use map_name/name "chest" so maps and procedural builders that place
-        # "chest" resolve to this config. The specific CvC type remains a label.
-        return ChestConfig(
-            render_symbol=vibes.VIBE_BY_NAME["chest"].symbol,
-            vibe_transfers={
-                "default": {"heart": 255, "carbon": 255, "oxygen": 255, "germanium": 255, "silicon": 255},
-                "heart_a": {"heart": 0},
-                "heart_b": {"heart": 1},
-                "carbon_a": {"carbon": -10},
-                "carbon_b": {"carbon": 10},
-                "oxygen_a": {"oxygen": -10},
-                "oxygen_b": {"oxygen": 10},
-                "germanium_a": {"germanium": -1},
-                "germanium_b": {"germanium": 1},
-                "silicon_a": {"silicon": -25},
-                "silicon_b": {"silicon": 25},
+    collective: str = Field(default="cogs", description="Collective this chest belongs to")
+    heart_cost: dict[str, int] = Field(default_factory=lambda: HEART_COST)
+
+    def station_cfg(self) -> GridObjectConfig:
+        return GridObjectConfig(
+            name="chest",
+            map_name="chest",
+            render_symbol="📦",
+            collective=self.collective,
+            on_use_handlers={
+                "get_heart": Handler(
+                    filters=[isAlignedToActor(), targetCollectiveHas({"heart": 1})],
+                    mutations=[collectiveWithdraw({"heart": 1})],
+                ),
+                "make_heart": Handler(
+                    filters=[isAlignedToActor(), targetCollectiveHas(self.heart_cost)],
+                    mutations=[
+                        updateTargetCollective(_neg(self.heart_cost)),
+                        updateActor({"heart": 1}),
+                    ],
+                ),
             },
-            inventory=InventoryConfig(initial=self.initial_inventory),
         )
 
 
-class CvCAssemblerConfig(CvCStationConfig):
-    # These could be "fixed_cost" and "variable_cost" instead, but we're more likely to want to read them like this.
-    first_heart_cost: int = Field(default=10)
-    additional_heart_cost: int = Field(default=5)
-
-    def station_cfg(self) -> AssemblerConfig:
-        gear = [("carbon", "decoder"), ("oxygen", "modulator"), ("germanium", "scrambler"), ("silicon", "resonator")]
-        return AssemblerConfig(
-            name="assembler",
-            render_symbol=vibes.VIBE_BY_NAME["assembler"].symbol,
-            clip_immune=True,
-            protocols=[
-                ProtocolConfig(
-                    vibes=["heart_a"] * (i + 1),
-                    input_resources={
-                        "carbon": self.first_heart_cost + self.additional_heart_cost * i,
-                        "oxygen": self.first_heart_cost + self.additional_heart_cost * i,
-                        "germanium": max(1, (self.first_heart_cost + self.additional_heart_cost * i) // 5),
-                        "silicon": 3 * (self.first_heart_cost + self.additional_heart_cost * i),
-                    },
-                    output_resources={"heart": i + 1},
-                )
-                for i in range(4)
-            ]
-            + [
-                # Specific gear protocols: ['gear', 'resource'] -> gear_item
-                # Agent must have the specific resource AND use gear vibe
-                ProtocolConfig(
-                    vibes=["gear", f"{gear[i][0]}_a"],
-                    input_resources={gear[i][0]: 1},
-                    output_resources={gear[i][1]: 1},
-                )
-                for i in range(len(gear))
-            ],
-            # Note: Generic ['gear'] protocol is added dynamically by clipping variants
-            # C++ only allows ONE protocol per unique vibe list, so we can't pre-add all 4 here
+class GearStationConfig(CvCStationConfig):
+    """Gear station that clears all gear and adds the specified gear type."""
+
+    gear_type: str = Field(description="Type of gear this station provides")
+    collective: str = Field(default="cogs", description="Collective this station belongs to")
+    gear_costs: dict[str, dict[str, int]] = Field(default_factory=lambda: GEAR_COSTS)
+
+    def station_cfg(self) -> GridObjectConfig:
+        cost = self.gear_costs.get(self.gear_type, {})
+        return GridObjectConfig(
+            name=f"{self.gear_type}_station",
+            map_name=f"{self.gear_type}_station",
+            render_symbol=GEAR_SYMBOLS.get(self.gear_type, "⚙️"),
+            collective=self.collective,
+            on_use_handlers={
+                "keep_gear": Handler(
+                    filters=[isAlignedToActor(), actorHas({self.gear_type: 1})],
+                    mutations=[],
+                ),
+                "change_gear": Handler(
+                    filters=[isAlignedToActor(), actorCollectiveHas(cost)],
+                    mutations=[
+                        ClearInventoryMutation(target=EntityTarget.ACTOR, limit_name="gear"),
+                        updateTargetCollective(_neg(cost)),
+                        updateActor({self.gear_type: 1}),
+                    ],
+                ),
+            },
         )

cogames/cogs_vs_clips/tutorial_missions.py

@@ -10,7 +10,7 @@ class TutorialVariant(MissionVariant):
 
     @override
     def modify_mission(self, mission: Mission) -> None:
-        mission.energy_regen_amount = 1
+        mission.cog.energy_regen = 1
 
     @override
     def modify_env(self, mission: Mission, env) -> None: