fixed water and changed to multithreaded lighting and block updates

Author: programmerjake

include/block/builtin/air.h

@@ -48,6 +48,10 @@ class Air final : public BlockDescriptor
     {
         return true;
     }
+    virtual bool isReplaceableByFluid() const override
+    {
+        return true;
+    }
     virtual bool isGroundBlock() const override
     {
         return false;

include/block/builtin/furnace.h

@@ -93,7 +93,7 @@ class Furnace final : public FullBlock
             {
                 fuelStack = temp.item.descriptor->getItemAfterBurnInFurnace();
             }
-            getDebugLog() << L"consumeFuel" << postnl;
+            //getDebugLog() << L"consumeFuel" << postnl;
             return true;
         }
         bool canProgressSmeltIgnoringFuel()
@@ -129,7 +129,7 @@ class Furnace final : public FullBlock
             inputStack.remove(inputStack.item);
             if(!inputStack.good())
                 currentElapsedSmeltTime = 0;
-            getDebugLog() << L"smeltItem" << postnl;
+            //getDebugLog() << L"smeltItem" << postnl;
         }
     };
     struct FurnaceBlockData final : BlockData
@@ -211,7 +211,7 @@ class Furnace final : public FullBlock
             data->currentElapsedSmeltTime = 0;
             return;
         }
-        getDebugLog() << L"currentElapsedSmeltTime = " << data->currentElapsedSmeltTime << L", burnTimeLeft = " << data->burnTimeLeft << postnl;
+        //getDebugLog() << L"currentElapsedSmeltTime = " << data->currentElapsedSmeltTime << L", burnTimeLeft = " << data->burnTimeLeft << postnl;
         if(!hasFuel)
         {
             data->currentElapsedSmeltTime -= 2 * deltaTime;

include/ui/gameui.h

@@ -83,7 +83,7 @@ class GameUi : public Ui
         if(GameVersion::DEBUG)
             gameInput->paused.set(true);
         PositionF startingPosition = PositionF(0.5f, World::SeaLevel + 8.5f, 0.5f, Dimension::Overworld);
-        viewPoint = std::make_shared<ViewPoint>(world, startingPosition, GameVersion::DEBUG ? 48 : 64);
+        viewPoint = std::make_shared<ViewPoint>(world, startingPosition, GameVersion::DEBUG ? 32 : 48);
         player = std::make_shared<Player>(L"default-player-name", gameInput, this);
         playerEntity = world.addEntity(Entities::builtin::PlayerEntity::descriptor(), startingPosition, VectorF(0), lock_manager, std::static_pointer_cast<void>(player));
     }

include/util/block_chunk.h

@@ -43,6 +43,7 @@
 #include <condition_variable>
 #include "util/linked_map.h"
 #include <vector>
+#include <chrono>
 
 namespace programmerjake
 {
@@ -236,6 +237,8 @@ struct BlockChunkChunkVariables final
     std::mutex blockUpdateListLock;
     BlockUpdate *blockUpdateListHead = nullptr;
     BlockUpdate *blockUpdateListTail = nullptr;
+    std::chrono::steady_clock::time_point lastBlockUpdateTime;
+    bool lastBlockUpdateTimeValid = false;
     std::recursive_mutex entityListLock;
     WrappedEntity::ChunkListType entityList;
     std::atomic_bool generated, generateStarted;

include/world/world.h

@@ -483,8 +483,8 @@ class World final
     const WorldGenerator *worldGenerator;
     SeedType worldGeneratorSeed;
     WorldLightingProperties lighting;
-    std::thread lightingThread;
-    std::thread blockUpdateThread;
+    std::list<std::thread> lightingThreads;
+    std::list<std::thread> blockUpdateThreads;
     std::thread particleGeneratingThread;
     std::list<std::thread> chunkGeneratingThreads;
     std::atomic_bool destructing, lightingStable;
@@ -496,7 +496,7 @@ class World final
     void chunkGeneratingThreadFn();
     void particleGeneratingThreadFn();
     static BlockUpdate *removeAllBlockUpdatesInChunk(BlockUpdateKind kind, BlockIterator bi, WorldLockManager &lock_manager);
-    static BlockUpdate *removeAllReadyBlockUpdatesInChunk(float deltaTime, BlockIterator bi, WorldLockManager &lock_manager);
+    static BlockUpdate *removeAllReadyBlockUpdatesInChunk(BlockIterator bi, WorldLockManager &lock_manager);
     static Lighting getBlockLighting(BlockIterator bi, WorldLockManager &lock_manager, bool isTopFace);
     float getChunkGeneratePriority(BlockIterator bi, WorldLockManager &lock_manager); /// low values mean high priority, NAN means don't generate
     RayCasting::Collision castRayCheckForEntitiesInSubchunk(BlockIterator sbi, RayCasting::Ray ray, WorldLockManager &lock_manager, float maxSearchDistance, const Entity *ignoreEntity);

src/world/world.cpp

@@ -47,6 +47,7 @@
 #include "item/builtin/ores.h"
 #include "item/builtin/cobblestone.h"
 #include "item/builtin/furnace.h"
+#include "item/builtin/bucket.h"
 
 using namespace std;
 
@@ -392,6 +393,7 @@ class MyWorldGenerator final : public RandomWorldGenerator
                 ItemDescriptor::addToWorld(world, lock_manager, ItemStack(Item(Items::builtin::CoalOre::descriptor())), PositionF(0, 80, 0, Dimension::Overworld));
                 ItemDescriptor::addToWorld(world, lock_manager, ItemStack(Item(Items::builtin::GoldOre::descriptor())), PositionF(0, 80, 0, Dimension::Overworld));
                 ItemDescriptor::addToWorld(world, lock_manager, ItemStack(Item(Items::builtin::Furnace::descriptor())), PositionF(0, 80, 0, Dimension::Overworld));
+                ItemDescriptor::addToWorld(world, lock_manager, ItemStack(Item(Items::builtin::WaterBucket::descriptor())), PositionF(0, 80, 0, Dimension::Overworld));
             }
         }
 #endif
