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

cogames/cogs_vs_clips/stations.py

@@ -2,8 +2,8 @@ from typing import Optional
 
 from pydantic import Field
 
+from cogames.cogs_vs_clips.config import CvCConfig
 from mettagrid.base_config import Config
-from mettagrid.config import vibes
 from mettagrid.config.handler_config import (
     AOEConfig,
     ClearInventoryMutation,
@@ -25,48 +25,11 @@ from mettagrid.config.handler_config import (
     withdraw,
 )
 from mettagrid.config.mettagrid_config import (
-    ChestConfig,
     GridObjectConfig,
     InventoryConfig,
     WallConfig,
 )
 
-resources = [
-    "energy",
-    "carbon",
-    "oxygen",
-    "germanium",
-    "silicon",
-    "heart",
-    "decoder",
-    "modulator",
-    "resonator",
-    "scrambler",
-]
-
-# CogsGuard constants
-GEAR = ["aligner", "scrambler", "miner", "scout"]
-ELEMENTS = ["oxygen", "carbon", "germanium", "silicon"]
-
-
-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()}
@@ -79,15 +42,10 @@ class CvCStationConfig(Config):
 
 class CvCWallConfig(CvCStationConfig):
     def station_cfg(self) -> WallConfig:
-        return WallConfig(name="wall", render_symbol=vibes.VIBE_BY_NAME["wall"].symbol)
-
+        return WallConfig(name="wall", render_symbol="⬛")
 
-# ==============================================================================
-# CogsGuard Station Configs
-# ==============================================================================
 
-
-class SimpleExtractorConfig(CvCStationConfig):
+class CvCExtractorConfig(CvCStationConfig):
     """Simple resource extractor with inventory that transfers resources to actors."""
 
     resource: str = Field(description="The resource to extract")
@@ -95,10 +53,9 @@ class SimpleExtractorConfig(CvCStationConfig):
     small_amount: int = Field(default=1, description="Amount extracted without mining equipment")
     large_amount: int = Field(default=10, description="Amount extracted with mining equipment")
 
