mettagrid 0.2.0.22__tar.gz → 0.2.0.24__tar.gz

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/.bazelrc

@@ -20,6 +20,15 @@ build:dbg --compilation_mode=dbg
 build:dbg --copt=-O0
 build:dbg --copt=-g
 build:dbg --strip=never
+build:dbg --copt=-fsanitize=address
+build:dbg --copt=-fsanitize=undefined
+build:dbg --copt=-fsanitize=float-divide-by-zero
+build:dbg --copt=-fno-sanitize-recover=all
+build:dbg --copt=-fstack-protector-strong
+build:dbg --linkopt=-fsanitize=address
+build:dbg --linkopt=-fsanitize=undefined
+build:dbg --linkopt=-fsanitize=float-divide-by-zero
+build:dbg --test_env=ASAN_OPTIONS=detect_leaks=0
 
 # Test configuration
 test --test_output=errors

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/Makefile

@@ -19,81 +19,89 @@ help:
 
 # Debug build
 build:
-	@echo "🔨 Building debug..."
+	@echo "Building debug..."
 	bazel build --config=dbg //:mettagrid_c
 
 # Production release build
 build-prod:
-	@echo "🔨 Building release..."
+	@echo "Building release..."
 	bazel build --config=opt //:mettagrid_c
 
 # Build and run benchmarks
 benchmark:
-	@echo "🔨 Building C++ benchmarks..."
+	@echo "Building C++ benchmarks..."
 	bazel build --config=opt //benchmarks:test_mettagrid_env_benchmark
-	@echo "📂 Creating build-release directory..."
+	@echo "Creating build-release directory..."
 	mkdir -p build-release
-	@echo "📋 Copying benchmark binaries..."
+	@echo "Copying benchmark binaries..."
 	cp -f bazel-bin/benchmarks/test_mettagrid_env_benchmark build-release/
 	chmod +x build-release/test_mettagrid_env_benchmark
-	@echo "🏃 Running C++ benchmarks..."
+	@echo "Running C++ benchmarks..."
 	# Note: Using the copied binary instead of 'bazel run' to avoid Python environment issues
-	./build-release/test_mettagrid_env_benchmark || echo "⚠️  C++ benchmark failed - this may be due to Python environment issues"
-	@echo "🏃 Running Python benchmarks..."
+	./build-release/test_mettagrid_env_benchmark || echo "C++ benchmark failed - this may be due to Python environment issues"
+	@echo "Running Python benchmarks..."
 	uv run pytest benchmarks/test_mettagrid_env_benchmark.py -v --benchmark-only
 
 # Run unit tests
 test: build
-	@echo "🧪 Running unit tests..."
-	bazel test //tests:tests_all
+	@echo "Running unit tests..."
+	bazel test --config=dbg //tests:tests_all
 
 # Generate coverage report
 coverage:
-	@echo "🔨 Building with coverage..."
-	@echo "⚠️  Note: C++ coverage on macOS is currently not supported by bazel"
+	@echo "Building with coverage..."
+	@echo "Note: C++ coverage on macOS is currently not supported by bazel"
 	@echo "    Running tests instead..."
-	bazel test //tests:tests_all
-	@echo "✅ Tests completed successfully"
+	bazel test --config=dbg //tests:tests_all
+	@echo "Tests completed successfully"
 	@echo "    For Python coverage, use: make pytest-coverage"
 
 # Alias for clang_tidy that only fails on errors (not warnings)
 tidy:
-	@echo "🔍 Running clang-tidy (errors only)..."
+	@echo "Running clang-tidy (errors only)..."
 	@bazel test //lint:clang_tidy --test_output=errors  --nocache_test_results
-	@echo "✅ Clang-tidy check complete (use 'make tidy-verbose' to see all warnings)"
+	@echo "Clang-tidy check complete (use 'make tidy-verbose' to see all warnings)"
 
 # Run clang-tidy with full output showing all warnings
 tidy-verbose:
-	@echo "🔍 Running clang-tidy with full output..."
+	@echo "Running clang-tidy with full output..."
 	@bazel test //lint:clang_tidy --test_output=all --nocache_test_results
 
 # Formatting
 format-check:
