From cdfc485ed44a704412fa3ec76982d7b109aef598 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sat, 8 Jun 2024 00:02:51 +0300
Subject: [PATCH 01/16] update blockstate structure

---
 src/voxels/Block.hpp |  4 ++--
 src/voxels/voxel.hpp | 16 +++++++++-------
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/voxels/Block.hpp b/src/voxels/Block.hpp
index 2d3d1577..e19c1dc6 100644
--- a/src/voxels/Block.hpp
+++ b/src/voxels/Block.hpp
@@ -9,7 +9,7 @@
 #include "../maths/UVRegion.hpp"
 #include "../typedefs.hpp"
 
-#define BLOCK_ITEM_SUFFIX ".item"
+inline std::string BLOCK_ITEM_SUFFIX = ".item";
 
 inline constexpr uint FACE_MX = 0;
 inline constexpr uint FACE_PX = 1;
@@ -191,4 +191,4 @@ public:
     Block(const Block&) = delete;
 };
 
-#endif /* VOXELS_BLOCK_HPP_ */
+#endif // VOXELS_BLOCK_HPP_
diff --git a/src/voxels/voxel.hpp b/src/voxels/voxel.hpp
index 9cfaf698..0e19415f 100644
--- a/src/voxels/voxel.hpp
+++ b/src/voxels/voxel.hpp
@@ -11,25 +11,27 @@ inline constexpr int BLOCK_DIR_UP = 0x4;
 inline constexpr int BLOCK_DIR_DOWN = 0x5;
 
 struct blockstate {
-    uint8_t rotation : 3;
-    uint8_t segment : 2; // planned to 0.22
-    uint8_t reserved : 3;
-    uint8_t userbits : 8;
+    uint8_t rotation : 3; // block rotation index
+    uint8_t segment : 1;  // segment block bit
+    uint8_t reserved : 4; // reserved bits
+    uint8_t userbits : 8; // bits for use in block script
 };
 static_assert (sizeof(blockstate) == 2);
 
+/// @brief blockstate cast to an integer (optimized out in most cases) 
 inline constexpr blockstate_t blockstate2int(blockstate b) {
     return static_cast<blockstate_t>(b.rotation) |
            static_cast<blockstate_t>(b.segment) << 3 |
-           static_cast<blockstate_t>(b.reserved) << 5 |
+           static_cast<blockstate_t>(b.reserved) << 4 |
            static_cast<blockstate_t>(b.userbits) << 8;
 }
 
+/// @brief integer cast to a blockstate (optimized out in most cases) 
 inline constexpr blockstate int2blockstate(blockstate_t i) {
     return {
         static_cast<uint8_t>(i & 0b111),
-        static_cast<uint8_t>((i >> 3) & 0b11),
-        static_cast<uint8_t>((i >> 5) & 0b111),
+        static_cast<uint8_t>((i >> 3) & 0b1),
+        static_cast<uint8_t>((i >> 4) & 0b1111),
         static_cast<uint8_t>((i >> 8) & 0xFF)
     };
 }

From 853f7fc9d17ef7f3992e8e1b3f5fd7aaa7f8fcc4 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sat, 8 Jun 2024 09:57:01 +0300
Subject: [PATCH 02/16] update blockstate.segment size

---
 src/voxels/voxel.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/voxels/voxel.hpp b/src/voxels/voxel.hpp
index 0e19415f..460a6a4f 100644
--- a/src/voxels/voxel.hpp
+++ b/src/voxels/voxel.hpp
@@ -12,8 +12,8 @@ inline constexpr int BLOCK_DIR_DOWN = 0x5;
 
 struct blockstate {
     uint8_t rotation : 3; // block rotation index
-    uint8_t segment : 1;  // segment block bit
-    uint8_t reserved : 4; // reserved bits
+    uint8_t segment :  3; // segment block bits
+    uint8_t reserved : 2; // reserved bits
     uint8_t userbits : 8; // bits for use in block script
 };
 static_assert (sizeof(blockstate) == 2);
@@ -22,7 +22,7 @@ static_assert (sizeof(blockstate) == 2);
 inline constexpr blockstate_t blockstate2int(blockstate b) {
     return static_cast<blockstate_t>(b.rotation) |
            static_cast<blockstate_t>(b.segment) << 3 |
-           static_cast<blockstate_t>(b.reserved) << 4 |
+           static_cast<blockstate_t>(b.reserved) << 6 |
            static_cast<blockstate_t>(b.userbits) << 8;
 }
 