@@ -466,12 +468,18 @@ BlockUpdate *World::removeAllBlockUpdatesInChunk(BlockUpdateKind kind, BlockIter
     return retval;
 }
 
-BlockUpdate *World::removeAllReadyBlockUpdatesInChunk(float deltaTime, BlockIterator bi, WorldLockManager &lock_manager)
+BlockUpdate *World::removeAllReadyBlockUpdatesInChunk(BlockIterator bi, WorldLockManager &lock_manager)
 {
     BlockChunk *chunk = bi.chunk;
     lock_manager.clear();
     BlockChunkFullLock lockChunk(*chunk);
     auto lockIt = std::unique_lock<decltype(chunk->chunkVariables.blockUpdateListLock)>(chunk->chunkVariables.blockUpdateListLock);
+    float deltaTime = 0;
+    std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
+    if(chunk->chunkVariables.lastBlockUpdateTimeValid)
+        deltaTime = std::chrono::duration_cast<std::chrono::duration<double>>(now - chunk->chunkVariables.lastBlockUpdateTime).count();
+    chunk->chunkVariables.lastBlockUpdateTimeValid = true;
+    chunk->chunkVariables.lastBlockUpdateTime = now;
     BlockUpdate *retval = nullptr;
     for(BlockUpdate *node = chunk->chunkVariables.blockUpdateListHead; node != nullptr;)
     {
@@ -532,10 +540,13 @@ World::World(SeedType seed, const WorldGenerator *worldGenerator)
         }
         break;
     }
-    lightingThread = thread([this]()
+    for(int i = 0; i < 2; i++)
     {
-        lightingThreadFn();
-    });
+        lightingThreads.emplace_back([this]()
+        {
+            lightingThreadFn();
+        });
+    }
     for(int dx = 0; dx >= -1; dx--)
     {
         for(int dz = 0; dz >= -1; dz--)
@@ -547,10 +558,13 @@ World::World(SeedType seed, const WorldGenerator *worldGenerator)
             initialChunk->chunkVariables.generated = true;
         }
     }
-    blockUpdateThread = thread([this]()
+    for(int i = 0; i < 3; i++)
     {
-        blockUpdateThreadFn();
-    });
+        blockUpdateThreads.emplace_back([this]()
+        {
+            blockUpdateThreadFn();
+        });
+    }
     lock_manager.clear();
     getDebugLog() << L"lighting initial world..." << postnl;
     for(int i = 0; i < 500 && !isLightingStable(); i++)
@@ -579,10 +593,12 @@ World::~World()
 {
     assert(viewPoints.empty());
     destructing = true;
-    if(lightingThread.joinable())
-        lightingThread.join();
-    if(blockUpdateThread.joinable())
-        blockUpdateThread.join();
+    for(auto &t : lightingThreads)
+        if(t.joinable())
+            t.join();
+    for(auto &t : blockUpdateThreads)
+        if(t.joinable())
+            t.join();
     for(auto &t : chunkGeneratingThreads)
         if(t.joinable())
             t.join();
@@ -682,13 +698,9 @@ void World::blockUpdateThreadFn()
     setThreadPriority(ThreadPriority::Low);
     WorldLockManager lock_manager;
     BlockChunkMap *chunks = &physicsWorld->chunks;
-    auto lastUpdateTime = std::chrono::steady_clock::now();
     while(!destructing)
     {
         bool didAnything = false;
-        auto currentUpdateTime = std::chrono::steady_clock::now();
-        float deltaTime = std::chrono::duration_cast<std::chrono::duration<float>>(currentUpdateTime - lastUpdateTime).count();
-        lastUpdateTime = currentUpdateTime;
         for(auto chunkIter = chunks->begin(); chunkIter != chunks->end(); chunkIter++)
         {
             if(destructing)
@@ -697,7 +709,7 @@ void World::blockUpdateThreadFn()
             if(chunkIter.is_locked())
                 chunkIter.unlock();
             BlockIterator cbi(chunk, chunks, chunk->basePosition, VectorI(0));
-            for(BlockUpdate *node = removeAllReadyBlockUpdatesInChunk(deltaTime, cbi, lock_manager); node != nullptr; node = removeAllReadyBlockUpdatesInChunk(0, cbi, lock_manager))
+            for(BlockUpdate *node = removeAllReadyBlockUpdatesInChunk(cbi, lock_manager); node != nullptr; node = removeAllReadyBlockUpdatesInChunk(cbi, lock_manager))
             {
                 didAnything = true;
                 while(node != nullptr)
@@ -729,7 +741,6 @@ void World::blockUpdateThreadFn()
         }
         if(!didAnything)
         {
-            lightingStable = true;
             std::this_thread::sleep_for(std::chrono::milliseconds(10));
         }
     }