-	@echo "🔎 Checking code formatting..."
+	@echo "Checking code formatting..."
 	@clang-format --dry-run --Werror -style=file $(shell find src include tests -name '*.c' -o -name '*.h' -o -name '*.cpp' -o -name '*.hpp')
-	@echo "✅ All files are correctly formatted"
+	@echo "All files are correctly formatted"
 
 format-fix:
-	@echo "🛠️  Reformatting code..."
+	@echo "Reformatting code..."
 	@clang-format -i -style=file $(shell find src include tests -name '*.c' -o -name '*.h' -o -name '*.cpp' -o -name '*.hpp')
-	@echo "✅ Code reformatted"
+	@echo "Code reformatted"
 
 # Python
 install:
-	@echo "📦 Installing package..."
+	@echo "Installing package..."
 	@cd ../.. && uv sync --active --inexact --frozen
 
-pytest: install
-	@echo "🐍 Running Python tests..."
-	@cd ../.. && uv run pytest packages/mettagrid/tests
+pytest:
+	@echo "Preparing environment for Python tests (ASAN disabled)..."
+	@cd ../.. && DEBUG= uv sync --active --inexact --frozen
+	@echo "Building C++ extension without ASAN (opt config)..."
+	@cd ../.. && PYTHONPATH=packages/mettagrid DEBUG= uv run python -c "import bazel_build as bb; bb._run_bazel_build()"
+	@echo "Running Python tests (ASAN disabled)..."
+	@cd ../.. && DEBUG= uv run pytest packages/mettagrid/tests
 
-pytest-coverage: install
-	@echo "📊 Running Python tests with coverage..."
-	@cd ../.. && uv run pytest packages/mettagrid/tests --cov=mettagrid --cov-report=term-missing --cov-report=html:packages/mettagrid/htmlcov
+pytest-coverage:
+	@echo "Preparing environment for Python tests (ASAN disabled)..."
+	@cd ../.. && DEBUG= uv sync --active --inexact --frozen
+	@echo "Building C++ extension without ASAN (opt config)..."
+	@cd ../.. && PYTHONPATH=packages/mettagrid DEBUG= uv run python -c "import bazel_build as bb; bb._run_bazel_build()"
+	@echo "Running Python tests with coverage (ASAN disabled)..."
+	@cd ../.. && DEBUG= uv run pytest packages/mettagrid/tests --cov=mettagrid --cov-report=term-missing --cov-report=html:packages/mettagrid/htmlcov
 
 # Cleanup
 clean:
-	@echo "🧹 Cleaning build artifacts..."
+	@echo "Cleaning build artifacts..."
 	bazel clean
 	rm -rf .venv uv.lock
 	rm -f coverage.info *.gcda *.gcno *.profraw *.profdata

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: mettagrid
-Version: 0.2.0.22
+Version: 0.2.0.24
 Summary: A fast grid-based open-ended MARL environment
 Author-email: David Bloomin <daveey@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://daveey.github.io
 Project-URL: Repository, https://github.com/Metta-AI/mettagrid
 Keywords: gridworld,minigrid,rl,reinforcement-learning,environment,gym
-Requires-Python: >=3.11
+Requires-Python: <3.13,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: boto3>=1.38.32

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/benchmarks/test_mettagrid_env_benchmark.cpp

@@ -55,7 +55,6 @@ GameConfig CreateBenchmarkConfig(size_t num_agents) {
   actions_cfg.push_back({"swap", action_cfg});
   actions_cfg.push_back({"put_items", action_cfg});
   actions_cfg.push_back({"get_items", action_cfg});
-  actions_cfg.push_back({"change_color", action_cfg});
   actions_cfg.push_back({"change_glyph", change_glyph_cfg});
 
   std::map<std::string, std::shared_ptr<GridObjectConfig>> objects_cfg;

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/bindings/mettagrid_c.cpp

@@ -12,13 +12,12 @@
 
 #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"
+#include "actions/resource_mod.hpp"
 #include "actions/rotate.hpp"
 #include "actions/swap.hpp"
 #include "core/event.hpp"
@@ -107,8 +106,6 @@ MettaGrid::MettaGrid(const GameConfig& game_config, const py::list map, unsigned
       _action_handlers.push_back(std::make_unique<ChangeGlyph>(*change_glyph_config));
     } else if (action_name == "swap") {
       _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));