@@ -30,8 +30,8 @@ inline constexpr blockstate_t blockstate2int(blockstate b) {
 inline constexpr blockstate int2blockstate(blockstate_t i) {
     return {
         static_cast<uint8_t>(i & 0b111),
-        static_cast<uint8_t>((i >> 3) & 0b1),
-        static_cast<uint8_t>((i >> 4) & 0b1111),
+        static_cast<uint8_t>((i >> 3) & 0b111),
+        static_cast<uint8_t>((i >> 6) & 0b11),
         static_cast<uint8_t>((i >> 8) & 0xFF)
     };
 }

From f181086d2a19630b54af16ff4a4e10c858c0a268 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sat, 8 Jun 2024 11:00:53 +0300
Subject: [PATCH 03/16] update debug_panel

---
 src/frontend/debug_panel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/frontend/debug_panel.cpp b/src/frontend/debug_panel.cpp
index a278b3e3..958b2f02 100644
--- a/src/frontend/debug_panel.cpp
+++ b/src/frontend/debug_panel.cpp
@@ -77,7 +77,7 @@ std::shared_ptr<UINode> create_debug_panel(
     panel->add(create_label([=](){
         std::wstringstream stream;
         stream << "r:" << player->selectedVoxel.state.rotation << " s:"
-                << player->selectedVoxel.state.segment << " u:"
+                << std::bitset<3>(player->selectedVoxel.state.segment) << " u:"
                 << std::bitset<8>(player->selectedVoxel.state.userbits);
         if (player->selectedVoxel.id == BLOCK_VOID) {
             return std::wstring {L"block: -"};

From 8aa6d5ee2d7838b3fa7647f868ed30ec2f16ba89 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sat, 8 Jun 2024 16:58:05 +0300
Subject: [PATCH 04/16] add extended blocks (block size property)

---
 src/content/ContentBuilder.cpp         |  1 +
 src/content/ContentLoader.cpp          | 37 +++++++----
 src/graphics/render/BlocksRenderer.cpp |  4 +-
 src/logic/BlocksController.cpp         |  9 ++-
 src/logic/PlayerController.cpp         | 15 +++--
 src/maths/aabb.hpp                     |  5 ++
 src/voxels/Block.hpp                   |  5 ++
 src/voxels/Chunks.cpp                  | 88 ++++++++++++++++++++++++--
 src/voxels/Chunks.hpp                  | 12 +++-
 9 files changed, 146 insertions(+), 30 deletions(-)

diff --git a/src/content/ContentBuilder.cpp b/src/content/ContentBuilder.cpp
index cda2ee3b..a660ca9a 100644
--- a/src/content/ContentBuilder.cpp
+++ b/src/content/ContentBuilder.cpp
@@ -62,6 +62,7 @@ std::unique_ptr<Content> ContentBuilder::build() {
         def.rt.id = blockDefsIndices.size();
         def.rt.emissive = *reinterpret_cast<uint32_t*>(def.emission);
         def.rt.solid = def.model == BlockModel::block;
+        def.rt.extended = def.size.x > 1 || def.size.y > 1 || def.size.z > 1;
 
         if (def.rotatable) {
             for (uint i = 0; i < BlockRotProfile::MAX_COUNT; i++) {
diff --git a/src/content/ContentLoader.cpp b/src/content/ContentLoader.cpp
index fb04c1b1..50f07dac 100644
--- a/src/content/ContentLoader.cpp
+++ b/src/content/ContentLoader.cpp
@@ -175,29 +175,38 @@ void ContentLoader::loadBlock(Block& def, const std::string& name, const fs::pat
             def.hitboxes[i].b = glm::vec3(box->num(3), box->num(4), box->num(5));
             def.hitboxes[i].b += def.hitboxes[i].a;
         }
+    } else if (auto boxarr = root->list("hitbox")){
+        AABB aabb;
+        aabb.a = glm::vec3(boxarr->num(0), boxarr->num(1), boxarr->num(2));
+        aabb.b = glm::vec3(boxarr->num(3), boxarr->num(4), boxarr->num(5));
+        aabb.b += aabb.a;
+        def.hitboxes = { aabb };
+    } else if (!def.modelBoxes.empty()) {
+        def.hitboxes = def.modelBoxes;
     } else {
-        boxarr = root->list("hitbox");
-        if (boxarr) {
-            AABB aabb;
-            aabb.a = glm::vec3(boxarr->num(0), boxarr->num(1), boxarr->num(2));
-            aabb.b = glm::vec3(boxarr->num(3), boxarr->num(4), boxarr->num(5));
-            aabb.b += aabb.a;
-            def.hitboxes = { aabb };
-        } else if (!def.modelBoxes.empty()) {
-            def.hitboxes = def.modelBoxes;
-        } else {
-            def.hitboxes = { AABB() };
-        }
+        def.hitboxes = { AABB() };
     }
 
+
     // block light emission [r, g, b] where r,g,b in range [0..15]
-    auto emissionarr = root->list("emission");
-    if (emissionarr) {
+    if (auto emissionarr = root->list("emission")) {
         def.emission[0] = emissionarr->num(0);
         def.emission[1] = emissionarr->num(1);
         def.emission[2] = emissionarr->num(2);
     }
 
+    // block size
+    if (auto sizearr = root->list("size")) {
+        def.size.x = sizearr->num(0);
+        def.size.y = sizearr->num(1);
+        def.size.z = sizearr->num(2);
+        if (def.model == BlockModel::block && 
+           (def.size.x != 1 || def.size.y != 1 || def.size.z != 1)) {
+            def.model = BlockModel::aabb;
+            def.hitboxes = {AABB(def.size)};
+        }
+    }
+
     // primitive properties
     root->flag("obstacle", def.obstacle);
     root->flag("replaceable", def.replaceable);
diff --git a/src/graphics/render/BlocksRenderer.cpp b/src/graphics/render/BlocksRenderer.cpp
index 9420d070..578b198d 100644
--- a/src/graphics/render/BlocksRenderer.cpp
+++ b/src/graphics/render/BlocksRenderer.cpp
@@ -414,9 +414,11 @@ void BlocksRenderer::render(const voxel* voxels) {
         for (int i = begin; i < end; i++) {
             const voxel& vox = voxels[i];
             blockid_t id = vox.id;
+            blockstate state = vox.state;
             const Block& def = *blockDefsCache[id];
-            if (id == 0 || def.drawGroup != drawGroup)
+            if (id == 0 || def.drawGroup != drawGroup || state.segment) {
                 continue;
+            }
             const UVRegion texfaces[6]{ cache->getRegion(id, 0), 
                                         cache->getRegion(id, 1),
                                         cache->getRegion(id, 2), 
diff --git a/src/logic/BlocksController.cpp b/src/logic/BlocksController.cpp
index 9ddf12b8..4748e7e3 100644
--- a/src/logic/BlocksController.cpp
+++ b/src/logic/BlocksController.cpp
@@ -130,11 +130,13 @@ void BlocksController::randomTick(int tickid, int parts) {
     for (uint z = padding; z < d-padding; z++){
         for (uint x = padding; x < w-padding; x++){
             int index = z * w + x;
-            if ((index + tickid) % parts != 0)
+            if ((index + tickid) % parts != 0) {
                 continue;
+            }
             auto& chunk = chunks->chunks[index];
-            if (chunk == nullptr || !chunk->flags.lighted)
+            if (chunk == nullptr || !chunk->flags.lighted) {
                 continue;
+            }
             for (int s = 0; s < segments; s++) {
                 for (int i = 0; i < 4; i++) {
                     int bx = random.rand() % CHUNK_W;
@@ -146,7 +148,8 @@ void BlocksController::randomTick(int tickid, int parts) {
                         scripting::random_update_block(
                             block, 
                             chunk->x * CHUNK_W + bx, by, 
-                            chunk->z * CHUNK_D + bz);
+                            chunk->z * CHUNK_D + bz
+                        );
                     }
                 }
             }
diff --git a/src/logic/PlayerController.cpp b/src/logic/PlayerController.cpp
index 74fa97a5..ec4b63df 100644
--- a/src/logic/PlayerController.cpp
+++ b/src/logic/PlayerController.cpp
@@ -364,9 +364,15 @@ void PlayerController::updateInteraction(){
         end, norm, iend
     );
     if (vox != nullptr) {
+        blockstate selectedState = vox->state;
         player->selectedVoxel = *vox;
         selectedBlockId = vox->id;
         selectedBlockRotation = vox->state.rotation;
+        if (selectedState.segment) {
+            iend = chunks->seekOrigin(
+                iend, indices->getBlockDef(selectedBlockId), selectedState
+            );
+        } 
         player->selectedBlockPosition = iend;
         selectedPointPosition = end;
         selectedBlockNormal = norm;
@@ -379,8 +385,9 @@ void PlayerController::updateInteraction(){
         state.rotation = determine_rotation(def, norm, camera->dir);
         
         if (lclick && !input.shift && item->rt.funcsset.on_block_break_by) {
-            if (scripting::on_item_break_block(player.get(), item, x, y, z))
+            if (scripting::on_item_break_block(player.get(), item, x, y, z)) {
                 return;
+            }
         }
 
         Block* target = indices->getBlockDef(vox->id);
@@ -411,10 +418,8 @@ void PlayerController::updateInteraction(){
                 x = (iend.x)+(norm.x);
                 y = (iend.y)+(norm.y);
                 z = (iend.z)+(norm.z);
-            } else {
-                if (def->rotations.name == "pipe") {
-                    state.rotation = BLOCK_DIR_UP;
-                }
+            } else if (def->rotations.name == "pipe") {
+                state.rotation = BLOCK_DIR_UP;
             }
             vox = chunks->get(x, y, z);
             blockid_t chosenBlock = def->rt.id;
diff --git a/src/maths/aabb.hpp b/src/maths/aabb.hpp
index 81ba856b..49177113 100644
--- a/src/maths/aabb.hpp
+++ b/src/maths/aabb.hpp
@@ -8,6 +8,11 @@ struct AABB {
     glm::vec3 a {0.0f};
     glm::vec3 b {1.0f};
 
+    AABB() {}
+
+    AABB(glm::vec3 size) : a(0.0f), b(size) {
+    }
+
     /* Get AABB point with minimal x,y,z */
     inline glm::vec3 min() const {
         return glm::min(a, b);
diff --git a/src/voxels/Block.hpp b/src/voxels/Block.hpp
index e19c1dc6..cdf997c0 100644
--- a/src/voxels/Block.hpp
+++ b/src/voxels/Block.hpp
@@ -110,6 +110,8 @@ public:
     /// @brief Light emission R, G, B, S (sky lights: sun, moon, radioactive clouds)
     uint8_t emission[4] {0, 0, 0, 0};
 
+    glm::i8vec3 size {1, 1, 1};
+
     /// @brief Influences visible block sides for transparent blocks
     uint8_t drawGroup = 0;
     
@@ -175,6 +177,9 @@ public:
         
         /// @brief does the block emit any lights
         bool emissive = false;
+
+        // @brief block size is greather than 1x1x1
+        bool extended = false;
         
         /// @brief set of hitboxes sets with all coord-systems precalculated
         std::vector<AABB> hitboxes[BlockRotProfile::MAX_COUNT];
diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp
index 2805c94b..b4107832 100644
--- a/src/voxels/Chunks.cpp
+++ b/src/voxels/Chunks.cpp
@@ -33,7 +33,7 @@ Chunks::Chunks(
     chunksCount = 0;
 }
 
-voxel* Chunks::get(int32_t x, int32_t y, int32_t z) {
+voxel* Chunks::get(int32_t x, int32_t y, int32_t z) const {
     x -= ox * CHUNK_W; 
     z -= oz * CHUNK_D;
     int cx = floordiv(x, CHUNK_W);
@@ -158,28 +158,104 @@ Chunk* Chunks::getChunk(int x, int z){
     return chunks[z * w + x].get();
 }
 
+glm::ivec3 Chunks::seekOrigin(glm::ivec3 pos, const Block* def, blockstate state) {
+    const auto& rotation = def->rotations.variants[state.rotation];
+    auto segment = state.segment;
+    while (true) {
+        if (!segment) {
+            return pos;
+        }
+        if (segment & 1) pos -= rotation.axisX;
+        if (segment & 2) pos -= rotation.axisY;
+        if (segment & 4) pos -= rotation.axisZ;
+
+        if (auto* voxel = get(pos.x, pos.y, pos.z)) {
+            segment = voxel->state.segment;
+        } else {
+            return pos;
+        }
+    }
+}
+
+void Chunks::eraseSegments(const Block* def, blockstate state, int x, int y, int z) {
+    const auto& rotation = def->rotations.variants[state.rotation];
+    for (int sy = 0; sy < def->size.y; sy++) {
+        for (int sz = 0; sz < def->size.z; sz++) {
+            for (int sx = 0; sx < def->size.x; sx++) {
+                if ((sx | sy | sz) == 0) {
+                    continue;
+                }
+                glm::ivec3 pos(x, y, z);
+                pos += rotation.axisX * sx;
+                pos += rotation.axisY * sy;
+                pos += rotation.axisZ * sz;
+                set(pos.x, pos.y, pos.z, 0, {});
+            }
+        }
+    }
+}
+
+void Chunks::repairSegments(const Block* def, blockstate state, int x, int y, int z) {
+    const auto& rotation = def->rotations.variants[state.rotation];
+    const auto id = def->rt.id;
+    const auto size = def->size;
+    for (int sy = 0; sy < size.y; sy++) {
+        for (int sz = 0; sz < size.z; sz++) {
+            for (int sx = 0; sx < size.x; sx++) {
+                if ((sx | sy | sz) == 0) {
+                    continue;
+                }
+                blockstate segState = state;
+                segState.segment = ((sx > 0) | ((sy > 0) << 1) | ((sz > 0) << 2));
+
+                glm::ivec3 pos(x, y, z);
+                pos += rotation.axisX * sx;
+                pos += rotation.axisY * sy;
+                pos += rotation.axisZ * sz;
+                set(pos.x, pos.y, pos.z, id, segState);
+            }
+        }
+    }
+}
+
 void Chunks::set(int32_t x, int32_t y, int32_t z, uint32_t id, blockstate state) {
-    if (y < 0 || y >= CHUNK_H)
+    if (y < 0 || y >= CHUNK_H) {
         return;
+    }
+    int32_t gx = x;
+    int32_t gz = z;
     x -= ox * CHUNK_W;
     z -= oz * CHUNK_D;
     int cx = floordiv(x, CHUNK_W);
     int cz = floordiv(z, CHUNK_D);
-    if (cx < 0 || cz < 0 || cx >= int(w) || cz >= int(d))
+    if (cx < 0 || cz < 0 || cx >= static_cast<int>(w) || cz >= static_cast<int>(d)) {
         return;
+    }
     Chunk* chunk = chunks[cz * w + cx].get();
-    if (chunk == nullptr)
+    if (chunk == nullptr) {
         return;
+    }
     int lx = x - cx * CHUNK_W;
     int lz = z - cz * CHUNK_D;
     
+    // block finalization
     voxel& vox = chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx]; 
-    auto def = contentIds->getBlockDef(vox.id);
-    if (def->inventorySize == 0)
+    auto prevdef = contentIds->getBlockDef(vox.id);
+    if (prevdef->inventorySize == 0) {
         chunk->removeBlockInventory(lx, y, lz);
+    }
+    if (prevdef->rt.extended && !vox.state.segment) {
+        eraseSegments(prevdef, vox.state, gx, y, gz);
+    }
+
+    // block initialization
+    auto newdef = contentIds->getBlockDef(id);
     vox.id = id;
     vox.state = state;
     chunk->setModifiedAndUnsaved();
+    if (!state.segment && newdef->rt.extended) {
+        repairSegments(newdef, state, gx, y, gz);
+    }
 
     if (y < chunk->bottom) chunk->bottom = y;
     else if (y + 1 > chunk->top) chunk->top = y + 1;
diff --git a/src/voxels/Chunks.hpp b/src/voxels/Chunks.hpp
index abeceae1..e73bf025 100644
--- a/src/voxels/Chunks.hpp
+++ b/src/voxels/Chunks.hpp
@@ -17,10 +17,14 @@ class ContentIndices;
 class Chunk;
 class WorldFiles;
 class LevelEvents;
+class Block;
 
 /* Player-centred chunks matrix */
 class Chunks {
     const ContentIndices* const contentIds;
+
+    void eraseSegments(const Block* def, blockstate state, int x, int y, int z);
+    void repairSegments(const Block* def, blockstate state, int x, int y, int z);
 public:
     std::vector<std::shared_ptr<Chunk>> chunks;
     std::vector<std::shared_ptr<Chunk>> chunksSecond;
@@ -40,10 +44,16 @@ public:
 
     Chunk* getChunk(int32_t x, int32_t z);
     Chunk* getChunkByVoxel(int32_t x, int32_t y, int32_t z);
-    voxel* get(int32_t x, int32_t y, int32_t z);
+    voxel* get(int32_t x, int32_t y, int32_t z) const;
+
+    inline voxel* get(glm::ivec3 pos) {
+        return get(pos.x, pos.y, pos.z);
+    }
+
     light_t getLight(int32_t x, int32_t y, int32_t z);
     ubyte getLight(int32_t x, int32_t y, int32_t z, int channel);
     void set(int32_t x, int32_t y, int32_t z, uint32_t id, blockstate state);
+    glm::ivec3 seekOrigin(glm::ivec3 pos, const Block* def, blockstate state);
 
     voxel* rayCast(
         glm::vec3 start, 

From c2aa4e3c267b9a1209faa1bfe02337a7675eaad3 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sat, 8 Jun 2024 20:22:52 +0300
Subject: [PATCH 05/16] fix: ancient aabb blocks rendering bug (lighting)

---
 src/graphics/render/BlocksRenderer.cpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/graphics/render/BlocksRenderer.cpp b/src/graphics/render/BlocksRenderer.cpp
index 578b198d..72a0d87f 100644
--- a/src/graphics/render/BlocksRenderer.cpp
+++ b/src/graphics/render/BlocksRenderer.cpp
@@ -126,7 +126,7 @@ void BlocksRenderer::face(const vec3& coord,
 
     float s = 0.5f;
     if (lights) {
-        float d = glm::dot(Z, SUN_VECTOR);
+        float d = glm::dot(glm::normalize(Z), SUN_VECTOR);
         d = 0.8f + d * 0.2f;
 
         vec3 axisX = glm::normalize(X);
@@ -229,13 +229,11 @@ void BlocksRenderer::blockAABB(
     if (block->hitboxes.empty()) {
         return;
     }
-
     AABB hitbox = block->hitboxes[0];
     for (const auto& box : block->hitboxes) {
         hitbox.a = glm::min(hitbox.a, box.a);
         hitbox.b = glm::max(hitbox.b, box.b);
     }
-
     vec3 size = hitbox.size();
     vec3 X(1, 0, 0);
     vec3 Y(0, 1, 0);
@@ -249,7 +247,6 @@ void BlocksRenderer::blockAABB(
         Z = orient.axisZ;
         orient.transform(hitbox);
     }
-
     coord = vec3(icoord) - vec3(0.5f) + hitbox.center();
     
     face(coord,  X*size.x,  Y*size.y,  Z*size.z, texfaces[5], lights); // north

From ee47213dbbf2e9071e13d4a56bb3b5de5dfb4ce6 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sat, 8 Jun 2024 21:42:44 +0300
Subject: [PATCH 06/16] add temporary test block

---
 res/content/base/blocks/door.json             |  15 ++++++++++++++
 res/content/base/content.json                 |   9 +++++----
 res/content/base/textures/blocks/door.png     | Bin 0 -> 8418 bytes
 .../base/textures/blocks/door_side.png        | Bin 0 -> 6856 bytes
 res/content/base/textures/blocks/door_top.png | Bin 0 -> 6556 bytes
 src/frontend/debug_panel.cpp                  |  19 ++++++++++++++++++
 src/logic/PlayerController.cpp                |   5 +++++
 src/objects/Player.hpp                        |   1 +
 8 files changed, 45 insertions(+), 4 deletions(-)
 create mode 100644 res/content/base/blocks/door.json
 create mode 100644 res/content/base/textures/blocks/door.png
 create mode 100644 res/content/base/textures/blocks/door_side.png
 create mode 100644 res/content/base/textures/blocks/door_top.png

diff --git a/res/content/base/blocks/door.json b/res/content/base/blocks/door.json
new file mode 100644
index 00000000..db12e660
--- /dev/null
+++ b/res/content/base/blocks/door.json
@@ -0,0 +1,15 @@
+{
+    "material": "base:wood",
+    "texture-faces": [
+        "door_side",
+        "door_side",
+        "door_top",
+        "door_top",
+        "door",
+        "door"
+    ],
+    "light-passing": true,
+    "sky-light-passing": true,
+    "size": [1, 2, 1],
+    "rotation": "pipe"
+}
diff --git a/res/content/base/content.json b/res/content/base/content.json
index ef2f084b..09fc42f1 100644
--- a/res/content/base/content.json
+++ b/res/content/base/content.json
@@ -1,7 +1,4 @@
 {
-  "items": [
-    "bazalt_breaker"
-  ],
   "blocks": [
     "dirt",
     "grass_block",
@@ -25,6 +22,10 @@
     "pane",
     "pipe",
     "lightbulb",
-    "torch"
+    "torch",
+    "door"
+  ],
+  "items": [
+    "bazalt_breaker"
   ]
 }
\ No newline at end of file
diff --git a/res/content/base/textures/blocks/door.png b/res/content/base/textures/blocks/door.png
new file mode 100644
index 0000000000000000000000000000000000000000..ad651ac66efe6de06134de64963dc0442048785f
GIT binary patch
literal 8418
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

literal 0
HcmV?d00001

diff --git a/res/content/base/textures/blocks/door_side.png b/res/content/base/textures/blocks/door_side.png
new file mode 100644
index 0000000000000000000000000000000000000000..9201f08cedfd6ab3683c771bfc5767aa250a3dc6
GIT binary patch
literal 6856
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

literal 0
HcmV?d00001

diff --git a/res/content/base/textures/blocks/door_top.png b/res/content/base/textures/blocks/door_top.png
new file mode 100644
index 0000000000000000000000000000000000000000..96e2a73d550e68b7ba4e3ec5147e776c5b28435c
GIT binary patch
literal 6556
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
ZW~O>i#H=uUo4uK(Z0vaN;xRF4{{^IkJFWl#

literal 0
HcmV?d00001

diff --git a/src/frontend/debug_panel.cpp b/src/frontend/debug_panel.cpp
index 958b2f02..91067211 100644
--- a/src/frontend/debug_panel.cpp
+++ b/src/frontend/debug_panel.cpp
@@ -31,6 +31,13 @@ static std::shared_ptr<Label> create_label(wstringsupplier supplier) {
     return label;
 }
 
+template <size_t T>
+inline std::wstring to_string(std::bitset<T> bs) {
+    std::wstringstream ss;
+    ss << bs;
+    return ss.str();
+}
+
 std::shared_ptr<UINode> create_debug_panel(
     Engine* engine, 
     Level* level, 
@@ -94,6 +101,18 @@ std::shared_ptr<UINode> create_debug_panel(
             return std::wstring {L"name: void"};
         }
     }));
+    panel->add(create_label([=](){
+        auto* indices = level->content->getIndices();
+        if (auto def = indices->getBlockDef(player->selectedVoxel.id)) {
+            return L"light: " + to_string(std::bitset<16>(level->chunks->getLight(
+                player->actualSelectedBlockPosition.x,
+                player->actualSelectedBlockPosition.y,
+                player->actualSelectedBlockPosition.z
+            )));
+        } else {
+            return std::wstring {L"no light: -"};
+        }
+    }));
     panel->add(create_label([=](){
         return L"seed: "+std::to_wstring(level->getWorld()->getSeed());
     }));
diff --git a/src/logic/PlayerController.cpp b/src/logic/PlayerController.cpp
index ec4b63df..5d5676c0 100644
--- a/src/logic/PlayerController.cpp
+++ b/src/logic/PlayerController.cpp
@@ -368,6 +368,7 @@ void PlayerController::updateInteraction(){
         player->selectedVoxel = *vox;
         selectedBlockId = vox->id;
         selectedBlockRotation = vox->state.rotation;
+        player->actualSelectedBlockPosition = iend;
         if (selectedState.segment) {
             iend = chunks->seekOrigin(
                 iend, indices->getBlockDef(selectedBlockId), selectedState
@@ -410,6 +411,7 @@ void PlayerController::updateInteraction(){
             }
         }
         if (def && rclick){
+            iend = player->actualSelectedBlockPosition;
             if (!input.shift && target->rt.funcsset.oninteract) {
                 if (scripting::on_block_interact(player.get(), target, x, y, z))
                     return;
@@ -420,6 +422,9 @@ void PlayerController::updateInteraction(){
                 z = (iend.z)+(norm.z);
             } else if (def->rotations.name == "pipe") {
                 state.rotation = BLOCK_DIR_UP;
+                x = iend.x;
+                y = iend.y;
+                z = iend.z;
             }
             vox = chunks->get(x, y, z);
             blockid_t chosenBlock = def->rt.id;
diff --git a/src/objects/Player.hpp b/src/objects/Player.hpp
index 0afeda5c..fa945d25 100644
--- a/src/objects/Player.hpp
+++ b/src/objects/Player.hpp
@@ -47,6 +47,7 @@ public:
     voxel selectedVoxel {0, {}};
     glm::vec3 cam {};
     glm::ivec3 selectedBlockPosition {};
+    glm::ivec3 actualSelectedBlockPosition {};
 
     Player(glm::vec3 position, float speed, std::shared_ptr<Inventory> inv);
     ~Player();

From c89d31ca20cf40c1ee7c005796238a63dd2886d1 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sun, 9 Jun 2024 13:12:12 +0300
Subject: [PATCH 07/16] refactor BlocksRenderer

---
 src/graphics/render/BlocksRenderer.cpp | 79 ++++++++++++++------------
 src/graphics/render/BlocksRenderer.hpp | 45 ++++++++-------
 2 files changed, 69 insertions(+), 55 deletions(-)

diff --git a/src/graphics/render/BlocksRenderer.cpp b/src/graphics/render/BlocksRenderer.cpp
index 72a0d87f..3eb6fe86 100644
--- a/src/graphics/render/BlocksRenderer.cpp
+++ b/src/graphics/render/BlocksRenderer.cpp
@@ -34,16 +34,16 @@ BlocksRenderer::BlocksRenderer(
     cache(cache),
     settings(settings) 
 {
-    vertexBuffer = new float[capacity];
-    indexBuffer = new int[capacity];
-    voxelsBuffer = new VoxelsVolume(CHUNK_W + 2, CHUNK_H, CHUNK_D + 2);
+    vertexBuffer = std::make_unique<float[]>(capacity);
+    indexBuffer = std::make_unique<int[]>(capacity);
+    voxelsBuffer = std::make_unique<VoxelsVolume>(
+        CHUNK_W + voxelBufferPadding*2, 
+        CHUNK_H, 
+        CHUNK_D + voxelBufferPadding*2);
     blockDefsCache = content->getIndices()->getBlockDefs();
 }
 
 BlocksRenderer::~BlocksRenderer() {
-    delete voxelsBuffer;
-    delete[] vertexBuffer;
-    delete[] indexBuffer;
 }
 
 /* Basic vertex add method */
@@ -416,45 +416,52 @@ void BlocksRenderer::render(const voxel* voxels) {
             if (id == 0 || def.drawGroup != drawGroup || state.segment) {
                 continue;
             }
-            const UVRegion texfaces[6]{ cache->getRegion(id, 0), 
-                                        cache->getRegion(id, 1),
-                                        cache->getRegion(id, 2), 
-                                        cache->getRegion(id, 3),
-                                        cache->getRegion(id, 4), 
-                                        cache->getRegion(id, 5)};
+            const UVRegion texfaces[6] {
+                cache->getRegion(id, 0), 
+                cache->getRegion(id, 1),
+                cache->getRegion(id, 2), 
+                cache->getRegion(id, 3),
+                cache->getRegion(id, 4), 
+                cache->getRegion(id, 5)
+            };
             int x = i % CHUNK_W;
             int y = i / (CHUNK_D * CHUNK_W);
             int z = (i / CHUNK_D) % CHUNK_W;
             switch (def.model) {
-            case BlockModel::block:
-                blockCube(x, y, z, texfaces, &def, vox.state, !def.rt.emissive);
-                break;
-            case BlockModel::xsprite: {
-                blockXSprite(x, y, z, vec3(1.0f), 
-                             texfaces[FACE_MX], texfaces[FACE_MZ], 1.0f);
-                break;
+                case BlockModel::block:
+                    blockCube(x, y, z, texfaces, &def, vox.state, !def.rt.emissive);
+                    break;
+                case BlockModel::xsprite: {
+                    blockXSprite(x, y, z, vec3(1.0f), 
+                                texfaces[FACE_MX], texfaces[FACE_MZ], 1.0f);
+                    break;
+                }
+                case BlockModel::aabb: {
+                    blockAABB(ivec3(x,y,z), texfaces, &def, vox.state.rotation, !def.rt.emissive);
+                    break;
+                }
+                case BlockModel::custom: {
+                    blockCustomModel(ivec3(x, y, z), &def, vox.state.rotation, !def.rt.emissive);
+                    break;
+                }
+                default:
+                    break;
             }
-            case BlockModel::aabb: {
-                blockAABB(ivec3(x,y,z), texfaces, &def, vox.state.rotation, !def.rt.emissive);
-                break;
-            }
-            case BlockModel::custom: {
-                blockCustomModel(ivec3(x, y, z), &def, vox.state.rotation, !def.rt.emissive);
-                break;
-            }
-            default:
-                break;
-            }
-            if (overflow)
+            if (overflow) {
                 return;
+            }
         }
     }
 }
 
 void BlocksRenderer::build(const Chunk* chunk, const ChunksStorage* chunks) {
     this->chunk = chunk;
-    voxelsBuffer->setPosition(chunk->x * CHUNK_W - 1, 0, chunk->z * CHUNK_D - 1);
-    chunks->getVoxels(voxelsBuffer, settings->graphics.backlight.get());
+    voxelsBuffer->setPosition(
+        chunk->x * CHUNK_W - voxelBufferPadding, 
+        0,
+        chunk->z * CHUNK_D - voxelBufferPadding
+    );
+    chunks->getVoxels(voxelsBuffer.get(), settings->graphics.backlight.get());
     overflow = false;
     vertexOffset = 0;
     indexOffset = indexSize = 0;
@@ -465,7 +472,9 @@ void BlocksRenderer::build(const Chunk* chunk, const ChunksStorage* chunks) {
 std::shared_ptr<Mesh> BlocksRenderer::createMesh() {
     const vattr attrs[]{ {3}, {2}, {1}, {0} };
     size_t vcount = vertexOffset / BlocksRenderer::VERTEX_SIZE;
-    return std::make_shared<Mesh>(vertexBuffer, vcount, indexBuffer, indexSize, attrs);
+    return std::make_shared<Mesh>(
+        vertexBuffer.get(), vcount, indexBuffer.get(), indexSize, attrs
+    );
 }
 
 std::shared_ptr<Mesh> BlocksRenderer::render(const Chunk* chunk, const ChunksStorage* chunks) {
@@ -474,5 +483,5 @@ std::shared_ptr<Mesh> BlocksRenderer::render(const Chunk* chunk, const ChunksSto
 }
 
 VoxelsVolume* BlocksRenderer::getVoxelsBuffer() const {
-    return voxelsBuffer;
+    return voxelsBuffer.get();
 }
diff --git a/src/graphics/render/BlocksRenderer.hpp b/src/graphics/render/BlocksRenderer.hpp
index 244d4674..e31fd163 100644
--- a/src/graphics/render/BlocksRenderer.hpp
+++ b/src/graphics/render/BlocksRenderer.hpp
@@ -3,6 +3,7 @@
 
 #include <stdlib.h>
 #include <vector>
+#include <memory>
 #include <glm/glm.hpp>
 #include "../../voxels/voxel.hpp"
 #include "../../typedefs.hpp"
@@ -22,16 +23,15 @@ class BlocksRenderer {
     static const glm::vec3 SUN_VECTOR;
     static const uint VERTEX_SIZE;
     const Content* const content;
-    float* vertexBuffer;
-    int* indexBuffer;
+    std::unique_ptr<float[]> vertexBuffer;
+    std::unique_ptr<int[]> indexBuffer;
     size_t vertexOffset;
     size_t indexOffset, indexSize;
     size_t capacity;
-
+    int voxelBufferPadding = 2;
     bool overflow = false;
-
     const Chunk* chunk = nullptr;
-    VoxelsVolume* voxelsBuffer;
+    std::unique_ptr<VoxelsVolume> voxelsBuffer;
 
     const Block* const* blockDefsCache;
     const ContentGfxCache* const cache;
@@ -40,36 +40,41 @@ class BlocksRenderer {
     void vertex(const glm::vec3& coord, float u, float v, const glm::vec4& light);
     void index(int a, int b, int c, int d, int e, int f);
 
-    void vertex(const glm::vec3& coord, float u, float v, 
-                const glm::vec4& brightness,
-                const glm::vec3& axisX,
-                const glm::vec3& axisY,
-                const glm::vec3& axisZ);
-
-    void face(const glm::vec3& coord, float w, float h, float d,
+    void vertex(
+        const glm::vec3& coord, float u, float v, 
+        const glm::vec4& brightness,
+        const glm::vec3& axisX,
+        const glm::vec3& axisY,
+        const glm::vec3& axisZ
+    );
+    void face(
+        const glm::vec3& coord, 
+        float w, float h, float d,
         const glm::vec3& axisX,
         const glm::vec3& axisY,
         const glm::vec3& axisZ,
         const UVRegion& region,
         const glm::vec4(&lights)[4],
-        const glm::vec4& tint);
-    
-    void face(const glm::vec3& coord,
+        const glm::vec4& tint
+    );
+    void face(
+        const glm::vec3& coord,
         const glm::vec3& axisX,
         const glm::vec3& axisY,
         const glm::vec3& axisZ,
         const UVRegion& region,
-        bool lights);
-
-    void tetragonicFace(const glm::vec3& coord,
+        bool lights
+    );
+    void tetragonicFace(
+        const glm::vec3& coord,
         const glm::vec3& p1, const glm::vec3& p2,
         const glm::vec3& p3, const glm::vec3& p4,
         const glm::vec3& X,
         const glm::vec3& Y,
         const glm::vec3& Z,
         const UVRegion& texreg,
-        bool lights);
-    
+        bool lights
+    );
     void blockCube(
         int x, int y, int z, 
         const UVRegion(&faces)[6], 

From b3ae8484a23d25e3aa096b052f654bb0d2f2dc07 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sun, 9 Jun 2024 13:48:43 +0300
Subject: [PATCH 08/16] fix: extended blocks raycast fix

---
 src/graphics/render/BlocksRenderer.cpp | 149 +++++++++++++------------
 src/logic/PlayerController.cpp         |   2 +-
 src/maths/aabb.hpp                     |  14 +--
 src/voxels/Chunks.cpp                  |  22 +++-
 4 files changed, 104 insertions(+), 83 deletions(-)

diff --git a/src/graphics/render/BlocksRenderer.cpp b/src/graphics/render/BlocksRenderer.cpp
index 3eb6fe86..378dc4e7 100644
--- a/src/graphics/render/BlocksRenderer.cpp
+++ b/src/graphics/render/BlocksRenderer.cpp
@@ -27,6 +27,8 @@ BlocksRenderer::BlocksRenderer(
     const ContentGfxCache* cache,
     const EngineSettings* settings
 ) : content(content),
+    vertexBuffer(std::make_unique<float[]>(capacity)),
+    indexBuffer(std::make_unique<int[]>(capacity)),
     vertexOffset(0),
     indexOffset(0),
     indexSize(0),
@@ -34,8 +36,6 @@ BlocksRenderer::BlocksRenderer(
     cache(cache),
     settings(settings) 
 {
-    vertexBuffer = std::make_unique<float[]>(capacity);
-    indexBuffer = std::make_unique<int[]>(capacity);
     voxelsBuffer = std::make_unique<VoxelsVolume>(
         CHUNK_W + voxelBufferPadding*2, 
         CHUNK_H, 
@@ -60,10 +60,10 @@ void BlocksRenderer::vertex(const vec3& coord, float u, float v, const vec4& lig
         uint32_t integer;
     } compressed;
 
-    compressed.integer = (uint32_t(light.r * 255) & 0xff) << 24;
-    compressed.integer |= (uint32_t(light.g * 255) & 0xff) << 16;
-    compressed.integer |= (uint32_t(light.b * 255) & 0xff) << 8;
-    compressed.integer |= (uint32_t(light.a * 255) & 0xff);
+    compressed.integer = (static_cast<uint32_t>(light.r * 255) & 0xff) << 24;
+    compressed.integer |= (static_cast<uint32_t>(light.g * 255) & 0xff) << 16;
+    compressed.integer |= (static_cast<uint32_t>(light.b * 255) & 0xff) << 8;
+    compressed.integer |= (static_cast<uint32_t>(light.a * 255) & 0xff);
 
     vertexBuffer[vertexOffset++] = compressed.floating;
 }
@@ -78,15 +78,17 @@ void BlocksRenderer::index(int a, int b, int c, int d, int e, int f) {
     indexOffset += 4;
 }
 
-/* Add face with precalculated lights */
-void BlocksRenderer::face(const vec3& coord, 
-                          float w, float h, float d,
-                          const vec3& axisX,
-                          const vec3& axisY,
-                          const vec3& axisZ,
-                          const UVRegion& region,
-                          const vec4(&lights)[4],
-                          const vec4& tint) {
+/// @brief Add face with precalculated lights
+void BlocksRenderer::face(
+    const vec3& coord, 
+    float w, float h, float d,
+    const vec3& axisX,
+    const vec3& axisY,
+    const vec3& axisZ,
+    const UVRegion& region,
+    const vec4(&lights)[4],
+    const vec4& tint
+) {
     if (vertexOffset + BlocksRenderer::VERTEX_SIZE * 4 > capacity) {
         overflow = true;
         return;
@@ -102,23 +104,27 @@ void BlocksRenderer::face(const vec3& coord,
     index(0, 1, 3, 1, 2, 3);
 }
 
-void BlocksRenderer::vertex(const vec3& coord, 
-                            float u, float v,
-                            const vec4& tint,
-                            const vec3& axisX,
-                            const vec3& axisY,
-                            const vec3& axisZ) {
+void BlocksRenderer::vertex(
+    const vec3& coord, 
+    float u, float v,
+    const vec4& tint,
+    const vec3& axisX,
+    const vec3& axisY,
+    const vec3& axisZ
+) {
     vec3 pos = coord+axisZ*0.5f+(axisX+axisY)*0.5f;
     vec4 light = pickSoftLight(ivec3(round(pos.x), round(pos.y), round(pos.z)), axisX, axisY);
     vertex(coord, u, v, light * tint);
 }
 
-void BlocksRenderer::face(const vec3& coord,
-                          const vec3& X,
-                          const vec3& Y,
-                          const vec3& Z,
-                          const UVRegion& region,
-                          bool lights) {
+void BlocksRenderer::face(
+    const vec3& coord,
+    const vec3& X,
+    const vec3& Y,
+    const vec3& Z,
+    const UVRegion& region,
+    bool lights
+) {
     if (vertexOffset + BlocksRenderer::VERTEX_SIZE * 4 > capacity) {
         overflow = true;
         return;
@@ -148,14 +154,13 @@ void BlocksRenderer::face(const vec3& coord,
     index(0, 1, 2, 0, 2, 3);
 }
 
-void BlocksRenderer::tetragonicFace(const vec3& coord, const vec3& p1,
-    const vec3& p2, const vec3& p3, const vec3& p4,
-                                    const vec3& X,
-                                    const vec3& Y,
-                                    const vec3& Z,
-                                    const UVRegion& texreg,
-                                    bool lights) {
-    
+void BlocksRenderer::tetragonicFace(
+    const vec3& coord, 
+    const vec3& p1, const vec3& p2, const vec3& p3, const vec3& p4,
+    const vec3& X, const vec3& Y, const vec3& Z,
+    const UVRegion& texreg,
+    bool lights
+) {    
     const vec3 fp1 = (p1.x - 0.5f) * X + (p1.y - 0.5f) * Y + (p1.z - 0.5f) * Z;
     const vec3 fp2 = (p2.x - 0.5f) * X + (p2.y - 0.5f) * Y + (p2.z - 0.5f) * Z;
     const vec3 fp3 = (p3.x - 0.5f) * X + (p3.y - 0.5f) * Y + (p3.z - 0.5f) * Z;
@@ -182,17 +187,19 @@ void BlocksRenderer::tetragonicFace(const vec3& coord, const vec3& p1,
     index(0, 1, 3, 1, 2, 3);
 }
 
-void BlocksRenderer::blockXSprite(int x, int y, int z, 
-                                  const vec3& size, 
-                                  const UVRegion& texface1, 
-                                  const UVRegion& texface2, 
-                                  float spread) {
-    vec4 lights[]{
-            pickSoftLight({x, y + 1, z}, {1, 0, 0}, {0, 1, 0}),
-            pickSoftLight({x + 1, y + 1, z}, {1, 0, 0}, {0, 1, 0}),
-            pickSoftLight({x + 1, y + 1, z}, {1, 0, 0}, {0, 1, 0}),
-            pickSoftLight({x, y + 1, z}, {1, 0, 0}, {0, 1, 0}) };
-
+void BlocksRenderer::blockXSprite(
+    int x, int y, int z, 
+    const vec3& size, 
+    const UVRegion& texface1, 
+    const UVRegion& texface2, 
+    float spread
+) {
+    vec4 lights[] {
+        pickSoftLight({x, y + 1, z}, {1, 0, 0}, {0, 1, 0}),
+        pickSoftLight({x + 1, y + 1, z}, {1, 0, 0}, {0, 1, 0}),
+        pickSoftLight({x + 1, y + 1, z}, {1, 0, 0}, {0, 1, 0}),
+        pickSoftLight({x, y + 1, z}, {1, 0, 0}, {0, 1, 0})
+    };
     int rand = ((x * z + y) ^ (z * y - x)) * (z + y);
 
     float xs = ((float)(char)rand / 512) * spread;
@@ -218,7 +225,7 @@ void BlocksRenderer::blockXSprite(int x, int y, int z,
 
 // HINT: texture faces order: {east, west, bottom, top, south, north}
 
-/* AABB blocks render method */
+/// @brief AABB blocks render method
 void BlocksRenderer::blockAABB(
     const ivec3& icoord,
     const UVRegion(&texfaces)[6], 
@@ -259,8 +266,9 @@ void BlocksRenderer::blockAABB(
     face(coord,  Z*size.z,  Y*size.y, -X*size.x, texfaces[0], lights); // east
 }
 
-void BlocksRenderer::blockCustomModel(const ivec3& icoord,
-                                      const Block* block, ubyte rotation, bool lights) {
+void BlocksRenderer::blockCustomModel(
+    const ivec3& icoord, const Block* block, ubyte rotation, bool lights
+) {
     vec3 X(1, 0, 0);
     vec3 Y(0, 1, 0);
     vec3 Z(0, 0, 1);
@@ -347,8 +355,9 @@ bool BlocksRenderer::isOpen(int x, int y, int z, ubyte group) const {
     blockid_t id = voxelsBuffer->pickBlockId(chunk->x * CHUNK_W + x, 
                                              y, 
                                              chunk->z * CHUNK_D + z);
-    if (id == BLOCK_VOID)
+    if (id == BLOCK_VOID) {
         return false;
+    }
     const Block& block = *blockDefsCache[id];
     if ((block.drawGroup != group && block.lightPassing) || !block.rt.solid) {
         return true;
@@ -360,8 +369,9 @@ bool BlocksRenderer::isOpenForLight(int x, int y, int z) const {
     blockid_t id = voxelsBuffer->pickBlockId(chunk->x * CHUNK_W + x, 
                                              y, 
                                              chunk->z * CHUNK_D + z);
-    if (id == BLOCK_VOID)
+    if (id == BLOCK_VOID) {
         return false;
+    }
     const Block& block = *blockDefsCache[id];
     if (block.lightPassing) {
         return true;
@@ -371,15 +381,13 @@ bool BlocksRenderer::isOpenForLight(int x, int y, int z) const {
 
 vec4 BlocksRenderer::pickLight(int x, int y, int z) const {
     if (isOpenForLight(x, y, z)) {
-        light_t light = voxelsBuffer->pickLight(chunk->x * CHUNK_W + x, 
-                                                y, 
+        light_t light = voxelsBuffer->pickLight(chunk->x * CHUNK_W + x, y, 
                                                 chunk->z * CHUNK_D + z);
         return vec4(Lightmap::extract(light, 0) / 15.0f,
-            Lightmap::extract(light, 1) / 15.0f,
-            Lightmap::extract(light, 2) / 15.0f,
-            Lightmap::extract(light, 3) / 15.0f);
-    }
-    else {
+                    Lightmap::extract(light, 1) / 15.0f,
+                    Lightmap::extract(light, 2) / 15.0f,
+                    Lightmap::extract(light, 3) / 15.0f);
+    } else {
         return vec4(0.0f);
     }
 }
@@ -391,17 +399,20 @@ vec4 BlocksRenderer::pickLight(const ivec3& coord) const {
 vec4 BlocksRenderer::pickSoftLight(const ivec3& coord, 
                                    const ivec3& right, 
                                    const ivec3& up) const {
-    return (
-        pickLight(coord) +
-        pickLight(coord - right) +
-        pickLight(coord - right - up) +
-        pickLight(coord - up)) * 0.25f;
+    return (pickLight(coord) +
+            pickLight(coord - right) +
+            pickLight(coord - right - up) +
+            pickLight(coord - up)) * 0.25f;
 }
 
 vec4 BlocksRenderer::pickSoftLight(float x, float y, float z, 
-                                  const ivec3& right, 
-                                  const ivec3& up) const {
-    return pickSoftLight({int(round(x)), int(round(y)), int(round(z))}, right, up);
+                                   const ivec3& right, 
+                                   const ivec3& up) const {
+    return pickSoftLight({
+        static_cast<int>(round(x)), 
+        static_cast<int>(round(y)), 
+        static_cast<int>(round(z))},
+        right, up);
 }
 
 void BlocksRenderer::render(const voxel* voxels) {
@@ -457,10 +468,8 @@ void BlocksRenderer::render(const voxel* voxels) {
 void BlocksRenderer::build(const Chunk* chunk, const ChunksStorage* chunks) {
     this->chunk = chunk;
     voxelsBuffer->setPosition(
-        chunk->x * CHUNK_W - voxelBufferPadding, 
-        0,
-        chunk->z * CHUNK_D - voxelBufferPadding
-    );
+        chunk->x * CHUNK_W - voxelBufferPadding, 0,
+        chunk->z * CHUNK_D - voxelBufferPadding);
     chunks->getVoxels(voxelsBuffer.get(), settings->graphics.backlight.get());
     overflow = false;
     vertexOffset = 0;
diff --git a/src/logic/PlayerController.cpp b/src/logic/PlayerController.cpp
index 5d5676c0..2384d7c2 100644
--- a/src/logic/PlayerController.cpp
+++ b/src/logic/PlayerController.cpp
@@ -293,7 +293,7 @@ void PlayerController::updateControls(float delta){
     player->updateInput(level, input, delta);
 }
 
-static int determine_rotation(Block* def, glm::ivec3& norm, glm::vec3& camDir) {
+static int determine_rotation(Block* def, const glm::ivec3& norm, glm::vec3& camDir) {
     if (def && def->rotatable){
         const std::string& name = def->rotations.name;
         if (name == "pipe") {
diff --git a/src/maths/aabb.hpp b/src/maths/aabb.hpp
index 49177113..40f57ccc 100644
--- a/src/maths/aabb.hpp
+++ b/src/maths/aabb.hpp
@@ -3,7 +3,7 @@
 
 #include <glm/glm.hpp>
 
-// Axis Aligned Bounding Box
+/// @brief Axis Aligned Bounding Box
 struct AABB {
     glm::vec3 a {0.0f};
     glm::vec3 b {1.0f};
@@ -13,17 +13,17 @@ struct AABB {
     AABB(glm::vec3 size) : a(0.0f), b(size) {
     }
 
-    /* Get AABB point with minimal x,y,z */
+    /// @brief Get AABB point with minimal x,y,z
     inline glm::vec3 min() const {
         return glm::min(a, b);
     }
 
-    /* Get AABB point with minimal x,y,z */
+    /// @brief Get AABB point with minimal x,y,z
     inline glm::vec3 max() const {
         return glm::max(a, b);
     }
 
-    /* Get AABB dimensions: width, height, depth */
+    /// @brief Get AABB dimensions: width, height, depth
     inline glm::vec3 size() const {
         return glm::vec3(
             fabs(b.x - a.x),
@@ -36,14 +36,14 @@ struct AABB {
         return (a + b) * 0.5f;
     }
 
-    /* Multiply AABB size from center */
+    /// @brief Multiply AABB size from center
     inline void scale(const glm::vec3 mul) {
         glm::vec3 center = (a + b) * 0.5f;
         a = (a - center) * mul + center;
         b = (b - center) * mul + center;
     }
 
-    /* Multiply AABB size from given origin */
+    /// @brief Multiply AABB size from given origin
     inline void scale(const glm::vec3 mul, const glm::vec3 orig) {
         glm::vec3 beg = min();
         glm::vec3 end = max();
@@ -52,7 +52,7 @@ struct AABB {
         b = (b - center) * mul + center;
     }
 
-    /* Check if given point is inside */
+    /// @brief Check if given point is inside
     inline bool contains(const glm::vec3 pos) const {
         const glm::vec3 p = min();
         const glm::vec3 s = size();
diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp
index b4107832..1a3d6bd1 100644
--- a/src/voxels/Chunks.cpp
+++ b/src/voxels/Chunks.cpp
@@ -323,9 +323,9 @@ voxel* Chunks::rayCast(
             end.x = px + t * dx;
             end.y = py + t * dy;
             end.z = pz + t * dz;
-                    iend.x = ix;
-                    iend.y = iy;
-                    iend.z = iz;
+            iend.x = ix;
+            iend.y = iy;
+            iend.z = iz;
             
             if (!def->rt.solid) {
                 const std::vector<AABB>& hitboxes = def->rotatable
@@ -337,7 +337,14 @@ voxel* Chunks::rayCast(
 
                 bool hit = false;
 
-                for (const auto& box : hitboxes) {
+                glm::vec3 offset {};
+                if (voxel->state.segment) {
+                    offset = seekOrigin(iend, def, voxel->state) - iend;
+                }
+
+                for (auto box : hitboxes) {
+                    box.a += offset;
+                    box.b += offset;
                     scalar_t boxDistance;
                     glm::ivec3 boxNorm;
                     if (ray.intersectAABB(iend, box, maxDist, boxNorm, boxDistance) > RayRelation::None && boxDistance < distance) {
@@ -446,9 +453,14 @@ glm::vec3 Chunks::rayCastToObstacle(glm::vec3 start, glm::vec3 dir, float maxDis
                 glm::ivec3 norm;
                 Ray ray(start, dir);
 
+                glm::ivec3 offset {};
+                if (voxel->state.segment) {
+                    offset = seekOrigin({ix, iy, iz}, def, voxel->state) - glm::ivec3(ix, iy, iz);
+                }
+
                 for (const auto& box : hitboxes) {
                     // norm is dummy now, can be inefficient
-                    if (ray.intersectAABB(glm::ivec3(ix, iy, iz), box, maxDist, norm, distance) > RayRelation::None) {
+                    if (ray.intersectAABB(glm::ivec3(ix, iy, iz)+offset, box, maxDist, norm, distance) > RayRelation::None) {
                         return start + (dir * glm::vec3(distance));
                     }
                 }

From 4e696520b6cdaafbfd2849fd8cfad637d4ea2860 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sun, 9 Jun 2024 16:30:01 +0300
Subject: [PATCH 09/16] refactor: PlayerController

---
 res/content/base/blocks/door.json     |   4 +-
 src/content/ContentLoader.cpp         |  21 +--
 src/frontend/debug_panel.cpp          |  32 +---
 src/graphics/render/WorldRenderer.cpp |  13 +-
 src/logic/PlayerController.cpp        | 240 +++++++++++++-------------
 src/logic/PlayerController.hpp        |   8 +-
 src/logic/scripting/lua/libplayer.cpp |   4 +-
 src/logic/scripting/scripting.cpp     |   6 +-
 src/logic/scripting/scripting.hpp     |   2 +-
 src/objects/Player.hpp                |  12 +-
 src/voxels/Block.hpp                  |   3 +
 src/voxels/Chunks.cpp                 |  45 ++++-
 src/voxels/Chunks.hpp                 |   3 +-
 13 files changed, 207 insertions(+), 186 deletions(-)

diff --git a/res/content/base/blocks/door.json b/res/content/base/blocks/door.json
index db12e660..2cc23144 100644
--- a/res/content/base/blocks/door.json
+++ b/res/content/base/blocks/door.json
@@ -11,5 +11,7 @@
     "light-passing": true,
     "sky-light-passing": true,
     "size": [1, 2, 1],
-    "rotation": "pipe"
+    "rotation": "pipe",
+    "model": "aabb",
+    "hitbox": [0.0, 0.0, 0.8, 1.0, 2.0, 0.2]
 }
diff --git a/src/content/ContentLoader.cpp b/src/content/ContentLoader.cpp
index 50f07dac..68cb44d7 100644
--- a/src/content/ContentLoader.cpp
+++ b/src/content/ContentLoader.cpp
@@ -137,16 +137,14 @@ void ContentLoader::loadBlock(Block& def, const std::string& name, const fs::pat
         def.model = BlockModel::custom;
         if (root->has("model-primitives")) {
             loadCustomBlockModel(def, root->map("model-primitives"));
-        }
-        else {
-            std::cerr << "ERROR occured while block "
-                       << name << " parsed: no \"model-primitives\" found" << std::endl;
+        } else {
+            logger.error() << name << ": no 'model-primitives' found";
         }
     }
     else if (model == "X") def.model = BlockModel::xsprite;
     else if (model == "none") def.model = BlockModel::none;
     else {
-        std::cerr << "unknown model " << model << std::endl;
+        logger.error() << "unknown model " << model;
         def.model = BlockModel::none;
     }
 
@@ -156,12 +154,12 @@ void ContentLoader::loadBlock(Block& def, const std::string& name, const fs::pat
     std::string profile = "none";
     root->str("rotation", profile);
     def.rotatable = profile != "none";
-    if (profile == "pipe") {
+    if (profile == BlockRotProfile::PIPE_NAME) {
         def.rotations = BlockRotProfile::PIPE;
-    } else if (profile == "pane") {
+    } else if (profile == BlockRotProfile::PANE_NAME) {
         def.rotations = BlockRotProfile::PANE;
     } else if (profile != "none") {
-        std::cerr << "unknown rotation profile " << profile << std::endl;
+        logger.error() << "unknown rotation profile " << profile;
         def.rotatable = false;
     }
     
@@ -187,7 +185,6 @@ void ContentLoader::loadBlock(Block& def, const std::string& name, const fs::pat
         def.hitboxes = { AABB() };
     }
 
-
     // block light emission [r, g, b] where r,g,b in range [0..15]
     if (auto emissionarr = root->list("emission")) {
         def.emission[0] = emissionarr->num(0);
@@ -263,8 +260,8 @@ void ContentLoader::loadCustomBlockModel(Block& def, dynamic::Map* primitives) {
             /* Parse tetragon to points */
             auto tgonobj = modeltetragons->list(i);
             glm::vec3 p1(tgonobj->num(0), tgonobj->num(1), tgonobj->num(2)),
-                    xw(tgonobj->num(3), tgonobj->num(4), tgonobj->num(5)),
-                    yh(tgonobj->num(6), tgonobj->num(7), tgonobj->num(8));
+                      xw(tgonobj->num(3), tgonobj->num(4), tgonobj->num(5)),
+                      yh(tgonobj->num(6), tgonobj->num(7), tgonobj->num(8));
             def.modelExtraPoints.push_back(p1);
             def.modelExtraPoints.push_back(p1+xw);
             def.modelExtraPoints.push_back(p1+xw+yh);
@@ -288,7 +285,7 @@ void ContentLoader::loadItem(ItemDef& def, const std::string& name, const fs::pa
     } else if (iconTypeStr == "sprite") {
         def.iconType = item_icon_type::sprite;
     } else if (iconTypeStr.length()){
-        std::cerr << "unknown icon type" << iconTypeStr << std::endl;
+        logger.error() << name << ": unknown icon type" << iconTypeStr;
     }
     root->str("icon", def.icon);
     root->str("placing-block", def.placingBlock);
diff --git a/src/frontend/debug_panel.cpp b/src/frontend/debug_panel.cpp
index 91067211..24caea8d 100644
--- a/src/frontend/debug_panel.cpp
+++ b/src/frontend/debug_panel.cpp
@@ -31,13 +31,6 @@ static std::shared_ptr<Label> create_label(wstringsupplier supplier) {
     return label;
 }
 
-template <size_t T>
-inline std::wstring to_string(std::bitset<T> bs) {
-    std::wstringstream ss;
-    ss << bs;
-    return ss.str();
-}
-
 std::shared_ptr<UINode> create_debug_panel(
     Engine* engine, 
     Level* level, 
@@ -82,37 +75,26 @@ std::shared_ptr<UINode> create_debug_panel(
                L" visible: "+std::to_wstring(level->chunks->visible);
     }));
     panel->add(create_label([=](){
+        const auto& vox = player->selection.vox;
         std::wstringstream stream;
-        stream << "r:" << player->selectedVoxel.state.rotation << " s:"
-                << std::bitset<3>(player->selectedVoxel.state.segment) << " u:"
-                << std::bitset<8>(player->selectedVoxel.state.userbits);
-        if (player->selectedVoxel.id == BLOCK_VOID) {
+        stream << "r:" << vox.state.rotation << " s:"
+                << std::bitset<3>(vox.state.segment) << " u:"
+                << std::bitset<8>(vox.state.userbits);
+        if (vox.id == BLOCK_VOID) {
             return std::wstring {L"block: -"};
         } else {
-            return L"block: "+std::to_wstring(player->selectedVoxel.id)+
+            return L"block: "+std::to_wstring(vox.id)+
                    L" "+stream.str();
         }
     }));
     panel->add(create_label([=](){
         auto* indices = level->content->getIndices();
-        if (auto def = indices->getBlockDef(player->selectedVoxel.id)) {
+        if (auto def = indices->getBlockDef(player->selection.vox.id)) {
             return L"name: " + util::str2wstr_utf8(def->name);
         } else {
             return std::wstring {L"name: void"};
         }
     }));
-    panel->add(create_label([=](){
-        auto* indices = level->content->getIndices();
-        if (auto def = indices->getBlockDef(player->selectedVoxel.id)) {
-            return L"light: " + to_string(std::bitset<16>(level->chunks->getLight(
-                player->actualSelectedBlockPosition.x,
-                player->actualSelectedBlockPosition.y,
-                player->actualSelectedBlockPosition.z
-            )));
-        } else {
-            return std::wstring {L"no light: -"};
-        }
-    }));
     panel->add(create_label([=](){
         return L"seed: "+std::to_wstring(level->getWorld()->getSeed());
     }));
diff --git a/src/graphics/render/WorldRenderer.cpp b/src/graphics/render/WorldRenderer.cpp
index 8d02a750..795e4c0d 100644
--- a/src/graphics/render/WorldRenderer.cpp
+++ b/src/graphics/render/WorldRenderer.cpp
@@ -195,15 +195,16 @@ void WorldRenderer::renderLevel(
 }
 
 void WorldRenderer::renderBlockSelection(Camera* camera, Shader* linesShader) {
+    const auto& selection = player->selection;
     auto indices = level->content->getIndices();
-    blockid_t id = PlayerController::selectedBlockId;
+    blockid_t id = selection.vox.id;
     auto block = indices->getBlockDef(id);
-    const glm::ivec3 pos = player->selectedBlockPosition;
-    const glm::vec3 point = PlayerController::selectedPointPosition;
-    const glm::vec3 norm = PlayerController::selectedBlockNormal;
+    const glm::ivec3 pos = player->selection.position;
+    const glm::vec3 point = selection.hitPosition;
+    const glm::vec3 norm = selection.normal;
 
     const std::vector<AABB>& hitboxes = block->rotatable
-        ? block->rt.hitboxes[PlayerController::selectedBlockRotation]
+        ? block->rt.hitboxes[selection.vox.state.rotation]
         : block->hitboxes;
 
     linesShader->use();
@@ -305,7 +306,7 @@ void WorldRenderer::draw(
             ctx.setCullFace(true);
             renderLevel(ctx, camera, settings);
             // Selected block
-            if (PlayerController::selectedBlockId != -1 && hudVisible){
+            if (player->selection.vox.id != BLOCK_VOID && hudVisible){
                 renderBlockSelection(camera, linesShader);
             }
         }
diff --git a/src/logic/PlayerController.cpp b/src/logic/PlayerController.cpp
index 2384d7c2..f63670f1 100644
--- a/src/logic/PlayerController.cpp
+++ b/src/logic/PlayerController.cpp
@@ -168,11 +168,6 @@ void CameraControl::update(const PlayerInput& input, float delta, Chunks* chunks
     }
 }
 
-glm::vec3 PlayerController::selectedPointPosition;
-glm::ivec3 PlayerController::selectedBlockNormal;
-int PlayerController::selectedBlockId = -1;
-int PlayerController::selectedBlockRotation = 0;
-
 PlayerController::PlayerController(
     Level* level, 
     const EngineSettings& settings,
@@ -250,8 +245,8 @@ void PlayerController::update(float delta, bool input, bool pause) {
     if (input) {
         updateInteraction();
     } else {
-        selectedBlockId = -1;
-        selectedBlockRotation = 0;
+        player->selection.vox.id = BLOCK_VOID;
+        player->selection.vox.state.rotation = 0;
     }
 }
 
@@ -334,25 +329,11 @@ static void pick_block(ContentIndices* indices, Chunks* chunks, Player* player,
     }
 }
 
-// TODO: refactor this nesting nest
-void PlayerController::updateInteraction(){
+voxel* PlayerController::updateSelection(float maxDistance) {
     auto indices = level->content->getIndices();
-    Chunks* chunks = level->chunks.get();
-    Lighting* lighting = level->lighting.get();
-    Camera* camera = player->camera.get();
-
-    bool xkey = Events::pressed(keycode::X);
-    bool lclick = Events::jactive(BIND_PLAYER_ATTACK) || 
-                  (xkey && Events::active(BIND_PLAYER_ATTACK));
-    bool rclick = Events::jactive(BIND_PLAYER_BUILD) || 
-                  (xkey && Events::active(BIND_PLAYER_BUILD));
-    float maxDistance = 10.0f;
-    if (xkey) {
-        maxDistance *= 20.0f;
-    }
-    auto inventory = player->getInventory();
-    const ItemStack& stack = inventory->getSlot(player->getChosenSlot());
-    ItemDef* item = indices->getItemDef(stack.getItemId());
+    auto chunks = level->chunks.get();
+    auto camera = player->camera.get();
+    auto& selection = player->selection;
 
     glm::vec3 end;
     glm::ivec3 iend;
@@ -363,105 +344,128 @@ void PlayerController::updateInteraction(){
         maxDistance, 
         end, norm, iend
     );
-    if (vox != nullptr) {
-        blockstate selectedState = vox->state;
-        player->selectedVoxel = *vox;
-        selectedBlockId = vox->id;
-        selectedBlockRotation = vox->state.rotation;
-        player->actualSelectedBlockPosition = iend;
-        if (selectedState.segment) {
-            iend = chunks->seekOrigin(
-                iend, indices->getBlockDef(selectedBlockId), selectedState
-            );
-        } 
-        player->selectedBlockPosition = iend;
-        selectedPointPosition = end;
-        selectedBlockNormal = norm;
-        int x = iend.x;
-        int y = iend.y;
-        int z = iend.z;
+    if (vox == nullptr) {
+        selection.vox = {BLOCK_VOID, {}};
+        return nullptr;
+    }
+    blockstate selectedState = vox->state;
+    selection.vox = *vox;
+    selection.actualPosition = iend;
+    if (selectedState.segment) {
+        iend = chunks->seekOrigin(
+            iend, indices->getBlockDef(selection.vox.id), selectedState
+        );
+    }
+    selection.position = iend;
+    selection.hitPosition = end;
+    selection.normal = norm;
+    return vox;
+}
 
-        Block* def = indices->getBlockDef(item->rt.placingBlock);
-        blockstate state {};
-        state.rotation = determine_rotation(def, norm, camera->dir);
-        
-        if (lclick && !input.shift && item->rt.funcsset.on_block_break_by) {
-            if (scripting::on_item_break_block(player.get(), item, x, y, z)) {
-                return;
-            }
-        }
+void PlayerController::processRightClick(Block* def, Block* target) {
+    const auto& selection = player->selection;
+    auto chunks = level->chunks.get();
+    auto camera = player->camera.get();
+    auto lighting = level->lighting.get();
 
-        Block* target = indices->getBlockDef(vox->id);
-        if (lclick && target->breakable){
-            onBlockInteraction(
-                glm::ivec3(x, y, z), target,
-                BlockInteraction::destruction
+    blockstate state {};
+    state.rotation = determine_rotation(def, selection.normal, camera->dir);
+
+    if (!input.shift && target->rt.funcsset.oninteract) {
+        if (scripting::on_block_interact(player.get(), target, selection.position)) {
+            return;
+        }
+    }
+    auto coord = selection.actualPosition;
+    if (!target->replaceable){
+        coord += selection.normal;
+    } else if (def->rotations.name == BlockRotProfile::PIPE_NAME) {
+        state.rotation = BLOCK_DIR_UP;
+    }
+    blockid_t chosenBlock = def->rt.id;
+
+    if (def->obstacle && level->physics->isBlockInside(
+            coord.x, coord.y, coord.z, def,state, player->hitbox.get())) {
+        return;
+    }
+    auto vox = chunks->get(coord);
+    if (vox == nullptr) {
+        return;
+    }
+    if (!chunks->checkReplaceability(def, state, coord)) {
+        return;
+    }
+    if (def->grounded && !chunks->isSolidBlock(coord.x, coord.y-1, coord.z)) {
+        return;
+    }
+    if (chosenBlock != vox->id) {
+        onBlockInteraction(coord, def, BlockInteraction::placing);
+        chunks->set(coord.x, coord.y, coord.z, chosenBlock, state);
+        lighting->onBlockSet(coord.x, coord.y, coord.z, chosenBlock);
+        if (def->rt.funcsset.onplaced) {
+            scripting::on_block_placed(player.get(), def, coord.x, coord.y, coord.z);
+        }
+        blocksController->updateSides(coord.x, coord.y, coord.z);
+    }
+}
+
+void PlayerController::updateInteraction() {
+    auto indices = level->content->getIndices();
+    auto chunks = level->chunks.get();
+    const auto& selection = player->selection;
+
+    bool xkey = Events::pressed(keycode::X);
+    bool lclick = Events::jactive(BIND_PLAYER_ATTACK) || (xkey && Events::active(BIND_PLAYER_ATTACK));
+    bool rclick = Events::jactive(BIND_PLAYER_BUILD) || (xkey && Events::active(BIND_PLAYER_BUILD));
+    float maxDistance = xkey ? 200.0f : 10.0f;
+    
+    auto inventory = player->getInventory();
+    const ItemStack& stack = inventory->getSlot(player->getChosenSlot());
+    ItemDef* item = indices->getItemDef(stack.getItemId());
+
+    auto vox = updateSelection(maxDistance);
+    if (vox == nullptr) {
+        if (rclick && item->rt.funcsset.on_use) {
+            scripting::on_item_use(player.get(), item);
+        }
+        return;
+    }
+    
+    auto iend = selection.position;
+    if (lclick && !input.shift && item->rt.funcsset.on_block_break_by) {
+        if (scripting::on_item_break_block(player.get(), item, iend.x, iend.y, iend.z)) {
+            return;
+        }
+    }
+    auto target = indices->getBlockDef(vox->id);
+    if (lclick && target->breakable){
+        onBlockInteraction(
+            iend, target,
+            BlockInteraction::destruction
+        );
+        blocksController->breakBlock(player.get(), target, iend.x, iend.y, iend.z);
+    }
+    if (rclick && !input.shift) {
+        bool preventDefault = false;
+        if (item->rt.funcsset.on_use_on_block) {
+            preventDefault = scripting::on_item_use_on_block(
+                player.get(), item, iend.x, iend.y, iend.z
             );
-            blocksController->breakBlock(player.get(), target, x, y, z);
+        } else if (item->rt.funcsset.on_use) {
+            preventDefault = scripting::on_item_use(player.get(), item);
         }
-        if (rclick && !input.shift) {
-            bool preventDefault = false;
-            if (item->rt.funcsset.on_use_on_block) {
-                preventDefault = scripting::on_item_use_on_block(player.get(), item, x, y, z);
-            } else if (item->rt.funcsset.on_use) {
-                preventDefault = scripting::on_item_use(player.get(), item);
-            }
-            if (preventDefault) {
-                return;
-            }
-        }
-        if (def && rclick){
-            iend = player->actualSelectedBlockPosition;
-            if (!input.shift && target->rt.funcsset.oninteract) {
-                if (scripting::on_block_interact(player.get(), target, x, y, z))
-                    return;
-            }
-            if (!target->replaceable){
-                x = (iend.x)+(norm.x);
-                y = (iend.y)+(norm.y);
-                z = (iend.z)+(norm.z);
-            } else if (def->rotations.name == "pipe") {
-                state.rotation = BLOCK_DIR_UP;
-                x = iend.x;
-                y = iend.y;
-                z = iend.z;
-            }
-            vox = chunks->get(x, y, z);
-            blockid_t chosenBlock = def->rt.id;
-            if (vox && (target = indices->getBlockDef(vox->id))->replaceable) {
-                if (!level->physics->isBlockInside(x,y,z,def,state, player->hitbox.get()) 
-                    || !def->obstacle){
-                    if (def->grounded && !chunks->isSolidBlock(x, y-1, z)) {
-                        chosenBlock = 0;
-                    }
-                    if (chosenBlock != vox->id && chosenBlock) {
-                        onBlockInteraction(
-                            glm::ivec3(x, y, z), def,
-                            BlockInteraction::placing
-                        );
-                        chunks->set(x, y, z, chosenBlock, state);
-                        lighting->onBlockSet(x,y,z, chosenBlock);
-                        if (def->rt.funcsset.onplaced) {
-                            scripting::on_block_placed(player.get(), def, x, y, z);
-                        }
-                        blocksController->updateSides(x, y, z);
-                    }
-                }
-            }
-        }
-        if (Events::jactive(BIND_PLAYER_PICK)) {
-            pick_block(indices, chunks, player.get(), x, y, z);
-        }
-    } else {
-        selectedBlockId = -1;
-        selectedBlockRotation = 0;
-        player->selectedVoxel.id = BLOCK_VOID;
-        if (rclick) {
-            if (item->rt.funcsset.on_use) {
-                scripting::on_item_use(player.get(), item);
-            } 
+        if (preventDefault) {
+            return;
         }
     }
+    auto def = indices->getBlockDef(item->rt.placingBlock);
+    if (def && rclick) {
+        processRightClick(def, target);
+    }
+    if (Events::jactive(BIND_PLAYER_PICK)) {
+        auto coord = selection.actualPosition;
+        pick_block(indices, chunks, player.get(), coord.x, coord.y, coord.z);
+    }
 }
 
 Player* PlayerController::getPlayer() {
diff --git a/src/logic/PlayerController.hpp b/src/logic/PlayerController.hpp
index 76d04b79..e1a09b99 100644
--- a/src/logic/PlayerController.hpp
+++ b/src/logic/PlayerController.hpp
@@ -76,12 +76,10 @@ class PlayerController {
     float stepsTimer = 0.0f;
     void onFootstep();
     void updateFootsteps(float delta);
-public:
-    static glm::ivec3 selectedBlockNormal;
-    static glm::vec3 selectedPointPosition;
-    static int selectedBlockId;
-    static int selectedBlockRotation;
+    void processRightClick(Block* def, Block* target);
 
+    voxel* updateSelection(float maxDistance);
+public:
     PlayerController(
         Level* level, 
         const EngineSettings& settings,
diff --git a/src/logic/scripting/lua/libplayer.cpp b/src/logic/scripting/lua/libplayer.cpp
index 045aae37..fde82362 100644
--- a/src/logic/scripting/lua/libplayer.cpp
+++ b/src/logic/scripting/lua/libplayer.cpp
@@ -134,10 +134,10 @@ static int l_player_set_noclip(lua_State* L) {
 
 static int l_player_get_selected_block(lua_State* L) {
     if (auto player = get_player(L, 1)) {
-        if (player->selectedVoxel.id == BLOCK_VOID) {
+        if (player->selection.vox.id == BLOCK_VOID) {
             return 0;
         }
-        const glm::ivec3 pos = player->selectedBlockPosition;
+        const glm::ivec3 pos = player->selection.position;
         lua_pushinteger(L, pos.x);
         lua_pushinteger(L, pos.y);
         lua_pushinteger(L, pos.z);
diff --git a/src/logic/scripting/scripting.cpp b/src/logic/scripting/scripting.cpp
index c24d9860..493b6f91 100644
--- a/src/logic/scripting/scripting.cpp
+++ b/src/logic/scripting/scripting.cpp
@@ -192,10 +192,10 @@ void scripting::on_block_broken(Player* player, const Block* block, int x, int y
     });
 }
 
-bool scripting::on_block_interact(Player* player, const Block* block, int x, int y, int z) {
+bool scripting::on_block_interact(Player* player, const Block* block, glm::ivec3 pos) {
     std::string name = block->name + ".interact";
-    return state->emit_event(name, [x, y, z, player] (lua::LuaState* state) {
-        state->pushivec3(x, y, z);
+    return state->emit_event(name, [pos, player] (lua::LuaState* state) {
+        state->pushivec3(pos.x, pos.y, pos.z);
         state->pushinteger(player->getId());
         return 4;
     });
diff --git a/src/logic/scripting/scripting.hpp b/src/logic/scripting/scripting.hpp
index 14e678d4..6b7f9b3d 100644
--- a/src/logic/scripting/scripting.hpp
+++ b/src/logic/scripting/scripting.hpp
@@ -58,7 +58,7 @@ namespace scripting {
     void random_update_block(const Block* block, int x, int y, int z);
     void on_block_placed(Player* player, const Block* block, int x, int y, int z);
     void on_block_broken(Player* player, const Block* block, int x, int y, int z);
-    bool on_block_interact(Player* player, const Block* block, int x, int y, int z);
+    bool on_block_interact(Player* player, const Block* block, glm::ivec3 pos);
 
     /// @brief Called on RMB click with the item selected 
     /// @return true if prevents default action
diff --git a/src/objects/Player.hpp b/src/objects/Player.hpp
index fa945d25..fdae39b5 100644
--- a/src/objects/Player.hpp
+++ b/src/objects/Player.hpp
@@ -32,6 +32,14 @@ struct PlayerInput {
     bool flight : 1;
 };
 
+struct BlockSelection {
+    voxel vox {0, {}};
+    glm::ivec3 position {};
+    glm::ivec3 actualPosition {};
+    glm::ivec3 normal {};
+    glm::vec3 hitPosition;
+};
+
 class Player : public Object, public Serializable {
     float speed;
     int chosenSlot;
@@ -44,10 +52,8 @@ public:
     std::shared_ptr<Camera> currentCamera;
     std::unique_ptr<Hitbox> hitbox;
     bool debug = false;
-    voxel selectedVoxel {0, {}};
     glm::vec3 cam {};
-    glm::ivec3 selectedBlockPosition {};
-    glm::ivec3 actualSelectedBlockPosition {};
+    BlockSelection selection {};
 
     Player(glm::vec3 position, float speed, std::shared_ptr<Inventory> inv);
     ~Player();
diff --git a/src/voxels/Block.hpp b/src/voxels/Block.hpp
index cdf997c0..d3d95d7c 100644
--- a/src/voxels/Block.hpp
+++ b/src/voxels/Block.hpp
@@ -62,6 +62,9 @@ struct BlockRotProfile {
 
     /// @brief Doors, signs and other panes
     static const BlockRotProfile PANE;
+
+    static inline std::string PIPE_NAME = "pipe";
+    static inline std::string PANE_NAME = "pane";
 };
 
 enum class BlockModel {
diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp
index 1a3d6bd1..65e7bc7f 100644
--- a/src/voxels/Chunks.cpp
+++ b/src/voxels/Chunks.cpp
@@ -22,7 +22,7 @@ Chunks::Chunks(
     WorldFiles* wfile, 
     LevelEvents* events, 
     const Content* content
-) : contentIds(content->getIndices()), 
+) : indices(content->getIndices()), 
     chunks(w*d),
     chunksSecond(w*d),
     w(w), d(d), ox(ox), oz(oz), 
@@ -65,7 +65,7 @@ const AABB* Chunks::isObstacleAt(float x, float y, float z){
             return &empty;
         }
     }
-    const Block* def = contentIds->getBlockDef(v->id);
+    const Block* def = indices->getBlockDef(v->id);
     if (def->obstacle) {
         const auto& boxes = def->rotatable 
                           ? def->rt.hitboxes[v->state.rotation] 
@@ -83,21 +83,21 @@ bool Chunks::isSolidBlock(int32_t x, int32_t y, int32_t z) {
     voxel* v = get(x, y, z);
     if (v == nullptr)
         return false;
-    return contentIds->getBlockDef(v->id)->rt.solid;
+    return indices->getBlockDef(v->id)->rt.solid;
 }
 
 bool Chunks::isReplaceableBlock(int32_t x, int32_t y, int32_t z) {
     voxel* v = get(x, y, z);
     if (v == nullptr)
         return false;
-    return contentIds->getBlockDef(v->id)->replaceable;
+    return indices->getBlockDef(v->id)->replaceable;
 }
 
 bool Chunks::isObstacleBlock(int32_t x, int32_t y, int32_t z) {
     voxel* v = get(x, y, z);
     if (v == nullptr)
         return false;
-    return contentIds->getBlockDef(v->id)->obstacle;
+    return indices->getBlockDef(v->id)->obstacle;
 }
 
 ubyte Chunks::getLight(int32_t x, int32_t y, int32_t z, int channel){
@@ -218,6 +218,33 @@ void Chunks::repairSegments(const Block* def, blockstate state, int x, int y, in
     }
 }
 
+bool Chunks::checkReplaceability(const Block* def, blockstate state, glm::ivec3 origin) {
+    const auto& rotation = def->rotations.variants[state.rotation];
+    const auto size = def->size;
+    for (int sy = 0; sy < size.y; sy++) {
+        for (int sz = 0; sz < size.z; sz++) {
+            for (int sx = 0; sx < size.x; sx++) {
+                blockstate segState = state;
+                segState.segment = ((sx > 0) | ((sy > 0) << 1) | ((sz > 0) << 2));
+
+                auto pos = origin;
+                pos += rotation.axisX * sx;
+                pos += rotation.axisY * sy;
+                pos += rotation.axisZ * sz;
+                if (auto vox = get(pos.x, pos.y, pos.z)) {
+                    auto target = indices->getBlockDef(vox->id);
+                    if (!target->replaceable) {
+                        return false;
+                    }
+                } else {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+
 void Chunks::set(int32_t x, int32_t y, int32_t z, uint32_t id, blockstate state) {
     if (y < 0 || y >= CHUNK_H) {
         return;
@@ -240,7 +267,7 @@ void Chunks::set(int32_t x, int32_t y, int32_t z, uint32_t id, blockstate state)
     
     // block finalization
     voxel& vox = chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx]; 
-    auto prevdef = contentIds->getBlockDef(vox.id);
+    auto prevdef = indices->getBlockDef(vox.id);
     if (prevdef->inventorySize == 0) {
         chunk->removeBlockInventory(lx, y, lz);
     }
@@ -249,7 +276,7 @@ void Chunks::set(int32_t x, int32_t y, int32_t z, uint32_t id, blockstate state)
     }
 
     // block initialization
-    auto newdef = contentIds->getBlockDef(id);
+    auto newdef = indices->getBlockDef(id);
     vox.id = id;
     vox.state = state;
     chunk->setModifiedAndUnsaved();
@@ -318,7 +345,7 @@ voxel* Chunks::rayCast(
         if (voxel == nullptr){
             return nullptr;
         }
-        const Block* def = contentIds->getBlockDef(voxel->id);
+        const auto def = indices->getBlockDef(voxel->id);
         if (def->selectable){
             end.x = px + t * dx;
             end.y = py + t * dy;
@@ -442,7 +469,7 @@ glm::vec3 Chunks::rayCastToObstacle(glm::vec3 start, glm::vec3 dir, float maxDis
         if (voxel == nullptr) { 
             return glm::vec3(px + t * dx, py + t * dy, pz + t * dz); 
         }
-        const Block* def = contentIds->getBlockDef(voxel->id);
+        const auto def = indices->getBlockDef(voxel->id);
         if (def->obstacle) {
             if (!def->rt.solid) {
                 const std::vector<AABB>& hitboxes = def->rotatable
diff --git a/src/voxels/Chunks.hpp b/src/voxels/Chunks.hpp
index e73bf025..fc2438c9 100644
--- a/src/voxels/Chunks.hpp
+++ b/src/voxels/Chunks.hpp
@@ -21,7 +21,7 @@ class Block;
 
 /* Player-centred chunks matrix */
 class Chunks {
-    const ContentIndices* const contentIds;
+    const ContentIndices* const indices;
 
     void eraseSegments(const Block* def, blockstate state, int x, int y, int z);
     void repairSegments(const Block* def, blockstate state, int x, int y, int z);
@@ -40,6 +40,7 @@ public:
            WorldFiles* worldFiles, LevelEvents* events, const Content* content);
     ~Chunks() = default;
 
+    bool checkReplaceability(const Block* def, blockstate state, glm::ivec3 coord);
     bool putChunk(const std::shared_ptr<Chunk>& chunk);
 
     Chunk* getChunk(int32_t x, int32_t z);

From 65a2a3e475988136e8ff57ec1c7807dbc3f5f347 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sun, 9 Jun 2024 17:40:01 +0300
Subject: [PATCH 10/16] fix: extended block collision detection

---
 src/voxels/Chunks.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp
index 65e7bc7f..9c09de7d 100644
--- a/src/voxels/Chunks.cpp
+++ b/src/voxels/Chunks.cpp
@@ -67,11 +67,16 @@ const AABB* Chunks::isObstacleAt(float x, float y, float z){
     }
     const Block* def = indices->getBlockDef(v->id);
     if (def->obstacle) {
+        glm::ivec3 offset {};
+        if (v->state.segment) {
+            glm::ivec3 point(ix, iy, iz);
+            offset = seekOrigin(point, def, v->state) - point;
+        }
         const auto& boxes = def->rotatable 
                           ? def->rt.hitboxes[v->state.rotation] 
                           : def->hitboxes;
         for (const auto& hitbox : boxes) {
-            if (hitbox.contains({x - ix, y - iy, z - iz})) {
+            if (hitbox.contains({x - ix - offset.x, y - iy - offset.y, z - iz - offset.z})) {
                 return &hitbox;
             }
         }

From 90ed175915bc3e81218da8cb59268ae5895486f1 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sun, 9 Jun 2024 19:54:34 +0300
Subject: [PATCH 11/16] feat: extended blocks rotation

---
 res/content/base/blocks/door.json             |   4 +-
 res/content/base/preload.json                 |   6 ++
 res/content/base/scripts/door.lua             |  13 +++
 res/content/base/sounds/blocks/door_close.ogg | Bin 0 -> 10119 bytes
 res/content/base/sounds/blocks/door_open.ogg  | Bin 0 -> 12073 bytes
 src/logic/scripting/lua/libblock.cpp          |   7 +-
 src/voxels/Chunks.cpp                         |  88 +++++++++++++++++-
 src/voxels/Chunks.hpp                         |   4 +-
 8 files changed, 109 insertions(+), 13 deletions(-)
 create mode 100644 res/content/base/preload.json
 create mode 100644 res/content/base/scripts/door.lua
 create mode 100644 res/content/base/sounds/blocks/door_close.ogg
 create mode 100644 res/content/base/sounds/blocks/door_open.ogg

diff --git a/res/content/base/blocks/door.json b/res/content/base/blocks/door.json
index 2cc23144..fd134355 100644
--- a/res/content/base/blocks/door.json
+++ b/res/content/base/blocks/door.json
@@ -11,7 +11,7 @@
     "light-passing": true,
     "sky-light-passing": true,
     "size": [1, 2, 1],
-    "rotation": "pipe",
+    "rotation": "pane",
     "model": "aabb",
-    "hitbox": [0.0, 0.0, 0.8, 1.0, 2.0, 0.2]
+    "hitbox": [0.0, 0.0, 0.0, 1.0, 2.0, 0.2]
 }
diff --git a/res/content/base/preload.json b/res/content/base/preload.json
new file mode 100644
index 00000000..801938a6
--- /dev/null
+++ b/res/content/base/preload.json
@@ -0,0 +1,6 @@
+{
+    "sounds": [
+        "blocks/door_open",
+        "blocks/door_close"
+    ]
+}
diff --git a/res/content/base/scripts/door.lua b/res/content/base/scripts/door.lua
new file mode 100644
index 00000000..b922464d
--- /dev/null
+++ b/res/content/base/scripts/door.lua
@@ -0,0 +1,13 @@
+function on_interact(x, y, z)
+    local inc = 1
+    if block.get_user_bits(x, y, z, 0, 1) > 0 then
+        inc = 3
+        block.set_user_bits(x, y, z, 0, 1, 0)
+        audio.play_sound("blocks/door_close", x+0.5, y+1, z+0.5, 1, 1)
+    else
+        block.set_user_bits(x, y, z, 0, 1, 1)
+        audio.play_sound("blocks/door_open", x+0.5, y+1, z+0.5, 1, 1)
+    end
+    block.set_rotation(x, y, z, (block.get_rotation(x, y, z) + inc) % 4)
+    return true
+end
diff --git a/res/content/base/sounds/blocks/door_close.ogg b/res/content/base/sounds/blocks/door_close.ogg
new file mode 100644
index 0000000000000000000000000000000000000000..53ead574012e0a8445c8f9b63941d9a0ae5c817d
GIT binary patch
literal 10119
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
bEVqo|>1mDK*F<A&(kS`ZTNIZ(Wq|(!6Yu}Y

literal 0
HcmV?d00001

diff --git a/res/content/base/sounds/blocks/door_open.ogg b/res/content/base/sounds/blocks/door_open.ogg
new file mode 100644
index 0000000000000000000000000000000000000000..77aadf809b10b6fec6d88dd7fc0bb6f03315450d
GIT binary patch
literal 12073
zcmaia1zc1?*Y{nzge3*3ML<}(k&>3Kg{2XsyF-+ckWN>myBnmHhNVM5Qa}VmK}1Oj
z^}FCx-}8OH_nqJD?A$qb&Y3yqf6hH~ceU*7bO8+DAEmHBU;e85@=yB-gaP8~=4t8R
zbu|D{sJi+Biy!3rs}-VkHS=HPYUUMXsM<Xes`%&sD#Mt683}`QLkD+z9xYEhn6rbW
z{xy4;3QT~H|1O^(zX*(7)6EaY&&S6Kv$gTF@q~HV+c-OW!LOu1u>UfF%gO6Q06cJn
zUmZ3OGL?h`04M-hu)v9*+p55eQTgotX(;8Z-T+^88Y+5#+A5A8{m%v_WK9VGSU?Cn
zenR0V6~_rNJ8HHB&pa^)&AX*A+!&n?V)(tscdT4X8cUp9C*Z7jH;k|WP(w1xOc4}_
ztHv^l=@~WHMACT<F_mU{5^$8|g%Su1!NSx9z7##z6#r6Im>|Bx-Z&*k$lW-ts?PsT
z->Rkq$1K2WLTo$h9}WKXK49Ql<Zx)Lp>lXv?4#f%X`UdfzuSTVA>cLvrDO_~dWz9{
zy79LxS_fP@<ic+S6?OGAkYMpKGw`*U_w||g4KzxNFlh}mYK<^ih%h^icu4*1AN6P8
z+UZrj-Z~5d<S~n-Zoms}-zxYhR)87)tO^6LzETMcKjk(&rBJ2B*0IJRv)R6~*=4kW
zYqWvr`W65J-f~s)95PD&pK5EAYV*HW8T%m)KnB$1pa<Qc2a6(tWzdrg_gce40BBPg
z1lNG4kdl|spqC_AmAn;(QR?GI>LmX(!j;(pK!%@gz=LiW)CPik##7k9OKRRrV;)q+
zl}7&O^7I-n;6|9TZBrdX@C1_{UaKVpWJ{foCr|WO5_m&Y{w6GAD&ufmj5uQ}ubd)t
zrYBl2ldY{hE%Vxf&J#2npe^Ae=>vJ`QyE?pDnuE@e|!F9nYh*E)8H7*b`~+3<{@~W
z!*m92`Jy2>*Jvu^Q&}4Y*o#JGvNg5o{pI%$Sd>4=n&=T*2WLbtWjeLtn}NME>#T3%
z_*Y~94IdfMZVwlz(b=J}zyusi3Z@dK=M3J7#Lx5ihu}pF@d@`;%fqx0G;GD*q1QWy
z0YEtP8pZ!?uA%%F#YHJG93$+n#so&Wu9~X83Gv;!KBznqKZs&3VGzafO`meSYQ&VC
ziks$)Ig3#URe14Vj{=Pfvrdx5p}BUFXK9`z@KVq#{?l;ZStd#8-~LCP{6VKf#tPQA
z0^GWSQb;|dfv=0vOP}SI2(tyBwfVrc`FQi2&;A=&|MDCFbeiyMpF~;4@egK&Y0BaM
zHSj+@$Ae-pnQl0lMXiBFW14IHKuGIQ=q<UTj*x~frP*6bpBX9}T@kYxVVfDG%{yP4
z#bz6mmO!KCe>luvw^^I_`47*za*^9&2^-2OSpW8%Jobc-cN3UZQdo>q?)azLMQ4<!
z=X@zIAowrOv5zTDiz$tY*^WwJk4|-n&ZuZBa2~1IZU0~EzdT3DlLf4x=O}uz{D<ds
z^V7+L-qgUQark$SQg1<pdMn=iPXhozcM_4>bsW(_aKA$cze8{%^`!o1j{&LggfwP^
zK*hcQ02%;b28|pJjqyy9bCoj0<Nw5hoiB!y-%lN03Kb+0yK&n)NtR8jHASqC=<oxA
zol-$PES^;~0d}Le#8hSLE*=>6umBwZ2;m>%@2B>hP#MlsnBd3HMh%Iv6+fR=fpe!)
z3&L4T$gDQ93a3?ui%`^RG1*0AR?*eqBmfuu5av%MQ9@)W0Kk$6K>&|HAtvCTk`N>O
zTXYCjvC=Hv2{AnS@DYBT>@X<2m`-;BK1dfnCcBjtHYLjr0I+Td_>p55vQ`A3Y`_P1
zmdWQrY80$$<cgCNHuK~f^Dl(Pg@kqVkfY?tcY4TWDh*^as|LA-#*rS9ToFl$oJrL{
zHn~g+*(~ZISE!Khnr)V;f(%l9)&w<-z{@$1>NB4jXg=p+mi7-;8Wh*8M3D2%!aCka
z9i)ws9@5Cy#^@AjFc+u>Qgt;JDUrx#<l?alGBt4B8);@>vv`U$q6#vZk61qmT&KR`
zJpaxIq&}RpdD!B!#_o{e;8;*rk-=V3QC`vPQc+WFQt-K=pkk!KuA-)Dq@lL5#(5W{
z)|6E=a8*=rRW?*zRB-J!msPY^k2KU})>Q5`?-TZM?Y6sD)YMcqe7&N!SMQ=dcH8*^
zO5md<l{@X_?d`6+?H*&zE_8(zJDnV(y>%lE`@8MDjXq2|NS_sy*@gkQ4;OR49Fx<C
z1{aC0>WdMO!SqkDNjJJSaM~+ZT5t?~$SM8sZbGqL2Ds9S>dcDD-3C|AzN%e09b}-{
z3!61jGozcXYoZAz^YH~0JMA2!ouDB8_h>h|*L-wl%OW5lyP=ve&}!%uf6{3g?QtQ#
zapF^0ON2j|2x0?rg$?o%nS3TrjF7t!0EcOtLKn(00P}_-c3?$%{5VWrnyLeIC~Z|o
zCe$nk8m5<^GL-e4Ow}HannvK}7i+6J<)h{hPW2_TmV2-wDpdz=)U>f<IeOMOj?@Y&
zuw7(5p@LuBctrqNZRZsc%c&L@QK+eM>yLpzE}WKCE-xa}RVi-*Srr#isj2ceQ<%8&
z&(VQ1ipWe<;Aje67jAS0Ga3f68om;KEn_PU1+q#HOHoy=evyJ0%X)srDl9=&1>T&Z
zst&G7Rkc0>VeHI5mxXW^23G~LN>O#@MjM-`H~Bz~39naG-K6j2Sd9jSvldgUsn$19
zIl1zGx~1w+eI>knfXXBR6t3$eTr%f)MKE!Zn#=G~t)81j#DfGYmyUNCPxk-0b4y2V
z^qgh&m2i&w7b&3dPfNyeVyJ0LkW~sI4xC})+*Xq62of?7u}z<ryqtwkW{s<^WT=5p
z2(QGpV|_5{gkS<PA^0|VS0UueZDpen6Dkf+&oMC$e7P|(wsKE(IXE0SCX2_~G$96u
z56p?-u@+OQac~dlJHg@LF1W$G<JxU;G@=I}1UHQE0R_;D(J(OX;LsFPhfPrzQCLB5
z7gK|FDW<RjbxZ9<EXP4(H6hCm57$=ZfJZ=8RalF`RF{Ab%;%h^P=<8ig8s%43nEJ*
z{%0_6Jpm5VaCKF-@~5Cit9?Ky6c3CUJ61O?$lz5+%n7Kmf>5xn?oTu31c0yLg1%nI
z5mq1x7m%SY1m%j^K`qC`KGO+-k&!N(m;;>^Ml6R%2`&SCR*i{)4O9*!fcaj27}yk}
zrmqMH)h{q`3|{PgML;140D!|C%!ulAti3{$^T3#i0r+3VOjR-5eAIn78iq<ifa1U{
zm3tC_x*O2HBA|@F!a!&^3;RMrSfP#ORjUUKoobkh=Pav)=RpuReadiB1qn{$Z2<5d
z8yBd<q*WAQqsHeDvcBF#2n<wX9RD*4%NYLcEO|WmKpL3ilu%!#9^gavD*uQB3E(9f
zB#3R(T{T%=3I9$^{@ug>|7@Zh%(F=K!KXEvnilVGR(_xC`qIkzA4z)J-^>5V+5err
z|4%&=r)m&#|JeXCT?DwmA6!~}rMvK3gj`p9gc5^^USArxVjTMLXYkKO;h=f)<yFPl
zSwWP*;UIiKk471*rh6d}9IVBuSD|CpSd|;(jmug*hj0X?h~pJE&R&UHkX42k&l$&Z
zgD$5EURuTpKSO}G3@lhy@fS@aK>wt+ssbIz*a=*^6F0nR&N8kE)IS&@<}71{=Zpz~
z53cS&h;p6Bvlm6Ldf$Gywlx!&Y|CA1`|4nT0Bw<Xg%&0SRS;EI7-0$r&G2_DJn3I!
zQ1R`*&;kLq{r5hUw%j$e@bbYiI6Vk5_Uj%i*u(#uz+HneoD59mP$1{OV<<9E#&vp!
zLR=vdRLvFP8miYle5NaPUEj>~ckWd#2tpL|Dhe}yW+@!G?JTt3i>YltqzZ%(0f5JX
z<1Tz|2sV%vo~jm}<O#LpAw|T9Db?F3(+p6*L-7|==pvjxXIaMSXk}Ze^7mDt^i|oD
zL#I8fntaE=vn31<;Da&=K9zw`P!EBE!m;2$US0PTzbO{hCYb;M5y4=%*R%sB01Y1^
zN{%ulA|tPOT3{&-7@ArP;f4^!$2Z0jeirD)Hhb>_3x{DbMGZhGl0w4BT_1hCq1D=h
zFRoZj{P!pf0T=)v<p%8b?F_L5;zW`pXfkOE*>iFf2wwpB00|)hLRhe)qM~dQ3i~!N
zSrn|pi~2XQSg*-f4IbX#qYBn_|L;**M&d8|>Zp7rW+V!+BrGDt%>m~Uy!&D8J)DD+
zi-S`@Ku|<Tn46PBKtynUj*F9%T~JtvLs(FNTS#Dgj$cyv{qiW$0d(VRqPQ+ffB1Ma
zl(4}<{!J{;Gkxj6$#0#T5xy_ay_`=J_8m<r<w{-Fr1yV6=u|LZ!y%&Th%LQbv}3Ej
z=oN7e+3L>1y_X^S`c?D8;Px!601uuWoto_r&Wq`oBhL}DrrKwtT0r9uU%km@u7;$%
z7j<r-%r~T$^5k7QZ<TI-)e6$05Un7NxM}@!q^~pJ4;BR2JbuFzGCDKF&uv_YLmm0l
zhv#`G@qN}GacIinLfgfSKN>v!ubIo(ApqCMaDbz|pMR1RDqDeR+^ofX?<v}1XIm}A
zUncj4ea%fiBhixE1A;;nJ5W|i)`Fy8ZZ;uAu%197>4J5X!eAYp?!u3oC<$Fo1o=|1
zvcjxG3kNaQdB6Rbz7bXXhhPR6V98)O7cb!`WPAE4{2l7$w+_+HEX=rF%(QdO+Q$wF
zl~Y)c|0wmJ#bnyyIS5;8`@CHm!6Jau@&czbC6AVhT()-4HeC*%Av_vMA<*-s$F6((
z`RPBM1#QW9OR$!N-&>SLYV)07K9sOd{B_T4{xT?rnmy!!c(Y1rG=fIxb16Ph7j0`d
zT;uvJ=Uu${TuWxoQq93I{2pz99*r4|xJ#PnD|@XM-ZY0&yIL~};421SyxtRhmu9ar
z1C3E}wMV@oSr>*|n85+vwZ}m_>?Tj)*+h}e7f6Ft0+N@+GA9;(aoYCc<c>w5g$ynC
z#5K9a7tK}~v3R1=eJmsrF6o`tr%h1QFP3V&caz>Iu=LAhyRh3Tv(mJ@4<gwOZs~Cq
z`pFRnxm;rlKoxJ7?9Suw9x8~kJhU^#t9mWgDXLI08e&-|ZGBuPzt3boVwTRuMVID_
zR3V2s0jARP08rN{@JsnIuNGC2UEIf)UP1fo1|;E!qnRoRP=WyIE|n~UUF#E)i{Moy
zFeu17Y{=G4Wi-xZlqYv;lFa(WK*wy~n`^$m(f#1u%NytIzTGwjMDZvP0vAzP=zpF1
zM<5=4Yc!H*_Dx<cD-F)ioBNj&Usv~rH{5u1ltUINN)8(7J(!Kyx)j`3n=OkEEzjgQ
znduTazVEp!RvFA3QQ5cJ9?ubZA$W7rl5Rn_ZTU$ETshhGd@Sa8vw>8RG21{qT#ukz
zw-)m+Ab|Z33zrZTW0fH`GaOhfP?x<To=Dnyx^(~dc^&t!Na6JCmf~P#^~4$Ri84zH
zR;@2i(H=NjZ+Z`=c``1R@pTtn=I`o?URZdox(z5kYDV-vT(nORvIJnOa~F=%Zd7y_
zLVQL9+>+gqT+2n{A8Ma;92ZUvndJ+nu$xMao@_-DDX{Vu7)1+P3zG_W|2pm3EwnbX
zblYD&6nfn^EGdZ!=K^@<n|{>Vc5;OiLw|X5rdB8q==-CmZWBx(2&G0htzqdJf4*Hs
zm9L9O(6IV|4QDpZkOscbRRX&s(X%-yex5%eewJ^oB&hHHmaRH?a09?vV#hKx#{Ir3
z3QJZEQ5)LD`S>enWZYdsrUxgbN=Rp3y`cg#!vp6f4&AvuepW{E%J?qiGX@uSPOd8g
zQB)CkMo9mmtc@@F7Vi7>H?di|G#{QOeqG0s?IY9Ke0$_@gSv?2srv4^s!mbRS$d*a
zH&dPZ>#2&Pk=UGXPAq?9AVeP(^i~B_Wcz=+U?k{~5TWj5$Enr@=`+#-G<k~}3R%40
zPZLS|?;3AoeG&qy#FgF@_k8Dt+zrL+k8BFJDsO=De0Hei;y7@nwvX`~e4y?p0symn
zLjA2qE2$PlCWItIX}|-`;XGT;U2$>Yu-_l2kd;1!+9qy3L!`53cc?lY#*7zlsN=*I
zU^x2Lf2=hCC=gaCi?-vA+lS&vGp#tzXkC*1wO^vTvaq@N72?YAr1|pL5)sprH%68S
zeuatO+Xb=%t{BJedW%cQ4e2iKVB3%{cSlz&BkJaJX<Qm}zA5x((H#!504x}>6--Fs
zn`O5Ghgf1z^pCOJ?M^rgi|N&E()$z%LnhVZjxW=iwkz6mw&-u)F*z^dHLrzS9*=}d
z$sIzNDvv85)>Xlw)%%G?DYq2F=FsJ?HD>|a+_|ACtIUVXK1covcuCBzwHw&)A)}m=
z_seZw`QIGx%{OMpc`EPExZ!QC*xO3c<$89ooBO(3)E`aW)T}i6(#X(`c|b-8a{0yA
zsJiTVjQ7lfGw%<8{83<leK7sSkjYvj#=U}#!7m18tPWdScgAoZlVEz|NI|H@$ZU?C
zaN;r~y4T(vysuAr7s(bU)4fUQa(1Y2$DDTC^BC)qKd!=W0t$9bRn)CuDl)oq1}Lt7
zT)jceSo;Qs;s`aZ*SjhLPDf??KxZ{ZJpvt@7JT66E{4p&r(VdI)q~t;>d`qD56-_W
zIu4(nH?%<%*QPCt25IlH#aSD^86C9dI4+Pv)ZqKgx7@UTA3|1u^%IqTVy!;mjK5UE
z`|Eemx)N46#{L|}83Fv8{ab^T&uaIR85%{Ha6Zo|D?Qo01(X@O;P%rEc;)$wZVu;+
z8L9m_e=}YB^z6>|&6|G&tx-OJ;b*RWw#W8kaQG0$CtT|1N~=;O^*-fKU|7_Zk5yFg
z>A!7b0m>~;ep98-4ALe9&oj*YrpT6F4(e$QoVu*q4a>Ay<<Zc=0J^pJuuVLvSY5DO
z0>pUD-kw$7CU1Id{4D9u(`^5lk8AYfz3MuoqsfLg$SPB94D~_}`zJ`xy=|-Nm26oN
ziLue&Nda2SY9sS);px+Cx-K;@iC$<sX4h&M$gLa8bMFWH-~LV<kVE@=1w1ExjC5=%
zF{8|5FtGn-=SR38fYyMJRFRm~cva9zh8OPy>zl0lsm+NtA{j9p><Jg12A>SqKcewl
z@Q1`XL|CydMZCiMa3ott=aItjsrHY~j92cAOQvM-W%GNNL!T{Y%hiRTFX^W4GXwYq
z2aA!l!ST6Y8UK7??>cA<eR82fb~f;{qExB<_WRo}v1y@58-q<eq?<HUr8jqtGdx}n
zPW!{DR!*OgvTXa#N{NgrX9j<fmPs?t!>(Xqx2LKH5Z+y<{<t_9*8+^+#;b+$FogUh
zzwszN!HtO`V>)_@N?l=9<CNQZ-SbDWp$k(@lHRGGnx*m9)^32|&y)clH(K9@Y8M~a
zR$jqN>ug6(>r@U?OCDVAF7J0qbc-_L@mKaZ`|)yO)14oY;VrVr)@4|>cVh~5OSiPC
z5j+bwyd%T(?!%$}#698m7_ueHx*le1Jz@w>gw|8PWoI=gJ}^`~*(q(V;mokcO6x8`
zHmTz#BDv^G_U-o1oDO=HPj5{7;8b5JAS~1FUR_cfWEHQJ{Pv>riW$_sGx^Ab7}a=#
zOz{CB44tL!`?nMuwGL}B^g?dIvWD#(Z^VnNj%gS{UgpO7KH}r1vNu>+61M-^gY}Dr
z><`d?RzudO?_EyrczNm_LbRYqmZilbjGsF^{OIC`gzox<&;o^H%xMK_yXCuauc~Nf
zo!5O3A_70G>hh}ePM-NpEEwVW<lLUOr@OW;t(s{>;$oe-R(@mh%nDFVtse0q*78Ly
zgCrKfa^j0M;QN4k+rt&BHDXMwKD{JHpW5Sf%EeT|<PRej#(aB&4RoS50I-m$q1eKi
znN>3%^ZseC<G2qrdCi0$RgAW+jD}%c(4z$&bG;~!-2CmhjQsB0zBN8q9*iMLp!Rg!
zmXcWd*rnJHj}P-r^UJZDg1bNOZ>f{5&zERDcDT)VH}Ax$>zQq|c&_EXJ`K47Mn@EG
zv{nT5US)jTi*X3CWcsRzG{aFB?qnraP^;VESpZGZ%U4}IxTiPTeR{nMt?6+51W6tq
zbKGm?wS^@+Vhlz^VB>29WM?}cK-!y{%^Jo_dTxsM@;1=Z)vBpe5vFm|taxp*hhMlA
z%A&n3SWj2zii*x0_06;Jxp-%qv;9iGNWS?jIl#)_nOhaFhb>{sK}b6FrmtVW^wfbT
z3Jti%I0d}Yv0zjU{@sjwsn@m&|C#FFyeakR(d)O}Y0@_arNyJ(m+fdRRh0QdBw87P
zka&+i%;)tb;>+_7aPo37fDnnZpL_#cABL(8xHnGgpKhe4NALAJTEEC2e%}9WJw209
zcXzapkrRCR034KTZqNxEXw17uO0Dhxtc&FC#F&+ku!>z=-dtTmid`mJ+FR$8kePg$
zolUQij95v+L_C@MfHy}yp~Qe!ak!*u-fHqziVc|MA|c>_$fvG()kt%cysP5;kR|Ch
z8OTh1r%G_+m|^h8Z&F$SB}<XBbcDBuMm)b?hWI?7<wdno523IQ{!TzEGvCV6Y$qG&
z938_aU-xT<n97iDLZgT9J75)XbX;;O>^Yw&`Ub}gDgHu=S&vWh93RN5b&F4T7GCS*
zM;m0r?7pp^D%p_~v32Q+q+af>Wh@rW%8$mGJ0mvCs4tg-D$2q4AtaZJDaB5kCAY>c
z0{s(v`x{4~roLZzwHSDqcA0&?e>?c5!QeN@yZFe2nW<~xz_IdZLT*s4kFMw!yJ3X?
z%v}y45(|~rzi=tggc?W9=c`kK1a6`eg6?S3CLM$F)6gP{T-<~uNt@M=zeIX#w`x0`
zeQ2L3_DxtYgm<=a5NpvKZ3Vo=R7r&l<##$VF>$lEyHd>B)u-l`T#!_K8Bu*_ZDraV
zYFTKQOitK7uw_SrCwa#YV=^R}mf%fp3za@5zx_jh6KwYnBd_}Q6PDw<PG5QOI%!rn
z<4SrL`<bH?D<w`c4=D3~yjt_hfCO;F*0Je{rOw>Az@uCq+3J2byW4#D>)V&}K9ZtZ
z3Tv}!#gEMH?YfR*T~M8fPOEaR%^KkG%lAJaH!EcEr4qi%Fm`OsZ}^DgaRO*}WL!S#
zE@sj_K>2PKI^z4}2d_-OGdAa)?vi!IVd8t#cWi~&_%#^<9<{&2-Wc`%6(B9u2>SR#
zrMH}#s1HvlyPI@o_GW$LI|<cIk;mKWnYtLyEM0`U#Pj0=q*@an=U>vitgVt67w!iz
zDg0~u+q})l@nZM(d3m@fS)Vw@jLt%bEXQAH4}FLzFW=&UP|x3M2&+$g9)aKVkg*~b
z`D3zDeojam!Uq|GP<1hwa>-GK6#W=2Bw?I5Cs};czo`Z=M2&4bW{4^?+<z2g_@suR
z4$ER%qms9QHyJX}9mD{H6i0|6zc){NS!4G7>deq=vv^(iO7d(*^xM%Cbz>>ckF1kE
z5zS^7v+QL|@bI#4T&XWYKj4xYp+;ah>3Oz&umszUS$o$Y_h;DHQ;u~8mB4X(N+X@o
zql_#s(eBoGv@myhrvD!^8rEns)GvD5M2AnD*4X%Fd5=aGi@XSe<S16-grZn%xt3`v
z>0-kVFKj0FDNRgo?QSI5Xck+)izv$*uH_0BNn}Un0(Q$?RYGlE*g*a1iYw`FgE4F4
zJO~LN+Da|oKE#*EAbqHFlM5qn!Wn@(nl0-;`THUnCG;wX_+Adhrwiv<DHDyCuh8wo
zM+Z0OZ8)JnlGJ;?p2m;g-W7DzfHBJWKP=^))lvHCkaABRIUl%K*vrH9QNSu7uvYmH
z!WiGSw8lEh`4ijYf@E3u3(E{)uM~j`x2T<9%S9f1Rp4&SawHa-;>An%Z`7P2=t`Y2
z8_oE-2e!Py?XH}3L66+zhe_#?{NHpK=_C?5rW)&wgMOcmOaBSDdiq|!=)l5{0J~th
zdeH$Y8^AA-{6Ri2I?+Eh)Q#>RLJtjf_jICPk22idlqJH-i!AVG95Y%^{klWO5>k&4
z+kZnA4*ozyUg*y$h|^{{oBi0(m2!Y`EiLj9mwctnea*L~!S;(^ehm{ocMWFe0~RNF
zkB?Wgw&(4=%RWpQE$H)S4f`cHVcOq1;&rCG?>Ic-dmlbsH#X`N#-*$x`6I<YOLcTT
z=dnT+ik92>$<utrZPo8CMD|?FgCFT$FMMSlk;ozziPb;DU)EC(HN4R9%MlgiQ0o})
z{n_xfvwV{MPGP@Be<8Z%tfY_wcp$3RM`0cIS<W~$u%`LN43Ph{vyrvR=l)!{4JoiA
zy=HzH{4M#Zd=X=p^gKt)SSI|iQCePYZZ<;s)dqAytXH@d|B+^w$%%x761&zD|Cw}q
zZnle`FXnHVN@;Yj%G>a>pG2`rbF`B87I+q`QvNvK_#ut5)&>Z@BUYcNII5G`O8bh_
z!;RY+sI15|>rcGe-K+0o+>tI3Z)5MDY)CCNS>CZIWD&hFwY`4t1`kmIY0VzRy*RTm
z9~ntM*>UPxzCj7AZ7{+Dt0H;=+!_>*haKbTKV*wJZ}gJtCINSZpP5v%goA)&Umqzo
z8fpF$dD<qHk)!r;T@TGtq2awC^X#c!q(V-9U7)cEr`3%n6ZPCTc*9nv%mued&+VcI
z3ldU^3vQ1OG!GP2iPlGB$98CXcRM)oIm-HV(8`C1_SOeRP!Bvl+>^m0|CxPHoS>6{
zMch=3&Fx8holi?5lZm=P_(g>xW~M`eUwQSumm-E?{VsW3Zbr<kY&U~{!2@gk7P+rJ
zb$qiqtxbadVsQQ|^f8FCgr!E|NahJme<_~s2*AwOn33_u*C9<+1o*PggYS<#jpe<u
zi(XI1#3XtzmX&2SUeIQ$xg^w}uSFC7`+NWQ7XnD4-Y)T*Cs7%9-6z#g8QO|cenI4(
z5k4g5Z&HjIk+Qd_&=3&)>bR5UW<bf>A!4k9I8KlYa<^Ekmlfx@X?4-8*@Luwgb~A=
ztj1xb98|)q-Qs&+k5a&DrY3k_-h!->;@SO=f1rHubA5xl(~QZ=1^MY>JAoELFGJ?5
zf77grD9FZsSC}>$n<l`N=JI$=C?`ONZmt$M2nkEdQUtp93A>uVdyuw}Pb@i@ck)H+
z?mnR@mm}(k<}CQU@yi=45}qY*)lSphU_`VbvwONTaC3D9FR(JDqgptK^{^6RR9iJM
zI1`HZe0-5oyFOJDDmg9pP%}wrcx&&H*8J9-tHX|Bg&#NBynUBD)8#nzY&_XTmXCID
zb>P=H%_u4BhdIX4kK0}j8HakkDSeAjQlSj;TP$QzMY&aYge(}=NAJ(}fB7ZQ;jQ@R
z$|k=>!WC}3g?$;P-st<<RF{-tj$y^h%C_`5#2X0N>1lOa7#K07aVh%M?BeqH{G>AY
z@#h5L!KKo*&>rvQDu)Sn?4WrugMBB(+`W$jWvlYL$9?*m%8|^sF^kPS2JkgTKTmw>
zd9o4E`du3uM10ywAgTKGL4TtuZ;Nn&AdSjk?@K??_e@Vy<^G^%Z+|;!R}~{YS8SFM
zT~*~fi8l-(wUtmmQFJ=guM-%z#>R%nHm0n8b(BmNgYHBo3-1Las41>nNP+L_9*D5~
zq~efG=3Wr9XZ)P4*)t;KP|5Ams09H!yi(SxjD#)aHQuDP&}m9at0AeX-)ZhxVIk?L
zhgxWHAD<4zvaL}Hc0Xb@)snn{yOf=Zhhu^f>fhD6b5!IrEOq9_b$&*Ba6{s&*;0XV
znU#)`2Qjl*V}C%cmaRu_s!{gn&_Jcxq^JW9b?Nb92WwflSm-XUy&UHXk!ksOXi3xY
z1qoSg-lR)P9`wkN7wyb9Sgz)zHET`X{`<*oHr);!VAY1@EH!F4?@LdbWL4H<h%HOp
zx?wSSip>`QO4b#$24$!@P*|Rs`QC7*>2~q{RrEdENPja!r<QD#>?ls+)25j!ELB+C
z?=qys@7FE4i<3|(tf!fc6Vo_3j*13V3&o!o9iQ=i8;_vd+4*n}oy^k8BcAJb?l={H
ztMb0_IbZBb$zg4b{!wsXLQM_&c-pdf!H+WnDy}Y)O?=7_{JkRH%w6q1y`*-%FKh9>
zXvsvHnLbbA$OCDVr7h3PO+icpNl6e*!YsoX`h+PHar|QFz6@Nx=65uE64?l#_nVf)
zk^86j?+3E?s&I+3y5<UgG;cl7Dsp#s%w7@W_BfeD(X;nF`GG0_Q$Q`tzSB?G^@ohk
zMuhff#uP24c41Bb+Jv6x_mZJ*p+1ZUp^hVICbeCNs=Tqztb<I7O?SNP-NHn{xR%wd
zH-GwTi<X<BHdn@bHYOl*&pE;zUVf?Iao)$SS>GY%dH<ov66axDv?1=}9eODDV%SW|
z0ezOr%&2>R+l%}gK&LPk40{pwxraFKaCxa@MIWLM)yqUBH@)DZ2Nv$yc1Y3Kt}X{$
zyyL~aS1po?{FF$M81~BfB-QM=pjcndW&2aLUC3#k+#+Lv*Adg^v>@a_oWsaFW%Y+{
zQ?K#2?H4$(k|x=PK3($|Js26sYx&lPCTbT3ZeG~M1SC|B4caj?HH4h<wtfV!I6hLQ
zU~v~W7O{38^4KSG@;zP3duAx=C`{K7t~(BuO>C=h&TKn=H)GxU#3bo91{xh_Q}Y;R
zUMQjl0G&2iRYcyQdAL@0M{l~)exgzdt>;LMT~bxSmDyZ*ak*UEkty1Bc_jLv?XV)V
zWxDZ!m;2-$?|aB65R>=Vjq1;f#z_QPDIN-B7ZV<@>JT@zGF9zMR*Olb&bZ$l-{F1s
zV6bv!Y_ro`uJvP5+oxX)4fTf2yfHFV<4*mkh!}I~_&9SO2`{gs@smh%yqldn+vicO
zpK1KgSRd1O8<#R0XJEWtaL6P-U$q%)TM}3{{noFyBPCT@+s~nN5MTOTI9Iv>0_50i
zI;b^brmS+HH;)v>`QBEFnDRSrtKrJreRNsrq{dUfnDW{!Q@Qic#uuv-S<yWn6xu`H
zH#@X$ZB156XoKM<iHsdAka!u@N?U;_(Js=Bs>8&^7ATCe>-cC>#jDdpLt65y+g$^4
zUrB2Lk{NLSNAduJ#+~IM0f$pw{F$6;mygiHTloPbDFPqU(h0{ZwDq~d>MwdT&I#og
zG;&IvF5pT;-A**5v1aid$0{R^{Y?5dRs?v($Ao&80^7#oKjqC&L$3VWaF-I7NQ%0z
zUOQq2Vr7_WLf>>pT^vA&O1XT@?aJMLa8}S&*RfA>YPbCCFl_%slFY>`gS>P1&Nk%|
zClEHr$ighuV>E7|L?avQ<90SXUOk9ah`p=WX)Ms<_PA(`f`B}C?i}r^z*}p2Tzx=L
zs-XOS$ZpL`kt*8wBifGTurbEg@JIW{_%Z{jt~iTYv8<a)Nn2Gno=A}OHe8w|6Q1$Z
zN;MuPy6mq26ig<&N=oL%du2YaR5oUDpJOyCW#$%O0zoz`?y6CkF$1C7k=db?ZD|(R
zY3K^-=~Q-l;F)*Lg9q%qF(+wh#Lk)}=#>|D-Di(w<`mJ{jOK#5!tYIrBp*U`(l?LX
z?l5GC2#mP=b~cH8NUP(I(BISB=W1(8d?M#@$oV#ED@SOAu0)<4$&^#0fWZ}raBrn%
zHctwfa;Cnu^>99q$<e|mNYlP`t;R`(g&YZ)fq%8ec7G|DxI+xScS02KW66cPAbT(B
zKU|Lf=y108VqBf*3!(>q?(4Ma7q~-?tEhd0?@lQz!K1iB^Pt(K=jssUK!!SX#Me)y
zV=cRpe#WoOCno|*c-_)dO%=*N+BooCdgL|Hl4@6bEWPfetNUe{{VMDzBFF~8NSMmO
zAdI=)EFm7iwueiB$6Vv)iiU=)@?gEKlTqQ<X}RY(C`^@VKhycysLZ-uWe2NzUMTqI
zD(lB5yT@_e71{k$#;)Ud8xN^^2-c@<Y>L*?-{LFi-_O@k=<oRQJuc@@UmdqVi0@dV
ziSkP@0TJ%+b<++Z$kC$Bspcwp8bi5U)|B!JFQonOvWYW&qt9=W<c*s;L-qDHV~G@<
zX(Zjo^vgd#*PE@0UYoMyxP1yzpWfMd>(`>u^|3RZq0#bv2e(GP7b0c4Qak+_g7tgd
zgd+CM=gmACcFOM$@}IjX;roPj2r7Liw~W$PQt*jAD8_(Rv{=~7*fV|GgBZ^=Mu?Of
ztr#oKgx4y+yhRf)Xcp4f$h0>B5h&ZH{IJL1yT19;n(SiM>*|+R5I*+!>M|r~ci%Q|
z4q!=jd9JOjxCj##bbc;35<LG>dav@Za&)!n-PYC*j|rajp7ysQF1uX{Qdajyy!#v6
z^L~5wz}rY0S5sY>428@P@#L*7I$o^=sc&NKtD9>~3oqql`XWwZl{|U9RT4_?!1Du1
zZi{!kOGaf>4sBtv;tvsdC1v-0&wnu?*lQagzD8SsDHz$|(b(Z|XZA~xwhi_DjOX>E
z+{p!==RyOR)|wiZ5K5}JFR!_WluGU{naii(K|m0(crQZ-LyKB0h)7g1+LUEXwnp%{
zqoyISnn1SBY_pRssSKhMs#%7*7jKgGhmY9p0#oSKg#0pYTW$@=trsi%4fWKsN2d8V
zg&t<?-Rm(dV|bH>F{`7eqit%mxa&YrvD)~sA$#R%v%5WI5Y}Dt{In-y0S7h;3Z5kQ
zT_S(obL0=7RWK7AL@6cz>aX{5(3dIub<~S*aF%3+L3Zn#9+y1Kl~Ki)p<e!s|D`rB
zuk!AcQQ-m^0LIfQhjSs?u?KxbgCZ?&G3EfP<AE4)mQir+t5Uyt#M**gPM6qrBRb}%
zYd-yHYjz7v_UAixey*PKO>K3av3~qCIgaqGe@^klsr7N{!PaQW)=Ds!cUMeI=cNtu
z#Y!YlQQ>SfmMvrYA?C5~j3+5X*upV5D2O5F*GyF>Yf36tu~sQQQM84QF&F%-^?W^F
zqxwk_L{c|x=#gu(hm$TVuoupSVyQ`7zno+iaD6o3TfjQ$D*o8ROUom<UK39Y+h0Yr
Id<+BlKd?cR?*IS*

literal 0
HcmV?d00001

diff --git a/src/logic/scripting/lua/libblock.cpp b/src/logic/scripting/lua/libblock.cpp
index 22e76b84..680ace15 100644
--- a/src/logic/scripting/lua/libblock.cpp
+++ b/src/logic/scripting/lua/libblock.cpp
@@ -152,12 +152,7 @@ int l_set_block_rotation(lua_State* L) {
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
     lua_Integer value = lua_tointeger(L, 4);
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    if (vox == nullptr) {
-        return 0;
-    }
-    vox->state.rotation = value;
-    scripting::level->chunks->getChunkByVoxel(x, y, z)->setModifiedAndUnsaved();
+    scripting::level->chunks->setRotation(x, y, z, value);
     return 0;
 }
 
diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp
index 9c09de7d..61c70058 100644
--- a/src/voxels/Chunks.cpp
+++ b/src/voxels/Chunks.cpp
@@ -200,6 +200,10 @@ void Chunks::eraseSegments(const Block* def, blockstate state, int x, int y, int
     }
 }
 
+static constexpr uint8_t segment_to_int(int sx, int sy, int sz) {
+    return ((sx > 0) | ((sy > 0) << 1) | ((sz > 0) << 2));
+}
+
 void Chunks::repairSegments(const Block* def, blockstate state, int x, int y, int z) {
     const auto& rotation = def->rotations.variants[state.rotation];
     const auto id = def->rt.id;
@@ -211,7 +215,7 @@ void Chunks::repairSegments(const Block* def, blockstate state, int x, int y, in
                     continue;
                 }
                 blockstate segState = state;
-                segState.segment = ((sx > 0) | ((sy > 0) << 1) | ((sz > 0) << 2));
+                segState.segment = segment_to_int(sx, sy, sz);
 
                 glm::ivec3 pos(x, y, z);
                 pos += rotation.axisX * sx;
@@ -223,14 +227,14 @@ void Chunks::repairSegments(const Block* def, blockstate state, int x, int y, in
     }
 }
 
-bool Chunks::checkReplaceability(const Block* def, blockstate state, glm::ivec3 origin) {
+bool Chunks::checkReplaceability(const Block* def, blockstate state, glm::ivec3 origin, blockid_t ignore) {
     const auto& rotation = def->rotations.variants[state.rotation];
     const auto size = def->size;
     for (int sy = 0; sy < size.y; sy++) {
         for (int sz = 0; sz < size.z; sz++) {
             for (int sx = 0; sx < size.x; sx++) {
                 blockstate segState = state;
-                segState.segment = ((sx > 0) | ((sy > 0) << 1) | ((sz > 0) << 2));
+                segState.segment = segment_to_int(sx, sy, sz);
 
                 auto pos = origin;
                 pos += rotation.axisX * sx;
@@ -238,7 +242,7 @@ bool Chunks::checkReplaceability(const Block* def, blockstate state, glm::ivec3
                 pos += rotation.axisZ * sz;
                 if (auto vox = get(pos.x, pos.y, pos.z)) {
                     auto target = indices->getBlockDef(vox->id);
-                    if (!target->replaceable) {
+                    if (!target->replaceable && vox->id != ignore) {
                         return false;
                     }
                 } else {
@@ -250,6 +254,82 @@ bool Chunks::checkReplaceability(const Block* def, blockstate state, glm::ivec3
     return true;
 }
 
+void Chunks::setRotationExtended(
+    Block* def, blockstate state, glm::ivec3 origin, uint8_t index
+) {
+    auto newstate = state;
+    newstate.rotation = index;
+    
+    // unable to rotate block (cause: obstacles)
+    if (!checkReplaceability(def, newstate, origin, def->rt.id)) {
+        return;
+    }
+
+    const auto& rotation = def->rotations.variants[index];
+    const auto size = def->size;
+    std::vector<glm::ivec3> segmentBlocks;
+
+    for (int sy = 0; sy < size.y; sy++) {
+        for (int sz = 0; sz < size.z; sz++) {
+            for (int sx = 0; sx < size.x; sx++) {
+                auto pos = origin;
+                pos += rotation.axisX * sx;
+                pos += rotation.axisY * sy;
+                pos += rotation.axisZ * sz;
+
+                blockstate segState = newstate;
+                segState.segment = segment_to_int(sx, sy, sz);
+                
+                auto vox = get(pos);
+                // checked for nullptr by checkReplaceability
+                if (vox->id != def->rt.id) {
+                    set(pos.x, pos.y, pos.z, def->rt.id, segState);
+                } else {
+                    vox->state = segState;
+                    auto chunk = getChunkByVoxel(pos.x, pos.y, pos.z);
+                    chunk->setModifiedAndUnsaved();
+                    segmentBlocks.emplace_back(pos);
+                }
+            }
+        }
+    }
+    const auto& prevRotation = def->rotations.variants[state.rotation];
+    for (int sy = 0; sy < size.y; sy++) {
+        for (int sz = 0; sz < size.z; sz++) {
+            for (int sx = 0; sx < size.x; sx++) {
+                auto pos = origin;
+                pos += prevRotation.axisX * sx;
+                pos += prevRotation.axisY * sy;
+                pos += prevRotation.axisZ * sz;
+                if (std::find(segmentBlocks.begin(), segmentBlocks.end(), pos) == segmentBlocks.end()) {
+                    set(pos.x, pos.y, pos.z, 0, {});
+                }
+            }
+        }
+    }
+}
+
+void Chunks::setRotation(int32_t x, int32_t y, int32_t z, uint8_t index) {
+    if (index >= BlockRotProfile::MAX_COUNT) {
+        return;
+    }
+    auto vox = get(x, y, z);
+    if (vox == nullptr) {
+        return;
+    }
+    auto def = indices->getBlockDef(vox->id);
+    if (!def->rotatable || vox->state.rotation == index) {
+        return;
+    }
+    if (def->rt.extended) {
+        setRotationExtended(def, vox->state, {x, y, z}, index);
+    } else {
+        vox->state.rotation = index;
+        auto chunk = getChunkByVoxel(x, y, z);
+        chunk->setModifiedAndUnsaved();   
+    }
+}
+
 void Chunks::set(int32_t x, int32_t y, int32_t z, uint32_t id, blockstate state) {
     if (y < 0 || y >= CHUNK_H) {
         return;
diff --git a/src/voxels/Chunks.hpp b/src/voxels/Chunks.hpp
index fc2438c9..54b20b29 100644
--- a/src/voxels/Chunks.hpp
+++ b/src/voxels/Chunks.hpp
@@ -25,6 +25,7 @@ class Chunks {
 
     void eraseSegments(const Block* def, blockstate state, int x, int y, int z);
     void repairSegments(const Block* def, blockstate state, int x, int y, int z);
+    void setRotationExtended(Block* def, blockstate state, glm::ivec3 origin, uint8_t rotation);
 public:
     std::vector<std::shared_ptr<Chunk>> chunks;
     std::vector<std::shared_ptr<Chunk>> chunksSecond;
@@ -40,7 +41,7 @@ public:
            WorldFiles* worldFiles, LevelEvents* events, const Content* content);
     ~Chunks() = default;
 
-    bool checkReplaceability(const Block* def, blockstate state, glm::ivec3 coord);
+    bool checkReplaceability(const Block* def, blockstate state, glm::ivec3 coord, blockid_t ignore=0);
     bool putChunk(const std::shared_ptr<Chunk>& chunk);
 
     Chunk* getChunk(int32_t x, int32_t z);
@@ -55,6 +56,7 @@ public:
     ubyte getLight(int32_t x, int32_t y, int32_t z, int channel);
     void set(int32_t x, int32_t y, int32_t z, uint32_t id, blockstate state);
     glm::ivec3 seekOrigin(glm::ivec3 pos, const Block* def, blockstate state);
+    void setRotation(int32_t x, int32_t y, int32_t z, uint8_t rotation);
 
     voxel* rayCast(
         glm::vec3 start, 

From 1abb2cf327b6f39758096a342a9308b3d1789ba1 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sun, 9 Jun 2024 23:36:19 +0300
Subject: [PATCH 12/16] add block.is_extended, .get_size, .is_segment and
 .seek_origin

---
 src/logic/scripting/lua/libblock.cpp | 143 +++++++++++++++++----------
 src/logic/scripting/lua/lua_util.hpp |   7 ++
 2 files changed, 98 insertions(+), 52 deletions(-)

diff --git a/src/logic/scripting/lua/libblock.cpp b/src/logic/scripting/lua/libblock.cpp
index 680ace15..8bdafb22 100644
--- a/src/logic/scripting/lua/libblock.cpp
+++ b/src/logic/scripting/lua/libblock.cpp
@@ -13,29 +13,32 @@
 #include "../../../content/Content.hpp"
 #include "../../../logic/BlocksController.hpp"
 
-int l_block_name(lua_State* L) {
+static Block* require_block(lua_State* L) {
     auto indices = scripting::content->getIndices();
     lua_Integer id = lua_tointeger(L, 1);
     if (static_cast<size_t>(id) >= indices->countBlockDefs()) {
-        return 0;
+        return nullptr;
     }
-    auto def = indices->getBlockDef(id);
-    lua_pushstring(L, def->name.c_str());
-    return 1;
+    return indices->getBlockDef(id);
 }
 
-int l_block_material(lua_State* L) {
-    auto indices = scripting::content->getIndices();
-    lua_Integer id = lua_tointeger(L, 1);
-    if (static_cast<size_t>(id) >= indices->countBlockDefs()) {
-        return 0;
+static int l_name(lua_State* L) {
+    if (auto def = require_block(L)) {
+        lua_pushstring(L, def->name.c_str());
+        return 1;
     }
-    auto def = indices->getBlockDef(id);
-    lua_pushstring(L, def->material.c_str());
-    return 1;
+    return 0;
 }
 
-int l_is_solid_at(lua_State* L) {
+static int l_material(lua_State* L) {
+    if (auto def = require_block(L)) {
+        lua_pushstring(L, def->material.c_str());
+        return 1;
+    }
+    return 0;
+}
+
+static int l_is_solid_at(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -44,18 +47,53 @@ int l_is_solid_at(lua_State* L) {
     return 1;
 }
 
-int l_blocks_count(lua_State* L) {
+static int l_count(lua_State* L) {
     lua_pushinteger(L, scripting::indices->countBlockDefs());
     return 1;
 }
 
-int l_block_index(lua_State* L) {
+static int l_index(lua_State* L) {
     std::string name = lua_tostring(L, 1);
     lua_pushinteger(L, scripting::content->requireBlock(name).rt.id);
     return 1;
 }
 
-int l_set_block(lua_State* L) {
+static int l_is_extended(lua_State* L) {
+    if (auto def = require_block(L)) {
+        lua_pushboolean(L, def->rt.extended);
+        return 1;
+    }
+    return 0;
+}
+
+static int l_get_size(lua_State* L) {
+    if (auto def = require_block(L)) {
+        return lua::pushivec3(L, def->size.x, def->size.y, def->size.z);
+    }
+    return 0;
+}
+
+static int l_is_segment(lua_State* L) {
+    lua_Integer x = lua_tointeger(L, 1);
+    lua_Integer y = lua_tointeger(L, 2);
+    lua_Integer z = lua_tointeger(L, 3);
+    auto vox = scripting::level->chunks->get(x, y, z);
+
+    lua_pushboolean(L, vox->state.segment);
+    return 1;
+}
+
+static int l_seek_origin(lua_State* L) {
+    lua_Integer x = lua_tointeger(L, 1);
+    lua_Integer y = lua_tointeger(L, 2);
+    lua_Integer z = lua_tointeger(L, 3);
+    auto vox = scripting::level->chunks->get(x, y, z);
+    auto def = scripting::indices->getBlockDef(vox->id);
+
+    return lua::pushivec3(L, scripting::level->chunks->seekOrigin({x, y, z}, def, vox->state));
+}
+
+static int l_set(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -76,7 +114,7 @@ int l_set_block(lua_State* L) {
     return 0;
 }
 
-int l_get_block(lua_State* L) {
+static int l_get(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -86,7 +124,7 @@ int l_get_block(lua_State* L) {
     return 1;
 }
 
-int l_get_block_x(lua_State* L) {
+static int l_get_x(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -103,7 +141,7 @@ int l_get_block_x(lua_State* L) {
     }
 }
 
-int l_get_block_y(lua_State* L) {
+static int l_get_y(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -120,7 +158,7 @@ int l_get_block_y(lua_State* L) {
     }
 }
 
-int l_get_block_z(lua_State* L) {
+static int l_get_z(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -137,7 +175,7 @@ int l_get_block_z(lua_State* L) {
     }
 }
 
-int l_get_block_rotation(lua_State* L) {
+static int l_get_rotation(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -147,7 +185,7 @@ int l_get_block_rotation(lua_State* L) {
     return 1;
 }
 
-int l_set_block_rotation(lua_State* L) {
+static int l_set_rotation(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -156,7 +194,7 @@ int l_set_block_rotation(lua_State* L) {
     return 0;
 }
 
-int l_get_block_states(lua_State* L) {
+static int l_get_states(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -166,7 +204,7 @@ int l_get_block_states(lua_State* L) {
     return 1;
 }
 
-int l_set_block_states(lua_State* L) {
+static int l_set_states(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -182,7 +220,7 @@ int l_set_block_states(lua_State* L) {
     return 0;
 }
 
-int l_get_block_user_bits(lua_State* L) {
+static int l_get_user_bits(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -200,7 +238,7 @@ int l_get_block_user_bits(lua_State* L) {
     return 1;
 }
 
-int l_set_block_user_bits(lua_State* L) {
+static int l_set_user_bits(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -223,7 +261,7 @@ int l_set_block_user_bits(lua_State* L) {
     return 0; 
 }
 
-int l_is_replaceable_at(lua_State* L) {
+static int l_is_replaceable_at(lua_State* L) {
     lua_Integer x = lua_tointeger(L, 1);
     lua_Integer y = lua_tointeger(L, 2);
     lua_Integer z = lua_tointeger(L, 3);
@@ -232,35 +270,36 @@ int l_is_replaceable_at(lua_State* L) {
     return 1;
 }
 
-int l_block_caption(lua_State* L) {
-    auto indices = scripting::content->getIndices();
-    lua_Integer id = lua_tointeger(L, 1);
-    if (static_cast<size_t>(id) >= indices->countBlockDefs()) {
-        return 0;
+static int l_caption(lua_State* L) {
+    if (auto def = require_block(L)) {
+        lua_pushstring(L, def->caption.c_str());
+        return 1;
     }
-    auto def = indices->getBlockDef(id);
-    lua_pushstring(L, def->caption.c_str());
-    return 1;
+    return 0;
 }
 
 const luaL_Reg blocklib [] = {
-    {"index", lua_wrap_errors<l_block_index>},
-    {"name", lua_wrap_errors<l_block_name>},
-    {"material", lua_wrap_errors<l_block_material>},
-    {"caption", lua_wrap_errors<l_block_caption>},
-    {"defs_count", lua_wrap_errors<l_blocks_count>},
+    {"index", lua_wrap_errors<l_index>},
+    {"name", lua_wrap_errors<l_name>},
+    {"material", lua_wrap_errors<l_material>},
+    {"caption", lua_wrap_errors<l_caption>},
+    {"defs_count", lua_wrap_errors<l_count>},
     {"is_solid_at", lua_wrap_errors<l_is_solid_at>},
     {"is_replaceable_at", lua_wrap_errors<l_is_replaceable_at>},
-    {"set", lua_wrap_errors<l_set_block>},
-    {"get", lua_wrap_errors<l_get_block>},
-    {"get_X", lua_wrap_errors<l_get_block_x>},
-    {"get_Y", lua_wrap_errors<l_get_block_y>},
-    {"get_Z", lua_wrap_errors<l_get_block_z>},
-    {"get_states", lua_wrap_errors<l_get_block_states>},
-    {"set_states", lua_wrap_errors<l_set_block_states>},
-    {"get_rotation", lua_wrap_errors<l_get_block_rotation>},
-    {"set_rotation", lua_wrap_errors<l_set_block_rotation>},
-    {"get_user_bits", lua_wrap_errors<l_get_block_user_bits>},
-    {"set_user_bits", lua_wrap_errors<l_set_block_user_bits>},
+    {"set", lua_wrap_errors<l_set>},
+    {"get", lua_wrap_errors<l_get>},
+    {"get_X", lua_wrap_errors<l_get_x>},
+    {"get_Y", lua_wrap_errors<l_get_y>},
+    {"get_Z", lua_wrap_errors<l_get_z>},
+    {"get_states", lua_wrap_errors<l_get_states>},
+    {"set_states", lua_wrap_errors<l_set_states>},
+    {"get_rotation", lua_wrap_errors<l_get_rotation>},
+    {"set_rotation", lua_wrap_errors<l_set_rotation>},
+    {"get_user_bits", lua_wrap_errors<l_get_user_bits>},
+    {"set_user_bits", lua_wrap_errors<l_set_user_bits>},
+    {"is_extended", lua_wrap_errors<l_is_extended>},
+    {"get_size", lua_wrap_errors<l_get_size>},
+    {"is_segment", lua_wrap_errors<l_is_segment>},
+    {"seek_origin", lua_wrap_errors<l_seek_origin>},
     {NULL, NULL}
 };
diff --git a/src/logic/scripting/lua/lua_util.hpp b/src/logic/scripting/lua/lua_util.hpp
index 0c4de9f3..799bd3d4 100644
--- a/src/logic/scripting/lua/lua_util.hpp
+++ b/src/logic/scripting/lua/lua_util.hpp
@@ -21,6 +21,13 @@ namespace lua {
         return 3;
     }
 
+    inline int pushivec3(lua_State* L, glm::ivec3 vec) {
+        lua_pushinteger(L, vec.x);
+        lua_pushinteger(L, vec.y);
+        lua_pushinteger(L, vec.z);
+        return 3;
+    }
+
     inline int pushvec3(lua_State* L, glm::vec3 vec) {
         lua_pushnumber(L, vec.x);
         lua_pushnumber(L, vec.y);

From 1bfd5ccad38c3801ca417e4f041fdb9de7ae657d Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Sun, 9 Jun 2024 23:59:04 +0300
Subject: [PATCH 13/16] fix: air blocks placement; ghost segments can not be
 removed

---
 src/logic/PlayerController.cpp | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/logic/PlayerController.cpp b/src/logic/PlayerController.cpp
index f63670f1..c2614531 100644
--- a/src/logic/PlayerController.cpp
+++ b/src/logic/PlayerController.cpp
@@ -352,11 +352,17 @@ voxel* PlayerController::updateSelection(float maxDistance) {
     selection.vox = *vox;
     selection.actualPosition = iend;
     if (selectedState.segment) {
-        iend = chunks->seekOrigin(
+        selection.position = chunks->seekOrigin(
             iend, indices->getBlockDef(selection.vox.id), selectedState
         );
+        auto origin = chunks->get(iend);
+        if (origin && origin->id != vox->id) {
+            chunks->set(iend.x, iend.y, iend.z, 0, {});
+            return updateSelection(maxDistance);
+        }
+    } else {
+        selection.position = iend;
     }
-    selection.position = iend;
     selection.hitPosition = end;
     selection.normal = norm;
     return vox;
@@ -398,7 +404,7 @@ void PlayerController::processRightClick(Block* def, Block* target) {
     if (def->grounded && !chunks->isSolidBlock(coord.x, coord.y-1, coord.z)) {
         return;
     }
-    if (chosenBlock != vox->id) {
+    if (chosenBlock != vox->id && chosenBlock) {
         onBlockInteraction(coord, def, BlockInteraction::placing);
         chunks->set(coord.x, coord.y, coord.z, chosenBlock, state);
         lighting->onBlockSet(coord.x, coord.y, coord.z, chosenBlock);

From 2dfd2abc40e5a94b65ba66d9732888039303fc04 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Mon, 10 Jun 2024 02:00:41 +0300
Subject: [PATCH 14/16] docs: Chunks.seekOrigin, Chunks.checkReplaceability

---
 src/voxels/Chunks.cpp |  3 ++-
 src/voxels/Chunks.hpp | 15 ++++++++++++++-
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp
index 61c70058..413cab85 100644
--- a/src/voxels/Chunks.cpp
+++ b/src/voxels/Chunks.cpp
@@ -158,8 +158,9 @@ Chunk* Chunks::getChunkByVoxel(int32_t x, int32_t y, int32_t z) {
 Chunk* Chunks::getChunk(int x, int z){
     x -= ox;
     z -= oz;
-    if (x < 0 || z < 0 || x >= int(w) || z >= int(d))
+    if (x < 0 || z < 0 || x >= static_cast<int>(w) || z >= static_cast<int>(d)) {
         return nullptr;
+    }
     return chunks[z * w + x].get();
 }
 
diff --git a/src/voxels/Chunks.hpp b/src/voxels/Chunks.hpp
index 54b20b29..fb8185d4 100644
--- a/src/voxels/Chunks.hpp
+++ b/src/voxels/Chunks.hpp
@@ -41,7 +41,6 @@ public:
            WorldFiles* worldFiles, LevelEvents* events, const Content* content);
     ~Chunks() = default;
 
-    bool checkReplaceability(const Block* def, blockstate state, glm::ivec3 coord, blockid_t ignore=0);
     bool putChunk(const std::shared_ptr<Chunk>& chunk);
 
     Chunk* getChunk(int32_t x, int32_t z);
@@ -55,7 +54,21 @@ public:
     light_t getLight(int32_t x, int32_t y, int32_t z);
     ubyte getLight(int32_t x, int32_t y, int32_t z, int channel);
     void set(int32_t x, int32_t y, int32_t z, uint32_t id, blockstate state);
+
+    /// @brief Seek for the extended block origin position
+    /// @param pos segment block position
+    /// @param def segment block definition
+    /// @param state segment block state
+    /// @return origin block position or `pos` if block is not extended
     glm::ivec3 seekOrigin(glm::ivec3 pos, const Block* def, blockstate state);
+
+    /// @brief Check if required zone is replaceable
+    /// @param def definition of the block that requires a replaceable zone
+    /// @param state the block state
+    /// @param coord position of the zone start
+    /// @param ignore ignored block id (will be counted as replaceable)
+    bool checkReplaceability(const Block* def, blockstate state, glm::ivec3 coord, blockid_t ignore=0);
+
     void setRotation(int32_t x, int32_t y, int32_t z, uint8_t rotation);
 
     voxel* rayCast(

From aadf2386ebe79f629886a539c33398bc2774f74d Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Mon, 10 Jun 2024 11:24:53 +0300
Subject: [PATCH 15/16] fix:  door aabb

---
 res/content/base/blocks/door.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/res/content/base/blocks/door.json b/res/content/base/blocks/door.json
index fd134355..0a300061 100644
--- a/res/content/base/blocks/door.json
+++ b/res/content/base/blocks/door.json
@@ -13,5 +13,5 @@
     "size": [1, 2, 1],
     "rotation": "pane",
     "model": "aabb",
-    "hitbox": [0.0, 0.0, 0.0, 1.0, 2.0, 0.2]
+    "hitbox": [0.0, 0.0, 0.8, 1.0, 2.0, 0.2]
 }

From 26a0dc5f43cb3c8b3d16511aaec5d4afda8a0118 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Mon, 10 Jun 2024 17:48:04 +0300
Subject: [PATCH 16/16] door replaced with wooden_door (id rename)

---
 .../base/blocks/{door.json => wooden_door.json}     |  12 ++++++------
 res/content/base/content.json                       |   8 ++++----
 .../base/scripts/{door.lua => wooden_door.lua}      |   0
 .../textures/blocks/{door.png => wooden_door.png}   | Bin
 .../blocks/{door_side.png => wooden_door_side.png}  | Bin
 .../blocks/{door_top.png => wooden_door_top.png}    | Bin
 6 files changed, 10 insertions(+), 10 deletions(-)
 rename res/content/base/blocks/{door.json => wooden_door.json} (60%)
 rename res/content/base/scripts/{door.lua => wooden_door.lua} (100%)
 rename res/content/base/textures/blocks/{door.png => wooden_door.png} (100%)
 rename res/content/base/textures/blocks/{door_side.png => wooden_door_side.png} (100%)
 rename res/content/base/textures/blocks/{door_top.png => wooden_door_top.png} (100%)

diff --git a/res/content/base/blocks/door.json b/res/content/base/blocks/wooden_door.json
similarity index 60%
rename from res/content/base/blocks/door.json
rename to res/content/base/blocks/wooden_door.json
index 0a300061..9a1eb666 100644
--- a/res/content/base/blocks/door.json
+++ b/res/content/base/blocks/wooden_door.json
@@ -1,12 +1,12 @@
 {
     "material": "base:wood",
     "texture-faces": [
-        "door_side",
-        "door_side",
-        "door_top",
-        "door_top",
-        "door",
-        "door"
+        "wooden_door_side",
+        "wooden_door_side",
+        "wooden_door_top",
+        "wooden_door_top",
+        "wooden_door",
+        "wooden_door"
     ],
     "light-passing": true,
     "sky-light-passing": true,
diff --git a/res/content/base/content.json b/res/content/base/content.json
index 09fc42f1..0e6dc07f 100644
--- a/res/content/base/content.json
+++ b/res/content/base/content.json
@@ -1,4 +1,7 @@
 {
+  "items": [
+    "bazalt_breaker"
+  ],
   "blocks": [
     "dirt",
     "grass_block",
@@ -23,9 +26,6 @@
     "pipe",
     "lightbulb",
     "torch",
-    "door"
-  ],
-  "items": [
-    "bazalt_breaker"
+    "wooden_door"
   ]
 }
\ No newline at end of file
diff --git a/res/content/base/scripts/door.lua b/res/content/base/scripts/wooden_door.lua
similarity index 100%
rename from res/content/base/scripts/door.lua
rename to res/content/base/scripts/wooden_door.lua
diff --git a/res/content/base/textures/blocks/door.png b/res/content/base/textures/blocks/wooden_door.png
similarity index 100%
rename from res/content/base/textures/blocks/door.png
rename to res/content/base/textures/blocks/wooden_door.png
diff --git a/res/content/base/textures/blocks/door_side.png b/res/content/base/textures/blocks/wooden_door_side.png
similarity index 100%
rename from res/content/base/textures/blocks/door_side.png
rename to res/content/base/textures/blocks/wooden_door_side.png
diff --git a/res/content/base/textures/blocks/door_top.png b/res/content/base/textures/blocks/wooden_door_top.png
similarity index 100%
rename from res/content/base/textures/blocks/door_top.png
rename to res/content/base/textures/blocks/wooden_door_top.png