diff --git a/src/nyqubel-client/client.cpp b/src/nyqubel-client/client.cpp
index fd41db448..4fbeaa571 100644
--- a/src/nyqubel-client/client.cpp
+++ b/src/nyqubel-client/client.cpp
@@ -49,6 +49,8 @@
 
 #include "Root.h"
 #include "ChatColor.h"
+#include "ChunkDef.h"
+#include "BlockType.h"
 
 namespace x11 {
 
@@ -211,14 +213,6 @@ public:
 
 namespace qubel {
 
-enum VoxelTypes {
-    kAir,
-    kStone,
-    kDirt,
-    kSand,
-    kGrass
-};
-
 enum CardinalDirections {
     kNorth,
     kSouth,
@@ -228,274 +222,272 @@ enum CardinalDirections {
     kDown*/
 };
 
-class Chunk {
+class FalseChunk {
 public:
     // "typedefs" or templates go here lol
-    static constexpr uint _dim_length = 2; // its in 2d!
-    static constexpr uint _size_in_power = 16; // 8x8 size
-    static constexpr std::size_t _chunk_array_size = _size_in_power * _size_in_power;
+    static constexpr std::size_t _chunk_array_size = cChunkDef::Width * cChunkDef::Width;
 
     using BlockType = uint8_t;
     // Using a single digit to locate the exact voxel's byte in the chunk, for very fast use.
     using ChunkDataType = std::array<uint8_t, _chunk_array_size>;
     using ChunkVecType = geo::internal::BVec2<uint8_t>;
     ChunkDataType raw_chunk_data = {
-        kStone,
-        kStone,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kStone,
-        kStone,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kGrass,
-        kGrass,
-        kGrass,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kGrass,
-        kDirt,
-        kDirt,
-        kDirt,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kGrass,
-        kGrass,
-        kDirt,
-        kDirt,
-        kDirt,
-        kDirt,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kSand,
-        kSand,
-        kDirt,
-        kDirt,
-        kDirt,
-        kStone,
-        kStone,
-        kStone,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kSand,
-        kSand,
-        kDirt,
-        kDirt,
-        kStone,
-        kStone,
-        kStone,
-        kStone,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kAir,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kAir,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kAir,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kAir,
-        kSand,
-        kAir,
-        kSand,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kSand,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kSand,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kAir,
-        kStone,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
+        ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
+        ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
+        ENUM_BLOCK_TYPE::E_BLOCK_GRASS,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_DIRT,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_PLANKS,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_AIR,
+        ENUM_BLOCK_TYPE::E_BLOCK_STONE,
     };
     class LocalVoxel {
     public:
@@ -503,23 +495,23 @@ public:
         // LocalVoxel(geo::internal::BVec2<uint8_t> raw_chunk_pos)
         //: pos(raw_chunk_pos) { }
         static LocalVoxel GetVoxelFromPosInChunk(geo::internal::BVec2<uint8_t> in_pos) { // basicly your 2d/3d position to a index, make sure ur in the chunk! lol
-            assert(in_pos.x < _size_in_power && in_pos.y < _size_in_power);
+            assert(in_pos.x < cChunkDef::Width && in_pos.y < cChunkDef::Width);
             LocalVoxel index;
             index.pos = 0;
             return index.AddPos(in_pos);
         }
         LocalVoxel& AddPos(geo::internal::BVec2<uint8_t> in_pos) {
             this->pos += in_pos.x;
-            this->pos += in_pos.y * _size_in_power;
+            this->pos += in_pos.y * cChunkDef::Width;
             // if constexpr (_dim_length >= 3) // We gotta move these to a seperate class all-together... do this once the templates are split.
-            //     index.pos += in_pos.z * (_size_in_power * _size_in_power);
+            //     index.pos += in_pos.z * (cChunkDef::Width * cChunkDef::Width);
             return *this;
         }
         ChunkVecType ExtractVec() const {
             ChunkVecType ret_pos;
-            ret_pos.x = this->pos % _size_in_power;
-            ret_pos.y = (this->pos / _size_in_power) % _size_in_power;
-            // ret_pos.z = ((this->pos / _size_in_power) / _size_in_power) % _size_in_power;
+            ret_pos.x = this->pos % cChunkDef::Width;
+            ret_pos.y = (this->pos / cChunkDef::Width) % cChunkDef::Width;
+            // ret_pos.z = ((this->pos / cChunkDef::Width) / cChunkDef::Width) % cChunkDef::Width;
             return ret_pos;
         }
         // tmp, TODO replace/add with chunk pointer or chunk x and y... both??? oof if so
@@ -610,11 +602,14 @@ public:
         glez::rgba clr;
     };
     static constexpr glez::rgba chunk_textures[] = {
-        glez::rgba(0, 0, 0, 0),
-        glez::rgba(40, 40, 40),
-        glez::rgba(120, 40, 40),
-        glez::color::yellow,
-        glez::color::green
+        glez::rgba(0, 0, 0, 0), // air
+        glez::rgba(40, 45, 45), // stone
+        glez::color::green, // grass
+        glez::rgba(22, 17, 17), // dirt
+        glez::rgba(60, 60, 60), // cobble
+        glez::rgba(120, 40, 40), // planks
+        glez::color::green, // sapling
+        glez::color::black // bedrock
     };
     std::vector<ChunkMeshedQuad> MeshChunk(MesherComplexity cmplxity) const {
         std::vector<ChunkMeshedQuad> finished_quads;
@@ -624,11 +619,11 @@ public:
         case MesherComplexity::kNieve: // I dont think this is possible in 2d for the time being...
         case MesherComplexity::kPlain: {
             std::cout << "Plain" << std::endl;
-            for (uint dim_x = 0; dim_x < _size_in_power; dim_x++) {
-                for (uint dim_y = 0; dim_y < _size_in_power; dim_y++) {
+            for (uint dim_x = 0; dim_x < cChunkDef::Width; dim_x++) {
+                for (uint dim_y = 0; dim_y < cChunkDef::Width; dim_y++) {
                     const LocalVoxel cube = GetVoxelFromPosInChunk({ dim_x, dim_y });
                     const auto type = this->GetVoxelType(cube);
-                    if (type == VoxelTypes::kAir)
+                    if (type == ENUM_BLOCK_TYPE::E_BLOCK_AIR)
                         continue;
                     ChunkMeshedQuad new_face;
                     const auto start = geo::Vec2(dim_x * box_size, dim_y * box_size);
@@ -651,8 +646,8 @@ public:
             std::cout << "Greedy" << std::endl;
             std::bitset<_chunk_array_size> chunk_finished_checksum;
             const auto FindOpenSpace = [&]() -> std::pair<std::size_t, std::optional<decltype(chunk_finished_checksum)::reference>> {
-                for (std::size_t x = 0; x < _size_in_power; x++) {
-                    for (std::size_t y = 0; y < _size_in_power; y++) {
+                for (std::size_t x = 0; x < cChunkDef::Width; x++) {
+                    for (std::size_t y = 0; y < cChunkDef::Width; y++) {
                         auto vox = this->GetVoxelFromPosInChunk({ x, y });
                         if (!chunk_finished_checksum[vox.pos])
                             return { vox.pos, chunk_finished_checksum[vox.pos] };
@@ -668,7 +663,7 @@ public:
                 LocalVoxel cube;
                 cube.pos = unmeshed_face.first;
                 const auto type = this->GetVoxelType(cube);
-                if (type == VoxelTypes::kAir) {
+                if (type == ENUM_BLOCK_TYPE::E_BLOCK_AIR) {
                     chunk_finished_checksum[cube.pos] = true;
                     continue;
                 }
@@ -682,7 +677,7 @@ public:
 
                 // Need a better "search line down" func... instead of one block we need to check multiple and return how many are the same.
                 constexpr auto south_dir_mask = AxisIterator::CreateCardinalMask(CardinalDirections::kSouth);
-                auto SearchLineSouthForSameTypes = [&](ChunkVecType src_line, std::uint8_t max_size = _size_in_power) -> std::uint8_t {
+                auto SearchLineSouthForSameTypes = [&](ChunkVecType src_line, std::uint8_t max_size = cChunkDef::Width) -> std::uint8_t {
                     std::size_t alike_counter = 0;
                     const auto end = AxisIterator::end();
                     for (auto axis_crawl = AxisIterator(src_line, south_dir_mask); axis_crawl != end; axis_crawl++) {
@@ -728,7 +723,7 @@ public:
                     //}
                     return alike_counter;
                 };
-                if (uint(src_block_loc.x + 1) < _size_in_power) { // only if we have room to check!
+                if (uint(src_block_loc.x + 1) < cChunkDef::Width) { // only if we have room to check!
                     const auto same_blocks_east_count = SearchLineEastForSameTypes();
                     block_quad_size.x = same_blocks_east_count;
                     std::cout << "  Found blocks going east: " << (int)block_quad_size.x << std::endl;
@@ -770,9 +765,9 @@ public:
         return finished_quads;
     }
     static bool IsPosValidWithinChunk(ChunkVecType voxel_loc) {
-        if (voxel_loc.x >= _size_in_power)
+        if (voxel_loc.x >= cChunkDef::Width)
             return false;
-        if (voxel_loc.y >= _size_in_power)
+        if (voxel_loc.y >= cChunkDef::Width)
             return false;
         return true;
     }
@@ -823,14 +818,14 @@ class QubelMeshingTestRenderingWindow : public CBaseWindow {
 public:
     const CTitleBar* titlebar;
     const QubelMeshingTestWindow* settings;
-    Chunk world_slice;
+    FalseChunk world_slice;
 
     class ChunkRenderer : public CBaseWidget {
     public:
         static constexpr std::pair<int, int> min_size = { 856, 480 };
-        const Chunk* world_slice;
+        const FalseChunk* world_slice;
         const QubelMeshingTestWindow* settings;
-        ChunkRenderer(IWidget* parent, QubelMeshingTestWindow* settings, Chunk* world_slice)
+        ChunkRenderer(IWidget* parent, QubelMeshingTestWindow* settings, FalseChunk* world_slice)
             : CBaseWidget("qubelmesh_test_renderer_sceneoutput", parent)
             , world_slice(world_slice)
             , settings(settings) {
@@ -840,7 +835,7 @@ public:
             });
             this->SetSize(min_size.first, min_size.second);
         }
-        std::vector<Chunk::ChunkMeshedQuad> current_render_quads;
+        std::vector<FalseChunk::ChunkMeshedQuad> current_render_quads;
         virtual void Draw(ICanvas* the_drawing_machine) override {
             this->CBaseWidget::Draw(the_drawing_machine);
             const auto ConvertGLMVecToSTDPairVec = [](const geo::Vec2& vec_in) -> std::pair<int, int> {
@@ -849,10 +844,10 @@ public:
             const auto ConvertGLMQuadToSTDPairQuad = [&](const geo::Box<geo::Vec2>& box_in) -> Canvas::TranslationMatrix {
                 return Canvas::TranslationMatrix(ConvertGLMVecToSTDPairVec(box_in.origin), ConvertGLMVecToSTDPairVec(box_in.GetSize()));
             };
-            for (const Chunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads)
+            for (const FalseChunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads)
                 the_drawing_machine->Rect(ConvertGLMQuadToSTDPairQuad(kinda_a_vert.quad), kinda_a_vert.clr);
             if (this->settings->wireframe->Value()) {
-                for (const Chunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads) {
+                for (const FalseChunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads) {
                     the_drawing_machine->Rect({ ConvertGLMQuadToSTDPairQuad(kinda_a_vert.quad) }, glez::color::black, Canvas::RectType::Outline);
                     the_drawing_machine->Line({ ConvertGLMQuadToSTDPairQuad(kinda_a_vert.quad) }, glez::color::black);
                 }
@@ -861,10 +856,10 @@ public:
         virtual void Update() override {
             this->CBaseWidget::Update();
             if (current_render_quads.empty()) {
-                current_render_quads = world_slice->MeshChunk(Chunk::MesherComplexity(settings->dropdown->Value()));
+                current_render_quads = world_slice->MeshChunk(FalseChunk::MesherComplexity(settings->dropdown->Value()));
 
                 std::pair<int, int> found_size;
-                for (const Chunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads) {
+                for (const FalseChunk::ChunkMeshedQuad& kinda_a_vert : current_render_quads) {
                     const auto max_coord = kinda_a_vert.quad.GetMax();
                     if (max_coord.x > found_size.first)
                         found_size.first = max_coord.x;