mettagrid 0.2.0.19__tar.gz → 0.2.0.20__tar.gz

{mettagrid-0.2.0.19 → mettagrid-0.2.0.20}/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.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mettagrid
-Version: 0.2.0.19
+Version: 0.2.0.20
 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.20}/cpp/bindings/mettagrid_c.cpp

@@ -14,6 +14,7 @@
 #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"
@@ -106,6 +107,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 +465,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;
       }
@@ -956,6 +960,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.20/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.20}/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.20}/mettagrid.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mettagrid
-Version: 0.2.0.19
+Version: 0.2.0.20
 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.20}/mettagrid.egg-info/SOURCES.txt

@@ -84,6 +84,7 @@ cpp/include/mettagrid/actions/move.hpp
 cpp/include/mettagrid/actions/noop.hpp
 cpp/include/mettagrid/actions/orientation.hpp
 cpp/include/mettagrid/actions/put_recipe_items.hpp
+cpp/include/mettagrid/actions/resource_mod.hpp
 cpp/include/mettagrid/actions/rotate.hpp
 cpp/include/mettagrid/actions/swap.hpp
 cpp/include/mettagrid/config/mettagrid_config.hpp
@@ -222,6 +223,10 @@ nim/mettascope/data/objects/carbon_ex_dep.png
 nim/mettascope/data/objects/carbon_extractor.png
 nim/mettascope/data/objects/charger.png
 nim/mettascope/data/objects/chest.png
+nim/mettascope/data/objects/chest_carbon.png
+nim/mettascope/data/objects/chest_germanium.png
+nim/mettascope/data/objects/chest_oxygen.png
+nim/mettascope/data/objects/chest_silicon.png
 nim/mettascope/data/objects/clay_oven.png
 nim/mettascope/data/objects/converter.png
 nim/mettascope/data/objects/empty.png
@@ -799,6 +804,8 @@ tests/test_observations.py
 tests/test_pettingzoo_env.py
 tests/test_pufferlib_integration.py
 tests/test_resource_loss.py
+tests/test_resource_mod.py
+tests/test_resource_mod_config.py
 tests/test_rewards.py
 tests/test_rotate.py
 tests/test_set_inventory.py

{mettagrid-0.2.0.19 → mettagrid-0.2.0.20}/python/src/mettagrid/config/mettagrid_c_config.py

@@ -23,6 +23,7 @@ from mettagrid.mettagrid_c import GameConfig as CppGameConfig
 from mettagrid.mettagrid_c import GlobalObsConfig as CppGlobalObsConfig
 from mettagrid.mettagrid_c import InventoryConfig as CppInventoryConfig
 from mettagrid.mettagrid_c import Recipe as CppRecipe
+from mettagrid.mettagrid_c import ResourceModConfig as CppResourceModConfig
 from mettagrid.mettagrid_c import WallConfig as CppWallConfig
 
 # Note that these are left to right, top to bottom.
@@ -401,6 +402,23 @@ def convert_to_cpp_game_config(mettagrid_config: dict | GameConfig):
                 "number_of_glyphs": action_config["number_of_glyphs"],
             }
             actions_cpp_params[action_name] = CppChangeGlyphActionConfig(**change_glyph_params)
+        elif action_name == "resource_mod":
+            # Extract the specific parameters needed for ResourceModConfig
+            modifies_dict = action_config.get("modifies", {})
+            unknown_modifies = set(modifies_dict.keys()) - set(resource_name_to_id.keys())
+            if unknown_modifies:
+                unknown_list = sorted(unknown_modifies)
+                raise ValueError(f"Unknown resource names in modifies for action '{action_name}': {unknown_list}")
+
+            resource_mod_params = {
+                "required_resources": action_cpp_params.get("required_resources", {}),
+                "consumed_resources": action_cpp_params.get("consumed_resources", {}),
+                "modifies": {resource_name_to_id[k]: float(v) for k, v in modifies_dict.items()},
+                "agent_radius": action_config.get("agent_radius", 0),
+                "converter_radius": action_config.get("converter_radius", 0),
+                "scales": action_config.get("scales", False),
+            }
+            actions_cpp_params[action_name] = CppResourceModConfig(**resource_mod_params)
         else:
             actions_cpp_params[action_name] = CppActionConfig(**action_cpp_params)
 

