Replay: deterministic record & playback (#4)

Add deterministic record/playback for a run.

Recording captures `(seed, config hash, ordered tick-tagged commands)` and re-simulates on playback — no state snapshots. `DotaFactory.exe --replay <file>` re-plays a recorded run view-only with manual speed/pause.

Reviewed-on: #4
Co-authored-by: Malte Langkabel <malte.langkabel@gmail.com>
Co-committed-by: Malte Langkabel <malte.langkabel@gmail.com>

src/lib/sim/BuildingSystem.cpp

@@ -5,6 +5,7 @@
 #include <random>
 #include <set>
 
+#include "StateChecksum.h"
 #include "SurfaceMask.h"
 #include "tracing.h"
 
@@ -1288,3 +1289,87 @@ void BuildingSystem::unregisterTileOccupancy(const std::vector<QPoint>& cells)
         m_tileOccupancy.erase({cell.x(), cell.y()});
     }
 }
+
+namespace
+{
+void appendItems(Hasher& hasher, const std::vector<Item>& items)
+{
+    hasher.append(items.size());
+    for (const Item& item : items)
+    {
+        hasher.append(item.type.id);
+    }
+}
+
+void appendInputBuffer(Hasher& hasher, const InputBuffer& buffer)
+{
+    // std::map<ItemType, int> iterates in sorted-id order (ItemType::operator<).
+    hasher.append(buffer.counts.size());
+    for (const std::pair<const ItemType, int>& entry : buffer.counts)
+    {
+        hasher.append(entry.first.id);
+        hasher.append(entry.second);
+    }
+    hasher.append(buffer.caps.size());
+    for (const std::pair<const ItemType, int>& entry : buffer.caps)
+    {
+        hasher.append(entry.first.id);
+        hasher.append(entry.second);
+    }
+}
+}  // namespace
+
+void BuildingSystem::appendChecksum(Hasher& hasher) const
+{
+    // m_buildings keeps a stable, deterministic order (append on build, swap-free
+    // erase aside — both runs perform identical operations, so order matches).
+    hasher.append(m_buildings.size());
+    for (const Building& b : m_buildings)
+    {
+        hasher.append(b.id);
+        hasher.append(b.anchor);
+        hasher.append(b.footprint.width());
+        hasher.append(b.footprint.height());
+        hasher.append(b.rotation);
+        hasher.append(b.type);
+        hasher.append(b.recipeId);
+        appendInputBuffer(hasher, b.inputBuffer);
+        appendItems(hasher, b.outputBuffer.items);
+        hasher.append(b.outputBuffer.capacity);
+        hasher.append(b.production.has_value());
+        if (b.production.has_value())
+        {
+            hasher.append(b.production->recipeId);
+            hasher.append(b.production->completesAt);
+            appendItems(hasher, b.production->chosenOutputs);
+        }
+        hasher.append(b.shipLayout.has_value());
+    }
+
+    hasher.append(m_constructionQueue.size());
+    for (const ConstructionSite& s : m_constructionQueue)
+    {
+        hasher.append(s.id);
+        hasher.append(s.anchor);
+        hasher.append(s.footprint.width());
+        hasher.append(s.footprint.height());
+        hasher.append(s.rotation);
+        hasher.append(s.type);
+        hasher.append(s.recipeId);
+        hasher.append(s.completesAt);
+        hasher.append(s.shipLayout.has_value());
+        hasher.append(s.splitterFilterA.size());
+        for (const ItemType& type : s.splitterFilterA) { hasher.append(type.id); }
+        hasher.append(s.splitterFilterB.size());
+        for (const ItemType& type : s.splitterFilterB) { hasher.append(type.id); }
+    }
+
+    // std::map iterates in sorted key order.
+    hasher.append(m_tileOccupancy.size());
+    for (const std::pair<const std::pair<int, int>, BuildingId>& entry : m_tileOccupancy)
+    {
+        hasher.append(entry.first.first);
+        hasher.append(entry.first.second);
+        hasher.append(entry.second);
+    }
+}