-    def station_cfg(self) -> ChestConfig:
-        return ChestConfig(
+    def station_cfg(self) -> GridObjectConfig:
+        return GridObjectConfig(
             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
@@ -115,24 +72,18 @@ class SimpleExtractorConfig(CvCStationConfig):
         )
 
 
-class JunctionConfig(CvCStationConfig):
+class CvCJunctionConfig(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:
+    def station_cfg(self, team: Optional[str] = None) -> GridObjectConfig:
         return GridObjectConfig(
             name="junction",
-            map_name=self.map_name,
             render_symbol="📦",
-            collective=self.team,
+            collective=team,
             aoes={
                 "influence": AOEConfig(
                     radius=self.aoe_range,
@@ -148,30 +99,33 @@ class JunctionConfig(CvCStationConfig):
             on_use_handlers={
                 "deposit": Handler(
                     filters=[isAlignedToActor()],
-                    mutations=[collectiveDeposit({resource: 100 for resource in self.elements})],
+                    mutations=[collectiveDeposit({resource: 100 for resource in CvCConfig.ELEMENTS})],
                 ),
                 "align": Handler(
-                    filters=[isNeutral(), actorHas({"aligner": 1, "influence": 1, **self.align_cost})],
-                    mutations=[updateActor(_neg(self.align_cost)), alignToActor()],
+                    filters=[isNeutral(), actorHas({"aligner": 1, "influence": 1, **CvCConfig.ALIGN_COST})],
+                    mutations=[updateActor(_neg(CvCConfig.ALIGN_COST)), alignToActor()],
                 ),
                 "scramble": Handler(
-                    filters=[isEnemy(), actorHas({"scrambler": 1, **self.scramble_cost})],
-                    mutations=[removeAlignment(), updateActor(_neg(self.scramble_cost))],
+                    filters=[isEnemy(), actorHas({"scrambler": 1, **CvCConfig.SCRAMBLE_COST})],
+                    mutations=[removeAlignment(), updateActor(_neg(CvCConfig.SCRAMBLE_COST))],
                 ),
             },
         )
 
 
-class HubConfig(JunctionConfig):
-    """Main hub with influence AOE effect. A junction without align/scramble handlers."""
+class CvCHubConfig(CvCStationConfig):
+    """Hub station that provides AOE influence/attack and accepts deposits."""
 
-    def station_cfg(self) -> GridObjectConfig:
+    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: CvCConfig.ELEMENTS)
+
+    def station_cfg(self, team: str) -> GridObjectConfig:
         return GridObjectConfig(
             name="hub",
-            map_name=self.map_name,
-            render_name="hub",
             render_symbol="📦",
-            collective=self.team,
+            collective=team,
             aoes={
                 "influence": AOEConfig(
                     radius=self.aoe_range,
@@ -193,18 +147,16 @@ class HubConfig(JunctionConfig):
         )
 
 
-class CogsGuardChestConfig(CvCStationConfig):
-    """Chest for heart management in CogsGuard."""
+class CvCChestConfig(CvCStationConfig):
+    """Chest station for heart management."""
 
-    collective: str = Field(default="cogs", description="Collective this chest belongs to")
-    heart_cost: dict[str, int] = Field(default_factory=lambda: HEART_COST)
+    heart_cost: dict[str, int] = Field(default_factory=lambda: CvCConfig.HEART_COST)
 
-    def station_cfg(self) -> GridObjectConfig:
+    def station_cfg(self, team: str) -> GridObjectConfig:
         return GridObjectConfig(
             name="chest",
-            map_name="chest",
             render_symbol="📦",
-            collective=self.collective,
+            collective=team,
             on_use_handlers={
                 "get_heart": Handler(
                     filters=[isAlignedToActor(), targetCollectiveHas({"heart": 1})],
@@ -221,20 +173,19 @@ class CogsGuardChestConfig(CvCStationConfig):
         )
 
 
-class GearStationConfig(CvCStationConfig):
+class CvCGearStationConfig(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)
+    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) -> GridObjectConfig:
+    def station_cfg(self, team: str) -> 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,
+            render_symbol=self.gear_symbols[self.gear_type],
+            collective=team,
             on_use_handlers={
                 "keep_gear": Handler(
                     filters=[isAlignedToActor(), actorHas({self.gear_type: 1})],

cogames/cogs_vs_clips/team.py

@@ -0,0 +1,44 @@
+"""Team configuration for CogsGuard missions.
+
+Teams are named collectives (resource pools) shared by agents.
+"""
+
+from pydantic import Field
+
+from cogames.cogs_vs_clips.config import CvCConfig
+from mettagrid.base_config import Config
+from mettagrid.config.mettagrid_config import (
+    CollectiveConfig,
+    InventoryConfig,
+    ResourceLimitsConfig,
+)
+
+
+class CogTeam(Config):
+    """Configuration for a cogs team."""
+
+    name: str = Field(default="cogs", description="Team name")
+    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")
+
+    def collective_config(self) -> CollectiveConfig:
+        """Create a CollectiveConfig for this team.
+
+        Returns:
+            CollectiveConfig with resource limits and initial inventory.
+        """
+        return CollectiveConfig(
+            inventory=InventoryConfig(
+                limits={
+                    "resources": ResourceLimitsConfig(min=10000, resources=CvCConfig.ELEMENTS),
+                    "hearts": ResourceLimitsConfig(min=65535, resources=["heart"]),
+                },
+                initial={
+                    "carbon": 10 * self.wealth,
+                    "oxygen": 10 * self.wealth,
+                    "germanium": 10 * self.wealth,
+                    "silicon": 10 * self.wealth,
+                    "heart": 5 * self.wealth,
+                },
+            ),
+        )

cogames/cogs_vs_clips/{procedural.py → terrain.py}

@@ -1,9 +1,14 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
-from typing import Any, Literal, override
+from typing import TYPE_CHECKING, Any, Literal, override
 
 import numpy as np
 
-from cogames.cogs_vs_clips.mission import Mission, MissionVariant
+from cogames.core import CoGameMissionVariant
+
+if TYPE_CHECKING:
+    from cogames.cogs_vs_clips.mission import CvCMission
 from mettagrid.config.mettagrid_config import MettaGridConfig
 from mettagrid.mapgen.area import AreaWhere
 from mettagrid.mapgen.mapgen import MapGen, MapGenConfig
@@ -65,6 +70,7 @@ class MachinaArenaConfig(SceneConfig):
         corner_bundle="extractors",
         cross_bundle="none",
         cross_distance=7,
+        junction_object="junction",
     )
 
     # Optional asteroid-shaped boundary mask.
@@ -547,7 +553,7 @@ class RandomTransform(Scene[RandomTransformConfig]):
         ]
 
 
-class EnvNodeVariant[T](MissionVariant, ABC):
+class EnvNodeVariant[T](CoGameMissionVariant, ABC):
     @abstractmethod
     def extract_node(self, env: MettaGridConfig) -> T: ...
 
@@ -590,7 +596,7 @@ class MapSeedVariant(MapGenVariant):
 
 class BaseHubVariant(EnvNodeVariant[BaseHubConfig]):
     @override
-    def compat(self, mission: Mission) -> bool:
+    def compat(self, mission: CvCMission) -> bool:
         env = mission.make_env()
         if not isinstance(env.game.map_builder, MapGen.Config):
             return False
@@ -618,7 +624,7 @@ class BaseHubVariant(EnvNodeVariant[BaseHubConfig]):
 
 
 class MachinaArenaVariant(EnvNodeVariant[MachinaArenaConfig]):
-    def compat(self, mission: Mission) -> bool:
+    def compat(self, mission: CvCMission) -> bool:
         env = mission.make_env()
         return isinstance(env.game.map_builder, MapGen.Config) and isinstance(
             env.game.map_builder.instance, MachinaArena.Config
@@ -632,7 +638,7 @@ class MachinaArenaVariant(EnvNodeVariant[MachinaArenaConfig]):
 
 
 class SequentialMachinaArenaVariant(EnvNodeVariant[SequentialMachinaArenaConfig]):
-    def compat(self, mission: Mission) -> bool:
+    def compat(self, mission: CvCMission) -> bool:
         env = mission.make_env()
         return isinstance(env.game.map_builder, MapGen.Config) and isinstance(
             env.game.map_builder.instance, SequentialMachinaArena.Config

cogames/cogs_vs_clips/variants.py

@@ -1,95 +1,74 @@
-from typing import override
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, override
 
 from cogames.cogs_vs_clips.evals.difficulty_variants import DIFFICULTY_VARIANTS
-from cogames.cogs_vs_clips.mission import Mission, MissionVariant
-from cogames.cogs_vs_clips.procedural import BaseHubVariant, MachinaArenaVariant
-from mettagrid.config.action_config import VibeTransfer
-from mettagrid.config.game_value import stat
-from mettagrid.config.reward_config import reward
+from cogames.cogs_vs_clips.terrain import BaseHubVariant, MachinaArenaVariant
+from cogames.core import CoGameMissionVariant
 from mettagrid.map_builder.map_builder import MapBuilderConfig
 from mettagrid.mapgen.mapgen import MapGen
 from mettagrid.mapgen.scenes.base_hub import DEFAULT_EXTRACTORS as HUB_EXTRACTORS
 from mettagrid.mapgen.scenes.building_distributions import DistributionConfig, DistributionType
 
+if TYPE_CHECKING:
+    from cogames.cogs_vs_clips.mission import CvCMission
+
+
+class NumCogsVariant(CoGameMissionVariant):
+    name: str = "num_cogs"
+    description: str = "Set the number of cogs for the mission."
+    num_cogs: int
 
-class DarkSideVariant(MissionVariant):
+    @override
+    def modify_mission(self, mission: CvCMission) -> None:
+        if self.num_cogs < mission.site.min_cogs or self.num_cogs > mission.site.max_cogs:
+            raise ValueError(
+                f"Invalid number of cogs for {mission.site.name}: {self.num_cogs}. "
+                + f"Must be between {mission.site.min_cogs} and {mission.site.max_cogs}"
+            )
+
+        mission.num_cogs = self.num_cogs
+
+
+class DarkSideVariant(CoGameMissionVariant):
     name: str = "dark_side"
     description: str = "You're on the dark side of the asteroid. You recharge slower."
 
     @override
-    def modify_mission(self, mission):
-        assert isinstance(mission, Mission)
+    def modify_mission(self, mission: CvCMission) -> None:
         mission.cog.energy_regen = 0
 
 
-class SuperChargedVariant(MissionVariant):
+class SuperChargedVariant(CoGameMissionVariant):
     name: str = "super_charged"
     description: str = "The sun is shining on you. You recharge faster."
 
     @override
-    def modify_mission(self, mission):
-        assert isinstance(mission, Mission)
+    def modify_mission(self, mission: CvCMission) -> None:
         mission.cog.energy_regen += 2
 
 
-class RoughTerrainVariant(MissionVariant):
-    name: str = "rough_terrain"
-    description: str = "The terrain is rough. Moving is more energy intensive."
-
-    @override
-    def modify_mission(self, mission):
-        assert isinstance(mission, Mission)
-        mission.cog.move_energy_cost += 2
-
-
-class PackRatVariant(MissionVariant):
-    name: str = "pack_rat"
-    description: str = "Raise heart, cargo, energy, and gear caps to 255."
-
-    @override
-    def modify_mission(self, mission):
-        assert isinstance(mission, Mission)
-        mission.cog.heart_limit = max(mission.cog.heart_limit, 255)
-        mission.cog.energy_limit = max(mission.cog.energy_limit, 255)
-        mission.cog.cargo_limit = max(mission.cog.cargo_limit, 255)
-        mission.cog.gear_limit = max(mission.cog.gear_limit, 255)
-
-
-class EnergizedVariant(MissionVariant):
+class EnergizedVariant(CoGameMissionVariant):
     name: str = "energized"
     description: str = "Max energy and full regen so agents never run dry."
 
     @override
-    def modify_mission(self, mission):
-        assert isinstance(mission, Mission)
+    def modify_mission(self, mission: CvCMission) -> None:
         mission.cog.energy_limit = max(mission.cog.energy_limit, 255)
         mission.cog.energy_regen = mission.cog.energy_limit
 
 
-class CompassVariant(MissionVariant):
-    name: str = "compass"
-    description: str = "Enable compass observation."
-
-    @override
-    def modify_env(self, mission, env):
-        env.game.obs.global_obs.compass = True
-
-
-class Small50Variant(MissionVariant):
+class Small50Variant(CoGameMissionVariant):
     name: str = "small_50"
     description: str = "Set map size to 50x50 for quick runs."
 
     def modify_env(self, mission, env) -> None:
         map_builder = env.game.map_builder
-        # Only set width/height if instance is a SceneConfig, not a MapBuilderConfig
-        # When instance is a MapBuilderConfig, width and height must be None
         if isinstance(map_builder, MapGen.Config) and isinstance(map_builder.instance, MapBuilderConfig):
-            # Skip setting width/height for MapBuilderConfig instances
             return
         env.game.map_builder = map_builder.model_copy(update={"width": 50, "height": 50})
 
 
-# Biome variants (weather) for procedural maps
 class DesertVariant(MachinaArenaVariant):
     name: str = "desert"
     description: str = "The desert sands make navigation challenging."
@@ -117,7 +96,6 @@ class CityVariant(MachinaArenaVariant):
     def modify_node(self, node):
         node.biome_weights = {"city": 1.0, "caves": 0.0, "desert": 0.0, "forest": 0.0}
         node.base_biome = "city"
-        # Fill almost the entire map with the city layer
         node.density_scale = 1.0
         node.biome_count = 1
         node.max_biome_zone_fraction = 0.95
@@ -140,32 +118,29 @@ class DistantResourcesVariant(MachinaArenaVariant):
 
     @override
     def modify_node(self, node):
-        # Bias buildings toward the map edges using bimodal clusters centered at
         node.building_coverage = 0.01
 
         vertical_edges = DistributionConfig(
             type=DistributionType.BIMODAL,
-            center1_x=0.92,  # top right corner
+            center1_x=0.92,
             center1_y=0.08,
-            center2_x=0.08,  # bottom left corner
+            center2_x=0.08,
             center2_y=0.92,
             cluster_std=0.18,
         )
         horizontal_edges = DistributionConfig(
             type=DistributionType.BIMODAL,
-            center1_x=0.08,  # top left corner
+            center1_x=0.08,
             center1_y=0.08,
-            center2_x=0.92,  # bottom right corner
+            center2_x=0.92,
             center2_y=0.92,
             cluster_std=0.18,
         )
 
-        # Apply edge-biased distributions to extractors; other buildings follow the global distribution
         names = list(self.building_names)
         node.building_distributions = {
             name: (vertical_edges if i % 2 == 0 else horizontal_edges) for i, name in enumerate(names)
         }
-        # Fallback for any unspecified building types
         node.distribution = DistributionConfig(type=DistributionType.UNIFORM)
 
 
@@ -180,10 +155,10 @@ class QuadrantBuildingsVariant(MachinaArenaVariant):
 
         names = list(node.building_names or self.building_names)
         centers = [
-            (0.25, 0.25),  # top-left
-            (0.75, 0.25),  # top-right
-            (0.25, 0.75),  # bottom-left
-            (0.75, 0.75),  # bottom-right
+            (0.25, 0.25),
+            (0.75, 0.25),
+            (0.25, 0.75),
+            (0.75, 0.75),
         ]
         dists: dict[str, DistributionConfig] = {}
         for i, name in enumerate(names):
@@ -206,8 +181,6 @@ class SingleResourceUniformVariant(MachinaArenaVariant):
 
     @override
     def modify_node(self, node):
-        # Resolve resource to a concrete building name
-        # Restrict building set to only the chosen building and enforce uniform distribution
         node.building_names = [self.building_name]
         node.building_weights = {self.building_name: 1.0}
         node.building_distributions = None
@@ -217,12 +190,10 @@ class SingleResourceUniformVariant(MachinaArenaVariant):
 class EmptyBaseVariant(BaseHubVariant):
     name: str = "empty_base"
     description: str = "Base hub with extractors removed from the four corners."
-    # Extractor object names to remove, e.g., ["oxygen_extractor"]
     missing: list[str] = list(HUB_EXTRACTORS)
 
     @override
     def modify_node(self, node):
-        # Use the default extractor order and blank out any that are missing
         missing_set = set(self.missing or [])
         corner_objects = [name if name not in missing_set else "" for name in HUB_EXTRACTORS]
         node.corner_objects = corner_objects
@@ -230,8 +201,6 @@ class EmptyBaseVariant(BaseHubVariant):
 
 
 class BalancedCornersVariant(MachinaArenaVariant):
-    """Enable corner balancing to ensure fair spawn distances."""
-
     name: str = "balanced_corners"
     description: str = "Balance path distances from center to corners for fair spawns."
     balance_tolerance: float = 1.5
@@ -244,65 +213,19 @@ class BalancedCornersVariant(MachinaArenaVariant):
         node.max_balance_shortcuts = self.max_balance_shortcuts
 
 
-class TraderVariant(MissionVariant):
-    name: str = "trader"
-    description: str = "Agents can trade resources with each other."
-
-    @override
-    def modify_env(self, mission, env):
-        # Define vibe transfers for trading resources (actor gives, target receives)
-        trade_transfers = [
-            VibeTransfer(vibe="carbon_a", target={"carbon": 1}, actor={"carbon": -1}),
-            VibeTransfer(vibe="carbon_b", target={"carbon": 10}, actor={"carbon": -10}),
-            VibeTransfer(vibe="oxygen_a", target={"oxygen": 1}, actor={"oxygen": -1}),
-            VibeTransfer(vibe="oxygen_b", target={"oxygen": 10}, actor={"oxygen": -10}),
-            VibeTransfer(vibe="germanium_a", target={"germanium": 1}, actor={"germanium": -1}),
-            VibeTransfer(vibe="germanium_b", target={"germanium": 4}, actor={"germanium": -4}),
-            VibeTransfer(vibe="silicon_a", target={"silicon": 10}, actor={"silicon": -10}),
-            VibeTransfer(vibe="silicon_b", target={"silicon": 50}, actor={"silicon": -50}),
-            VibeTransfer(vibe="heart_a", target={"heart": 1}, actor={"heart": -1}),
-            VibeTransfer(vibe="heart_b", target={"heart": 4}, actor={"heart": -4}),
-        ]
-        # Enable transfer action with these vibes
-        env.game.actions.transfer.enabled = True
-        env.game.actions.transfer.vibe_transfers.extend(trade_transfers)
-
-
-class SharedRewardsVariant(MissionVariant):
-    name: str = "shared_rewards"
-    description: str = "Rewards for deposited hearts are shared among all agents."
-
-    @override
-    def modify_env(self, mission, env):
-        num_cogs = mission.num_cogs if mission.num_cogs is not None else mission.site.min_cogs
-        env.game.agent.rewards["chest_heart_deposited_by_agent"] = reward(
-            stat("chest.heart.deposited_by_agent"), weight=0
-        )
-        env.game.agent.rewards["chest_heart_amount"] = reward(stat("chest.heart.amount"), weight=1 / num_cogs)
-
-
-# TODO - validate that all variant names are unique
-VARIANTS: list[MissionVariant] = [
+VARIANTS: list[CoGameMissionVariant] = [
     CavesVariant(),
     CityVariant(),
-    CompassVariant(),
     DarkSideVariant(),
     DesertVariant(),
     EmptyBaseVariant(),
     EnergizedVariant(),
     ForestVariant(),
-    PackRatVariant(),
     QuadrantBuildingsVariant(),
-    RoughTerrainVariant(),
-    SharedRewardsVariant(),
     SingleResourceUniformVariant(),
     Small50Variant(),
     SuperChargedVariant(),
-    TraderVariant(),
     *DIFFICULTY_VARIANTS,
 ]
 
-# Hidden variants registry: Remains usable but will NOT appear in `cogames variants` listing
-HIDDEN_VARIANTS: list[MissionVariant] = [
-    # Example: ExperimentalVariant(),  # keep empty by default
-]
+HIDDEN_VARIANTS: list[CoGameMissionVariant] = []