@@ -260,8 +257,12 @@ MettaGrid::MettaGrid(const GameConfig& game_config, const py::list map, unsigned
     if (clipper_cfg.unclipping_recipes.empty()) {
       throw std::runtime_error("Clipper config provided but unclipping_recipes is empty");
     }
-    _clipper = std::make_unique<Clipper>(*_grid, clipper_cfg.unclipping_recipes, clipper_cfg.length_scale,
-                                         clipper_cfg.cutoff_distance, clipper_cfg.clip_rate, _rng);
+    _clipper = std::make_unique<Clipper>(*_grid,
+                                         clipper_cfg.unclipping_recipes,
+                                         clipper_cfg.length_scale,
+                                         clipper_cfg.cutoff_distance,
+                                         clipper_cfg.clip_rate,
+                                         _rng);
   }
 }
 
@@ -284,6 +285,70 @@ void MettaGrid::init_action_handlers() {
       _max_action_arg = _max_action_args[i];
     }
   }
+
+  build_flat_action_catalog();
+}
+
+void MettaGrid::build_flat_action_catalog() {
+  _flat_action_map.clear();
+  _flat_action_names.clear();
+  _action_arg_to_flat.clear();
+
+  size_t total_variants = 0;
+  for (unsigned char max_arg : _max_action_args) {
+    total_variants += static_cast<size_t>(max_arg) + 1;
+  }
+
+  _flat_action_map.reserve(total_variants);
+  _flat_action_names.reserve(total_variants);
+  _action_arg_to_flat.resize(_action_handlers.size());
+
+  std::unordered_set<std::string> seen_names;
+  seen_names.reserve(total_variants);
+
+  for (size_t handler_index = 0; handler_index < _action_handlers.size(); ++handler_index) {
+    auto& handler = _action_handlers[handler_index];
+    unsigned char max_arg = _max_action_args[handler_index];
+    auto& arg_map = _action_arg_to_flat[handler_index];
+    arg_map.assign(static_cast<size_t>(max_arg) + 1, -1);
+
+    const int max_arg_int = static_cast<int>(max_arg);
+    for (int raw_arg = 0; raw_arg <= max_arg_int; ++raw_arg) {
+      const ActionArg arg = static_cast<ActionArg>(raw_arg);
+
+      std::string base_name = handler->variant_name(arg);
+      if (base_name.empty()) {
+        base_name = handler->action_name();
+      }
+
+      std::string variant = base_name;
+      int suffix = 1;
+      while (!seen_names.insert(variant).second) {
+        variant = base_name + "_" + std::to_string(suffix++);
+      }
+
+      const auto flat_index = static_cast<int>(_flat_action_map.size());
+      _flat_action_map.emplace_back(static_cast<ActionType>(handler_index), arg);
+      _flat_action_names.emplace_back(std::move(variant));
+      arg_map[static_cast<size_t>(arg)] = flat_index;
+    }
+  }
+}
+
+int MettaGrid::flat_action_index(ActionType action, ActionArg arg) const {
+  if (action < 0) {
+    return -1;
+  }
+  size_t action_idx = static_cast<size_t>(action);
+  if (action_idx >= _action_arg_to_flat.size()) {
+    return -1;
+  }
+  size_t arg_idx = static_cast<size_t>(arg);
+  const auto& mapping = _action_arg_to_flat[action_idx];
+  if (arg_idx >= mapping.size()) {
+    return -1;
+  }
+  return mapping[arg_idx];
 }
 
 void MettaGrid::add_agent(Agent* agent) {
@@ -324,6 +389,7 @@ void MettaGrid::_compute_observation(GridCoord observer_row,
 
   // Build global tokens based on configuration
   std::vector<PartialObservationToken> global_tokens;
+  int flat_action = flat_action_index(action, action_arg);
 
   if (_global_obs_config.episode_completion_pct) {
     ObservationType episode_completion_pct = 0;
@@ -336,7 +402,8 @@ void MettaGrid::_compute_observation(GridCoord observer_row,
   }
 
   if (_global_obs_config.last_action) {
-    global_tokens.push_back({ObservationFeature::LastAction, static_cast<ObservationType>(action)});
+    ObservationType action_value = static_cast<ObservationType>(std::max(0, flat_action));
+    global_tokens.push_back({ObservationFeature::LastAction, action_value});
     global_tokens.push_back({ObservationFeature::LastActionArg, static_cast<ObservationType>(action_arg)});
   }
 
@@ -650,7 +717,56 @@ void MettaGrid::set_buffers(const py::array_t<uint8_t, py::array::c_style>& obse
 }
 
 py::tuple MettaGrid::step(const py::array_t<ActionType, py::array::c_style> actions) {
-  _step(actions);
+  auto info = actions.request();
+  py::array_t<ActionType, py::array::c_style> converted;
+
+  auto assign_flat = [&](auto& view, size_t agent_idx, ActionType flat_index) {
+    if (flat_index < 0 || static_cast<size_t>(flat_index) >= _flat_action_map.size()) {
+      view(agent_idx, 0) = -1;
+      view(agent_idx, 1) = 0;
+      return;
+    }
+    const auto& mapping = _flat_action_map[static_cast<size_t>(flat_index)];
+    view(agent_idx, 0) = mapping.first;
+    view(agent_idx, 1) = mapping.second;
+  };
+
+  if (info.ndim == 1) {
+    if (info.shape[0] != static_cast<ssize_t>(_agents.size())) {
+      throw std::runtime_error("actions has the wrong shape");
+    }
+    auto view = actions.unchecked<1>();
+    converted = py::array_t<ActionType, py::array::c_style>(
+        py::array::ShapeContainer{static_cast<ssize_t>(_agents.size()), static_cast<ssize_t>(2)});
+    auto converted_view = converted.mutable_unchecked<2>();
+    for (size_t agent_idx = 0; agent_idx < _agents.size(); ++agent_idx) {
+      auto flat_index = view(agent_idx);
+      assign_flat(converted_view, agent_idx, flat_index);
+    }
+    _step(converted);
+  } else if (info.ndim == 2) {
+    if (info.shape[0] != static_cast<ssize_t>(_agents.size())) {
+      throw std::runtime_error("actions has the wrong shape");
+    }
+
+    if (info.shape[1] == 1) {
+      auto view = actions.unchecked<2>();
+      converted = py::array_t<ActionType, py::array::c_style>(
+          py::array::ShapeContainer{static_cast<ssize_t>(_agents.size()), static_cast<ssize_t>(2)});
+      auto converted_view = converted.mutable_unchecked<2>();
+      for (size_t agent_idx = 0; agent_idx < _agents.size(); ++agent_idx) {
+        auto flat_index = view(agent_idx, 0);
+        assign_flat(converted_view, agent_idx, flat_index);
+      }
+      _step(converted);
+    } else if (info.shape[1] == 2) {
+      _step(actions);
+    } else {
+      throw std::runtime_error("actions has the wrong shape");
+    }
+  } else {
+    throw std::runtime_error("actions has the wrong shape");
+  }
 
   auto rewards_view = _rewards.mutable_unchecked<1>();
 
@@ -717,8 +833,8 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
 
     // Filter by bounding box if specified
     if (use_bounds) {
-      if (obj->location.r < min_row || obj->location.r >= max_row ||
-          obj->location.c < min_col || obj->location.c >= max_col) {
+      if (obj->location.r < min_row || obj->location.r >= max_row || obj->location.c < min_col ||
+          obj->location.c >= max_col) {
         continue;
       }
     }
@@ -760,7 +876,6 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
       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;
@@ -782,7 +897,6 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
       obj_dict["conversion_duration"] = converter->conversion_ticks;
       obj_dict["cooldown_duration"] = converter->cooldown;
       obj_dict["output_limit"] = converter->max_output;
-      obj_dict["color"] = converter->color;
       py::dict input_resources_dict;
       for (const auto& [resource, quantity] : converter->input_resources) {
         input_resources_dict[py::int_(resource)] = quantity;
@@ -829,7 +943,8 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
       }
 
       // Add all recipes information (only non-null recipes)
-      const std::vector<std::shared_ptr<Recipe>>& active_recipes = assembler->is_clipped ? assembler->unclip_recipes : assembler->recipes;
+      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) {
@@ -876,8 +991,8 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
 
 py::list MettaGrid::action_names() {
   py::list names;
-  for (const auto& handler : _action_handlers) {
-    names.append(handler->action_name());
+  for (const auto& name : _flat_action_names) {
+    names.append(py::str(name));
   }
   return names;
 }
@@ -947,10 +1062,7 @@ py::object MettaGrid::action_space() {
   auto gym = py::module_::import("gymnasium");
   auto spaces = gym.attr("spaces");
 
-  size_t number_of_actions = py::len(action_names());
-  size_t number_of_action_args = _max_action_arg + 1;
-  return spaces.attr("MultiDiscrete")(py::make_tuple(number_of_actions, number_of_action_args),
-                                      py::arg("dtype") = dtype_actions());
+  return spaces.attr("Discrete")(py::int_(_flat_action_map.size()));
 }
 
 py::object MettaGrid::observation_space() {

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/bindings/mettagrid_c.hpp

@@ -162,6 +162,10 @@ private:
   std::mt19937 _rng;
   unsigned int _seed;
 
+  std::vector<std::pair<ActionType, ActionArg>> _flat_action_map;
+  std::vector<std::string> _flat_action_names;
+  std::vector<std::vector<int>> _action_arg_to_flat;
+
   // Movement tracking
   bool _track_movement_metrics;
   float _resource_loss_prob;
@@ -188,6 +192,8 @@ private:
   AgentConfig _create_agent_config(const py::dict& agent_group_cfg_py);
   ConverterConfig _create_converter_config(const py::dict& converter_cfg_py);
   WallConfig _create_wall_config(const py::dict& wall_cfg_py);
+  void build_flat_action_catalog();
+  int flat_action_index(ActionType action, ActionArg arg) const;
 };
 
 #endif  // PACKAGES_METTAGRID_CPP_BINDINGS_METTAGRID_C_HPP_

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/include/mettagrid/actions/action_handler.hpp

@@ -144,6 +144,13 @@ public:
     return _action_name;
   }
 
+  virtual std::string variant_name(ActionArg arg) const {
+    if (max_arg() == 0) {
+      return _action_name;
+    }
+    return _action_name + "_" + std::to_string(static_cast<int>(arg));
+  }
+
 protected:
   virtual bool _handle_action(Agent& actor, ActionArg arg) = 0;
 

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/include/mettagrid/actions/move.hpp

@@ -88,6 +88,14 @@ protected:
     return _grid->move_object(actor, target_location);
   }
 
+  std::string variant_name(ActionArg arg) const override {
+    Orientation move_direction = static_cast<Orientation>(arg);
+    if (!isValidOrientation(move_direction, _game_config->allow_diagonals)) {
+      return ActionHandler::variant_name(arg);
+    }
+    return std::string(action_name()) + "_" + OrientationFullNames[static_cast<size_t>(move_direction)];
+  }
+
 private:
   const GameConfig* _game_config;
 };

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/include/mettagrid/actions/orientation.hpp

@@ -125,4 +125,15 @@ inline const char* OrientationNames[8] = {
     "SE"   // 7
 };
 
+inline const char* OrientationFullNames[8] = {
+    "north",      // 0
+    "south",      // 1
+    "west",       // 2
+    "east",       // 3
+    "northwest",  // 4
+    "northeast",  // 5
+    "southwest",  // 6
+    "southeast"   // 7
+};
+
 #endif  // PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_ACTIONS_ORIENTATION_HPP_

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/include/mettagrid/actions/resource_mod.hpp

@@ -63,6 +63,13 @@ public:
   }
 
 protected:
+  std::string variant_name(ActionArg arg) const override {
+    if (arg == 0) {
+      return action_name();
+    }
+    return ActionHandler::variant_name(arg);
+  }
+
   bool _handle_action(Agent& actor, ActionArg /* arg */) override {
     // Center AoE on actor's position
     int center_row = static_cast<int>(actor.location.r);

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/include/mettagrid/actions/rotate.hpp

@@ -42,6 +42,14 @@ protected:
     return true;
   }
 
+  std::string variant_name(ActionArg arg) const override {
+    Orientation orientation = static_cast<Orientation>(arg);
+    if (!_game_config->allow_diagonals && isDiagonal(orientation)) {
+      return ActionHandler::variant_name(arg);
+    }
+    return std::string(action_name()) + "_" + OrientationFullNames[static_cast<size_t>(orientation)];
+  }
+
 private:
   const GameConfig* _game_config;
 };

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/include/mettagrid/objects/agent.hpp

@@ -31,7 +31,6 @@ public:
   std::vector<InventoryItem> soul_bound_resources;
   // Resources that this agent will try to share when it uses another agent.
   std::vector<InventoryItem> shareable_resources;
-  ObservationType color;
   ObservationType glyph;
   // Despite being a GridObjectId, this is different from the `id` property.
   // This is the index into MettaGrid._agents (std::vector<Agent*>)
@@ -61,7 +60,6 @@ public:
         group_name(config.group_name),
         soul_bound_resources(config.soul_bound_resources),
         shareable_resources(config.shareable_resources),
-        color(0),
         glyph(0),
         agent_id(0),
         stats(resource_names),
@@ -216,7 +214,6 @@ public:
     features.push_back({ObservationFeature::Group, static_cast<ObservationType>(group)});
     features.push_back({ObservationFeature::Frozen, static_cast<ObservationType>(frozen != 0 ? 1 : 0)});
     features.push_back({ObservationFeature::Orientation, static_cast<ObservationType>(orientation)});
-    features.push_back({ObservationFeature::Color, static_cast<ObservationType>(color)});
     if (glyph != 0) features.push_back({ObservationFeature::Glyph, static_cast<ObservationType>(glyph)});
 
     for (const auto& [item, amount] : this->inventory.get()) {

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/include/mettagrid/objects/assembler.hpp

@@ -33,6 +33,7 @@ private:
         }
       }
     }
