mettagrid 0.2.0.19__tar.gz → 0.2.0.21__tar.gz

{mettagrid-0.2.0.19 → mettagrid-0.2.0.21}/MODULE.bazel

@@ -37,3 +37,11 @@ bazel_dep(name = "google_benchmark", version = "1.9.4")
 
 # Abseil (dependency of some Google libraries)
 bazel_dep(name = "abseil-cpp", version = "20250814.0")
+
+# make compile_commands.json with: bazel run @hedron_compile_commands//:refresh_all
+bazel_dep(name = "hedron_compile_commands", version = "")
+git_override(
+    module_name = "hedron_compile_commands",
+    remote = "https://github.com/hedronvision/bazel-compile-commands-extractor.git",
+    commit = "abb61a688167623088f8768cc9264798df6a9d10",
+)

{mettagrid-0.2.0.19 → mettagrid-0.2.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mettagrid
-Version: 0.2.0.19
+Version: 0.2.0.21
 Summary: A fast grid-based open-ended MARL environment
 Author-email: David Bloomin <daveey@gmail.com>
 License-Expression: MIT

{mettagrid-0.2.0.19 → mettagrid-0.2.0.21}/cpp/bindings/mettagrid_c.cpp

@@ -8,12 +8,14 @@
 #include <iostream>
 #include <numeric>
 #include <random>
+#include <unordered_set>
 
 #include "actions/action_handler.hpp"
 #include "actions/attack.hpp"
 #include "actions/change_color.hpp"
 #include "actions/change_glyph.hpp"
 #include "actions/get_output.hpp"
+#include "actions/resource_mod.hpp"
 #include "actions/move.hpp"
 #include "actions/noop.hpp"
 #include "actions/put_recipe_items.hpp"
@@ -26,6 +28,7 @@
 #include "objects/agent.hpp"
 #include "objects/assembler.hpp"
 #include "objects/assembler_config.hpp"
+#include "objects/chest.hpp"
 #include "objects/constants.hpp"
 #include "objects/converter.hpp"
 #include "objects/converter_config.hpp"
@@ -106,6 +109,9 @@ MettaGrid::MettaGrid(const GameConfig& game_config, const py::list map, unsigned
       _action_handlers.push_back(std::make_unique<Swap>(*action_config));
     } else if (action_name == "change_color") {
       _action_handlers.push_back(std::make_unique<ChangeColor>(*action_config));
+    } else if (action_name == "resource_mod") {
+      auto modify_config = std::static_pointer_cast<const ResourceModConfig>(action_config);
+      _action_handlers.push_back(std::make_unique<ResourceMod>(*modify_config, action_name));
     } else {
       throw std::runtime_error("Unknown action: " + action_name);
     }
@@ -461,7 +467,7 @@ void MettaGrid::_step(Actions actions) {
       }
 
       // Tolerate invalid action arguments
-      if (arg > _max_action_args[action_idx]) {
+      if (arg < 0 || arg > _max_action_args[action_idx]) {
         _handle_invalid_action(agent_idx, "action.invalid_arg", action, arg);
         continue;
       }
@@ -678,16 +684,37 @@ py::tuple MettaGrid::step(const py::array_t<ActionType, py::array::c_style> acti
   return py::make_tuple(_observations, _rewards, _terminals, _truncations, py::dict());
 }
 
-py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_col) {
+py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_col, const py::list& ignore_types) {
   py::dict objects;
 
   // Determine if bounding box filtering is enabled
   bool use_bounds = (min_row >= 0 && max_row >= 0 && min_col >= 0 && max_col >= 0);
 
+  // Convert ignore_types list (type names) to type IDs for O(1) integer comparison
+  std::unordered_set<TypeId> ignore_type_ids;
+  for (const auto& item : ignore_types) {
+    std::string type_name = item.cast<std::string>();
+    // Find the type_id for this type_name
+    for (size_t type_id = 0; type_id < object_type_names.size(); ++type_id) {
+      if (object_type_names[type_id] == type_name) {
+        ignore_type_ids.insert(static_cast<TypeId>(type_id));
+        break;
+      }
+    }
+  }
+  bool use_type_filter = !ignore_type_ids.empty();
+
   for (unsigned int obj_id = 1; obj_id < _grid->objects.size(); obj_id++) {
     auto obj = _grid->object(obj_id);
     if (!obj) continue;
 
+    // Filter by type_id if specified (fast integer comparison)
+    if (use_type_filter) {
+      if (ignore_type_ids.find(obj->type_id) != ignore_type_ids.end()) {
+        continue;
+      }
+    }
+
     // Filter by bounding box if specified
     if (use_bounds) {
       if (obj->location.r < min_row || obj->location.r >= max_row ||
@@ -699,6 +726,8 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
     py::dict obj_dict;
     obj_dict["id"] = obj_id;
     obj_dict["type"] = obj->type_id;
+    obj_dict["type_id"] = obj->type_id;
+    obj_dict["type_name"] = object_type_names[obj->type_id];
     // Location here is defined as XYZ coordinates specifically to be used by MettaScope.
     // We define that for location: x is column, y is row, and z is layer.
     // Note: it might be different for matrix computations.
@@ -727,10 +756,17 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
     if (auto* agent = dynamic_cast<Agent*>(obj)) {
       obj_dict["orientation"] = static_cast<int>(agent->orientation);
       obj_dict["group_id"] = agent->group;
+      obj_dict["group_name"] = agent->group_name;
       obj_dict["is_frozen"] = !!agent->frozen;
       obj_dict["freeze_remaining"] = agent->frozen;
       obj_dict["freeze_duration"] = agent->freeze_duration;
       obj_dict["color"] = agent->color;
+      obj_dict["glyph"] = agent->glyph;
+      obj_dict["agent_id"] = agent->agent_id;
+      obj_dict["action_failure_penalty"] = agent->action_failure_penalty;
+      obj_dict["current_stat_reward"] = agent->current_stat_reward;
+      obj_dict["prev_action_name"] = agent->prev_action_name;
+      obj_dict["steps_without_motion"] = agent->steps_without_motion;
 
       // We made resource limits more complicated than this, and need to review how to expose them.
       // py::dict resource_limits_dict;
@@ -738,7 +774,6 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
       //   resource_limits_dict[py::int_(resource)] = quantity;
       // }
       // obj_dict["resource_limits"] = resource_limits_dict;
-      obj_dict["agent_id"] = agent->agent_id;
     }
 
     if (auto* converter = dynamic_cast<Converter*>(obj)) {
@@ -760,6 +795,76 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
       obj_dict["output_resources"] = output_resources_dict;
     }
 
+    // Add assembler-specific info
+    if (auto* assembler = dynamic_cast<Assembler*>(obj)) {
+      obj_dict["cooldown_remaining"] = assembler->cooldown_remaining();
+      obj_dict["cooldown_duration"] = assembler->cooldown_duration;
+      obj_dict["cooldown_progress"] = assembler->cooldown_progress();
+      obj_dict["is_clipped"] = assembler->is_clipped;
+      obj_dict["clip_immune"] = assembler->clip_immune;
+      obj_dict["uses_count"] = assembler->uses_count;
+      obj_dict["max_uses"] = assembler->max_uses;
+      obj_dict["allow_partial_usage"] = assembler->allow_partial_usage;
+      obj_dict["exhaustion"] = assembler->exhaustion;
+      obj_dict["cooldown_multiplier"] = assembler->cooldown_multiplier;
+
+      // Add current recipe information
+      const Recipe* current_recipe = assembler->get_current_recipe();
+      if (current_recipe) {
+        py::dict input_resources_dict;
+        for (const auto& [resource, quantity] : current_recipe->input_resources) {
+          input_resources_dict[py::int_(resource)] = quantity;
+        }
+        obj_dict["current_recipe_inputs"] = input_resources_dict;
+
+        py::dict output_resources_dict;
+        for (const auto& [resource, quantity] : current_recipe->output_resources) {
+          output_resources_dict[py::int_(resource)] = quantity;
+        }
+        obj_dict["current_recipe_outputs"] = output_resources_dict;
+        obj_dict["current_recipe_cooldown"] = current_recipe->cooldown;
+      }
+
+      // Add all recipes information
+      const std::vector<std::shared_ptr<Recipe>>& active_recipes = assembler->is_clipped ? assembler->unclip_recipes : assembler->recipes;
+      py::list recipes_list;
+      for (size_t i = 0; i < active_recipes.size(); ++i) {
+        if (active_recipes[i]) {
+          py::dict recipe_dict;
+          recipe_dict["pattern_index"] = static_cast<int>(i);
+
+          py::dict input_resources_dict;
+          for (const auto& [resource, quantity] : active_recipes[i]->input_resources) {
+            input_resources_dict[py::int_(resource)] = quantity;
+          }
+          recipe_dict["input_resources"] = input_resources_dict;
+
+          py::dict output_resources_dict;
+          for (const auto& [resource, quantity] : active_recipes[i]->output_resources) {
+            output_resources_dict[py::int_(resource)] = quantity;
+          }
+          recipe_dict["output_resources"] = output_resources_dict;
+          recipe_dict["cooldown"] = active_recipes[i]->cooldown;
+
+          recipes_list.append(recipe_dict);
+        }
+      }
+      obj_dict["recipes"] = recipes_list;
+    }
+
+    // Add chest-specific info
+    if (auto* chest = dynamic_cast<Chest*>(obj)) {
+      obj_dict["resource_type"] = static_cast<int>(chest->resource_type);
+      obj_dict["max_inventory"] = chest->max_inventory;
+
+      // Convert position_deltas map to dict
+      py::dict position_deltas_dict;
+      for (const auto& [pos, delta] : chest->position_deltas) {
+        position_deltas_dict[py::int_(pos)] = delta;
+      }
+      obj_dict["position_deltas"] = position_deltas_dict;
+    }
+
     objects[py::int_(obj_id)] = obj_dict;
   }
 
@@ -913,7 +1018,8 @@ PYBIND11_MODULE(mettagrid_c, m) {
            py::arg("min_row") = -1,
            py::arg("max_row") = -1,
            py::arg("min_col") = -1,
-           py::arg("max_col") = -1)
+           py::arg("max_col") = -1,
+           py::arg("ignore_types") = py::list())
       .def("action_names", &MettaGrid::action_names)
       .def_property_readonly("map_width", &MettaGrid::map_width)
       .def_property_readonly("map_height", &MettaGrid::map_height)
@@ -956,6 +1062,7 @@ PYBIND11_MODULE(mettagrid_c, m) {
   bind_action_config(m);
   bind_attack_action_config(m);
   bind_change_glyph_action_config(m);
+  bind_resource_mod_config(m);
   bind_global_obs_config(m);
   bind_clipper_config(m);
   bind_game_config(m);

{mettagrid-0.2.0.19 → mettagrid-0.2.0.21}/cpp/bindings/mettagrid_c.hpp

@@ -73,7 +73,11 @@ public:
                    const py::array_t<TruncationType, py::array::c_style>& truncations,
                    const py::array_t<RewardType, py::array::c_style>& rewards);
   void validate_buffers();
-  py::dict grid_objects(int min_row = -1, int max_row = -1, int min_col = -1, int max_col = -1);
+  py::dict grid_objects(int min_row = -1,
+                        int max_row = -1,
+                        int min_col = -1,
+                        int max_col = -1,
+                        const py::list& ignore_types = py::list());
   py::list action_names();
 
   GridCoord map_width();

mettagrid-0.2.0.21/cpp/include/mettagrid/actions/resource_mod.hpp

@@ -0,0 +1,194 @@
+#ifndef PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_ACTIONS_RESOURCE_MOD_HPP_
+#define PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_ACTIONS_RESOURCE_MOD_HPP_
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <cmath>
+#include <map>
+#include <limits>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "actions/action_handler.hpp"
+#include "core/grid.hpp"
+#include "core/grid_object.hpp"
+#include "core/types.hpp"
+#include "objects/agent.hpp"
+#include "objects/converter.hpp"
+
+struct ResourceModConfig : public ActionConfig {
+  std::map<InventoryItem, InventoryProbability> modifies;
+  GridCoord agent_radius;
+  GridCoord converter_radius;
+  bool scales;
+
+  ResourceModConfig(const std::map<InventoryItem, InventoryQuantity>& required_resources = {},
+                    const std::map<InventoryItem, InventoryProbability>& consumed_resources = {},
+                    const std::map<InventoryItem, InventoryProbability>& modifies = {},
+                    GridCoord agent_radius = 0,
+                    GridCoord converter_radius = 0,
+                    bool scales = false)
+      : ActionConfig(required_resources, consumed_resources),
+        modifies(modifies),
+        agent_radius(agent_radius),
+        converter_radius(converter_radius),
+        scales(scales) {
+    // Validate modifies values for finiteness and magnitude
+    for (const auto& [item, value] : modifies) {
+      if (!std::isfinite(value)) {
+        throw std::invalid_argument("ResourceModConfig: modifies values must be finite");
+      }
+      // Check that absolute value when rounded up doesn't exceed 255
+      // (since inventories are uint8_t and deltas are int16_t)
+      if (std::ceil(std::abs(value)) > 255) {
+        throw std::invalid_argument("ResourceModConfig: modifies values must have |ceil(value)| <= 255");
+      }
+    }
+  }
+};
+
+class ResourceMod : public ActionHandler {
+public:
+  explicit ResourceMod(const ResourceModConfig& cfg, const std::string& name = "resource_mod")
+      : ActionHandler(cfg, name),
+        _modifies(cfg.modifies),
+        _agent_radius(cfg.agent_radius),
+        _converter_radius(cfg.converter_radius),
+        _scales(cfg.scales) {}
+
+  unsigned char max_arg() const override {
+    return std::numeric_limits<unsigned char>::max();
+  }
+
+protected:
+  bool _handle_action(Agent& actor, ActionArg /* arg */) override {
+    // Center AoE on actor's position
+    int center_row = static_cast<int>(actor.location.r);
+    int center_col = static_cast<int>(actor.location.c);
+
+    std::vector<Agent*> affected_agents;
+    std::vector<Converter*> affected_converters;
+
+    // Find all agents within agent_radius of the center
+    // radius=0 means skip agents entirely
+    if (_agent_radius > 0) {
+      for (int dr = -static_cast<int>(_agent_radius); dr <= static_cast<int>(_agent_radius); ++dr) {
+        for (int dc = -static_cast<int>(_agent_radius); dc <= static_cast<int>(_agent_radius); ++dc) {
+          // Manhattan distance
+          if (std::abs(dr) + std::abs(dc) > static_cast<int>(_agent_radius)) {
+            continue;
+          }
+
+          int target_row = center_row + dr;
+          int target_col = center_col + dc;
+
+          if (target_row >= 0 && target_row < static_cast<int>(_grid->height) &&
+              target_col >= 0 && target_col < static_cast<int>(_grid->width)) {
+            GridLocation loc(target_row, target_col, GridLayer::AgentLayer);
+            GridObject* obj = _grid->object_at(loc);
+            if (obj != nullptr) {
+              Agent* agent = static_cast<Agent*>(obj);
+              affected_agents.push_back(agent);
+            }
+          }
+        }
+      }
+    }
+
+    // Find all converters within converter_radius of the center
+    // radius=0 means skip converters entirely
+    if (_converter_radius > 0) {
+      for (int dr = -static_cast<int>(_converter_radius); dr <= static_cast<int>(_converter_radius); ++dr) {
+        for (int dc = -static_cast<int>(_converter_radius); dc <= static_cast<int>(_converter_radius); ++dc) {
+          // Manhattan distance
+          if (std::abs(dr) + std::abs(dc) > static_cast<int>(_converter_radius)) {
+            continue;
+          }
+
+          int target_row = center_row + dr;
+          int target_col = center_col + dc;
+
+          if (target_row >= 0 && target_row < static_cast<int>(_grid->height) &&
+              target_col >= 0 && target_col < static_cast<int>(_grid->width)) {
+            GridLocation loc(target_row, target_col, GridLayer::ObjectLayer);
+            GridObject* obj = _grid->object_at(loc);
+            if (obj != nullptr) {
+              Converter* converter = dynamic_cast<Converter*>(obj);
+              if (converter != nullptr) {
+                affected_converters.push_back(converter);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // No targets found - still consume resources and succeed
+    if (affected_agents.empty() && affected_converters.empty()) {
+      return true;
+    }
+
+    // Calculate total number of affected targets for scaling
+    size_t total_affected = affected_agents.size() + affected_converters.size();
+
+    // Apply modifications to all targets
+    for (const auto& [item, amount] : _modifies) {
+      InventoryProbability effective_amount = amount;
+
+      // Scale by number of targets if scales flag is true
+      if (_scales && total_affected > 1) {
+        effective_amount = amount / static_cast<float>(total_affected);
+      }
+
+      // Apply to agents - compute delta independently for each target
+      for (Agent* agent : affected_agents) {
+        InventoryDelta delta = compute_probabilistic_delta(effective_amount);
+        if (delta != 0) {
+          agent->update_inventory(item, delta);
+        }
+      }
+
+      // Apply to converters - compute delta independently for each target
+      for (Converter* converter : affected_converters) {
+        InventoryDelta delta = compute_probabilistic_delta(effective_amount);
+        if (delta != 0) {
+          converter->update_inventory(item, delta);
+        }
+      }
+    }
+
+    return true;
+  }
+
+private:
+  std::map<InventoryItem, InventoryProbability> _modifies;
+  GridCoord _agent_radius;
+  GridCoord _converter_radius;
+  bool _scales;
+};
+
+namespace py = pybind11;
+
+inline void bind_resource_mod_config(py::module& m) {
+  py::class_<ResourceModConfig, ActionConfig, std::shared_ptr<ResourceModConfig>>(m, "ResourceModConfig")
+      .def(py::init<const std::map<InventoryItem, InventoryQuantity>&,
+                    const std::map<InventoryItem, InventoryProbability>&,
+                    const std::map<InventoryItem, InventoryProbability>&,
+                    GridCoord,
+                    GridCoord,
+                    bool>(),
+           py::arg("required_resources") = std::map<InventoryItem, InventoryQuantity>(),
+           py::arg("consumed_resources") = std::map<InventoryItem, InventoryProbability>(),
+           py::arg("modifies") = std::map<InventoryItem, InventoryProbability>(),
+           py::arg("agent_radius") = 0,
+           py::arg("converter_radius") = 0,
+           py::arg("scales") = false)
+      .def_readwrite("modifies", &ResourceModConfig::modifies)
+      .def_readwrite("agent_radius", &ResourceModConfig::agent_radius)
+      .def_readwrite("converter_radius", &ResourceModConfig::converter_radius)
+      .def_readwrite("scales", &ResourceModConfig::scales);
+}
+
+#endif  // PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_ACTIONS_RESOURCE_MOD_HPP_

{mettagrid-0.2.0.19 → mettagrid-0.2.0.21}/cpp/include/mettagrid/core/grid_object.hpp

@@ -1,11 +1,12 @@
 #ifndef PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_CORE_GRID_OBJECT_HPP_
 #define PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_CORE_GRID_OBJECT_HPP_
 
-#include <cstdint>
 #include <span>
 #include <string>
 #include <vector>
 
+#include <cstdint>
+
 #include "objects/constants.hpp"
 #include "core/types.hpp"
 

{mettagrid-0.2.0.19 → mettagrid-0.2.0.21}/cpp/include/mettagrid/objects/chest.hpp

@@ -46,57 +46,71 @@ private:
     return -1;  // Agent is not adjacent
   }
 
-  // Check if the given position index is a deposit position
-  bool is_deposit_position(int position_index) const {
-    return deposit_positions.find(position_index) != deposit_positions.end();
-  }
-
-  // Check if the given position index is a withdrawal position
-  bool is_withdrawal_position(int position_index) const {
-    return withdrawal_positions.find(position_index) != withdrawal_positions.end();
-  }
+  // Transfer resources based on position delta
+  // Positive delta = deposit from agent to chest
+  // Negative delta = withdraw from chest to agent
+  bool transfer_resource(Agent& agent, int delta) {
+    if (delta > 0) {
+      // Deposit: agent -> chest
+      int agent_amount = static_cast<int>(agent.inventory.amount(resource_type));
+      int transfer_amount = std::min(delta, agent_amount);
+      if (transfer_amount == 0) {
+        return false;
+      }
 
-  // Deposit a resource from agent to chest
-  bool deposit_resource(Agent& agent) {
-    // Check if agent has the required resource
-    if (agent.inventory.amount(resource_type) == 0) {
-      return false;
-    }
+      // Check if chest has space (unless max_inventory is unlimited)
+      if (max_inventory >= 0) {
+        int current_amount = static_cast<int>(inventory.amount(resource_type));
+        int available_space = max_inventory - current_amount;
+        transfer_amount = std::min(transfer_amount, available_space);
+
+        if (transfer_amount == 0) {
+          // Chest is full, destroy the resource from agent
+          agent.update_inventory(resource_type, -delta);
+          stats_tracker->add("chest." + stats_tracker->resource_name(resource_type) + ".destroyed", delta);
+          return true;
+        }
+      }
 
-    InventoryDelta deposited = update_inventory(resource_type, 1);
-    if (deposited == 1) {
-      agent.update_inventory(resource_type, -1);
-      stats_tracker->incr("chest." + stats_tracker->resource_name(resource_type) + ".deposited");
-      stats_tracker->incr("chest." + stats_tracker->resource_name(resource_type) + ".amount");
+      // Transfer from agent to chest
+      InventoryDelta deposited = update_inventory(resource_type, transfer_amount);
+      agent.update_inventory(resource_type, -transfer_amount);
+      stats_tracker->add("chest." + stats_tracker->resource_name(resource_type) + ".deposited", transfer_amount);
+      stats_tracker->set("chest." + stats_tracker->resource_name(resource_type) + ".amount", inventory.amount(resource_type));
+
+      // If we couldn't transfer the full delta due to max_inventory, destroy the rest
+      int destroyed = delta - transfer_amount;
+      if (destroyed > 0) {
+        agent.update_inventory(resource_type, -destroyed);
+        stats_tracker->add("chest." + stats_tracker->resource_name(resource_type) + ".destroyed", destroyed);
+      }
       return true;
-    }
-    // Chest couldn't accept the resource, give it back to agent
-    return false;
-  }
+    } else if (delta < 0) {
+      // Withdraw: chest -> agent
+      int chest_amount = static_cast<int>(inventory.amount(resource_type));
+      int withdraw_amount = std::min(-delta, chest_amount);
+      if (withdraw_amount == 0) {
+        return false;
+      }
 
-  // Withdraw a resource from chest to agent
-  bool withdraw_resource(Agent& agent) {
-    // Check if chest has the required resource
-    if (inventory.amount(resource_type) == 0) {
+      // Transfer from chest to agent
+      InventoryDelta withdrawn = agent.update_inventory(resource_type, withdraw_amount);
+      if (withdrawn > 0) {
+        update_inventory(resource_type, -withdrawn);
+        stats_tracker->add("chest." + stats_tracker->resource_name(resource_type) + ".withdrawn", withdrawn);
+        stats_tracker->set("chest." + stats_tracker->resource_name(resource_type) + ".amount", inventory.amount(resource_type));
+        return true;
+      }
       return false;
     }
-
-    InventoryDelta withdrawn = agent.update_inventory(resource_type, 1);
-    if (withdrawn == 1) {
-      update_inventory(resource_type, -1);
-      stats_tracker->incr("chest." + stats_tracker->resource_name(resource_type) + ".withdrawn");
-      stats_tracker->add("chest." + stats_tracker->resource_name(resource_type) + ".amount", -1);
-      return true;
-    }
-    // Agent couldn't accept the resource, give it back to chest
-    return false;
+    return false;  // delta == 0, no-op
   }
 
 public:
   // Configuration
   InventoryItem resource_type;
-  std::set<int> deposit_positions;
-  std::set<int> withdrawal_positions;
+  std::map<int, int> position_deltas;  // position_index -> delta
+  int max_inventory;                   // Maximum inventory (-1 = unlimited)
 
   // Grid access for finding agent positions
   class Grid* grid;
@@ -105,11 +119,15 @@ public:
       : GridObject(),
         HasInventory(InventoryConfig()),  // Chests have nothing to configure in their inventory. Yet.
         resource_type(cfg.resource_type),
-        deposit_positions(cfg.deposit_positions),
-        withdrawal_positions(cfg.withdrawal_positions),
+        position_deltas(cfg.position_deltas),
+        max_inventory(cfg.max_inventory),
         stats_tracker(stats_tracker),
         grid(nullptr) {
     GridObject::init(cfg.type_id, cfg.type_name, GridLocation(r, c, GridLayer::ObjectLayer), cfg.tag_ids);
+    // Set initial inventory
+    if (cfg.initial_inventory > 0) {
+      update_inventory(cfg.resource_type, cfg.initial_inventory);
+    }
   }
 
   virtual ~Chest() = default;
@@ -130,14 +148,14 @@ public:
       return false;
     }
 
-    // Check if agent is in a valid position for deposit or withdrawal
-    if (is_deposit_position(agent_position_index)) {
-      return deposit_resource(actor);
-    } else if (is_withdrawal_position(agent_position_index)) {
-      return withdraw_resource(actor);
-    } else {
-      return false;
+    // Check if there's a configured delta for this position
+    auto it = position_deltas.find(agent_position_index);
+    if (it == position_deltas.end()) {
+      return false;  // No action configured for this position
     }
+
+    int delta = it->second;
+    return transfer_resource(actor, delta);
   }
 
   virtual std::vector<PartialObservationToken> obs_features() const override {

{mettagrid-0.2.0.19 → mettagrid-0.2.0.21}/cpp/include/mettagrid/objects/chest_config.hpp

@@ -4,6 +4,7 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
+#include <map>
 #include <set>
 
 #include "core/grid_object.hpp"
@@ -13,35 +14,40 @@ struct ChestConfig : public GridObjectConfig {
   ChestConfig(TypeId type_id,
               const std::string& type_name,
               InventoryItem resource_type,
-              const std::set<int>& deposit_positions,
-              const std::set<int>& withdrawal_positions,
+              const std::map<int, int>& position_deltas,
+              int initial_inventory = 0,
+              int max_inventory = 255,
               const std::vector<int>& tag_ids = {})
       : GridObjectConfig(type_id, type_name, tag_ids),
         resource_type(resource_type),
-        deposit_positions(deposit_positions),
-        withdrawal_positions(withdrawal_positions) {}
+        position_deltas(position_deltas),
+        initial_inventory(initial_inventory),
+        max_inventory(max_inventory) {}
 
   InventoryItem resource_type;
-  std::set<int> deposit_positions;
-  std::set<int> withdrawal_positions;
+  std::map<int, int> position_deltas;  // position_index -> delta (positive = deposit amount, negative = withdraw amount)
+  int initial_inventory;               // Initial amount of resource_type in the chest
+  int max_inventory;                   // Maximum inventory (-1 = unlimited)
 };
 
 namespace py = pybind11;
 
 inline void bind_chest_config(py::module& m) {
   py::class_<ChestConfig, GridObjectConfig, std::shared_ptr<ChestConfig>>(m, "ChestConfig")
-      .def(py::init<TypeId, const std::string&, InventoryItem, const std::set<int>&, const std::set<int>&, const std::vector<int>&>(),
+      .def(py::init<TypeId, const std::string&, InventoryItem, const std::map<int, int>&, int, int, const std::vector<int>&>(),
            py::arg("type_id"),
            py::arg("type_name"),
            py::arg("resource_type"),
-           py::arg("deposit_positions"),
-           py::arg("withdrawal_positions"),
+           py::arg("position_deltas"),
+           py::arg("initial_inventory") = 0,
+           py::arg("max_inventory") = 255,
            py::arg("tag_ids") = std::vector<int>())
       .def_readwrite("type_id", &ChestConfig::type_id)
       .def_readwrite("type_name", &ChestConfig::type_name)
       .def_readwrite("resource_type", &ChestConfig::resource_type)
-      .def_readwrite("deposit_positions", &ChestConfig::deposit_positions)
-      .def_readwrite("withdrawal_positions", &ChestConfig::withdrawal_positions)
+      .def_readwrite("position_deltas", &ChestConfig::position_deltas)
+      .def_readwrite("initial_inventory", &ChestConfig::initial_inventory)
+      .def_readwrite("max_inventory", &ChestConfig::max_inventory)
       .def_readwrite("tag_ids", &ChestConfig::tag_ids);
 }