mettagrid 0.2.0.21__tar.gz → 0.2.0.22__tar.gz

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

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

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

@@ -260,8 +260,8 @@ 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);
+    _clipper = std::make_unique<Clipper>(*_grid, clipper_cfg.unclipping_recipes, clipper_cfg.length_scale,
+                                         clipper_cfg.cutoff_distance, clipper_cfg.clip_rate, _rng);
   }
 }
 
@@ -515,7 +515,7 @@ void MettaGrid::_step(Actions actions) {
 
   // Apply global systems
   if (_clipper) {
-    _clipper->maybe_clip_new_assembler(_rng);
+    _clipper->maybe_clip_new_assembler();
   }
 
   // Compute observations for next step
@@ -801,13 +801,16 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
       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["is_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 ID (pattern byte)
+      obj_dict["current_recipe_id"] = static_cast<int>(assembler->get_agent_pattern_byte());
+
       // Add current recipe information
       const Recipe* current_recipe = assembler->get_current_recipe();
       if (current_recipe) {
@@ -825,25 +828,25 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
         obj_dict["current_recipe_cooldown"] = current_recipe->cooldown;
       }
 
-      // Add all recipes information
+      // 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;
       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;
+          recipe_dict["inputs"] = 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["outputs"] = output_resources_dict;
           recipe_dict["cooldown"] = active_recipes[i]->cooldown;
 
           recipes_list.append(recipe_dict);

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

@@ -111,6 +111,9 @@ public:
   // Clip immunity - if true, cannot be clipped
   bool clip_immune;
 
+  // Start clipped - if true, starts in clipped state
+  bool start_clipped;
+
   // Current cooldown state
   unsigned int cooldown_end_timestep;
   unsigned int cooldown_duration;  // Total duration of current cooldown
@@ -145,6 +148,7 @@ public:
         unclip_recipes(),
         is_clipped(false),
         clip_immune(cfg.clip_immune),
+        start_clipped(cfg.start_clipped),
         cooldown_end_timestep(0),
         cooldown_duration(0),
         uses_count(0),

{mettagrid-0.2.0.21 → mettagrid-0.2.0.22}/cpp/include/mettagrid/objects/assembler_config.hpp

@@ -22,7 +22,8 @@ struct AssemblerConfig : public GridObjectConfig {
         allow_partial_usage(false),
         max_uses(0),           // 0 means unlimited uses
         exhaustion(0.0f),      // 0 means no exhaustion
-        clip_immune(false) {}  // Not immune by default
+        clip_immune(false),    // Not immune by default
+        start_clipped(false) {}  // Not clipped at start by default
 
   // Recipes will be set separately via initialize_recipes()
   std::vector<std::shared_ptr<Recipe>> recipes;
@@ -42,6 +43,9 @@ struct AssemblerConfig : public GridObjectConfig {
 
   // Clip immunity - if true, this assembler cannot be clipped
   bool clip_immune;
+
+  // Start clipped - if true, this assembler starts in a clipped state
+  bool start_clipped;
 };
 
 namespace py = pybind11;
@@ -60,7 +64,8 @@ inline void bind_assembler_config(py::module& m) {
       .def_readwrite("allow_partial_usage", &AssemblerConfig::allow_partial_usage)
       .def_readwrite("max_uses", &AssemblerConfig::max_uses)
       .def_readwrite("exhaustion", &AssemblerConfig::exhaustion)
-      .def_readwrite("clip_immune", &AssemblerConfig::clip_immune);
+      .def_readwrite("clip_immune", &AssemblerConfig::clip_immune)
+      .def_readwrite("start_clipped", &AssemblerConfig::start_clipped);
 }
 
 #endif  // PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_OBJECTS_ASSEMBLER_CONFIG_HPP_

{mettagrid-0.2.0.21 → mettagrid-0.2.0.22}/cpp/include/mettagrid/systems/clipper.hpp

@@ -3,6 +3,7 @@
 
 #include <cmath>
 #include <memory>
+#include <numbers>
 #include <random>
 #include <vector>
 
@@ -18,23 +19,61 @@ public:
   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)
+  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) {
+        clip_rate(clip_rate),
+        rng(std::move(rng_init)) {
     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);
+
+        // Check if this assembler should start clipped
+        if (assembler->start_clipped) {
+          // Clip it immediately without adding to unclipped set
+          clip_assembler(*assembler);
+        } else {
+          // Add to unclipped assemblers set
+          unclipped_assemblers.insert(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;
+    }
   }
 
   float infection_weight(Assembler& from, Assembler& to) const {
@@ -50,7 +89,7 @@ public:
     return std::sqrt(std::pow(location_a.r - location_b.r, 2) + std::pow(location_a.c - location_b.c, 2));
   }
 
-  void clip_assembler(Assembler& to_infect, std::mt19937& rng) {
+  void clip_assembler(Assembler& to_infect) {
     for (auto& [other, weight] : assembler_infection_weight) {
       if (other == &to_infect) continue;
       weight += infection_weight(to_infect, *other);
@@ -76,7 +115,7 @@ public:
     unclipped_assemblers.insert(&to_unclip);
   }
 
-  Assembler* pick_assembler_to_clip(std::mt19937& rng) {
+  Assembler* pick_assembler_to_clip() {
     float total_weight = 0.0f;
     for (auto& candidate_assembler : unclipped_assemblers) {
       total_weight += assembler_infection_weight.at(candidate_assembler);
@@ -91,7 +130,7 @@ public:
     return nullptr;
   }
 
-  Assembler* pick_initial_assembler_to_clip(std::mt19937& rng) {
+  Assembler* pick_initial_assembler_to_clip() {
     // Pick an assembler uniformly at random.
     float total_weight = unclipped_assemblers.size();
     float random_weight = std::generate_canonical<float, 10>(rng) * total_weight;
@@ -106,10 +145,10 @@ public:
     return nullptr;
   }
 
-  void maybe_clip_new_assembler(std::mt19937& rng) {
+  void maybe_clip_new_assembler() {
     if (std::generate_canonical<float, 10>(rng) < clip_rate) {
-      Assembler* assembler = pick_assembler_to_clip(rng);
-      if (assembler) clip_assembler(*assembler, rng);
+      Assembler* assembler = pick_assembler_to_clip();
+      if (assembler) clip_assembler(*assembler);
     }
   }
 };

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

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

{mettagrid-0.2.0.21 → mettagrid-0.2.0.22}/mettagrid.egg-info/SOURCES.txt

@@ -366,6 +366,7 @@ nim/mettascope/src/mettascope/utils.nim
 nim/mettascope/src/mettascope/worldmap.nim
 python/README.md
 python/src/mettagrid/__init__.py
+python/src/mettagrid/base_config.py
 python/src/mettagrid/core.py
 python/src/mettagrid/demo.py
 python/src/mettagrid/mettagrid_c.pyi
@@ -377,7 +378,6 @@ python/src/mettagrid/builder/building.py
 python/src/mettagrid/builder/empty_converters.py
 python/src/mettagrid/builder/envs.py
 python/src/mettagrid/config/__init__.py
-python/src/mettagrid/config/config.py
 python/src/mettagrid/config/mettagrid_c_config.py
 python/src/mettagrid/config/mettagrid_config.py
 python/src/mettagrid/envs/__init__.py
@@ -395,6 +395,7 @@ python/src/mettagrid/map_builder/perimeter_incontext.py
 python/src/mettagrid/map_builder/random.py
 python/src/mettagrid/map_builder/utils.py
 python/src/mettagrid/mapgen/__init__.py
+python/src/mettagrid/mapgen/area.py
 python/src/mettagrid/mapgen/load.py
 python/src/mettagrid/mapgen/mapgen.py
 python/src/mettagrid/mapgen/mapgen_ascii.py
@@ -751,6 +752,7 @@ python/src/mettagrid/renderer/assets/puffer_chars.png
 python/src/mettagrid/renderer/assets/wall.png
 python/src/mettagrid/renderer/miniscope/__init__.py
 python/src/mettagrid/renderer/miniscope/buffer.py
+python/src/mettagrid/renderer/miniscope/help.py
 python/src/mettagrid/renderer/miniscope/info_panels.py
 python/src/mettagrid/renderer/miniscope/interactive.py
 python/src/mettagrid/renderer/miniscope/renderer.py
@@ -823,6 +825,7 @@ tests/map_builder/test_utils.py
 tests/mapgen/__init__.py
 tests/mapgen/test_mapgen.py
 tests/mapgen/test_scene.py
+tests/mapgen/test_transform.py
 tests/mapgen/test_validate_all_ascii_maps.py
 tests/mapgen/random/test_float.py
 tests/mapgen/random/test_int.py

{mettagrid-0.2.0.21 → mettagrid-0.2.0.22}/nim/mettascope/src/mettascope/actions.nim

@@ -50,31 +50,42 @@ proc processActions*() =
     
     if agentDestinations.hasKey(agentId) and agentDestinations[agentId].len > 0:
       let dest = agentDestinations[agentId][0]
-
-      # If this is a 'bump' destination and we are adjacent to it, bump it once.
-      if dest.destinationType == Bump and currentPos in findAdjacentWalkable(dest.pos):
-        # TODO: Chests have special behavior.
-        #   You must deposit on the right side and take out on the left side.
-        #   This is not implemented yet.
-        let dx = dest.pos.x - currentPos.x
-        let dy = dest.pos.y - currentPos.y
-        let targetOrientation = getOrientationFromDelta(dx.int, dy.int)
-        sendAction(agentId, replay.moveActionId, targetOrientation.int)
-        # after bumping, the current destination is fulfilled.
+      
+      # Check if we've reached a Move destination and remove it.
+      if dest.destinationType == Move and dest.pos == currentPos:
         agentDestinations[agentId].delete(0)
-        agentPaths.del(agentId)
-        # if there's another destination, pathfind to it.
-        if agentDestinations[agentId].len > 0:
+        if agentDestinations[agentId].len == 0:
+          agentPaths.del(agentId)
+          continue
+        else:
           recomputePath(agentId, currentPos)
-        continue
+      
+      # If this is a Bump destination and we are at the approach position, bump it once.
+      if dest.destinationType == Bump:
+        let approachPos = ivec2(dest.pos.x + dest.approachDir.x, dest.pos.y + dest.approachDir.y)
+        if currentPos == approachPos:
+          # TODO: Chests have special behavior.
+          #   You must deposit on the right side and take out on the left side.
+          #   This is not implemented yet.
+          let dx = dest.pos.x - currentPos.x
+          let dy = dest.pos.y - currentPos.y
+          let targetOrientation = getOrientationFromDelta(dx.int, dy.int)
+          sendAction(agentId, replay.moveActionId, targetOrientation.int)
+          # After bumping, the current destination is fulfilled.
+          agentDestinations[agentId].delete(0)
+          agentPaths.del(agentId)
+          # If there's another destination, pathfind to it.
+          if agentDestinations[agentId].len > 0:
+            recomputePath(agentId, currentPos)
+          continue
     
     if not agentPaths.hasKey(agentId):
       continue
     let path = agentPaths[agentId]
     
-    if path.len > 1:
+    if path.len > 0:
       # If we are still on the expected path, continue moving.
-      # otherwise, assume something is blocking the path and recompute.
+      # Otherwise, assume something is blocking the path and recompute.
       if path[0] == currentPos:
         if path.len > 1:
           let nextPos = path[1]

{mettagrid-0.2.0.21 → mettagrid-0.2.0.22}/nim/mettascope/src/mettascope/common.nim

@@ -105,6 +105,7 @@ type
   Destination* = object
     pos*: IVec2
     destinationType*: DestinationType
+    approachDir*: IVec2 ## Direction to approach from for Bump actions (e.g., ivec2(-1, 0) means approach from the left).
 
 var
   requestActions*: seq[ActionRequest]

{mettagrid-0.2.0.21 → mettagrid-0.2.0.22}/nim/mettascope/src/mettascope/pathfinding.nim

@@ -94,52 +94,55 @@ proc clearPath*(agentId: int) =
   agentPaths.del(agentId)
   agentDestinations.del(agentId)
 
-proc findAdjacentWalkable*(target: IVec2): seq[IVec2] =
-  ## Find walkable positions adjacent to the target position.
-  ## mainly used to path to an object before bumping it.
-  const directions = [ivec2(0, -1), ivec2(0, 1), ivec2(-1, 0), ivec2(1, 0)]
-  var adjacent: seq[IVec2] = @[]
-  for dir in directions:
-    let pos = ivec2(target.x + dir.x, target.y + dir.y)
-    if isWalkablePos(pos):
-      adjacent.add(pos)
-  return adjacent
 
 proc recomputePath*(agentId: int, currentPos: IVec2) =
-  ## Recompute the path for an agent to their current destination.
+  ## Recompute the path for an agent through all their queued destinations.
   if not agentDestinations.hasKey(agentId) or agentDestinations[agentId].len == 0:
+    agentPaths.del(agentId)
     return
-  let dest = agentDestinations[agentId][0]
-  case dest.destinationType
-  of Move:
-    # for moving, we can path directly to the destination.
-    if currentPos == dest.pos:
-      agentDestinations[agentId].delete(0)
-      agentPaths.del(agentId)
-      if agentDestinations[agentId].len > 0:
-        recomputePath(agentId, currentPos)
-      return
-    let newPath = findPath(currentPos, dest.pos)
-    if newPath.len > 0:
-      agentPaths[agentId] = newPath
-    else:
-      clearPath(agentId)
-  of Bump:
-    # for bumping, we need to path to an adjacent walkable position before bumping it.
-    let adjacentTiles = findAdjacentWalkable(dest.pos)
-    if adjacentTiles.len == 0:
+  
+  # Compute path through all destinations.
+  var fullPath: seq[IVec2] = @[]
+  var lastPos = currentPos
+  
+  for i, dest in agentDestinations[agentId]:
+    var segmentPath: seq[IVec2] = @[]
+    
+    case dest.destinationType
+    of Move:
+      # For moving, path directly to the destination.
+      segmentPath = findPath(lastPos, dest.pos)
+      lastPos = dest.pos
+    of Bump:
+      # For bumping, path to the specified approach position.
+      let approachPos = ivec2(dest.pos.x + dest.approachDir.x, dest.pos.y + dest.approachDir.y)
+      if not isWalkablePos(approachPos):
+        # Approach position is not walkable, clear path.
+        clearPath(agentId)
+        return
+      if lastPos == approachPos:
+        # Already at the approach position, use current position.
+        segmentPath = @[lastPos]
+      else:
+        # Path to the approach position.
+        segmentPath = findPath(lastPos, approachPos)
+      lastPos = approachPos
+    
+    if segmentPath.len == 0:
       clearPath(agentId)
       return
-    if currentPos in adjacentTiles:
-      agentPaths[agentId] = @[currentPos]
-      return
-    var bestPath: seq[IVec2] = @[]
-    for adjacent in adjacentTiles:
-      let path = findPath(currentPos, adjacent)
-      if path.len > 0 and (bestPath.len == 0 or path.len < bestPath.len):
-        bestPath = path
-    if bestPath.len > 0:
-      agentPaths[agentId] = bestPath
+    
+    if i == 0:
+      fullPath = segmentPath
     else:
-      clearPath(agentId)
+      if segmentPath.len > 1:
+        for j in 1 ..< segmentPath.len:
+          fullPath.add(segmentPath[j])
+      elif segmentPath.len == 1 and segmentPath[0] != fullPath[fullPath.len - 1]:
+        fullPath.add(segmentPath[0])
+  
+  if fullPath.len > 0:
+    agentPaths[agentId] = fullPath
+  else:
+    clearPath(agentId)
 

{mettagrid-0.2.0.21 → mettagrid-0.2.0.22}/nim/mettascope/src/mettascope/worldmap.nim

@@ -27,6 +27,8 @@ proc useSelections*(panel: Panel) =
   else:
     window.buttonDown[KeyLeftControl] or window.buttonDown[KeyRightControl]
   
+  let shiftDown = window.buttonDown[KeyLeftShift] or window.buttonDown[KeyRightShift]
+  
   # Track mouse down position to distinguish clicks from drags.
   if window.buttonPressed[MouseLeft] and not modifierDown:
     mouseDownPos = window.mousePos.vec2
@@ -54,22 +56,55 @@ proc useSelections*(panel: Panel) =
       if gridPos.x >= 0 and gridPos.x < replay.mapSize[0] and
         gridPos.y >= 0 and gridPos.y < replay.mapSize[1]:
         let startPos = selection.location.at(step).xy
+        
+        # Determine if this is a Bump or Move destination.
         let targetObj = getObjectAtLocation(gridPos)
+        var destType = Move
+        var approachDir = ivec2(0, 0)
         if targetObj != nil:
           let typeName = replay.typeNames[targetObj.typeId]
           if typeName != "agent" and typeName != "wall":
-            agentDestinations[selection.agentId] = @[Destination(pos: gridPos, destinationType: Bump)]
+            destType = Bump
+            # Calculate which quadrant of the tile was clicked.
+            # The tile center is at gridPos, and mousePos has fractional parts.
+            let
+              tileCenterX = gridPos.x.float32
+              tileCenterY = gridPos.y.float32
+              offsetX = mousePos.x - tileCenterX
+              offsetY = mousePos.y - tileCenterY
+            # Divide the tile into 4 quadrants at 45-degree angles (diamond shape).
+            # If the click is more horizontal than vertical, use left/right approach.
+            # If the click is more vertical than horizontal, use top/bottom approach.
+            if abs(offsetX) > abs(offsetY):
+              # Left or right quadrant.
+              if offsetX > 0:
+                approachDir = ivec2(1, 0)   # Clicked right, approach from right.
+              else:
+                approachDir = ivec2(-1, 0)  # Clicked left, approach from left.
+            else:
+              # Top or bottom quadrant.
+              if offsetY > 0:
+                approachDir = ivec2(0, 1)   # Clicked bottom, approach from bottom.
+              else:
+                approachDir = ivec2(0, -1)  # Clicked top, approach from top.
+        
+        let destination = Destination(pos: gridPos, destinationType: destType, approachDir: approachDir)
+        
+        if shiftDown:
+          # Queue up additional destinations.
+          if not agentDestinations.hasKey(selection.agentId) or agentDestinations[selection.agentId].len == 0:
+            # No existing destinations, start fresh.
+            agentDestinations[selection.agentId] = @[destination]
             recomputePath(selection.agentId, startPos)
           else:
-            let path = findPath(startPos, gridPos)
-            if path.len > 0:
-              agentPaths[selection.agentId] = path
-              agentDestinations[selection.agentId] = @[Destination(pos: gridPos, destinationType: Move)]
+            # Append to existing destinations.
+            agentDestinations[selection.agentId].add(destination)
+            # Recompute path to include all destinations.
+            recomputePath(selection.agentId, startPos)
         else:
-          let path = findPath(startPos, gridPos)
-          if path.len > 0:
-            agentPaths[selection.agentId] = path
-            agentDestinations[selection.agentId] = @[Destination(pos: gridPos, destinationType: Move)]
+          # Replace the entire destination queue.
+          agentDestinations[selection.agentId] = @[destination]
+          recomputePath(selection.agentId, startPos)
 
 proc drawFloor*() =
   # Draw the floor tiles.
@@ -389,15 +424,41 @@ proc drawPlannedPath*() =
           scale = 1/200,
           tint = color(1, 1, 1, alpha)
         )
+    
+    # Draw final queued destination.
+    if agentDestinations.hasKey(agentId):
+      let destinations = agentDestinations[agentId]
+      if destinations.len > 0:
+        let dest = destinations[^1]
+        bxy.drawImage(
+          "selection",
+          dest.pos.vec2,
+          angle = 0,
+          scale = 1.0 / 200.0,
+          tint = color(1, 1, 1, 0.5)
+        )
       
-      let goalPos = path[path.len - 1]
-      bxy.drawImage(
-        "selection",
-        goalPos.vec2,
-        angle = 0,
-        scale = 1/200,
-        tint = color(1, 1, 1, 0.5)
-      )
+      # Draw approach arrows for bump destinations.
+      for dest in destinations:
+        if dest.destinationType == Bump and (dest.approachDir.x != 0 or dest.approachDir.y != 0):
+          let approachPos = ivec2(dest.pos.x + dest.approachDir.x, dest.pos.y + dest.approachDir.y)
+          let offset = vec2(-dest.approachDir.x.float32 * 0.35, -dest.approachDir.y.float32 * 0.35)
+          var rotation: float32 = 0
+          if dest.approachDir.x > 0:
+            rotation = Pi / 2
+          elif dest.approachDir.x < 0:
+            rotation = -Pi / 2
+          elif dest.approachDir.y > 0:
+            rotation = 0
+          elif dest.approachDir.y < 0:
+            rotation = Pi
+          bxy.drawImage(
+            "actions/arrow",
+            approachPos.vec2 + offset,
+            angle = rotation,
+            scale = 1/200,
+            tint = color(1, 1, 1, 0.7)
+          )
 
 proc drawSelection*() =
   # Draw selection.

mettagrid-0.2.0.21/python/src/mettagrid/config/config.py → mettagrid-0.2.0.22/python/src/mettagrid/base_config.py

@@ -5,6 +5,7 @@ from typing import Any, NoReturn, Self, Union, get_args, get_origin
 from pydantic import BaseModel, ConfigDict, TypeAdapter
 
 
+# Please don't move this class to mettagrid.config, it creates circular imports.
 class Config(BaseModel):
     """
     Common extension of Pydantic's BaseModel that:

{mettagrid-0.2.0.21 → mettagrid-0.2.0.22}/python/src/mettagrid/config/__init__.py

@@ -1,4 +1,3 @@
-from .config import Config
 from .mettagrid_c_config import from_mettagrid_config
 from .mettagrid_config import (
     ActionConfig,
@@ -24,7 +23,6 @@ __all__ = [
     "AssemblerConfig",
     "AttackActionConfig",
     "ChangeGlyphActionConfig",
-    "Config",
     "ConverterConfig",
     "from_mettagrid_config",
     "GameConfig",

{mettagrid-0.2.0.21 → mettagrid-0.2.0.22}/python/src/mettagrid/config/mettagrid_c_config.py

@@ -319,6 +319,7 @@ def convert_to_cpp_game_config(mettagrid_config: dict | GameConfig):
             cpp_assembler_config.max_uses = object_config.max_uses
             cpp_assembler_config.exhaustion = object_config.exhaustion
             cpp_assembler_config.clip_immune = object_config.clip_immune
+            cpp_assembler_config.start_clipped = object_config.start_clipped
             objects_cpp_params[object_type] = cpp_assembler_config
         elif isinstance(object_config, ChestConfig):
             # Convert resource type name to ID