mettagrid 0.2.0.22__tar.gz → 0.2.0.23__tar.gz

{mettagrid-0.2.0.22 → mettagrid-0.2.0.23}/.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.23}/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.23}/PKG-INFO

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

{mettagrid-0.2.0.22 → mettagrid-0.2.0.23}/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);
   }
 }
 
@@ -717,8 +718,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 +761,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 +782,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 +828,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) {

{mettagrid-0.2.0.22 → mettagrid-0.2.0.23}/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.23}/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.23}/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.23}/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.23}/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)});
 

{mettagrid-0.2.0.22 → mettagrid-0.2.0.23}/cpp/include/mettagrid/objects/converter_config.hpp

@@ -21,7 +21,6 @@ struct ConverterConfig : public GridObjectConfig {
                   unsigned short conversion_ticks,
                   unsigned short cooldown,
                   InventoryQuantity initial_resource_count = 0,
-                  ObservationType color = 0,
                   bool recipe_details_obs = false,
                   const std::vector<int>& tag_ids = {})
       : GridObjectConfig(type_id, type_name, tag_ids),
@@ -32,7 +31,6 @@ struct ConverterConfig : public GridObjectConfig {
         conversion_ticks(conversion_ticks),
         cooldown(cooldown),
         initial_resource_count(initial_resource_count),
-        color(color),
         recipe_details_obs(recipe_details_obs),
         input_recipe_offset(0),
         output_recipe_offset(0) {}
@@ -44,7 +42,6 @@ struct ConverterConfig : public GridObjectConfig {
   unsigned short conversion_ticks;
   unsigned short cooldown;
   InventoryQuantity initial_resource_count;
-  ObservationType color;
   bool recipe_details_obs;
   ObservationType input_recipe_offset;
   ObservationType output_recipe_offset;
@@ -63,7 +60,6 @@ inline void bind_converter_config(py::module& m) {
                     unsigned short,
                     unsigned short,
                     unsigned char,
-                    ObservationType,
                     bool,
                     const std::vector<int>&>(),
            py::arg("type_id"),
@@ -75,7 +71,6 @@ inline void bind_converter_config(py::module& m) {
            py::arg("conversion_ticks"),
            py::arg("cooldown"),
            py::arg("initial_resource_count") = 0,
-           py::arg("color") = 0,
            py::arg("recipe_details_obs") = false,
            py::arg("tag_ids") = std::vector<int>())
       .def_readwrite("type_id", &ConverterConfig::type_id)
@@ -87,7 +82,6 @@ inline void bind_converter_config(py::module& m) {
       .def_readwrite("conversion_ticks", &ConverterConfig::conversion_ticks)
       .def_readwrite("cooldown", &ConverterConfig::cooldown)
       .def_readwrite("initial_resource_count", &ConverterConfig::initial_resource_count)
-      .def_readwrite("color", &ConverterConfig::color)
       .def_readwrite("recipe_details_obs", &ConverterConfig::recipe_details_obs)
       .def_readwrite("tag_ids", &ConverterConfig::tag_ids);
 }

mettagrid-0.2.0.23/cpp/include/mettagrid/systems/clipper.hpp

@@ -0,0 +1,228 @@
+#ifndef PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_SYSTEMS_CLIPPER_HPP_
+#define PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_SYSTEMS_CLIPPER_HPP_
+
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <memory>
+#include <numbers>
+#include <random>
+#include <vector>
+
+#include "core/grid.hpp"
+#include "objects/assembler.hpp"
+
+class Clipper {
+public:
+  std::vector<std::shared_ptr<Recipe>> unclipping_recipes;
+  // A map from assembler to its adjacent assemblers. This should be constant once computed.
+  std::map<Assembler*, std::vector<Assembler*>> adjacent_assemblers;
+  // A map of all assemblers to their current infection weight. This is the weight at which they'll be selected
+  // for clipping (if currently unclipped).
+  std::map<Assembler*, float> assembler_infection_weight;
+  // A set of assemblers that are adjacent to the set of clipped assemblers. Any unclipped assembler with
+  // non-zero infection weight will be in this set.
+  std::set<Assembler*> border_assemblers;
+  // A set of all unclipped assemblers. Any assembler that is not in this set will be clipped.
+  std::set<Assembler*> unclipped_assemblers;
+
+  float length_scale;
+  float cutoff_distance;
+  Grid& grid;
+  float clip_rate;
+  std::mt19937 rng;
+
+  Clipper(Grid& grid,
+          std::vector<std::shared_ptr<Recipe>> recipe_ptrs,
+          float length_scale,
+          float cutoff_distance,
+          float clip_rate,
+          std::mt19937 rng_init)
+      : unclipping_recipes(std::move(recipe_ptrs)),
+        length_scale(length_scale),
+        cutoff_distance(cutoff_distance),
+        grid(grid),
+        clip_rate(clip_rate),
+        rng(std::move(rng_init)) {
+    std::vector<Assembler*> starting_clipped_assemblers;
+    for (size_t obj_id = 1; obj_id < grid.objects.size(); obj_id++) {
+      auto* obj = grid.object(static_cast<GridObjectId>(obj_id));
+      if (!obj) continue;
+      if (auto* assembler = dynamic_cast<Assembler*>(obj)) {
+        // Skip clip-immune assemblers
+        if (assembler->clip_immune) continue;
+
+        assembler_infection_weight[assembler] = 0.0f;
+        unclipped_assemblers.insert(assembler);
+
+        if (assembler->start_clipped) {
+          // We'll actually do the clipping in a later step.
+          starting_clipped_assemblers.push_back(assembler);
+        }
+      }
+    }
+
+    // Auto-calculate length_scale based on percolation theory if length_scale <= 0
+    if (length_scale <= 0.0f && !assembler_infection_weight.empty()) {
+      // Get grid dimensions
+      GridCoord grid_width = grid.width;
+      GridCoord grid_height = grid.height;
+      float grid_size = static_cast<float>(std::max(grid_width, grid_height));
+
+      // Calculate percolation-based length scale
+      // The constant 4.51 is the critical percolation density λ_c for 2D continuum percolation,
+      // empirically determined through Monte Carlo simulations (not analytically derivable).
+      // Reference:
+      // https://en.wikipedia.org/wiki/Percolation_threshold#Thresholds_for_2D_continuum_models
+      // Note: Wikipedia provides a value of ~1.127 when defined in terms of radius,
+      // We use diameter basis which becomes 4.51
+
+      constexpr float PERCOLATION_CONSTANT = 4.51f;
+      this->length_scale = (grid_size / std::sqrt(static_cast<float>(assembler_infection_weight.size()))) *
+                           std::sqrt(PERCOLATION_CONSTANT / (4.0f * std::numbers::pi_v<float>));
+    }
+    // else: use the provided positive length_scale value as-is
+
+    // Auto-calculate cutoff_distance if not provided (cutoff_distance <= 0)
+    // At 3*length_scale, exp(-3) ≈ 0.05, so weights beyond this are negligible
+    if (cutoff_distance <= 0.0f) {
+      this->cutoff_distance = 3.0f * this->length_scale;
+    }
+
+    // This can be expensive, so only do it if the clipper is active. Note that having a Clipper with
+    // a zero clip rate is value, since we can still clip assemblers that start clipped.
+    if (clip_rate > 0.0f) {
+      compute_adjacencies();
+    }
+
+    // Clip all starting clipped assemblers
+    for (auto* assembler : starting_clipped_assemblers) {
+      clip_assembler(*assembler);
+    }
+  }
+
+  float infection_weight(Assembler& from, Assembler& to) const {
+    float distance = this->distance(from, to);
+    if (cutoff_distance > 0.0f && distance > cutoff_distance) return 0.0f;
+    return std::exp(-distance / length_scale);
+  }
+
+  // it's a little funky to use L2 distance here, since everywhere else we use L1 or Linf.
+  float distance(Assembler& assembler_a, Assembler& assembler_b) const {
+    GridLocation location_a = assembler_a.location;
+    GridLocation location_b = assembler_b.location;
+    return std::sqrt(std::pow(location_a.r - location_b.r, 2) + std::pow(location_a.c - location_b.c, 2));
+  }
+
+  void compute_adjacencies() {
+    // Clear existing adjacencies
+    adjacent_assemblers.clear();
+
+    // Collect all assemblers and sort by x coordinate (column)
+    std::vector<Assembler*> sorted_assemblers;
+    for (auto& [assembler, _] : assembler_infection_weight) {
+      sorted_assemblers.push_back(assembler);
+    }
+
+    // Sort assemblers by their column. In the future we could consider sorting by row instead when
+    // height > width.
+    std::sort(sorted_assemblers.begin(), sorted_assemblers.end(), [](Assembler* a, Assembler* b) {
+      return a->location.c < b->location.c;
+    });
+
+    // For each assembler, find adjacent assemblers within cutoff_distance
+    for (size_t i = 0; i < sorted_assemblers.size(); ++i) {
+      Assembler* assembler_a = sorted_assemblers[i];
+      GridCoord a_x = assembler_a->location.c;
+
+      // Check assemblers with x coordinates within cutoff_distance
+      for (size_t j = i + 1; j < sorted_assemblers.size(); ++j) {
+        Assembler* assembler_b = sorted_assemblers[j];
+        GridCoord b_x = assembler_b->location.c;
+
+        // If x difference exceeds cutoff_distance, no need to check further
+        if (b_x - a_x > cutoff_distance) {
+          break;
+        }
+
+        // Calculate actual distance
+        float dist = distance(*assembler_a, *assembler_b);
+
+        // If within cutoff_distance, they are adjacent
+        if (dist <= cutoff_distance) {
+          // Add both directions of connection
+          adjacent_assemblers[assembler_a].push_back(assembler_b);
+          adjacent_assemblers[assembler_b].push_back(assembler_a);
+        }
+      }
+    }
+  }
+
+  void clip_assembler(Assembler& to_infect) {
+    assert(!to_infect.is_clipped);
+    // Update infection weights only for adjacent assemblers
+    for (auto* adjacent : adjacent_assemblers[&to_infect]) {
+      // Track this even for clipped assemblers, so we'll have an accurate number if they become unclipped.
+      assembler_infection_weight[adjacent] += infection_weight(to_infect, *adjacent);
+      if (adjacent->is_clipped) continue;
+      border_assemblers.insert(adjacent);
+    }
+    border_assemblers.erase(&to_infect);
+    unclipped_assemblers.erase(&to_infect);
+
+    // Randomly select one recipe from the list
+    std::uniform_int_distribution<size_t> dist(0, unclipping_recipes.size() - 1);
+    size_t selected_idx = dist(rng);
+    std::shared_ptr<Recipe> selected_recipe = unclipping_recipes[selected_idx];
+
+    // Create a vector of 256 copies of the selected recipe
+    std::vector<std::shared_ptr<Recipe>> unclip_recipes;
+    unclip_recipes.assign(256, selected_recipe);
+    to_infect.become_clipped(unclip_recipes, this);
+  }
+
+  void on_unclip_assembler(Assembler& to_unclip) {
+    // Update infection weights only for adjacent assemblers
+    for (auto* adjacent : adjacent_assemblers[&to_unclip]) {
+      assembler_infection_weight[adjacent] -= infection_weight(to_unclip, *adjacent);
+    }
+    unclipped_assemblers.insert(&to_unclip);
+    if (assembler_infection_weight[&to_unclip] > 0.0f) {
+      border_assemblers.insert(&to_unclip);
+    }
+  }
+
+  Assembler* pick_assembler_to_clip() {
+    float total_weight = 0.0f;
+    for (auto& candidate_assembler : border_assemblers) {
+      total_weight += assembler_infection_weight.at(candidate_assembler);
+    }
+    float random_weight = std::generate_canonical<float, 10>(rng) * total_weight;
+    for (auto& candidate_assembler : border_assemblers) {
+      random_weight -= assembler_infection_weight.at(candidate_assembler);
+      if (random_weight <= 0.0f) {
+        return candidate_assembler;
+      }
+    }
+    // We failed to find an assembler to clip. That _should_ be because there are no border assemblers. But maybe
+    // it's a floating point error. In any case, pick a random assembler from the unclipped assemblers.
+    if (!unclipped_assemblers.empty()) {
+      auto it = unclipped_assemblers.begin();
+      std::advance(it, std::uniform_int_distribution<size_t>(0, unclipped_assemblers.size() - 1)(rng));
+      return *it;
+    }
+
+    return nullptr;
+  }
+
+  void maybe_clip_new_assembler() {
+    if (std::generate_canonical<float, 10>(rng) < clip_rate) {
+      Assembler* assembler = pick_assembler_to_clip();
+      if (assembler) {
+        clip_assembler(*assembler);
+      }
+    }
+  }
+};
+
+#endif  // PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_SYSTEMS_CLIPPER_HPP_

{mettagrid-0.2.0.22 → mettagrid-0.2.0.23}/mettagrid.egg-info/PKG-INFO

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