refactor: terrain generation (#9)

* feat: add BlockType * refactor: use fBM for heightmap generation * feat: improve mountain realism * refactor: adjust mountain spawn probability * feat: add biome boundary blending * refactor: remove resolve_biome_adjacency_conflict function * feat: add snowy plain * perf: speed up world generation * refactor: lower overall terrain height
2026-06-18 00:27:02 +08:00 · 2026-05-23 10:33:52 +08:00
parent 1a26474a05
commit a54e87dbc6
28 changed files with 455 additions and 155 deletions
--- a/src/gameplay/biome.cpp
+++ b/src/gameplay/biome.cpp
@@ -1,12 +1,13 @@
 #include "Cubed/gameplay/biome.hpp"

 #include "Cubed/tools/cubed_assert.hpp"
-#include "Cubed/tools/log.hpp"

 #include <unordered_map>

 namespace Cubed {

+using enum BiomeType;
+
 static PlainParams plain{{BiomeType::PLAIN,
                          {0.0f, 0.5f},
                          {0.0f, 0.5f},
@@ -59,6 +60,8 @@ std::string get_biome_str(BiomeType biome) {
    case RIVER:
        str = "River";
        break;
+    case SNOWY_PLAIN:
+        str = "Snowy Plain";
    case NONE:
        str = "Unknown";
        break;
@@ -84,27 +87,7 @@ Biome get_biome_from_noise(float temp, float humid) {
    return Biome::FOREST;
 }
 */
-BiomeType get_biome_from_noise(float temp, float humid) {
-    using enum BiomeType;
-    if (plain.temp.first <= temp && temp < plain.temp.second &&
-        plain.humid.first <= humid && humid < plain.humid.second) {
-        return PLAIN;
-    }
-    if (forest.temp.first <= temp && temp < forest.temp.second &&
-        forest.humid.first <= humid && humid < forest.humid.second) {
-        return FOREST;
-    }
-    if (desert.temp.first <= temp && temp < desert.temp.second &&
-        desert.humid.first <= humid && humid < desert.humid.second) {
-        return DESERT;
-    }
-    if (mountain.temp.first <= temp && temp <= mountain.temp.second &&
-        mountain.humid.first <= humid && humid <= mountain.humid.second) {
-        return MOUNTAIN;
-    }
-    Logger::warn("Invail Temp {} or Humid {}", temp, humid);
-    return PLAIN;
-}
+/*
 std::array<float, 3> get_noise_frequencies_for_biome(BiomeType biome) {
    using enum BiomeType;
    switch (biome) {
@@ -125,7 +108,8 @@ std::array<float, 3> get_noise_frequencies_for_biome(BiomeType biome) {
    Logger::warn("Unknown Biome");
    return {0.003f, 0.015f, 0.06f};
 }
-
+*/
+/*
 BiomeHeightRange get_biome_height_range(BiomeType biome) {
    using enum BiomeType;
    switch (biome) {
@@ -146,7 +130,7 @@ BiomeHeightRange get_biome_height_range(BiomeType biome) {
    Logger::warn("Unknown Biome");
    return {62, 4};
 }
-
+*/
 BiomeType safe_int_to_biome(int x) {
    using enum BiomeType;
    static const std::unordered_map<int, BiomeType> INT_TO_BIOME_MAP{
@@ -201,6 +185,30 @@ int get_interpolated_height(float world_x, float world_z, float temp,
    return static_cast<int>(h);
 }
 */
+
+BiomeType determine_biome(const BiomeConditions& conditions) {
+    if (conditions.mountainous > 0.75) {
+        return MOUNTAIN;
+    }
+    auto temp = conditions.temp;
+    auto humid = conditions.humid;
+    if (temp < 0.5) {
+        if (humid < 0.5) {
+            return SNOWY_PLAIN;
+        } else {
+            return PLAIN;
+        }
+    } else {
+        if (humid < 0.5) {
+            return DESERT;
+        } else {
+            return FOREST;
+        }
+    }
+
+    return PLAIN;
+}
+
 PlainParams& plain_params() { return plain; }
 ForestParams& forest_params() { return forest; }
 DesertParams& desert_params() { return desert; }
--- a/src/gameplay/builders/biome_builder.cpp
+++ b/src/gameplay/builders/biome_builder.cpp
@@ -10,7 +10,7 @@ void BiomeBuilder::build_bottom() {
    for (int x = 0; x < CHUNK_SIZE; x++) {
        for (int y = 0; y < 5; y++) {
            for (int z = 0; z < CHUNK_SIZE; z++) {
-                m_blocks[Chunk::get_index(x, y, z)] = 3;
+                m_blocks[Chunk::index(x, y, z)] = 3;
            }
        }
    }
@@ -30,7 +30,7 @@ void BiomeBuilder::fill_water() {
                    }
                    int height = heightmap[x][z];
                    for (int y = height; y < SEA_LEVEL; y++) {
-                        m_blocks[Chunk::get_index(x, y, z)] = 7;
+                        m_blocks[Chunk::index(x, y, z)] = 7;
                    }
                }
            }
--- a/src/gameplay/builders/desert_builder.cpp
+++ b/src/gameplay/builders/desert_builder.cpp
@@ -19,11 +19,11 @@ void DesertBuilder::build_blocks() {
        for (int z = 0; z < CHUNK_SIZE; z++) {
            int height = static_cast<int>(m_heightmap[x][z]);
            for (int y = 5; y < height - 5; y++) {
-                m_blocks[Chunk::get_index(x, y, z)] = 3;
+                m_blocks[Chunk::index(x, y, z)] = 3;
            }

            for (int y = height - 5; y <= height; y++) {
-                m_blocks[Chunk::get_index(x, y, z)] = 4;
+                m_blocks[Chunk::index(x, y, z)] = 4;
            }
        }
    }
--- a/src/gameplay/builders/forest_builder.cpp
+++ b/src/gameplay/builders/forest_builder.cpp
@@ -23,12 +23,12 @@ void ForestBuilder::build_blocks() {
        for (int z = 0; z < CHUNK_SIZE; z++) {
            int height = static_cast<int>(m_heightmap[x][z]);
            for (int y = 5; y < height - 5; y++) {
-                m_blocks[Chunk::get_index(x, y, z)] = 3;
+                m_blocks[Chunk::index(x, y, z)] = 3;
            }
            for (int y = height - 5; y < height; y++) {
-                m_blocks[Chunk::get_index(x, y, z)] = 2;
+                m_blocks[Chunk::index(x, y, z)] = 2;
            }
-            m_blocks[Chunk::get_index(x, height, z)] = 1;
+            m_blocks[Chunk::index(x, height, z)] = 1;
        }
    }
 }
--- a/src/gameplay/builders/mountain_builder.cpp
+++ b/src/gameplay/builders/mountain_builder.cpp
@@ -18,20 +18,8 @@ void MountainBuilder::build_blocks() {
    for (int x = 0; x < CHUNK_SIZE; x++) {
        for (int z = 0; z < CHUNK_SIZE; z++) {
            int height = static_cast<int>(m_heightmap[x][z]);
-            for (int y = 5; y < height - 5; y++) {
-                m_blocks[Chunk::get_index(x, y, z)] = 3;
-            }
-            for (int y = height - 5; y <= height - 1; y++) {
-                if (y > 110) {
-                    m_blocks[Chunk::get_index(x, y, z)] = 3;
-                } else {
-                    m_blocks[Chunk::get_index(x, y, z)] = 2;
-                }
-            }
-            if (height > 110) {
-                m_blocks[Chunk::get_index(x, height, z)] = 3;
-            } else {
-                m_blocks[Chunk::get_index(x, height, z)] = 1;
+            for (int y = 5; y <= height; y++) {
+                m_blocks[Chunk::index(x, y, z)] = 3;
            }
        }
    }
--- a/src/gameplay/builders/plain_builder.cpp
+++ b/src/gameplay/builders/plain_builder.cpp
@@ -19,12 +19,12 @@ void PlainBuilder::build_blocks() {
        for (int z = 0; z < CHUNK_SIZE; z++) {
            int height = static_cast<int>(m_heightmap[x][z]);
            for (int y = 5; y < height - 5; y++) {
-                m_blocks[Chunk::get_index(x, y, z)] = 3;
+                m_blocks[Chunk::index(x, y, z)] = 3;
            }
            for (int y = height - 5; y < height; y++) {
-                m_blocks[Chunk::get_index(x, y, z)] = 2;
+                m_blocks[Chunk::index(x, y, z)] = 2;
            }
-            m_blocks[Chunk::get_index(x, height, z)] = 1;
+            m_blocks[Chunk::index(x, height, z)] = 1;
        }
    }
 }
--- a/src/gameplay/builders/river_builder.cpp
+++ b/src/gameplay/builders/river_builder.cpp
@@ -19,16 +19,16 @@ void RiverBuilder::build_blocks() {
        for (int z = 0; z < CHUNK_SIZE; z++) {
            int height = static_cast<int>(m_heightmap[x][z]);
            for (int y = 5; y < height - 5; y++) {
-                m_blocks[Chunk::get_index(x, y, z)] = 3;
+                m_blocks[Chunk::index(x, y, z)] = 3;
            }
            for (int y = height - 5; y <= height - 1; y++) {
-                m_blocks[Chunk::get_index(x, y, z)] = 2;
+                m_blocks[Chunk::index(x, y, z)] = 2;
            }
            for (int y = height; y <= height; y++) {
                if (y >= SEA_LEVEL - 1) {
-                    m_blocks[Chunk::get_index(x, y, z)] = 1;
+                    m_blocks[Chunk::index(x, y, z)] = 1;
                } else {
-                    m_blocks[Chunk::get_index(x, y, z)] = 2;
+                    m_blocks[Chunk::index(x, y, z)] = 2;
                }
            }
        }
@@ -46,7 +46,7 @@ void RiverBuilder::build_vegetation() {
                continue;
            }
            for (int y = height + 1; y < SEA_LEVEL; y++) {
-                m_blocks[Chunk::get_index(x, y, z)] = 7;
+                m_blocks[Chunk::index(x, y, z)] = 7;
            }
        }
    }
--- a/src/gameplay/builders/snowy_plain_builder.cpp
+++ b/src/gameplay/builders/snowy_plain_builder.cpp
@@ -0,0 +1,38 @@
+#include "Cubed/gameplay/builders/snowy_plain_builder.hpp"
+
+#include "Cubed/gameplay/chunk.hpp"
+#include "Cubed/gameplay/chunk_generator.hpp"
+namespace Cubed {
+SnowyPlainBuilder::SnowyPlainBuilder(ChunkGenerator& chunk_generator)
+    : m_chunk_generator(chunk_generator) {}
+
+void SnowyPlainBuilder::build_biome() {
+    BiomeBuilder::build_bottom();
+    build_blocks();
+};
+
+void SnowyPlainBuilder::build_blocks() {
+    auto& m_chunk = m_chunk_generator.chunk();
+    auto& m_blocks = m_chunk.blocks();
+    auto& m_heightmap = m_chunk.heightmap();
+    for (int x = 0; x < CHUNK_SIZE; x++) {
+        for (int z = 0; z < CHUNK_SIZE; z++) {
+            int height = static_cast<int>(m_heightmap[x][z]);
+            for (int y = 5; y < height - 5; y++) {
+                m_blocks[Chunk::index(x, y, z)] = 3;
+            }
+            for (int y = height - 5; y < height; y++) {
+                m_blocks[Chunk::index(x, y, z)] = 2;
+            }
+            m_blocks[Chunk::index(x, height, z)] = 8;
+        }
+    }
+}
+
+void SnowyPlainBuilder::build_vegetation() { fill_water(); }
+
+ChunkGenerator& SnowyPlainBuilder::get_chunk_generator() {
+    return m_chunk_generator;
+};
+
+} // namespace Cubed
--- a/src/gameplay/chunk.cpp
+++ b/src/gameplay/chunk.cpp
@@ -24,7 +24,8 @@ Chunk::Chunk(Chunk&& other) noexcept
      m_chunk_pos(std::move(other.m_chunk_pos)), m_world(other.m_world),
      m_heightmap(std::move(other.m_heightmap)),
      m_blocks(std::move(other.m_blocks)), m_vbo(other.m_vbo),
-      m_vertexs_data(std::move(other.m_vertexs_data)), m_seed(other.m_seed) {
+      m_vertexs_data(std::move(other.m_vertexs_data)), m_seed(other.m_seed),
+      m_conditions(other.m_conditions) {
    other.m_vbo = 0;
 }

@@ -44,14 +45,46 @@ Chunk& Chunk::operator=(Chunk&& other) noexcept {
    m_need_upload = other.m_need_upload.load();
    m_vertex_sum = other.m_vertex_sum.load();
    m_seed = other.m_seed;
+    m_conditions = other.m_conditions;
    return *this;
 }

+std::tuple<int, int, int> Chunk::world_to_block(int world_x, int world_y,
+                                                int world_z, int chunk_x,
+                                                int chunk_z) {
+    int x, y, z;
+    y = world_y;
+    x = world_x - chunk_x * CHUNK_SIZE;
+    z = world_z - chunk_z * CHUNK_SIZE;
+    return {x, y, z};
+}
+
+std::tuple<int, int, int> Chunk::world_to_block(const glm::ivec3& block_pos,
+                                                ChunkPos chunk_pos) {
+    return world_to_block(block_pos.x, block_pos.y, block_pos.z, chunk_pos.x,
+                          chunk_pos.z);
+}
+
+std::tuple<int, int, int> Chunk::block_to_world(int x, int y, int z,
+                                                int chunk_x, int chunk_z) {
+    int world_x = x + chunk_x * CHUNK_SIZE;
+    int world_z = z + chunk_z * CHUNK_SIZE;
+    int world_y = y;
+    return {world_x, world_y, world_z};
+}
+std::tuple<int, int, int> Chunk::block_to_world(const glm::ivec3& block_pos,
+                                                ChunkPos chunk_pos) {
+    return block_to_world(block_pos.x, block_pos.y, block_pos.z, chunk_pos.x,
+                          chunk_pos.z);
+}
+
 BiomeType Chunk::get_biome() const { return m_biome.load(); }

 ChunkPos Chunk::get_chunk_pos() const { return m_chunk_pos; }

-const std::vector<uint8_t>& Chunk::get_chunk_blocks() const { return m_blocks; }
+const std::vector<BlockType>& Chunk::get_chunk_blocks() const {
+    return m_blocks;
+}

 HeightMapArray Chunk::get_heightmap() const {
    // Logger::info("Chunk pos {} {} in get_heightmap this {}", m_chunk_pos.x,
@@ -59,7 +92,7 @@ HeightMapArray Chunk::get_heightmap() const {
    return m_heightmap;
 }

-int Chunk::get_index(int x, int y, int z) {
+int Chunk::index(int x, int y, int z) {
    ASSERT(!(x < 0 || y < 0 || z < 0 || x >= CHUNK_SIZE || y >= WORLD_SIZE_Y ||
             z >= CHUNK_SIZE));
    if ((x * WORLD_SIZE_Y + y) * CHUNK_SIZE + z < 0 ||
@@ -71,12 +104,12 @@ int Chunk::get_index(int x, int y, int z) {
    return (x * WORLD_SIZE_Y + y) * CHUNK_SIZE + z;
 }

-int Chunk::get_index(const glm::vec3& pos) {
-    return Chunk::get_index(pos.x, pos.y, pos.z);
+int Chunk::index(const glm::vec3& pos) {
+    return Chunk::index(pos.x, pos.y, pos.z);
 }

 void Chunk::gen_vertex_data(
-    const std::array<const std::vector<uint8_t>*, 4>& neighbor_block) {
+    const std::array<const std::vector<BlockType>*, 4>& neighbor_block) {
    if (m_is_on_gen_vertex_data) {
        return;
    }
@@ -93,7 +126,7 @@ void Chunk::gen_vertex_data(
                int world_x = x + m_chunk_pos.x * CHUNK_SIZE;
                int world_z = z + m_chunk_pos.z * CHUNK_SIZE;
                int world_y = y;
-                int cur_id = m_blocks[get_index(x, y, z)];
+                int cur_id = m_blocks[index(x, y, z)];
                // air
                if (cur_id == 0) {
                    continue;
@@ -116,7 +149,7 @@ void Chunk::gen_vertex_data(
                            World::chunk_pos(world_nx, world_nz);

                        auto is_cull =
-                            [&](const std::vector<uint8_t>* chunk_blocks) {
+                            [&](const std::vector<BlockType>* chunk_blocks) {
                                if (chunk_blocks == nullptr) {
                                    return false;
                                }
@@ -130,12 +163,12 @@ void Chunk::gen_vertex_data(
                                    return false;
                                }

-                                int idx = Chunk::get_index(x, y, z);
+                                int idx = Chunk::index(x, y, z);
                                // not init
                                if (static_cast<size_t>(idx) >=
                                    chunk_blocks->size()) {
-                                    Logger::warn("not init");
-                                    return false;
+                                    // Logger::warn("not init");
+                                    return true;
                                }
                                auto id = (*chunk_blocks)[idx];
                                if (is_in_transparent_map(id)) {
@@ -162,7 +195,7 @@ void Chunk::gen_vertex_data(
                        // neighbor_cull = m_world.is_block(glm::ivec3(world_x,
                        // world_y, world_z) + DIR[face]);
                    } else {
-                        auto id = m_blocks[get_index(nx, ny, nz)];
+                        auto id = m_blocks[index(nx, ny, nz)];
                        if (!is_in_transparent_map(id)) {
                            neighbor_cull = true;
                        } else {
@@ -222,7 +255,7 @@ void Chunk::gen_phase_two(const std::array<const Chunk*, 8>& adj_chunks) {
        Logger::error("ChunkGenerator is Nullptr");
        return;
    }
-    m_generator->resolve_biome_adjacency_conflict(adj_chunks);
+    // m_generator->resolve_biome_adjacency_conflict(adj_chunks);
 }

 void Chunk::gen_phase_three() {
@@ -240,7 +273,8 @@ void Chunk::gen_phase_four(
        Logger::error("ChunkGenerator is Nullptr");
        return;
    }
-    m_generator->blend_heightmap_boundaries(neighbor_heightmap, neighbor_biome);
+    // m_generator->blend_heightmap_boundaries(neighbor_heightmap,
+    // neighbor_biome);
 }

 void Chunk::gen_phase_five() {
@@ -252,12 +286,14 @@ void Chunk::gen_phase_five() {
 }

 void Chunk::gen_phase_six(
-    const std::array<std::optional<std::vector<uint8_t>>, 4>& neighbor_block) {
+    const std::array<std::optional<std::vector<BlockType>>, 4>&
+        neighbor_block) {
    if (!m_generator) {
        Logger::error("ChunkGenerator is Nullptr");
        return;
    }
-    // m_generator->blend_surface_blocks_borders(neighbor_block);
+    m_generator->blend_surface_blocks_borders(neighbor_block);
+    m_generator->generate_cave();
 }

 void Chunk::gen_phase_seven() {
@@ -308,7 +344,7 @@ BiomeType Chunk::biome() const { return m_biome; }
 void Chunk::biome(BiomeType b) { m_biome = b; }

 HeightMapArray& Chunk::heightmap() { return m_heightmap; }
-std::vector<uint8_t>& Chunk::blocks() { return m_blocks; }
+std::vector<BlockType>& Chunk::blocks() { return m_blocks; }
 World& Chunk::world() { return m_world; }
 unsigned Chunk::seed() const {
    if (m_seed == 0) {
@@ -316,4 +352,7 @@ unsigned Chunk::seed() const {
    }
    return m_seed;
 }
+
+BiomeConditions& Chunk::conditions() { return m_conditions; }
+
 } // namespace Cubed
--- a/src/gameplay/chunk_generator.cpp
+++ b/src/gameplay/chunk_generator.cpp
@@ -5,10 +5,12 @@
 #include "Cubed/gameplay/builders/mountain_builder.hpp"
 #include "Cubed/gameplay/builders/plain_builder.hpp"
 #include "Cubed/gameplay/builders/river_builder.hpp"
+#include "Cubed/gameplay/builders/snowy_plain_builder.hpp"
 #include "Cubed/gameplay/chunk.hpp"
 #include "Cubed/gameplay/tree.hpp"
 #include "Cubed/gameplay/world.hpp"
 #include "Cubed/tools/cubed_hash.hpp"
+#include "Cubed/tools/math_tools.hpp"
 #include "Cubed/tools/perlin_noise.hpp"
 namespace Cubed {

@@ -27,7 +29,8 @@ void ChunkGenerator::init() {
    std::random_device d;
    m_generator_seed = d();
    Logger::info("Chunk Generator Seed {}", m_generator_seed);
-    PerlinNoise::init(m_generator_seed);
+    PerlinNoise3D::init(m_generator_seed);
+    PerlinNoise2D::init(m_generator_seed);
    is_init = true;
 }

@@ -35,7 +38,7 @@ void ChunkGenerator::reload() {
    if (!is_seed_change) {
        return;
    }
-    PerlinNoise::reload(m_generator_seed);
+    PerlinNoise3D::reload(m_generator_seed);
    is_seed_change = false;
 }

@@ -54,11 +57,20 @@ void ChunkGenerator::assign_chunk_biome() {
    auto m_chunk_pos = m_chunk.chunk_pos();
    float x = static_cast<float>(m_chunk_pos.x);
    float z = static_cast<float>(m_chunk_pos.z);
-    float temp = PerlinNoise::noise(x * BIOME_NOISE_FREQUENCY, 0.0f,
-                                    z * BIOME_NOISE_FREQUENCY);
-    float humid = PerlinNoise::noise(x * BIOME_NOISE_FREQUENCY, 1.0f,
-                                     z * BIOME_NOISE_FREQUENCY);
-    auto biome = get_biome_from_noise(temp, humid);
+    float temp = PerlinNoise3D::noise(x * BIOME_NOISE_FREQUENCY, 0.0f,
+                                      z * BIOME_NOISE_FREQUENCY);
+    float humid = PerlinNoise3D::noise(x * BIOME_NOISE_FREQUENCY, 1.0f,
+                                       z * BIOME_NOISE_FREQUENCY);
+    float center_x = static_cast<float>(SIZE_X / 2) + x * CHUNK_SIZE + 0.5f;
+    float center_z = static_cast<float>(SIZE_Z / 2) + z * CHUNK_SIZE + 0.5f;
+    float mountainous =
+        PerlinNoise2D::noise(center_x * MOUNTAINOUS_NOISE_FREQUENCY,
+                             center_z * MOUNTAINOUS_NOISE_FREQUENCY);
+    auto& conditions = m_chunk.conditions();
+    conditions.mountainous = mountainous;
+    conditions.humid = humid;
+    conditions.temp = temp;
+    auto biome = determine_biome(conditions);
    m_chunk.biome(biome);
 }

@@ -86,6 +98,7 @@ void ChunkGenerator::resolve_biome_adjacency_conflict(
    }
 }

+/*
 void ChunkGenerator::generate_heightmap() {

    auto m_chunk_pos = m_chunk.chunk_pos();
@@ -114,6 +127,63 @@ void ChunkGenerator::generate_heightmap() {
        }
    }
 }
+*/
+
+void ChunkGenerator::generate_heightmap() {
+    auto chunk_pos = m_chunk.chunk_pos();
+    auto& heightmap = m_chunk.heightmap();
+
+    for (int x = 0; x < CHUNK_SIZE; ++x) {
+        for (int z = 0; z < CHUNK_SIZE; ++z) {
+            float world_x = static_cast<float>(x + chunk_pos.x * CHUNK_SIZE);
+            float world_z = static_cast<float>(z + chunk_pos.z * CHUNK_SIZE);
+
+            auto fbm_height = [](float x, float y, int octaves,
+                                 float lacunarity, float gain, float amplitude,
+                                 float frequency) -> float {
+                float value = 0.0f;
+                for (int i = 0; i < octaves; i++) {
+                    value += amplitude *
+                             PerlinNoise2D::noise(x * frequency, y * frequency);
+                    frequency *= lacunarity;
+                    amplitude *= gain;
+                }
+                return value;
+            };
+
+            int octaves = 4;
+            float lacunarity = 2.0f;
+            float gain = 0.5f;
+            float base_y = 64;
+            float amplitude = 40.0f;
+            float mountainous =
+                PerlinNoise2D::noise(world_x * MOUNTAINOUS_NOISE_FREQUENCY,
+                                     world_z * MOUNTAINOUS_NOISE_FREQUENCY);
+            /*
+            float t = Math::smootherstep(0.6, 0.7, mountainous);
+            base_y = std::lerp(64, 85, t);
+            amplitude = std::lerp(10, 40, t);
+            */
+            float t;
+            if (mountainous >= 0.7f) {
+                t = Math::smootherstep(0.7f, 0.75, mountainous);
+                base_y = std::lerp(70, 88, t);
+                amplitude = std::lerp(28, 48, t);
+            } else if (mountainous >= 0.65f) {
+                t = Math::smootherstep(0.65f, 0.7f, mountainous);
+                base_y = std::lerp(66, 70, t);
+                amplitude = std::lerp(18, 28, t);
+            } else {
+                t = Math::smootherstep(0.55, 0.65, mountainous);
+                base_y = std::lerp(58, 66, t);
+                amplitude = std::lerp(8, 18, t);
+            }
+            heightmap[x][z] =
+                base_y + fbm_height(world_x, world_z, octaves, lacunarity, gain,
+                                    amplitude, 0.005f);
+        }
+    }
+}

 void ChunkGenerator::blend_heightmap_boundaries(
    const std::array<std::optional<HeightMapArray>, 8>& neighbor_heightmap,
@@ -362,11 +432,11 @@ void ChunkGenerator::generate_terrain_blocks() {
    }
    m_chunk.blocks().assign(CHUNK_SIZE * CHUNK_SIZE * WORLD_SIZE_Y, 0);
    m_biome_builder->build_biome();
-    generate_cave();
 }

 void ChunkGenerator::blend_surface_blocks_borders(
-    const std::array<std::optional<std::vector<uint8_t>>, 4>& neighbor_block) {
+    const std::array<std::optional<std::vector<BlockType>>, 4>&
+        neighbor_block) {
    auto& m_blocks = m_chunk.blocks();
    auto& m_heightmap = m_chunk.heightmap();

@@ -374,12 +444,12 @@ void ChunkGenerator::blend_surface_blocks_borders(

    // Helper lambda: get top block type from a neighbor's block data at (nx,
    // nz)
-    auto get_top_block_from_neighbor = [&](const std::vector<uint8_t>& blocks,
-                                           int nx, int nz) -> uint8_t {
+    auto get_top_block_from_neighbor = [&](const std::vector<BlockType>& blocks,
+                                           int nx, int nz) -> BlockType {
        // Search from topmost y downwards for the first non-zero block
        for (int y = WORLD_HEIGHT - 1; y >= 0; --y) {
-            int idx = Chunk::get_index(
-                nx, y, nz); // linear index: y * area + z * size + x
+            int idx = Chunk::index(nx, y,
+                                   nz); // linear index: y * area + z * size + x
            if (idx >= 0 && idx < static_cast<int>(blocks.size()) &&
                blocks[idx] != 0) {
                return blocks[idx];
@@ -392,16 +462,16 @@ void ChunkGenerator::blend_surface_blocks_borders(
    for (int x = 0; x < CHUNK_SIZE; ++x) {
        for (int z = 0; z < CHUNK_SIZE; ++z) {
            // Get the current top block type of this column from m_blocks
-            uint8_t type_self = 0;
+            BlockType type_self = 0;
            int top_y = -1;
            top_y = m_heightmap[x][z];
-            type_self = m_blocks[Chunk::get_index(x, top_y, z)];
+            type_self = m_blocks[Chunk::index(x, top_y, z)];

            if (top_y == -1)
                continue; // no block? skip

            // Weight map: type -> total weight
-            std::unordered_map<uint8_t, float> weights;
+            std::unordered_map<BlockType, float> weights;
            weights[type_self] = 1.0f; // self weight

            // --- Right neighbor (index 0) ---
@@ -410,7 +480,7 @@ void ChunkGenerator::blend_surface_blocks_borders(
                float t = 1.0f - static_cast<float>(dist) / BLEND_RADIUS;
                t = t * t * (3.0f - 2.0f * t); // smoothstep
                if (t > 0.0f) {
-                    uint8_t type_neighbor =
+                    BlockType type_neighbor =
                        get_top_block_from_neighbor(*neighbor_block[0], 0, z);
                    weights[type_neighbor] += t;
                }
@@ -422,7 +492,7 @@ void ChunkGenerator::blend_surface_blocks_borders(
                float t = 1.0f - static_cast<float>(dist) / BLEND_RADIUS;
                t = t * t * (3.0f - 2.0f * t);
                if (t > 0.0f) {
-                    uint8_t type_neighbor = get_top_block_from_neighbor(
+                    BlockType type_neighbor = get_top_block_from_neighbor(
                        *neighbor_block[1], CHUNK_SIZE - 1, z);
                    weights[type_neighbor] += t;
                }
@@ -434,7 +504,7 @@ void ChunkGenerator::blend_surface_blocks_borders(
                float t = 1.0f - static_cast<float>(dist) / BLEND_RADIUS;
                t = t * t * (3.0f - 2.0f * t);
                if (t > 0.0f) {
-                    uint8_t type_neighbor =
+                    BlockType type_neighbor =
                        get_top_block_from_neighbor(*neighbor_block[2], x, 0);
                    weights[type_neighbor] += t;
                }
@@ -446,14 +516,14 @@ void ChunkGenerator::blend_surface_blocks_borders(
                float t = 1.0f - static_cast<float>(dist) / BLEND_RADIUS;
                t = t * t * (3.0f - 2.0f * t);
                if (t > 0.0f) {
-                    uint8_t type_neighbor = get_top_block_from_neighbor(
+                    BlockType type_neighbor = get_top_block_from_neighbor(
                        *neighbor_block[3], x, CHUNK_SIZE - 1);
                    weights[type_neighbor] += t;
                }
            }

            // Find type with maximum total weight
-            uint8_t final_type = type_self;
+            BlockType final_type = type_self;
            float max_weight = weights[type_self];
            for (const auto& [type, w] : weights) {
                if (w > max_weight) {
@@ -462,6 +532,10 @@ void ChunkGenerator::blend_surface_blocks_borders(
                }
            }

+            if (final_type == 0) {
+                return;
+            }
+
            // Update the top block if the type changed
            if (final_type != type_self) {
                // top block
@@ -469,7 +543,7 @@ void ChunkGenerator::blend_surface_blocks_borders(
                    final_type = 2;
                }

-                m_blocks[Chunk::get_index(x, top_y, z)] = final_type;
+                m_blocks[Chunk::index(x, top_y, z)] = final_type;
                // bottom block
                unsigned fill_type = 2;
                if (final_type == 1) {
@@ -478,7 +552,7 @@ void ChunkGenerator::blend_surface_blocks_borders(
                    fill_type = 4;
                }
                for (int y = top_y - 5; y < top_y; y++) {
-                    m_blocks[Chunk::get_index(x, y, z)] = fill_type;
+                    m_blocks[Chunk::index(x, y, z)] = fill_type;
                }
            }
        }
@@ -512,6 +586,9 @@ void ChunkGenerator::make_biome_builder() {
    case RIVER:
        m_biome_builder = std::make_unique<RiverBuilder>(*this);
        break;
+    case SNOWY_PLAIN:
+        m_biome_builder = std::make_unique<SnowyPlainBuilder>(*this);
+        break;
    case NONE:
        m_biome_builder = nullptr;
        break;
@@ -563,7 +640,7 @@ void ChunkGenerator::generate_cave() {
                            if (y == 0) {
                                continue;
                            }
-                            blocks[Chunk::get_index(x, y, z)] = 0;
+                            blocks[Chunk::index(x, y, z)] = 0;
                        }
                    }
                }
--- a/src/gameplay/tree.cpp
+++ b/src/gameplay/tree.cpp
@@ -30,7 +30,7 @@ static constexpr std::array<TreeStructNode, 62> TREE{{
 bool build_tree(Chunk& chunk, const glm::ivec3& pos) {
    auto& block = chunk.get_chunk_blocks();

-    if (block[Chunk::get_index(pos)] != 1) {
+    if (block[Chunk::index(pos)] != 1) {
        Logger::info("Root is not Grass Block");
        return false;
    }
@@ -43,13 +43,13 @@ bool build_tree(Chunk& chunk, const glm::ivec3& pos) {
            z >= CHUNK_SIZE) {
            return false;
        }
-        if (block[Chunk::get_index(tree_node)] != 0) {
+        if (block[Chunk::index(tree_node)] != 0) {
            return false;
        }
    }
    for (const auto& d : TREE) {
        auto tree_node = pos + d.offset;
-        chunk.set_chunk_block(Chunk::get_index(tree_node), d.id);
+        chunk.set_chunk_block(Chunk::index(tree_node), d.id);
    }
    return true;
 }
--- a/src/gameplay/world.cpp
+++ b/src/gameplay/world.cpp
@@ -10,7 +10,7 @@
 namespace Cubed {

 struct ChunkRenderData {
-    std::array<const std::vector<uint8_t>*, 4> neighbor_block;
+    std::array<const std::vector<BlockType>*, 4> neighbor_block;
    Chunk* chunk;
 };

@@ -86,6 +86,7 @@ void World::init_chunks() {
        std::this_thread::sleep_for(std::chrono::microseconds(200));
    }
 }
+
 /*
 void World::init_chunks() {

@@ -230,7 +231,7 @@ void World::init_chunks() {
    for (auto& [pos, chunks] : temp_neighbor) {
        chunks.gen_phase_five();
    }
-    std::array<std::optional<std::vector<uint8_t>>, 4> neighbor_block;
+    std::array<std::optional<std::vector<BlockType>>, 4> neighbor_block;
    for (auto& [pos, chunks] : m_chunks) {
        for (int i = 0; i < 4; i++) {
            auto neighbor_pos = pos + CHUNK_DIR[i];
@@ -332,6 +333,8 @@ ChunkPos World::chunk_pos(int world_x, int world_z) {
    return {chunk_x, chunk_z};
 }

+#pragma region ChunkGenerate
+
 void World::gen_chunks_internal() {
    m_chunk_gen_fraction = 0.0f;
    m_chunk_gen_finished = false;
@@ -344,35 +347,43 @@ void World::gen_chunks_internal() {
    sync_and_collect_missing_chunks(need_gen_chunks_pos, required_chunks);

    Logger::info("New Gen Chunks Sum: {}", need_gen_chunks_pos.size());
+
    if (need_gen_chunks_pos.empty()) {
        m_could_gen = true;
        m_chunk_gen_fraction = 1.0f;
        return;
    }
+
    m_chunk_gen_fraction = 0.1f;
+
    ChunkUpdateList new_chunks;
    for (auto& pos : need_gen_chunks_pos) {
        new_chunks.push_back({pos, Chunk(*this, pos)});
    }

    ConstChunkMap new_chunks_neighbor;
-    // affected neighbor
+    //  affected neighbor
    ChunkPtrUpdateList affected_neighbor;
    ChunkHashMap temp_neighbor;
+
    build_neighbor_context_for_new_chunks(
        new_chunks_neighbor, affected_neighbor, new_chunks, temp_neighbor);
-    Logger::info("Temp neighbor sum {}", temp_neighbor.size());
-    // build new chunk, but the neighbor in m_chunks also need to re-build
+
+    // Logger::info("Temp neighbor sum {}", temp_neighbor.size());
+    //  build new chunk, but the neighbor in m_chunks also need to re-build

    for (auto& [pos, chunk] : new_chunks) {
        chunk.gen_phase_one();
        m_cave_carcer.try_to_add_path(pos, chunk.seed());
    }
-    for (auto& [pos, chunk] : temp_neighbor) {
-        chunk.gen_phase_one();
-        m_cave_carcer.try_to_add_path(pos, chunk.seed());
-    }
+
+    // for (auto& [pos, chunk] : temp_neighbor) {
+    //     chunk.gen_phase_one();
+    //     m_cave_carcer.try_to_add_path(pos, chunk.seed());
+    // }
+
    m_chunk_gen_fraction = 0.2f;
+
    std::array<const Chunk*, 8> neighbor_chunks;
    for (auto& [pos, chunks] : new_chunks) {
        for (int i = 0; i < 8; i++) {
@@ -387,6 +398,8 @@ void World::gen_chunks_internal() {
        }
        chunks.gen_phase_two(neighbor_chunks);
    }
+
+    /*
    for (auto& [pos, chunks] : temp_neighbor) {
        for (int i = 0; i < 8; i++) {
            auto neighbor_pos = pos + CHUNK_DIR[i];
@@ -399,14 +412,20 @@ void World::gen_chunks_internal() {
        }
        chunks.gen_phase_two(neighbor_chunks);
    }
+    */
+
    m_chunk_gen_fraction = 0.3f;
+
    for (auto& [pos, chunks] : new_chunks) {
        chunks.gen_phase_three();
    }
-    for (auto& [pos, chunks] : temp_neighbor) {
-        chunks.gen_phase_three();
-    }
+    // for (auto& [pos, chunks] : temp_neighbor) {
+    //     chunks.gen_phase_three();
+    // }
+
    m_chunk_gen_fraction = 0.4f;
+
+    /*
    for (int i = 0; i < 4; i++) {
        for (auto& [pos, chunks] : temp_neighbor) {
            std::array<std::optional<HeightMapArray>, 8>
@@ -448,15 +467,20 @@ void World::gen_chunks_internal() {
            chunks.gen_phase_four(neighbor_chunk_heightmap, neighbor_biome);
        }
    }
+    */

    m_chunk_gen_fraction = 0.5f;
    for (auto& [pos, chunks] : new_chunks) {
        chunks.gen_phase_five();
    }
+
+    /*
    for (auto& [pos, chunks] : temp_neighbor) {
        chunks.gen_phase_five();
    }
-    std::array<std::optional<std::vector<uint8_t>>, 4> neighbor_blocks_data;
+    */
+
+    std::array<std::optional<std::vector<BlockType>>, 4> neighbor_blocks_data;
    for (auto& [pos, chunks] : new_chunks) {
        {
            // std::lock_guard lk(m_chunks_mutex);
@@ -472,12 +496,14 @@ void World::gen_chunks_internal() {
        }
        chunks.gen_phase_six(neighbor_blocks_data);
    }
+
    for (auto& [pos, chunks] : new_chunks) {
        chunks.gen_phase_seven();
    }

    m_chunk_gen_fraction = 0.6f;
-    std::array<const std::vector<uint8_t>*, 4> neighbor_block;
+
+    std::array<const std::vector<BlockType>*, 4> neighbor_block;
    for (auto& [pos, chunk] : new_chunks) {
        for (int i = 0; i < 4; i++) {
            auto it = new_chunks_neighbor.find(pos + CHUNK_DIR[i]);
@@ -489,10 +515,14 @@ void World::gen_chunks_internal() {
        }
        chunk.gen_vertex_data(neighbor_block);
    }
+
    m_chunk_gen_fraction = 0.7f;
+
    build_neighbor_context_for_affected_neighbors(affected_neighbor,
                                                  new_chunks_neighbor);
+
    m_chunk_gen_fraction = 0.8f;
+
    for (auto& [pos, chunk] : affected_neighbor) {
        for (int i = 0; i < 4; i++) {
            auto it = new_chunks_neighbor.find(pos + CHUNK_DIR[i]);
@@ -505,7 +535,9 @@ void World::gen_chunks_internal() {
        chunk->gen_vertex_data(neighbor_block);
        chunk->need_upload();
    }
+
    m_chunk_gen_fraction = 0.9f;
+
    {
        std::lock_guard lk(m_new_chunk_queue_mutex);
        for (auto& x : new_chunks) {
@@ -597,6 +629,8 @@ void World::build_neighbor_context_for_affected_neighbors(
    }
 }

+#pragma endregion
+
 void World::start_gen_thread() {
    m_gen_running = true;
    Logger::info("Gen Thread Started");
@@ -667,15 +701,12 @@ int World::get_block(const glm::ivec3& block_pos) const {
    }

    const auto& chunk_blocks = it->second.get_chunk_blocks();
-    int x, y, z;
-    y = block_pos.y;
-    x = block_pos.x - chunk_x * CHUNK_SIZE;
-    z = block_pos.z - chunk_z * CHUNK_SIZE;
+    auto [x, y, z] = Chunk::world_to_block(block_pos, {chunk_x, chunk_z});
    if (x < 0 || y < 0 || z < 0 || x >= CHUNK_SIZE || y >= WORLD_SIZE_Y ||
        z >= CHUNK_SIZE) {
        return 0;
    }
-    return chunk_blocks[Chunk::get_index(x, y, z)];
+    return chunk_blocks[Chunk::index(x, y, z)];
 }

 bool World::is_block(const glm::ivec3& block_pos) const {
@@ -687,15 +718,12 @@ bool World::is_block(const glm::ivec3& block_pos) const {
        return false;
    }
    const auto& chunk_blocks = it->second.get_chunk_blocks();
-    int x, y, z;
-    y = block_pos.y;
-    x = block_pos.x - chunk_x * CHUNK_SIZE;
-    z = block_pos.z - chunk_z * CHUNK_SIZE;
+    auto [x, y, z] = Chunk::world_to_block(block_pos, {chunk_x, chunk_z});
    if (x < 0 || y < 0 || z < 0 || x >= CHUNK_SIZE || y >= WORLD_SIZE_Y ||
        z >= CHUNK_SIZE) {
        return false;
    }
-    auto id = chunk_blocks[Chunk::get_index(x, y, z)];
+    auto id = chunk_blocks[Chunk::index(x, y, z)];
    if (id == 0) {
        return false;
    } else {
@@ -718,16 +746,14 @@ void World::set_block(const glm::ivec3& block_pos, unsigned id) {
        return;
    }

-    int x, y, z;
-    y = world_y;
-    x = world_x - chunk_x * CHUNK_SIZE;
-    z = world_z - chunk_z * CHUNK_SIZE;
+    auto [x, y, z] =
+        Chunk::world_to_block(world_x, world_y, world_z, chunk_x, chunk_z);
    if (x < 0 || y < 0 || z < 0 || x >= CHUNK_SIZE || y >= WORLD_SIZE_Y ||
        z >= CHUNK_SIZE) {
        return;
    }

-    it->second.set_chunk_block(Chunk::get_index(x, y, z), id);
+    it->second.set_chunk_block(Chunk::index(x, y, z), id);

    static const glm::ivec3 NEIGHBOR_DIRS[] = {
        {1, 0, 0}, {-1, 0, 0}, {0, 0, -1}, {0, 0, 1}};
@@ -784,7 +810,7 @@ void World::update(float delta_time) {
        for (auto& [pos, chunk] : m_chunks) {
            if (chunk.is_dirty()) {
                // the curial fator influence
-                std::array<const std::vector<uint8_t>*, 4> neighbor_block;
+                std::array<const std::vector<BlockType>*, 4> neighbor_block;
                for (int i = 0; i < 4; i++) {
                    auto it = m_chunks.find(pos + CHUNK_DIR[i]);
                    if (it != m_chunks.end()) {
--- a/src/tools/perlin_noise.cpp
+++ b/src/tools/perlin_noise.cpp
@@ -1,8 +1,6 @@
 #include "Cubed/tools/perlin_noise.hpp"

-#include "Cubed/config.hpp"
 #include "Cubed/tools/cubed_assert.hpp"
-#include "Cubed/tools/cubed_random.hpp"

 #include <algorithm>
 #include <numeric>
@@ -10,7 +8,7 @@

 namespace Cubed {

-void PerlinNoise::init(unsigned seed) {
+void PerlinNoise3D::init(unsigned seed) {
    p.resize(256);
    std::iota(p.begin(), p.end(), 0);
    Logger::info("Init Perlin Noise With Seed {}", seed);
@@ -20,7 +18,7 @@ void PerlinNoise::init(unsigned seed) {
    is_init = true;
 }

-float PerlinNoise::noise(float x, float y, float z) {
+float PerlinNoise3D::noise(float x, float y, float z) {
    ASSERT_MSG(is_init, "The PerlinNoise don't init!");
    int ix = static_cast<int>(std::floor(x)) & 255;
    int iy = static_cast<int>(std::floor(y)) & 255;
@@ -55,11 +53,13 @@ float PerlinNoise::noise(float x, float y, float z) {
    return (res + 1.0f) / 2.0f;
 }

-float PerlinNoise::fade(float t) { return t * t * t * (t * (t * 6 - 15) + 10); }
+float PerlinNoise3D::fade(float t) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+}

-float PerlinNoise::lerp(float t, float a, float b) { return a + t * (b - a); }
+float PerlinNoise3D::lerp(float t, float a, float b) { return a + t * (b - a); }

-float PerlinNoise::grad(int hash, float x, float y, float z) {
+float PerlinNoise3D::grad(int hash, float x, float y, float z) {
    int h = hash & 15;

    float u = h < 8 ? x : y;
@@ -68,7 +68,7 @@ float PerlinNoise::grad(int hash, float x, float y, float z) {
    return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
 }

-void PerlinNoise::reload(unsigned seed) {
+void PerlinNoise3D::reload(unsigned seed) {
    is_init = false;
    p.resize(256);
    std::iota(p.begin(), p.end(), 0);
@@ -79,4 +79,59 @@ void PerlinNoise::reload(unsigned seed) {
    is_init = true;
 }

+void PerlinNoise2D::init(unsigned seed) {
+    p.resize(256);
+    std::iota(p.begin(), p.end(), 0);
+    Logger::info("Init Perlin Noise With Seed {}", seed);
+    std::shuffle(p.begin(), p.end(), std::mt19937(seed));
+
+    p.insert(p.end(), p.begin(), p.end()); // 扩展到 512，方便索引
+    is_init = true;
+}
+
+float PerlinNoise2D::noise(float x, float y) {
+    ASSERT_MSG(is_init, "The PerlinNoise2D don't init!");
+
+    int ix = static_cast<int>(std::floor(x)) & 255;
+    int iy = static_cast<int>(std::floor(y)) & 255;
+
+    x -= std::floor(x);
+    y -= std::floor(y);
+
+    float u = fade(x);
+    float v = fade(y);
+
+    int a = p[ix] + iy;
+    int b = p[ix + 1] + iy;
+
+    float res =
+        lerp(v, lerp(u, grad(p[a], x, y), grad(p[b], x - 1, y)),
+             lerp(u, grad(p[a + 1], x, y - 1), grad(p[b + 1], x - 1, y - 1)));
+
+    return (res + 1.0f) / 2.0f; // 映射到 [0, 1]
+}
+
+float PerlinNoise2D::fade(float t) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+}
+
+float PerlinNoise2D::lerp(float t, float a, float b) { return a + t * (b - a); }
+
+float PerlinNoise2D::grad(int hash, float x, float y) {
+    int h = hash & 3; // 使用低 2 位选择 4 个梯度方向
+    float u = (h & 1) ? -x : x;
+    float v = (h & 2) ? -y : y;
+    return u + v;
+}
+
+void PerlinNoise2D::reload(unsigned seed) {
+    is_init = false;
+    p.resize(256);
+    std::iota(p.begin(), p.end(), 0);
+    Logger::info("Reload Perlin Noise With Seed {}", seed);
+    std::shuffle(p.begin(), p.end(), std::mt19937(seed));
+
+    p.insert(p.end(), p.begin(), p.end());
+    is_init = true;
+}
 } // namespace Cubed