+
     return positions;
   }
 
@@ -83,6 +84,16 @@ private:
     }
   }
 
+  // Returns true if the recipe yields any positive output amount (legacy name retained for compatibility)
+  bool recipe_has_positive_output(const Recipe& recipe) const {
+    for (const auto& [item, amount] : recipe.output_resources) {
+      if (amount > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+
 public:
   // Consume resources from surrounding agents for the given recipe
   // Intended to be private, but made public for testing. We couldn't get `friend` to work as expected.
@@ -298,6 +309,14 @@ public:
     Recipe recipe_to_use = *original_recipe;
     if (progress < 1.0f && allow_partial_usage) {
       recipe_to_use = scale_recipe_for_partial_usage(*original_recipe, progress);
+
+      // Prevent usage that would yield no outputs (and would only serve to burn inputs and increment uses_count)
+      // Do not prevent usage if:
+      // - the unscaled recipe does not have outputs
+      // - usage would unclip the assembler; the unscaled unclipping recipe may happen to include outputs
+      if (!recipe_has_positive_output(recipe_to_use) && recipe_has_positive_output(*original_recipe) && !is_clipped) {
+        return false;
+      }
     }
 
     std::vector<Agent*> surrounding_agents = get_surrounding_agents();

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/include/mettagrid/objects/chest.hpp

@@ -76,7 +76,8 @@ private:
       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));
+      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;
@@ -98,7 +99,8 @@ private:
       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));
