cp

Author: daveey

packages/mettagrid/cpp/bindings/mettagrid_c.cpp

@@ -1024,8 +1024,19 @@ PYBIND11_MODULE(mettagrid_c, m) {
       .def_readonly("resource_names", &MettaGrid::resource_names)
       .def("set_inventory", &MettaGrid::set_inventory, py::arg("agent_id"), py::arg("inventory"));
 
+  // Bind DemolishConfig for building destruction
+  py::class_<DemolishConfig>(m, "DemolishConfig")
+      .def(py::init<>())
+      .def(py::init<const std::unordered_map<InventoryItem, InventoryQuantity>&,
+                    const std::unordered_map<InventoryItem, InventoryQuantity>&>(),
+           py::arg("cost") = std::unordered_map<InventoryItem, InventoryQuantity>(),
+           py::arg("scrap") = std::unordered_map<InventoryItem, InventoryQuantity>())
+      .def_readwrite("cost", &DemolishConfig::cost)
+      .def_readwrite("scrap", &DemolishConfig::scrap);
+
   // Expose this so we can cast python WallConfig / AgentConfig to a common GridConfig cpp object.
-  py::class_<GridObjectConfig, std::shared_ptr<GridObjectConfig>>(m, "GridObjectConfig");
+  py::class_<GridObjectConfig, std::shared_ptr<GridObjectConfig>>(m, "GridObjectConfig")
+      .def_readwrite("demolish", &GridObjectConfig::demolish);
 
   bind_wall_config(m);
 

packages/mettagrid/cpp/include/mettagrid/actions/attack.hpp

@@ -93,32 +93,84 @@ class Attack : public ActionHandler {
   bool try_attack(Agent& actor, GridObject* target_object) {
     if (!target_object) return false;
 
+    // First try to attack as agent
     Agent* target = dynamic_cast<Agent*>(target_object);
-    if (!target) return false;  // Can only attack agents
+    if (target) {
+      // Don't attack already frozen agents - let move handler swap instead
+      if (target->frozen > 0) return false;
 
-    // Don't attack already frozen agents - let move handler swap instead
-    if (target->frozen > 0) return false;
+      // Check if actor has required resources for attack
+      for (const auto& [item, amount] : _consumed_resources) {
+        if (actor.inventory.amount(item) < amount) {
+          return false;  // Can't afford attack
+        }
+      }
+
+      bool success = _handle_target(actor, *target);
+
+      // Consume resources on success
+      if (success) {
+        for (const auto& [item, amount] : _consumed_resources) {
+          if (amount > 0) {
+            InventoryDelta delta = static_cast<InventoryDelta>(-static_cast<int>(amount));
+            actor.inventory.update(item, delta);
+          }
+        }
+      }
+      return success;
+    }
+
+    // Not an agent - try to demolish if target has demolish config
+    return try_demolish(actor, target_object);
+  }
+
+  // Attempt to demolish a building
+  bool try_demolish(Agent& actor, GridObject* target) {
+    if (!target || !target->demolish_config) {
+      return false;  // No demolish config, can't demolish
+    }
+
+    const DemolishConfig& demolish = *target->demolish_config;
 
-    // Check if actor has required resources for attack
-    for (const auto& [item, amount] : _consumed_resources) {
+    // Check if actor has required resources for demolition
+    for (const auto& [item, amount] : demolish.cost) {
       if (actor.inventory.amount(item) < amount) {
-        return false;  // Can't afford attack
+        const std::string& actor_group = actor.group_name;
+        actor.stats.incr(_action_prefix(actor_group) + "demolish.failed.insufficient_resources");
+        return false;
       }
     }
 
-    bool success = _handle_target(actor, *target);
+    // Pay the demolition cost
+    for (const auto& [item, amount] : demolish.cost) {
+      if (amount > 0) {
+        InventoryDelta delta = static_cast<InventoryDelta>(-static_cast<int>(amount));
+        actor.inventory.update(item, delta);
+      }
+    }
 
-    // Consume resources on success
-    if (success) {
-      for (const auto& [item, amount] : _consumed_resources) {
-        if (amount > 0) {
-          InventoryDelta delta = static_cast<InventoryDelta>(-static_cast<int>(amount));
-          actor.inventory.update(item, delta);
-        }
+    // Log demolition BEFORE removing (target will be deleted)
+    const std::string& actor_group = actor.group_name;
+    const std::string target_type_name = target->type_name;  // Copy before removal
+    actor.stats.incr(_action_prefix(actor_group) + "demolish." + target_type_name);
+    actor.stats.incr("demolish." + target_type_name);
+
+    // Call on_demolish before removing
+    target->on_demolish();
+
+    // Give scrap resources to actor
+    for (const auto& [item, amount] : demolish.scrap) {
+      if (amount > 0) {
+        actor.inventory.update(item, amount);
       }
     }
 
-    return success;
+    // Remove the object from grid (this deletes the object)
+    if (_grid) {
+      _grid->remove_object(*target);
+    }
+
+    return true;
   }
 
 protected:

packages/mettagrid/cpp/include/mettagrid/core/grid.hpp

@@ -93,6 +93,27 @@ class Grid {
     return true;
   }
 
+  // Remove an object from the grid. Returns true if successful.
+  // Note: The object's ID slot in the objects vector becomes null but is not reused,
+  // keeping all other IDs stable.
+  inline bool remove_object(GridObject& obj) {
+    if (!is_valid_location(obj.location)) {
+      return false;
+    }
+    if (grid[obj.location.r][obj.location.c] != &obj) {
+      return false;  // Object not at expected location
+    }
+
+    // Clear the grid cell
+    grid[obj.location.r][obj.location.c] = nullptr;
+
+    // Release the object (unique_ptr becomes null but slot remains)
+    if (obj.id < objects.size()) {
+      objects[obj.id].reset();
+    }
+    return true;
+  }
+
   inline GridObject* object(GridObjectId obj_id) const {
     assert(obj_id < objects.size() && "Invalid object ID");
     return objects[obj_id].get();

packages/mettagrid/cpp/include/mettagrid/core/grid_object.hpp

@@ -2,8 +2,10 @@
 #define PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_CORE_GRID_OBJECT_HPP_
 
 #include <cstdint>
+#include <optional>
 #include <span>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "core/types.hpp"
@@ -47,14 +49,26 @@ class GridLocation {
   }
 };
 
+// Configuration for demolishing a building via attack
+struct DemolishConfig {
+  std::unordered_map<InventoryItem, InventoryQuantity> cost;   // Resources required to demolish
+  std::unordered_map<InventoryItem, InventoryQuantity> scrap;  // Resources returned after demolish
+
+  DemolishConfig() = default;
+  DemolishConfig(const std::unordered_map<InventoryItem, InventoryQuantity>& cost,
+                 const std::unordered_map<InventoryItem, InventoryQuantity>& scrap)
+      : cost(cost), scrap(scrap) {}
+};
+
 struct GridObjectConfig {
   TypeId type_id;
   std::string type_name;
   std::vector<int> tag_ids;
   ObservationType initial_vibe;
+  std::optional<DemolishConfig> demolish;  // If set, object can be demolished
 
   GridObjectConfig(TypeId type_id, const std::string& type_name, ObservationType initial_vibe = 0)
-      : type_id(type_id), type_name(type_name), tag_ids({}), initial_vibe(initial_vibe) {}
+      : type_id(type_id), type_name(type_name), tag_ids({}), initial_vibe(initial_vibe), demolish(std::nullopt) {}
 
   virtual ~GridObjectConfig() = default;
 };
@@ -66,21 +80,27 @@ class GridObject : public HasVibe {
   TypeId type_id{};
   std::string type_name;
   std::vector<int> tag_ids;
+  const DemolishConfig* demolish_config = nullptr;  // Optional demolish config for buildings
 
   virtual ~GridObject() = default;
 
   void init(TypeId object_type_id,
             const std::string& object_type_name,
             const GridLocation& object_location,
             const std::vector<int>& tags,
-            ObservationType object_vibe = 0) {
+            ObservationType object_vibe = 0,
+            const DemolishConfig* demolish = nullptr) {
     this->type_id = object_type_id;
     this->type_name = object_type_name;
     this->location = object_location;
     this->tag_ids = tags;
     this->vibe = object_vibe;
+    this->demolish_config = demolish;
   }
 
+  // Called when this object is demolished. Override for cleanup.
+  virtual void on_demolish() {}
+
   virtual std::vector<PartialObservationToken> obs_features() const {
     return {};  // Default: no observable features
   }

packages/mettagrid/cpp/include/mettagrid/objects/assembler.hpp

@@ -266,7 +266,8 @@ class Assembler : public GridObject, public Usable {
         allow_partial_usage(cfg.allow_partial_usage),
         chest_search_distance(cfg.chest_search_distance),
         clipper_ptr(nullptr) {
-    GridObject::init(cfg.type_id, cfg.type_name, GridLocation(r, c), cfg.tag_ids, cfg.initial_vibe);
+    const DemolishConfig* demolish = cfg.demolish.has_value() ? &cfg.demolish.value() : nullptr;
+    GridObject::init(cfg.type_id, cfg.type_name, GridLocation(r, c), cfg.tag_ids, cfg.initial_vibe, demolish);
   }
   virtual ~Assembler() = default;
 

packages/mettagrid/cpp/include/mettagrid/objects/chest.hpp

@@ -78,7 +78,8 @@ class Chest : public GridObject, public Usable, public HasInventory {
         vibe_transfers(cfg.vibe_transfers),
         stats_tracker(stats_tracker),
         grid(nullptr) {
-    GridObject::init(cfg.type_id, cfg.type_name, GridLocation(r, c), cfg.tag_ids, cfg.initial_vibe);
+    const DemolishConfig* demolish = cfg.demolish.has_value() ? &cfg.demolish.value() : nullptr;
+    GridObject::init(cfg.type_id, cfg.type_name, GridLocation(r, c), cfg.tag_ids, cfg.initial_vibe, demolish);
     // Set initial inventory for all configured resources (ignore limits for initial setup)
     for (const auto& [resource, amount] : cfg.initial_inventory) {
       if (amount > 0) {

packages/mettagrid/cpp/include/mettagrid/objects/protocol.hpp

@@ -4,6 +4,8 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
+#include <algorithm>
+#include <cmath>
 #include <memory>
 #include <unordered_map>
 
@@ -16,13 +18,40 @@ class Protocol {
   std::unordered_map<InventoryItem, InventoryQuantity> input_resources;
   std::unordered_map<InventoryItem, InventoryQuantity> output_resources;
   unsigned short cooldown;
+  float slope;     // Linear component: adds slope * activation_count to the multiplier
+  float exponent;  // Exponential component: multiplies by (1 + exponent)^activation_count
+
+  // Track activation count for inflation calculation
+  mutable unsigned int activation_count;
 
   Protocol(unsigned short min_agents = 0,
            const std::vector<ObservationType>& vibes = {},
            const std::unordered_map<InventoryItem, InventoryQuantity>& inputs = {},
            const std::unordered_map<InventoryItem, InventoryQuantity>& outputs = {},
-           unsigned short cooldown = 0)
-      : min_agents(min_agents), vibes(vibes), input_resources(inputs), output_resources(outputs), cooldown(cooldown) {}
+           unsigned short cooldown = 0,
+           float slope = 0.0f,
+           float exponent = 0.0f)
+      : min_agents(min_agents),
+        vibes(vibes),
+        input_resources(inputs),
+        output_resources(outputs),
+        cooldown(cooldown),
+        slope(slope),
+        exponent(exponent),
+        activation_count(0) {}
+
+  // Calculate cost multiplier based on activation count
+  // Formula: max(0, 1 + slope * n) * (1 + exponent)^n
+  // - slope < 0: discounting (starts at 1, decreases linearly, floors at 0)
+  // - slope > 0: linear cost increase
+  // - exponent > 0: exponential cost increase
+  // - exponent < 0: exponential cost decrease
+  float get_cost_multiplier() const {
+    float n = static_cast<float>(activation_count);
+    float linear_component = std::max(0.0f, 1.0f + slope * n);
+    float exponential_component = std::pow(1.0f + exponent, n);
+    return linear_component * exponential_component;
+  }
 };
 
 inline void bind_protocol(py::module& m) {
@@ -32,7 +61,10 @@ inline void bind_protocol(py::module& m) {
       .def_readwrite("vibes", &Protocol::vibes)
       .def_readwrite("input_resources", &Protocol::input_resources)
       .def_readwrite("output_resources", &Protocol::output_resources)
-      .def_readwrite("cooldown", &Protocol::cooldown);
+      .def_readwrite("cooldown", &Protocol::cooldown)
+      .def_readwrite("slope", &Protocol::slope)
+      .def_readwrite("exponent", &Protocol::exponent)
+      .def_readwrite("activation_count", &Protocol::activation_count);
 }
 
 #endif  // PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_OBJECTS_PROTOCOL_HPP_

packages/mettagrid/cpp/include/mettagrid/objects/wall.hpp

@@ -20,7 +20,8 @@ struct WallConfig : public GridObjectConfig {
 class Wall : public GridObject {
 public:
   Wall(GridCoord r, GridCoord c, const WallConfig& cfg) {
-    GridObject::init(cfg.type_id, cfg.type_name, GridLocation(r, c), cfg.tag_ids, cfg.initial_vibe);
+    const DemolishConfig* demolish = cfg.demolish.has_value() ? &cfg.demolish.value() : nullptr;
+    GridObject::init(cfg.type_id, cfg.type_name, GridLocation(r, c), cfg.tag_ids, cfg.initial_vibe, demolish);
   }
 
   std::vector<PartialObservationToken> obs_features() const override {

packages/mettagrid/nim/mettascope/libmettascope.dylib

@@ -95,6 +95,7 @@ type
     # Computed fields.
     gainMap*: seq[seq[ItemAmount]]
     isAgent*: bool
+    removedAtStep*: int  # Step when object was removed, -1 if not removed
 
   Replay* = ref object
     version*: int
@@ -737,6 +738,7 @@ proc loadReplayString*(jsonData: string, fileName: string): Replay =
       inventory: inventory,
       inventoryMax: obj.getInt("inventory_max", 0),
       color: obj.getExpandedIntSeq("color", replay.maxSteps),
+      removedAtStep: -1,  # Not removed
     )
     entity.groupId = getInt(obj, "group_id", 0)
 
@@ -861,10 +863,17 @@ proc loadReplay*(fileName: string): Replay =
 proc apply*(replay: Replay, step: int, objects: seq[ReplayEntity]) =
   ## Apply a replay step to the replay.
   const agentTypeName = "agent"
+
+  # Track which object IDs are present in this step
+  var presentIds: set[uint16]
+  for obj in objects:
+    if obj.id >= 0 and obj.id < 65536:
+      presentIds.incl(obj.id.uint16)
+
   for obj in objects:
     let index = obj.id - 1
     while index >= replay.objects.len:
-      replay.objects.add(Entity(id: obj.id))
+      replay.objects.add(Entity(id: replay.objects.len + 1, removedAtStep: -1))
 
     let entity = replay.objects[index]
     doAssert entity.id == obj.id, "Object id mismatch"
@@ -908,6 +917,24 @@ proc apply*(replay: Replay, step: int, objects: seq[ReplayEntity]) =
     entity.allowPartialUsage = obj.allowPartialUsage
     entity.protocols = obj.protocols
 
+  # Check for removed objects (existed before but not in current step)
+  # Only mark as removed if:
+  # - Not already removed
+  # - Not a wall (walls are optimized out after step 0)
+  # - Not an agent (agents are never removed)
+  # - Has location data (was actually initialized with real data)
+  # - Not in current step's data
+  for entity in replay.objects:
+    if entity.removedAtStep < 0 and  # Not already removed
+       entity.typeName != "wall" and  # Skip walls (static, optimized out)
+       entity.typeName != "agent" and  # Skip agents (never removed)
+       entity.typeName.len > 0 and  # Has a type (was initialized)
+       entity.location.len > 0 and  # Has been seen before (has location data)
+       entity.id >= 0 and entity.id < 65536 and
+       entity.id.uint16 notin presentIds:
+      # This object was not in the step data - it was removed
+      entity.removedAtStep = step
+
   # Extend the max steps.
   replay.maxSteps = max(replay.maxSteps, step + 1)