{mettagrid-0.2.0.19 → mettagrid-0.2.0.20}/python/src/mettagrid/config/mettagrid_config.py

@@ -101,6 +101,15 @@ class ChangeGlyphActionConfig(ActionConfig):
     number_of_glyphs: int = Field(default=0, ge=0, le=255)
 
 
+class ResourceModActionConfig(ActionConfig):
+    """Resource mod action configuration."""
+
+    modifies: dict[str, float] = Field(default_factory=dict)
+    agent_radius: int = Field(default=0, ge=0, le=255)
+    converter_radius: int = Field(default=0, ge=0, le=255)
+    scales: bool = Field(default=False)
+
+
 class ActionsConfig(Config):
     """
     Actions configuration.
@@ -117,6 +126,7 @@ class ActionsConfig(Config):
     swap: ActionConfig = Field(default_factory=lambda: ActionConfig(enabled=False))
     change_color: ActionConfig = Field(default_factory=lambda: ActionConfig(enabled=False))
     change_glyph: ChangeGlyphActionConfig = Field(default_factory=lambda: ChangeGlyphActionConfig(enabled=False))
+    resource_mod: ResourceModActionConfig = Field(default_factory=lambda: ResourceModActionConfig(enabled=False))
 
 
 class GlobalObsConfig(Config):
@@ -168,7 +178,6 @@ class RecipeConfig(Config):
     input_resources: dict[str, int] = Field(default_factory=dict)
     output_resources: dict[str, int] = Field(default_factory=dict)
     cooldown: int = Field(ge=0, default=0)
-    max_use: Optional[int] = Field(ge=0, default=None)
 
 
 class AssemblerConfig(GridObjectConfig):

{mettagrid-0.2.0.19 → mettagrid-0.2.0.20}/python/src/mettagrid/mettagrid_c.pyi

@@ -167,6 +167,21 @@ class ChangeGlyphActionConfig(ActionConfig):
     ) -> None: ...
     number_of_glyphs: int
 
+class ResourceModConfig(ActionConfig):
+    def __init__(
+        self,
+        required_resources: dict[int, int] = {},
+        consumed_resources: dict[int, float] = {},
+        modifies: dict[int, float] = {},
+        agent_radius: int = 0,
+        converter_radius: int = 0,
+        scales: bool = False,
+    ) -> None: ...
+    modifies: dict[int, float]
+    agent_radius: int
+    converter_radius: int
+    scales: bool
+
 class GlobalObsConfig:
     def __init__(
         self,

{mettagrid-0.2.0.19 → mettagrid-0.2.0.20}/python/src/mettagrid/mettascope.py

@@ -13,9 +13,11 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 # Find the nim/mettascope/bindings/generated directory
-# This is relative to the mettagrid package root
+# This is in the nim package, not the python package
 package_root = Path(__file__).resolve().parent
-nim_root = package_root / "nim" / "mettascope"
+# Navigate up to the packages directory and then into the nim package
+packages_dir = package_root.parent.parent.parent.parent
+nim_root = packages_dir / "mettagrid" / "nim" / "mettascope"
 nim_bindings_path = nim_root / "bindings" / "generated"
 
 # Type stubs for static analysis

{mettagrid-0.2.0.19 → mettagrid-0.2.0.20}/tests/test_mettagrid.cpp

@@ -7,6 +7,7 @@
 #include "actions/get_output.hpp"
 #include "actions/noop.hpp"
 #include "actions/put_recipe_items.hpp"
+#include "actions/resource_mod.hpp"
 #include "config/mettagrid_config.hpp"
 #include "core/event.hpp"
 #include "core/grid.hpp"
@@ -1084,7 +1085,8 @@ TEST_F(MettaGridCppTest, EventManager) {
   EXPECT_NO_THROW(event_manager.process_events(1));
 }
 
-// Assembler Tests
+// ==================== Assembler Tests ====================
+
 TEST_F(MettaGridCppTest, AssemblerBasicObservationFeatures) {
   AssemblerConfig config(1, "test_assembler", std::vector<int>{1, 2});
   Assembler assembler(5, 5, config);
@@ -1672,5 +1674,158 @@ TEST_F(MettaGridCppTest, AssemblerExhaustion) {
   EXPECT_TRUE(success) << "Fourth use should succeed";
   // Fourth cooldown should be 10 * 3.375 = 33.75, rounded to 33
   EXPECT_EQ(assembler.cooldown_end_timestep, 80) << "Fourth cooldown should end at 80 (47 + 33)";
-  EXPECT_FLOAT_EQ(assembler.cooldown_multiplier, 5.0625f) << "Cooldown multiplier should be 5.0625 after fourth use";
+  EXPECT_FLOAT_EQ(assembler.cooldown_multiplier, 5.0625f)
+      << "Cooldown multiplier should be 5.0625 after fourth use";
+}
+
+// ==================== ResourceMod Tests ====================
+
+TEST_F(MettaGridCppTest, ResourceModBasic) {
+  Grid grid(5, 5);
+  std::mt19937 rng(42);
+  auto resource_names = create_test_resource_names();
+
+  // Create actor at center
+  AgentConfig actor_cfg = create_test_agent_config();
+  actor_cfg.initial_inventory[TestItems::ORE] = 10;
+  Agent* actor = new Agent(2, 2, actor_cfg, &resource_names);
+  float actor_reward = 0.0f;
+  actor->init(&actor_reward);
+  grid.add_object(actor);
+
+  // Create target agent nearby
+  AgentConfig target_cfg = create_test_agent_config();
+  target_cfg.initial_inventory[TestItems::HEART] = 10;
+  Agent* target = new Agent(2, 3, target_cfg, &resource_names);
+  float target_reward = 0.0f;
+  target->init(&target_reward);
+  grid.add_object(target);
+
+  // Create resource mod action that adds hearts with 100% probability
+  ResourceModConfig modify_cfg({{TestItems::ORE, 1}},       // required_resources
+                               {{TestItems::ORE, 1.0f}},    // consumed_resources
+                               {{TestItems::HEART, 1.0f}},  // modifies - adds 1 heart
+                               1,                           // agent_radius
+                               0,                           // converter_radius
+                               false);                       // scales
+  ResourceMod modify(modify_cfg);
+  modify.init(&grid, &rng);
+
+  ActionArg arg = 0;  // Unused
+  bool success = modify.handle_action(*actor, arg);
+  EXPECT_TRUE(success);
+
+  // Check that target gained 1 heart
+  EXPECT_EQ(target->inventory.amount(TestItems::HEART), 11);
+  // Check that actor lost 1 ore
+  EXPECT_EQ(actor->inventory.amount(TestItems::ORE), 9);
+}
+
+TEST_F(MettaGridCppTest, ResourceModProbabilistic) {
+  Grid grid(5, 5);
+  std::mt19937 rng(42);
+  auto resource_names = create_test_resource_names();
+
+  // Create actor
+  AgentConfig actor_cfg = create_test_agent_config();
+  actor_cfg.initial_inventory[TestItems::ORE] = 200;
+  Agent* actor = new Agent(2, 2, actor_cfg, &resource_names);
+  float actor_reward = 0.0f;
+  actor->init(&actor_reward);
+  grid.add_object(actor);
+
+  // Create target
+  AgentConfig target_cfg = create_test_agent_config();
+  target_cfg.initial_inventory[TestItems::HEART] = 10;
+  Agent* target = new Agent(2, 3, target_cfg, &resource_names);
+  float target_reward = 0.0f;
+  target->init(&target_reward);
+  grid.add_object(target);
+
+  // Create action with fractional modifications (30% chance)
+  ResourceModConfig modify_cfg({{TestItems::ORE, 1}},       // required_resources must have ceil(0.5) = 1
+                               {{TestItems::ORE, 0.5f}},    // 50% chance to consume
+                               {{TestItems::HEART, 0.3f}},  // 30% chance to add 1 heart
+                               1,
+                               0,
+                               false);  // radius 1, no converters, no scaling
+  ResourceMod modify(modify_cfg);
+  modify.init(&grid, &rng);
+
+  // Execute multiple times to test probabilistic behavior
+  ActionArg arg = 0;  // Unused
+  int hearts_added = 0;
+  int ore_consumed = 0;
+
+  for (int i = 0; i < 100; i++) {
+    int ore_before = actor->inventory.amount(TestItems::ORE);
+    int hearts_before = target->inventory.amount(TestItems::HEART);
+
+    // Check if actor has required resources
+    if (ore_before < 1) {
+      // Actor is out of ore, can't continue test
+      break;
+    }
+
+    bool success = modify.handle_action(*actor, arg);
+    EXPECT_TRUE(success);
+
+    ore_consumed += (ore_before - actor->inventory.amount(TestItems::ORE));
+    hearts_added += (target->inventory.amount(TestItems::HEART) - hearts_before);
+  }
+
+  // With 30% probability for hearts and 50% for ore consumption
+  // Expect around 30 hearts added and 50 ore consumed
+  EXPECT_GE(hearts_added, 20);  // At least 20
+  EXPECT_LE(hearts_added, 40);  // At most 40
+  EXPECT_GE(ore_consumed, 40);  // At least 40
+  EXPECT_LE(ore_consumed, 60);  // At most 60
+}
+
+TEST_F(MettaGridCppTest, ResourceModConverter) {
+  Grid grid(5, 5);
+  std::mt19937 rng(42);
+  EventManager event_manager;
+  auto resource_names = create_test_resource_names();
+
+  // Create actor
+  AgentConfig actor_cfg = create_test_agent_config();
+  Agent* actor = new Agent(2, 2, actor_cfg, &resource_names);
+  float actor_reward = 0.0f;
+  actor->init(&actor_reward);
+  grid.add_object(actor);
+
+  // Create converter nearby
+  ConverterConfig converter_cfg(TestItems::CONVERTER,  // type_id
+                                "converter",           // type_name
+                                {},                    // input_resources
+                                {},                    // output_resources
+                                -1,                    // max_output
+                                -1,                    // max_conversions
+                                0,                     // conversion_ticks
+                                0,                     // cooldown
+                                0,                     // initial_items
+                                0,                     // color
+                                false);                 // recipe_details_obs
+  Converter* converter = new Converter(3, 2, converter_cfg);
+  grid.add_object(converter);
+  converter->set_event_manager(&event_manager);
+
+  // Create action that modifies converter resources
+  ResourceModConfig modify_cfg({},
+                               {},
+                               {{TestItems::ORE, 1.0f}},  // Add 1 ore to converter
+                               0,
+                               1,
+                               false);  // No agents, converters within radius 1
+  ResourceMod modify(modify_cfg);
+  modify.init(&grid, &rng);
+
+  // Target converter at (3, 2) from actor at (2, 2)
+  ActionArg arg = 0;  // Unused
+  bool success = modify.handle_action(*actor, arg);
+  EXPECT_TRUE(success);
+
+  // Check that converter gained 1 ore
+  EXPECT_EQ(converter->inventory.amount(TestItems::ORE), 1);
 }