+        stats_tracker->set("chest." + stats_tracker->resource_name(resource_type) + ".amount",
+                           inventory.amount(resource_type));
         return true;
       }
       return false;
@@ -163,7 +165,6 @@ public:
     features.reserve(2 + this->inventory.get().size() + this->tag_ids.size());
 
     features.push_back({ObservationFeature::TypeId, static_cast<ObservationType>(this->type_id)});
-    features.push_back({ObservationFeature::Color, static_cast<ObservationType>(this->resource_type)});
 
     // Add current inventory (inv:resource)
     for (const auto& [item, amount] : this->inventory.get()) {

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/include/mettagrid/objects/constants.hpp

@@ -37,7 +37,9 @@ constexpr ObservationType TypeId = 0;
 constexpr ObservationType Group = 1;
 constexpr ObservationType Frozen = 2;
 constexpr ObservationType Orientation = 3;
-constexpr ObservationType Color = 4;
+// This used to be Color, but we removed it. We're leaving this here for backward compatibility, but may fill it
+// in with a more useful feature in the future.
+constexpr ObservationType ReservedForFutureUse = 4;
 constexpr ObservationType ConvertingOrCoolingDown = 5;
 constexpr ObservationType Swappable = 6;
 constexpr ObservationType EpisodeCompletionPct = 7;
@@ -62,7 +64,7 @@ inline const std::map<ObservationType, std::string>& GetFeatureNames() {
       {ObservationFeature::Group, "agent:group"},
       {ObservationFeature::Frozen, "agent:frozen"},
       {ObservationFeature::Orientation, "agent:orientation"},
-      {ObservationFeature::Color, "agent:color"},
+      {ObservationFeature::ReservedForFutureUse, "agent:reserved_for_future_use"},
       {ObservationFeature::ConvertingOrCoolingDown, "converting"},
       {ObservationFeature::Swappable, "swappable"},
       {ObservationFeature::EpisodeCompletionPct, "episode_completion_pct"},
@@ -81,7 +83,6 @@ inline const std::map<ObservationType, std::string>& GetFeatureNames() {
 // ##ObservationNormalization
 // These are approximate maximum values for each feature. Ideally they would be defined closer to their source,
 // but here we are. If you add / remove a feature, you should add / remove the corresponding normalization.
-// These should move to configuration "soon". E.g., by 2025-06-10.
 inline const std::map<ObservationType, float>& GetFeatureNormalizations() {
   static const std::map<ObservationType, float> feature_normalizations = {
       {ObservationFeature::LastAction, 10.0},
@@ -92,7 +93,7 @@ inline const std::map<ObservationType, float>& GetFeatureNormalizations() {
       {ObservationFeature::Group, 10.0},
       {ObservationFeature::Frozen, 1.0},
       {ObservationFeature::Orientation, 1.0},
-      {ObservationFeature::Color, 255.0},
+      {ObservationFeature::ReservedForFutureUse, 255.0},
       {ObservationFeature::ConvertingOrCoolingDown, 1.0},
       {ObservationFeature::Swappable, 1.0},
       {ObservationFeature::Glyph, 255.0},

{mettagrid-0.2.0.22 → mettagrid-0.2.0.24}/cpp/include/mettagrid/objects/converter.hpp

@@ -77,7 +77,6 @@ public:
   unsigned short cooldown;          // Time to wait after producing before starting again
   bool converting;                  // Currently in production phase
   bool cooling_down;                // Currently in cooldown phase
-  unsigned char color;
   bool recipe_details_obs;
   EventManager* event_manager;
   ObservationType input_recipe_offset;
@@ -95,7 +94,6 @@ public:
         cooldown(cfg.cooldown),
         converting(false),
         cooling_down(false),
-        color(cfg.color),
         recipe_details_obs(cfg.recipe_details_obs),
         event_manager(nullptr),
         input_recipe_offset(cfg.input_recipe_offset),
@@ -160,7 +158,6 @@ public:
     features.reserve(capacity);
 
     features.push_back({ObservationFeature::TypeId, static_cast<ObservationType>(this->type_id)});
-    features.push_back({ObservationFeature::Color, static_cast<ObservationType>(this->color)});
     features.push_back({ObservationFeature::ConvertingOrCoolingDown,
                         static_cast<ObservationType>(this->converting || this->cooling_down)});