cp

Author: daveey

packages/mettagrid/cpp/bindings/mettagrid_c.cpp

@@ -14,13 +14,10 @@
 
 #include "actions/action_handler.hpp"
 #include "actions/attack.hpp"
-#include "actions/build.hpp"
-#include "actions/build_config.hpp"
 #include "actions/change_vibe.hpp"
 #include "actions/move.hpp"
 #include "actions/move_config.hpp"
 #include "actions/noop.hpp"
-#include "actions/transfer.hpp"
 #include "config/observation_features.hpp"
 #include "core/grid.hpp"
 #include "core/types.hpp"
@@ -85,15 +82,10 @@ MettaGrid::MettaGrid(const GameConfig& game_config, const py::list map, unsigned
 
   _action_success.resize(num_agents);
 
-  init_action_handlers();
+  init_action_handlers(_game_config);
 
   _init_grid(_game_config, map);
 
-  // Set runtime context for Build handler (needs obs_encoder and agents count)
-  if (_build_handler) {
-    _build_handler->set_runtime_context(&current_step, _obs_encoder.get(), num_agents);
-  }
-
   // Pre-compute goal_obs tokens for each agent
   if (_global_obs_config.goal_obs) {
     _agent_goal_obs_tokens.resize(_agents.size());
@@ -259,11 +251,11 @@ void MettaGrid::_init_buffers(unsigned int num_agents) {
   _compute_observations(executed_actions);
 }
 
-void MettaGrid::init_action_handlers() {
+void MettaGrid::init_action_handlers(const GameConfig& game_config) {
   _max_action_priority = 0;
 
   // Noop
-  auto noop = std::make_unique<Noop>(*_game_config.actions.at("noop"));
+  auto noop = std::make_unique<Noop>(*game_config.actions.at("noop"));
   noop->init(_grid.get(), &_rng);
   if (noop->priority > _max_action_priority) _max_action_priority = noop->priority;
   for (const auto& action : noop->actions()) {
@@ -272,72 +264,39 @@ void MettaGrid::init_action_handlers() {
   _action_handler_impl.push_back(std::move(noop));
 
   // Move
-  auto move_config = std::static_pointer_cast<const MoveActionConfig>(_game_config.actions.at("move"));
-  auto move = std::make_unique<Move>(*move_config, &_game_config);
+  auto move_config = std::static_pointer_cast<const MoveActionConfig>(game_config.actions.at("move"));
+  auto move = std::make_unique<Move>(*move_config, &game_config);
   move->init(_grid.get(), &_rng);
   if (move->priority > _max_action_priority) _max_action_priority = move->priority;
   for (const auto& action : move->actions()) {
     _action_handlers.push_back(action);
   }
-  // Capture the raw pointer to pass to other handlers
-  Move* move_ptr = move.get();
   _action_handler_impl.push_back(std::move(move));
 
   // Attack
-  auto attack_config = std::static_pointer_cast<const AttackActionConfig>(_game_config.actions.at("attack"));
-  auto attack = std::make_unique<Attack>(*attack_config, &_game_config);
-  attack->init(_grid.get(), &_rng);
-  if (attack->priority > _max_action_priority) _max_action_priority = attack->priority;
-  for (const auto& action : attack->actions()) {
-    _action_handlers.push_back(action);
-  }
-
-  // Transfer
-  auto transfer_config = std::static_pointer_cast<const TransferActionConfig>(_game_config.actions.at("transfer"));
-  auto transfer = std::make_unique<Transfer>(*transfer_config, &_game_config);
-  transfer->init(_grid.get(), &_rng);
-  if (transfer->priority > _max_action_priority) _max_action_priority = transfer->priority;
-  for (const auto& action : transfer->actions()) {
-    _action_handlers.push_back(action);
-  }
-
-  // Build (creates objects at previous location after successful move)
-  _build_handler = nullptr;
-  std::unique_ptr<Build> build;
-  if (_game_config.actions.find("build") != _game_config.actions.end()) {
-    auto build_config = std::static_pointer_cast<const BuildActionConfig>(_game_config.actions.at("build"));
-    build = std::make_unique<Build>(*build_config, &_game_config, _stats.get());
-    build->init(_grid.get(), &_rng);
-    if (build->priority > _max_action_priority) _max_action_priority = build->priority;
-    // Build doesn't create standalone actions - it's triggered by move
-    _build_handler = build.get();
-  }
-
-  // Register vibe-triggered action handlers with Move
-  std::unordered_map<std::string, ActionHandler*> handlers;
-  handlers["attack"] = attack.get();
-  handlers["transfer"] = transfer.get();
-  if (build) {
-    handlers["build"] = build.get();
-  }
-  move_ptr->set_action_handlers(handlers);
-
-  _action_handler_impl.push_back(std::move(attack));
-  _action_handler_impl.push_back(std::move(transfer));
-  if (build) {
-    _action_handler_impl.push_back(std::move(build));
+  if (game_config.actions.find("attack") != game_config.actions.end()) {
+    auto attack_config = std::static_pointer_cast<const AttackActionConfig>(game_config.actions.at("attack"));
+    auto attack = std::make_unique<Attack>(*attack_config, &game_config);
+    attack->init(_grid.get(), &_rng);
+    if (attack->priority > _max_action_priority) _max_action_priority = attack->priority;
+    for (const auto& action : attack->actions()) {
+      _action_handlers.push_back(action);
+    }
+    _action_handler_impl.push_back(std::move(attack));
   }
 
   // ChangeVibe
-  auto change_vibe_config =
-      std::static_pointer_cast<const ChangeVibeActionConfig>(_game_config.actions.at("change_vibe"));
-  auto change_vibe = std::make_unique<ChangeVibe>(*change_vibe_config, &_game_config);
-  change_vibe->init(_grid.get(), &_rng);
-  if (change_vibe->priority > _max_action_priority) _max_action_priority = change_vibe->priority;
-  for (const auto& action : change_vibe->actions()) {
-    _action_handlers.push_back(action);
+  if (game_config.actions.find("change_vibe") != game_config.actions.end()) {
+    auto change_vibe_config =
+        std::static_pointer_cast<const ChangeVibeActionConfig>(game_config.actions.at("change_vibe"));
+    auto change_vibe = std::make_unique<ChangeVibe>(*change_vibe_config, &game_config);
+    change_vibe->init(_grid.get(), &_rng);
+    if (change_vibe->priority > _max_action_priority) _max_action_priority = change_vibe->priority;
+    for (const auto& action : change_vibe->actions()) {
+      _action_handlers.push_back(action);
+    }
+    _action_handler_impl.push_back(std::move(change_vibe));
   }
-  _action_handler_impl.push_back(std::move(change_vibe));
 }
 
 void MettaGrid::add_agent(Agent* agent) {
@@ -1091,10 +1050,6 @@ PYBIND11_MODULE(mettagrid_c, m) {
   bind_chest_config(m);
   bind_action_config(m);
   bind_attack_action_config(m);
-  bind_vibe_transfer_effect(m);
-  bind_transfer_action_config(m);
-  bind_vibe_build_effect(m);
-  bind_build_action_config(m);
   bind_change_vibe_action_config(m);
   bind_move_action_config(m);
   bind_global_obs_config(m);

packages/mettagrid/cpp/include/mettagrid/core/grid.hpp

@@ -2,6 +2,7 @@
 #define PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_CORE_GRID_HPP_
 
 #include <algorithm>
+#include <cstdlib>
 #include <memory>
 #include <unordered_map>
 #include <vector>

packages/mettagrid/cpp/include/mettagrid/objects/agent.hpp

@@ -65,7 +65,7 @@ class Agent : public GridObject, public HasInventory, public Usable {
   // Implementation of Usable interface
   bool onUse(Agent& actor, ActionArg arg) override;
 
-  std::vector<PartialObservationToken> obs_features() const override;
+  std::vector<PartialObservationToken> obs_features(unsigned int observer_agent_id = UINT_MAX) const override;
 
   // Set observation encoder for inventory feature ID lookup
   void set_obs_encoder(const ObservationEncoder* encoder) {

packages/mettagrid/cpp/include/mettagrid/objects/assembler.hpp

@@ -266,7 +266,7 @@ class Assembler : public GridObject, public Usable {
         allow_partial_usage(cfg.allow_partial_usage),
         chest_search_distance(cfg.chest_search_distance),
         clipper_ptr(nullptr) {
-    GridObject::init(cfg.type_id, cfg.type_name, GridLocation(r, c), cfg.tag_ids, cfg.initial_vibe);
+    GridObject::init(cfg, GridLocation(r, c));
   }
   virtual ~Assembler() = default;
 
@@ -499,7 +499,8 @@ class Assembler : public GridObject, public Usable {
     return true;
   }
 
-  virtual std::vector<PartialObservationToken> obs_features() const override {
+  virtual std::vector<PartialObservationToken> obs_features(
+      unsigned int /*observer_agent_id*/ = UINT_MAX) const override {
     std::vector<PartialObservationToken> features;
 
     unsigned int remaining = std::min(cooldown_remaining(), 255u);

packages/mettagrid/cpp/include/mettagrid/objects/chest.hpp

@@ -79,7 +79,7 @@ class Chest : public GridObject, public Usable, public HasInventory {
         vibe_transfers(cfg.vibe_transfers),
         stats_tracker(stats_tracker),
         grid(nullptr) {
-    GridObject::init(cfg.type_id, cfg.type_name, GridLocation(r, c), cfg.tag_ids, cfg.initial_vibe);
+    GridObject::init(cfg, GridLocation(r, c));
     // Set initial inventory for all configured resources (ignore limits for initial setup)
     for (const auto& [resource, amount] : cfg.initial_inventory) {
       if (amount > 0) {
@@ -123,7 +123,8 @@ class Chest : public GridObject, public Usable, public HasInventory {
     return false;
   }
 
-  virtual std::vector<PartialObservationToken> obs_features() const override {
+  virtual std::vector<PartialObservationToken> obs_features(
+      unsigned int /*observer_agent_id*/ = UINT_MAX) const override {
     if (!this->obs_encoder) {
       throw std::runtime_error("Observation encoder not set for chest");
     }

packages/mettagrid/cpp/include/mettagrid/objects/wall.hpp

@@ -20,10 +20,10 @@ struct WallConfig : public GridObjectConfig {
 class Wall : public GridObject {
 public:
   Wall(GridCoord r, GridCoord c, const WallConfig& cfg) {
-    GridObject::init(cfg.type_id, cfg.type_name, GridLocation(r, c), cfg.tag_ids, cfg.initial_vibe);
+    GridObject::init(cfg, GridLocation(r, c));
   }
 
-  std::vector<PartialObservationToken> obs_features() const override {
+  std::vector<PartialObservationToken> obs_features(unsigned int /*observer_agent_id*/ = UINT_MAX) const override {
     std::vector<PartialObservationToken> features;
     features.reserve(1 + tag_ids.size() + (this->vibe != 0 ? 1 : 0));
 

packages/mettagrid/cpp/include/mettagrid/systems/observation_encoder.hpp

@@ -111,8 +111,11 @@ class ObservationEncoder {
 
   // Returns the number of tokens that were available to write. This will be the number of tokens actually
   // written if there was enough space -- or a greater number if there was not enough space.
-  size_t encode_tokens(const GridObject* obj, ObservationTokens tokens, ObservationType location) {
-    return append_tokens_if_room_available(tokens, obj->obs_features(), location);
+  size_t encode_tokens(const GridObject* obj,
+                       ObservationTokens tokens,
+                       ObservationType location,
+                       unsigned int observer_agent_id = UINT_MAX) {
+    return append_tokens_if_room_available(tokens, obj->obs_features(observer_agent_id), location);
   }
 
   size_t get_resource_count() const {

packages/mettagrid/cpp/src/mettagrid/objects/agent.cpp

@@ -42,7 +42,7 @@ Agent::Agent(GridCoord r,
     }
   }
   populate_initial_inventory(config.initial_inventory);
-  GridObject::init(config.type_id, config.type_name, GridLocation(r, c), config.tag_ids, config.initial_vibe);
+  GridObject::init(config, GridLocation(r, c));
 }
 
 void Agent::init(RewardType* reward_ptr) {
@@ -205,7 +205,7 @@ bool Agent::onUse(Agent& actor, ActionArg arg) {
   return any_transfer_occurred;
 }
 
-std::vector<PartialObservationToken> Agent::obs_features() const {
+std::vector<PartialObservationToken> Agent::obs_features(unsigned int /*observer_agent_id*/) const {
   if (!this->obs_encoder) {
     throw std::runtime_error("Observation encoder not set for agent");
   }

packages/mettagrid/python/src/mettagrid/config/mettagrid_c_config.py

@@ -16,7 +16,6 @@
 from mettagrid.mettagrid_c import AssemblerConfig as CppAssemblerConfig
 from mettagrid.mettagrid_c import AttackActionConfig as CppAttackActionConfig
 from mettagrid.mettagrid_c import AttackOutcome as CppAttackOutcome
-from mettagrid.mettagrid_c import BuildActionConfig as CppBuildActionConfig
 from mettagrid.mettagrid_c import ChangeVibeActionConfig as CppChangeVibeActionConfig
 from mettagrid.mettagrid_c import ChestConfig as CppChestConfig
 from mettagrid.mettagrid_c import ClipperConfig as CppClipperConfig
@@ -28,9 +27,6 @@
 from mettagrid.mettagrid_c import LimitDef as CppLimitDef
 from mettagrid.mettagrid_c import MoveActionConfig as CppMoveActionConfig
 from mettagrid.mettagrid_c import Protocol as CppProtocol
-from mettagrid.mettagrid_c import TransferActionConfig as CppTransferActionConfig
-from mettagrid.mettagrid_c import VibeBuildEffect as CppVibeBuildEffect
-from mettagrid.mettagrid_c import VibeTransferEffect as CppVibeTransferEffect
 from mettagrid.mettagrid_c import WallConfig as CppWallConfig
 
 
@@ -513,26 +509,6 @@ def process_action_config(action_name: str, action_config):
     action_params["vibe_bonus"] = {vibe_name_to_id[vibe]: bonus for vibe, bonus in attack_cfg.vibe_bonus.items()}
     actions_cpp_params["attack"] = CppAttackActionConfig(**action_params)
 
-    # Process transfer - vibes are derived from vibe_transfers keys in C++
-    transfer_cfg = actions_config.transfer
-    vibe_transfers_cpp = {}
-    seen_vibes: set[str] = set()
-    for vt in transfer_cfg.vibe_transfers:
-        if vt.vibe not in vibe_name_to_id:
-            raise ValueError(f"Unknown vibe name '{vt.vibe}' in transfer.vibe_transfers")
-        if vt.vibe in seen_vibes:
-            raise ValueError(f"Duplicate vibe name '{vt.vibe}' in transfer.vibe_transfers")
-        seen_vibes.add(vt.vibe)
-        vibe_id = vibe_name_to_id[vt.vibe]
-        target_deltas = {resource_name_to_id[k]: v for k, v in vt.target.items()}
-        actor_deltas = {resource_name_to_id[k]: v for k, v in vt.actor.items()}
-        vibe_transfers_cpp[vibe_id] = CppVibeTransferEffect(target_deltas, actor_deltas)
-    actions_cpp_params["transfer"] = CppTransferActionConfig(
-        required_resources={resource_name_to_id[k]: int(v) for k, v in transfer_cfg.required_resources.items()},
-        vibe_transfers=vibe_transfers_cpp,
-        enabled=transfer_cfg.enabled,
-    )
-
     # Process change_vibe - always add to map
     action_params = process_action_config("change_vibe", actions_config.change_vibe)
     # Use vibes length if explicitly set, otherwise fall back to number_of_vibes
@@ -546,39 +522,6 @@ def process_action_config(action_name: str, action_config):
         action_params["number_of_vibes"] = 0
     actions_cpp_params["change_vibe"] = CppChangeVibeActionConfig(**action_params)
 
-    # Process build - collect build configs from all objects that have a build field
-    vibe_builds: dict[int, CppVibeBuildEffect] = {}
-    build_vibes: list[int] = []
-    for object_type, object_config in game_config.objects.items():
-        if isinstance(object_config, WallConfig) and object_config.build is not None:
-            build_cfg = object_config.build
-            # Validate vibe name exists
-            if build_cfg.vibe not in vibe_name_to_id:
-                raise ValueError(f"Unknown vibe name '{build_cfg.vibe}' in build config for '{object_type}'")
-            vibe_id = vibe_name_to_id[build_cfg.vibe]
-            # Validate and convert resource costs
-            cost_cpp: dict[int, int] = {}
-            for resource_name, amount in build_cfg.cost.items():
-                if resource_name not in resource_name_to_id:
-                    raise ValueError(
-                        f"Unknown resource '{resource_name}' in build config cost for '{object_type}'. "
-                        f"Available resources: {list(resource_name_to_id.keys())}"
-                    )
-                cost_cpp[resource_name_to_id[resource_name]] = int(amount)
-            # Create VibeBuildEffect
-            vibe_builds[vibe_id] = CppVibeBuildEffect(cost_cpp, object_type)
-            build_vibes.append(vibe_id)
-
-    # Only add build action if there are any build configs
-    if vibe_builds:
-        actions_cpp_params["build"] = CppBuildActionConfig(
-            required_resources={},
-            consumed_resources={},
-            vibe_builds=vibe_builds,
-            enabled=True,
-            vibes=build_vibes,
-        )
-
     game_cpp_params["actions"] = actions_cpp_params
     game_cpp_params["objects"] = objects_cpp_params
 

packages/mettagrid/python/src/mettagrid/simulator/simulator.py

@@ -65,17 +65,15 @@ def __init__(
         self._timer = Stopwatch(log_level=logger.getEffectiveLevel())
         self._timer.start()
 
-        game_config_dict = self._config.game.model_dump()
-
         with self._timer("sim.init.make_map"):
             map_grid = self._make_map().grid.tolist()
 
         # Create C++ config
         try:
-            c_cfg = mettagrid_c_config.convert_to_cpp_game_config(game_config_dict)
+            c_cfg = mettagrid_c_config.convert_to_cpp_game_config(self._config.game)
         except Exception as e:
             logger.error(f"Error creating C++ config: {e}")
-            logger.error(f"Game config: {game_config_dict}")
+            logger.error(f"Game config: {self._config.game.model_dump()}")
             raise e
 
         # Create C++ environment