Tile Prediction improvements

each tile modification is now validated and then added to prediction one-by-one

source/game/StarWorldClient.cpp

@@ -322,23 +322,27 @@ TileModificationList WorldClient::applyTileModifications(TileModificationList co
   if (!inWorld())
     return {};
   
-  auto extraCheck = [this](Vec2I pos, TileModification) {
+  // thanks to new prediction: do each one by one so that previous modifications affect placeability
-    return !isTileProtected(pos);
-  };
   
-  // thanks to new prediction: do it aggressively until no changes occur
+  TileModificationList success;
-  auto result = WorldImpl::splitTileModifications(m_entityMap, modificationList, allowEntityOverlap, m_tileGetterFunction, extraCheck);
+  TileModificationList failures;
-  while (true) {
+  for (auto const& pair : modificationList) {
-    if (!result.first.empty()) {
+    if (!isTileProtected(pair.first)) {
-      informTilePredictions(result.first);
+      auto result = WorldImpl::validateTileModification(m_entityMap, pair.first, pair.second, allowEntityOverlap, m_tileGetterFunction);
-      m_outgoingPackets.append(make_shared<ModifyTileListPacket>(result.first, true));
 
-      auto list = move(result.second);
+      if (result.first) {
-      result = WorldImpl::splitTileModifications(m_entityMap, list, allowEntityOverlap, m_tileGetterFunction, extraCheck);
+        informTilePrediction(pair.first, pair.second);
+        success.append(pair);
+        continue;
       }
-    else
-      return result.second;
     }
+    failures.append(pair);
+  }
+
+  if (!success.empty())
+    m_outgoingPackets.append(make_shared<ModifyTileListPacket>(move(success), true));
+
+  return failures;
 }
 
 float WorldClient::gravity(Vec2F const& pos) const {
@@ -817,8 +821,41 @@ void WorldClient::handleIncomingPackets(List<PacketPtr> const& packets) {
       // player, but this may not be true in the future.  In the future, there
       // may be context hints with tile modifications to figure out what to do
       // with failures.
-      for (auto modification : tileModificationFailure->modifications) {
+      for (auto& modification : tileModificationFailure->modifications) {
-        m_predictedTiles.remove(modification.first);
+        auto findPrediction = m_predictedTiles.find(modification.first);
+        if (findPrediction != m_predictedTiles.end()) {
+          auto& p = findPrediction->second;
+          if (auto placeMaterial = modification.second.ptr<PlaceMaterial>()) {
+            if (placeMaterial->layer == TileLayer::Foreground) {
+              p.foreground.reset();
+              p.foregroundHueShift.reset();
+            }
+            else {
+              p.background.reset();
+              p.backgroundHueShift.reset();
+            }
+          } else if (auto placeMod = modification.second.ptr<PlaceMod>()) {
+            if (placeMod->layer == TileLayer::Foreground) {
+              p.foregroundMod.reset();
+              p.foregroundModHueShift.reset();
+            }
+            else {
+              p.backgroundMod.reset();
+              p.backgroundModHueShift.reset();
+            }
+          } else if (auto placeColor = modification.second.ptr<PlaceMaterialColor>()) {
+            if (placeColor->layer == TileLayer::Foreground)
+              p.foregroundColorVariant.reset();
+            else
+              p.backgroundColorVariant.reset();
+          } else if (auto placeLiquid = modification.second.ptr<PlaceLiquid>()) {
+            p.liquid.reset();
+          }
+
+          if (!p)
+            m_predictedTiles.erase(findPrediction);
+        }
+
         if (auto placeMaterial = modification.second.ptr<PlaceMaterial>()) {
           auto stack = materialDatabase->materialItemDrop(placeMaterial->material);
           tryGiveMainPlayerItem(itemDatabase->item(stack));
@@ -2148,12 +2185,11 @@ void WorldClient::renderCollisionDebug() {
   }
 }
 
-void WorldClient::informTilePredictions(TileModificationList const& modifications) {
+void WorldClient::informTilePrediction(Vec2I const& pos, TileModification const& modification) {
   auto now = Time::monotonicMilliseconds();
-  for (auto& pair : modifications) {
+  auto& p = m_predictedTiles[pos];
-    auto& p = m_predictedTiles[pair.first];
   p.time = now;
-    if (auto placeMaterial = pair.second.ptr<PlaceMaterial>()) {
+  if (auto placeMaterial = modification.ptr<PlaceMaterial>()) {
     if (placeMaterial->layer == TileLayer::Foreground) {
       p.foreground = placeMaterial->material;
       p.foregroundHueShift = placeMaterial->materialHueShift;
@@ -2162,25 +2198,24 @@ void WorldClient::informTilePredictions(TileModificationList const& modification
       p.backgroundHueShift = placeMaterial->materialHueShift;
     }
   }
-    else if (auto placeMod = pair.second.ptr<PlaceMod>()) {
+  else if (auto placeMod = modification.ptr<PlaceMod>()) {
     if (placeMod->layer == TileLayer::Foreground)
       p.foregroundMod = placeMod->mod;
     else
       p.backgroundMod = placeMod->mod;
   }
-    else if (auto placeColor = pair.second.ptr<PlaceMaterialColor>()) {
+  else if (auto placeColor = modification.ptr<PlaceMaterialColor>()) {
     if (placeColor->layer == TileLayer::Foreground)
       p.foregroundColorVariant = placeColor->color;
     else
       p.backgroundColorVariant = placeColor->color;
   }
-    else if (auto placeLiquid = pair.second.ptr<PlaceLiquid>()) {
+  else if (auto placeLiquid = modification.ptr<PlaceLiquid>()) {
     if (!p.liquid || p.liquid->liquid != placeLiquid->liquid)
       p.liquid = LiquidLevel(placeLiquid->liquid, placeLiquid->liquidLevel);
     else
       p.liquid->level += placeLiquid->liquidLevel;
   }
-  }
 }
 
 void WorldClient::setupForceRegions() {

source/game/StarWorldClient.hpp

@@ -236,7 +236,7 @@ private:
   void freshenCollision(RectI const& region);
   void renderCollisionDebug();
 
-  void informTilePredictions(TileModificationList const& modifications);
+  void informTilePrediction(Vec2I const& pos, TileModification const& modification);
 
   void setTileProtection(DungeonId dungeonId, bool isProtected);
 

source/game/StarWorldImpl.hpp

@@ -49,10 +49,12 @@ namespace WorldImpl {
   bool canPlaceMaterialColorVariant(Vec2I const& pos, TileLayer layer, MaterialColorVariant color, GetTileFunction& getTile);
   template <typename GetTileFunction>
   bool canPlaceMod(Vec2I const& pos, TileLayer layer, ModId mod, GetTileFunction& getTile);
+  template <typename GetTileFunction>
+  pair<bool, bool> validateTileModification(EntityMapPtr const& entityMap, Vec2I const& pos, TileModification const& modification, bool allowEntityOverlap, GetTileFunction& getTile);
   // Split modification list into good and bad
   template <typename GetTileFunction>
   pair<TileModificationList, TileModificationList> splitTileModifications(EntityMapPtr const& entityMap, TileModificationList const& modificationList,
-    bool allowEntityOverlap, function<bool(Vec2I pos, GetTileFunction& getTile, TileModification modification)> extraCheck = {});
+    bool allowEntityOverlap, GetTileFunction& getTile, function<bool(Vec2I pos, TileModification modification)> extraCheck = {});
 
   template <typename TileSectorArray>
   float windLevel(shared_ptr<TileSectorArray> const& tileSectorArray, Vec2F const& position, float weatherWindLevel);
@@ -314,21 +316,11 @@ namespace WorldImpl {
   }
 
   template <typename GetTileFunction>
-  pair<TileModificationList, TileModificationList> splitTileModifications(EntityMapPtr const& entityMap,
+  pair<bool, bool> validateTileModification(EntityMapPtr const& entityMap, Vec2I const& pos, TileModification const& modification, bool allowEntityOverlap, GetTileFunction& getTile) {
-      TileModificationList const& modificationList, bool allowEntityOverlap, GetTileFunction& getTile, function<bool(Vec2I pos, TileModification modification)> extraCheck) {
-    TileModificationList success;
-    TileModificationList unknown;
-    TileModificationList failures;
-    for (auto const& pair : modificationList) {
-      Vec2I pos;
-      TileModification modification;
-      std::tie(pos, modification) = pair;
-
     bool good = false;
     bool perhaps = false;
-      if (extraCheck && !extraCheck(pos, modification)) {
+    
-        good = false;
+    if (auto placeMaterial = modification.ptr<PlaceMaterial>()) {
-      } else if (auto placeMaterial = modification.ptr<PlaceMaterial>()) {
       perhaps = WorldImpl::perhapsCanPlaceMaterial(entityMap, pos, placeMaterial->layer, placeMaterial->material, allowEntityOverlap, getTile);
       if (perhaps)
         good = WorldImpl::canPlaceMaterial(entityMap, pos, placeMaterial->layer, placeMaterial->material, allowEntityOverlap, getTile);
@@ -342,6 +334,21 @@ namespace WorldImpl {
       good = false;
     }
 
+    return { good, perhaps };
+  }
+
+  template <typename GetTileFunction>
+  pair<TileModificationList, TileModificationList> splitTileModifications(EntityMapPtr const& entityMap, TileModificationList const& modificationList,
+    bool allowEntityOverlap, GetTileFunction& getTile, function<bool(Vec2I pos, TileModification modification)> extraCheck) {
+    TileModificationList success;
+    TileModificationList unknown;
+    TileModificationList failures;
+    for (auto const& pair : modificationList) {
+
+      bool good = false, perhaps = false;
+      if (!extraCheck || extraCheck(pair.first, pair.second))
+        std::tie(good, perhaps) = validateTileModification(entityMap, pair.first, pair.second, allowEntityOverlap, getTile);
+
       if (good)
         success.append(pair);
       else if (perhaps)