9 files changed, 966 insertions, 966 deletions
diff --git a/game/server/world/inhabited.hh b/game/server/world/inhabited.hh
index 57008e9..5eba9ef 100644
--- a/game/server/world/inhabited.hh
+++ b/game/server/world/inhabited.hh
@@ -1,6 +1,6 @@
-#pragma once
-
-namespace world
-{
-struct Inhabited final {};
-} // namespace world
+#pragma once
+
+namespace world
+{
+struct Inhabited final {};
+} // namespace world
diff --git a/game/server/world/overworld.cc b/game/server/world/overworld.cc
index fca3edf..eb801de 100644
--- a/game/server/world/overworld.cc
+++ b/game/server/world/overworld.cc
@@ -1,383 +1,383 @@
-#include "server/pch.hh"
-
-#include "server/world/overworld.hh"
-
-#include "core/math/vectors.hh"
-
-#include "shared/world/voxel_storage.hh"
-
-#include "shared/coord.hh"
-#include "shared/game_voxels.hh"
-
-// FIXME: load these from a file
-static void compute_tree_feature(unsigned int height, world::Feature& feature, voxel_id log_voxel, voxel_id leaves_voxel)
-{
-    // Ensure the tree height is too small
-    height = math::max<unsigned int>(height, 4U);
-
-    // Put down a single piece of dirt
-    feature.push_back({ voxel_pos(0, -1, 0), game_voxels::dirt, true });
-
-    // Generate tree stem
-    for(unsigned int i = 0; i < height; ++i) {
-        feature.push_back({ voxel_pos(0, i, 0), log_voxel, true });
-    }
-
-    auto leaves_start = height - 3U;
-    auto leaves_thick_end = height - 2U;
-    auto leaves_thin_end = height - 1U;
-
-    // Generate the thin 3x3 layer of leaves that
-    // starts from leaves_start and ends at leaves_thin_end
-    for(unsigned int i = leaves_start; i <= leaves_thin_end; ++i) {
-        feature.push_back({ local_pos(-1, i, -1), leaves_voxel, false });
-        feature.push_back({ local_pos(-1, i, +0), leaves_voxel, false });
-        feature.push_back({ local_pos(-1, i, +1), leaves_voxel, false });
-        feature.push_back({ local_pos(+0, i, -1), leaves_voxel, false });
-        feature.push_back({ local_pos(+0, i, +1), leaves_voxel, false });
-        feature.push_back({ local_pos(+1, i, -1), leaves_voxel, false });
-        feature.push_back({ local_pos(+1, i, +0), leaves_voxel, false });
-        feature.push_back({ local_pos(+1, i, +1), leaves_voxel, false });
-    }
-
-    // Generate the tree cap; a 3x3 patch of leaves
-    // that is slapped right on top of the thin 3x3 layer
-    feature.push_back({ local_pos(-1, height, +0), leaves_voxel, false });
-    feature.push_back({ local_pos(+0, height, -1), leaves_voxel, false });
-    feature.push_back({ local_pos(+0, height, +0), leaves_voxel, false });
-    feature.push_back({ local_pos(+0, height, +1), leaves_voxel, false });
-    feature.push_back({ local_pos(+1, height, +0), leaves_voxel, false });
-
-    // Generate the thin 5x5 layer of leaves that
-    // starts from leaves_start and ends at leaves_thin_end
-    for(unsigned int i = leaves_start; i <= leaves_thick_end; ++i) {
-        feature.push_back({ local_pos(-1, i, -2), leaves_voxel, false });
-        feature.push_back({ local_pos(-1, i, +2), leaves_voxel, false });
-        feature.push_back({ local_pos(-2, i, -1), leaves_voxel, false });
-        feature.push_back({ local_pos(-2, i, -2), leaves_voxel, false });
-        feature.push_back({ local_pos(-2, i, +0), leaves_voxel, false });
-        feature.push_back({ local_pos(-2, i, +1), leaves_voxel, false });
-        feature.push_back({ local_pos(-2, i, +2), leaves_voxel, false });
-        feature.push_back({ local_pos(+0, i, -2), leaves_voxel, false });
-        feature.push_back({ local_pos(+0, i, +2), leaves_voxel, false });
-        feature.push_back({ local_pos(+1, i, -2), leaves_voxel, false });
-        feature.push_back({ local_pos(+1, i, +2), leaves_voxel, false });
-        feature.push_back({ local_pos(+2, i, -1), leaves_voxel, false });
-        feature.push_back({ local_pos(+2, i, -2), leaves_voxel, false });
-        feature.push_back({ local_pos(+2, i, +0), leaves_voxel, false });
-        feature.push_back({ local_pos(+2, i, +1), leaves_voxel, false });
-        feature.push_back({ local_pos(+2, i, +2), leaves_voxel, false });
-    }
-}
-
-world::Overworld::Overworld(std::string_view name) : Dimension(name, -30.0f)
-{
-    m_bottommost_chunk.set_limits(-64, -4);
-    m_terrain_variation.set_limits(16, 256);
-
-    compute_tree_feature(4U, m_feat_tree[0], game_voxels::oak_log, game_voxels::oak_leaves);
-    compute_tree_feature(5U, m_feat_tree[1], game_voxels::oak_log, game_voxels::oak_leaves);
-    compute_tree_feature(6U, m_feat_tree[2], game_voxels::oak_log, game_voxels::oak_leaves);
-    compute_tree_feature(8U, m_feat_tree[3], game_voxels::oak_log, game_voxels::oak_leaves);
-}
-
-void world::Overworld::init(io::ConfigMap& config)
-{
-    m_terrain_variation.set_value(64);
-    m_bottommost_chunk.set_value(-4);
-
-    config.add_value("overworld.terrain_variation", m_terrain_variation);
-    config.add_value("overworld.bottommost_chunk", m_bottommost_chunk);
-}
-
-void world::Overworld::init_late(std::uint64_t global_seed)
-{
-    std::mt19937 twister(global_seed);
-
-    m_fnl_variation = fnlCreateState();
-    m_fnl_variation.seed = static_cast<int>(twister());
-    m_fnl_variation.noise_type = FNL_NOISE_PERLIN;
-    m_fnl_variation.frequency = 0.001f;
-
-    m_fnl_terrain = fnlCreateState();
-    m_fnl_terrain.seed = static_cast<int>(twister());
-    m_fnl_terrain.noise_type = FNL_NOISE_OPENSIMPLEX2S;
-    m_fnl_terrain.fractal_type = FNL_FRACTAL_FBM;
-    m_fnl_terrain.frequency = 0.005f;
-    m_fnl_terrain.octaves = 4;
-
-    m_fnl_caves_a = fnlCreateState();
-    m_fnl_caves_a.seed = static_cast<int>(twister());
-    m_fnl_caves_a.noise_type = FNL_NOISE_PERLIN;
-    m_fnl_caves_a.fractal_type = FNL_FRACTAL_RIDGED;
-    m_fnl_caves_a.frequency = 0.0125f;
-    m_fnl_caves_a.octaves = 1;
-
-    m_fnl_caves_b = fnlCreateState();
-    m_fnl_caves_b.seed = static_cast<int>(twister());
-    m_fnl_caves_b.noise_type = FNL_NOISE_OPENSIMPLEX2S;
-    m_fnl_caves_b.fractal_type = FNL_FRACTAL_RIDGED;
-    m_fnl_caves_b.frequency = 0.0125f;
-    m_fnl_caves_b.octaves = 1;
-
-    m_fnl_nvdi = fnlCreateState();
-    m_fnl_nvdi.seed = static_cast<int>(twister());
-    m_fnl_nvdi.noise_type = FNL_NOISE_OPENSIMPLEX2S;
-    m_fnl_nvdi.frequency = 1.0f;
-
-    m_metamap.clear();
-}
-
-bool world::Overworld::generate(const chunk_pos& cpos, VoxelStorage& voxels)
-{
-    if(cpos.y <= m_bottommost_chunk.get_value()) {
-        // If the player asks the generator
-        // to generate a lot of stuff below
-        // the surface, it will happily chew
-        // through all the server threads
-        return false;
-    }
-
-    voxels.fill(NULL_VOXEL_ID);
-
-    m_mutex.lock();
-    generate_terrain(cpos, voxels);
-    m_mutex.unlock();
-
-    m_mutex.lock();
-    generate_surface(cpos, voxels);
-    m_mutex.unlock();
-
-    m_mutex.lock();
-    generate_caves(cpos, voxels);
-    m_mutex.unlock();
-
-    m_mutex.lock();
-    generate_features(cpos, voxels);
-    m_mutex.unlock();
-
-    return true;
-}
-
-bool world::Overworld::is_inside_cave(const voxel_pos& vpos)
-{
-    auto noise_a = fnlGetNoise3D(&m_fnl_caves_a, vpos.x, vpos.y * 2.0f, vpos.z);
-    auto noise_b = fnlGetNoise3D(&m_fnl_caves_b, vpos.x, vpos.y * 2.0f, vpos.z);
-    return (noise_a > 0.95f) && (noise_b > 0.85f);
-}
-
-bool world::Overworld::is_inside_terrain(const voxel_pos& vpos)
-{
-    auto variation_noise = fnlGetNoise3D(&m_fnl_terrain, vpos.x, vpos.y, vpos.z);
-    auto variation = m_terrain_variation.get_value() * (1.0f - (variation_noise * variation_noise));
-    auto noise = variation * fnlGetNoise3D(&m_fnl_terrain, vpos.x, vpos.y, vpos.z) - vpos.y;
-    return noise > 0.0f;
-}
-
-const world::Overworld_Metadata& world::Overworld::get_or_create_metadata(const chunk_pos_xz& cpos)
-{
-    auto it = m_metamap.find(cpos);
-
-    if(it != m_metamap.cend()) {
-        // Metadata is present
-        return it->second;
-    }
-
-    auto& metadata = m_metamap.insert_or_assign(cpos, Overworld_Metadata()).first->second;
-    metadata.entropy.fill(std::numeric_limits<std::uint64_t>::max());
-    metadata.heightmap.fill(std::numeric_limits<voxel_pos::value_type>::min());
-
-    auto twister = std::mt19937_64(std::hash<chunk_pos_xz>()(cpos));
-    auto variation = m_terrain_variation.get_value();
-
-    // Generator might need some randomness
-    // that depends on 2D coordinates, so we
-    // generate this entropy ahead of time
-    for(int i = 0; i < CHUNK_AREA; ++i) {
-        metadata.entropy[i] = twister();
-    }
-
-    // Generate speculative heightmap;
-    // Cave generation might have issues with placing
-    // surface features such as trees but I genuinely don't give a shit
-    for(int lx = 0; lx < CHUNK_SIZE; lx += 1) {
-        for(int lz = 0; lz < CHUNK_SIZE; lz += 1) {
-            auto hdx = static_cast<std::size_t>(lx + lz * CHUNK_SIZE);
-            auto vpos = coord::to_voxel(chunk_pos(cpos.x, 0, cpos.y), local_pos(lx, 0, lz));
-
-            for(vpos.y = variation; vpos.y >= -variation; vpos.y -= 1) {
-                if(is_inside_terrain(vpos)) {
-                    metadata.heightmap[hdx] = vpos.y;
-                    break;
-                }
-            }
-        }
-    }
-
-    auto nvdi_value = 0.5f + 0.5f * fnlGetNoise2D(&m_fnl_nvdi, cpos.x, cpos.y);
-    auto tree_density = (nvdi_value >= 0.33f) ? math::floor<unsigned int>(nvdi_value * 4.0f) : 0U;
-
-    for(unsigned int i = 0U; i < tree_density; ++i) {
-        auto lpos = local_pos((twister() % CHUNK_SIZE), (twister() % OW_NUM_TREES), (twister() % CHUNK_SIZE));
-        auto is_unique = true;
-
-        for(const auto& check_lpos : metadata.trees) {
-            if(math::distance2(check_lpos, lpos) <= 9) {
-                is_unique = false;
-                break;
-            }
-        }
-
-        if(is_unique) {
-            metadata.trees.push_back(lpos);
-        }
-    }
-
-    return metadata;
-}
-
-void world::Overworld::generate_terrain(const chunk_pos& cpos, VoxelStorage& voxels)
-{
-    auto& metadata = get_or_create_metadata(chunk_pos_xz(cpos.x, cpos.z));
-    auto variation = m_terrain_variation.get_value();
-
-    for(unsigned long i = 0; i < CHUNK_VOLUME; ++i) {
-        auto lpos = coord::to_local(i);
-        auto vpos = coord::to_voxel(cpos, lpos);
-
-        if(vpos.y > variation) {
-            voxels[i] = NULL_VOXEL_ID;
-            continue;
-        }
-
-        if(vpos.y < -variation) {
-            voxels[i] = game_voxels::stone;
-            continue;
-        }
-
-        if(is_inside_terrain(vpos)) {
-            voxels[i] = game_voxels::stone;
-            continue;
-        }
-    }
-}
-
-void world::Overworld::generate_surface(const chunk_pos& cpos, VoxelStorage& voxels)
-{
-    auto& metadata = get_or_create_metadata(chunk_pos_xz(cpos.x, cpos.z));
-    auto variation = m_terrain_variation.get_value();
-
-    for(unsigned long i = 0; i < CHUNK_VOLUME; ++i) {
-        auto lpos = coord::to_local(i);
-        auto vpos = coord::to_voxel(cpos, lpos);
-        auto hdx = static_cast<std::size_t>(lpos.x + lpos.z * CHUNK_SIZE);
-
-        if((vpos.y > variation) || (vpos.y < -variation)) {
-            // Speculative optimization
-            continue;
-        }
-
-        if(voxels[i] == NULL_VOXEL_ID) {
-            // Surface voxel checks only apply for solid voxels;
-            // it's kind of obvious you can't replace air with grass
-            continue;
-        }
-
-        unsigned int depth = 0U;
-
-        for(unsigned int dy = 0U; dy < 5U; dy += 1U) {
-            auto d_lpos = local_pos(lpos.x, lpos.y + dy + 1, lpos.z);
-            auto d_vpos = coord::to_voxel(cpos, d_lpos);
-            auto d_index = coord::to_index(d_lpos);
-
-            if(d_lpos.y >= CHUNK_SIZE) {
-                if(!is_inside_terrain(d_vpos)) {
-                    break;
-                }
-
-                depth += 1U;
-            }
-            else {
-                if(voxels[d_index] == NULL_VOXEL_ID) {
-                    break;
-                }
-
-                depth += 1U;
-            }
-        }
-
-        if(depth < 5U) {
-            if(depth == 0U) {
-                voxels[i] = game_voxels::grass;
-            }
-            else {
-                voxels[i] = game_voxels::dirt;
-            }
-        }
-    }
-}
-
-void world::Overworld::generate_caves(const chunk_pos& cpos, VoxelStorage& voxels)
-{
-    auto& metadata = get_or_create_metadata(chunk_pos_xz(cpos.x, cpos.z));
-    auto variation = m_terrain_variation.get_value();
-
-    for(unsigned long i = 0U; i < CHUNK_VOLUME; ++i) {
-        auto lpos = coord::to_local(i);
-        auto vpos = coord::to_voxel(cpos, lpos);
-
-        if(vpos.y > variation) {
-            // Speculative optimization - there's no solid
-            // terrain above variation to carve caves out from
-            continue;
-        }
-
-        if(is_inside_cave(vpos)) {
-            voxels[i] = NULL_VOXEL_ID;
-            continue;
-        }
-    }
-}
-
-void world::Overworld::generate_features(const chunk_pos& cpos, VoxelStorage& voxels)
-{
-    const chunk_pos_xz tree_chunks[] = {
-        chunk_pos_xz(cpos.x - 0, cpos.z - 1),
-        chunk_pos_xz(cpos.x - 1, cpos.z - 1),
-        chunk_pos_xz(cpos.x - 1, cpos.z + 0),
-        chunk_pos_xz(cpos.x - 1, cpos.z + 1),
-        chunk_pos_xz(cpos.x + 0, cpos.z + 0),
-        chunk_pos_xz(cpos.x + 0, cpos.z + 1),
-        chunk_pos_xz(cpos.x + 1, cpos.z - 1),
-        chunk_pos_xz(cpos.x + 1, cpos.z + 0),
-        chunk_pos_xz(cpos.x + 1, cpos.z + 1),
-    };
-
-    for(unsigned int i = 0U; i < math::array_size(tree_chunks); ++i) {
-        const auto& cpos_xz = tree_chunks[i];
-        const auto& metadata = get_or_create_metadata(cpos_xz);
-
-        for(const auto& tree_info : metadata.trees) {
-            auto hdx = static_cast<std::size_t>(tree_info.x + tree_info.z * CHUNK_SIZE);
-            auto height = metadata.heightmap[hdx];
-
-            if(height == std::numeric_limits<voxel_pos::value_type>::min()) {
-                // What happened? Cave happened
-                continue;
-            }
-
-            auto cpos_xyz = chunk_pos(cpos_xz.x, 0, cpos_xz.y);
-            auto lpos_xyz = local_pos(tree_info.x, 0, tree_info.z);
-
-            auto vpos = coord::to_voxel(cpos_xyz, lpos_xyz);
-            vpos.y = height;
-
-            if(is_inside_cave(vpos)) {
-                // Cave is in the way
-                continue;
-            }
-
-            m_feat_tree[tree_info.y].place(vpos + DIR_UP<voxel_pos::value_type>, cpos, voxels);
-        }
-    }
-}
+#include "server/pch.hh"
+
+#include "server/world/overworld.hh"
+
+#include "core/math/vectors.hh"
+
+#include "shared/world/voxel_storage.hh"
+
+#include "shared/coord.hh"
+#include "shared/game_voxels.hh"
+
+// FIXME: load these from a file
+static void compute_tree_feature(unsigned int height, world::Feature& feature, voxel_id log_voxel, voxel_id leaves_voxel)
+{
+    // Ensure the tree height is too small
+    height = math::max<unsigned int>(height, 4U);
+
+    // Put down a single piece of dirt
+    feature.push_back({ voxel_pos(0, -1, 0), game_voxels::dirt, true });
+
+    // Generate tree stem
+    for(unsigned int i = 0; i < height; ++i) {
+        feature.push_back({ voxel_pos(0, i, 0), log_voxel, true });
+    }
+
+    auto leaves_start = height - 3U;
+    auto leaves_thick_end = height - 2U;
+    auto leaves_thin_end = height - 1U;
+
+    // Generate the thin 3x3 layer of leaves that
+    // starts from leaves_start and ends at leaves_thin_end
+    for(unsigned int i = leaves_start; i <= leaves_thin_end; ++i) {
+        feature.push_back({ local_pos(-1, i, -1), leaves_voxel, false });
+        feature.push_back({ local_pos(-1, i, +0), leaves_voxel, false });
+        feature.push_back({ local_pos(-1, i, +1), leaves_voxel, false });
+        feature.push_back({ local_pos(+0, i, -1), leaves_voxel, false });
+        feature.push_back({ local_pos(+0, i, +1), leaves_voxel, false });
+        feature.push_back({ local_pos(+1, i, -1), leaves_voxel, false });
+        feature.push_back({ local_pos(+1, i, +0), leaves_voxel, false });
+        feature.push_back({ local_pos(+1, i, +1), leaves_voxel, false });
+    }
+
+    // Generate the tree cap; a 3x3 patch of leaves
+    // that is slapped right on top of the thin 3x3 layer
+    feature.push_back({ local_pos(-1, height, +0), leaves_voxel, false });
+    feature.push_back({ local_pos(+0, height, -1), leaves_voxel, false });
+    feature.push_back({ local_pos(+0, height, +0), leaves_voxel, false });
+    feature.push_back({ local_pos(+0, height, +1), leaves_voxel, false });
+    feature.push_back({ local_pos(+1, height, +0), leaves_voxel, false });
+
+    // Generate the thin 5x5 layer of leaves that
+    // starts from leaves_start and ends at leaves_thin_end
+    for(unsigned int i = leaves_start; i <= leaves_thick_end; ++i) {
+        feature.push_back({ local_pos(-1, i, -2), leaves_voxel, false });
+        feature.push_back({ local_pos(-1, i, +2), leaves_voxel, false });
+        feature.push_back({ local_pos(-2, i, -1), leaves_voxel, false });
+        feature.push_back({ local_pos(-2, i, -2), leaves_voxel, false });
+        feature.push_back({ local_pos(-2, i, +0), leaves_voxel, false });
+        feature.push_back({ local_pos(-2, i, +1), leaves_voxel, false });
+        feature.push_back({ local_pos(-2, i, +2), leaves_voxel, false });
+        feature.push_back({ local_pos(+0, i, -2), leaves_voxel, false });
+        feature.push_back({ local_pos(+0, i, +2), leaves_voxel, false });
+        feature.push_back({ local_pos(+1, i, -2), leaves_voxel, false });
+        feature.push_back({ local_pos(+1, i, +2), leaves_voxel, false });
+        feature.push_back({ local_pos(+2, i, -1), leaves_voxel, false });
+        feature.push_back({ local_pos(+2, i, -2), leaves_voxel, false });
+        feature.push_back({ local_pos(+2, i, +0), leaves_voxel, false });
+        feature.push_back({ local_pos(+2, i, +1), leaves_voxel, false });
+        feature.push_back({ local_pos(+2, i, +2), leaves_voxel, false });
+    }
+}
+
+world::Overworld::Overworld(std::string_view name) : Dimension(name, -30.0f)
+{
+    m_bottommost_chunk.set_limits(-64, -4);
+    m_terrain_variation.set_limits(16, 256);
+
+    compute_tree_feature(4U, m_feat_tree[0], game_voxels::oak_log, game_voxels::oak_leaves);
+    compute_tree_feature(5U, m_feat_tree[1], game_voxels::oak_log, game_voxels::oak_leaves);
+    compute_tree_feature(6U, m_feat_tree[2], game_voxels::oak_log, game_voxels::oak_leaves);
+    compute_tree_feature(8U, m_feat_tree[3], game_voxels::oak_log, game_voxels::oak_leaves);
+}
+
+void world::Overworld::init(io::ConfigMap& config)
+{
+    m_terrain_variation.set_value(64);
+    m_bottommost_chunk.set_value(-4);
+
+    config.add_value("overworld.terrain_variation", m_terrain_variation);
+    config.add_value("overworld.bottommost_chunk", m_bottommost_chunk);
+}
+
+void world::Overworld::init_late(std::uint64_t global_seed)
+{
+    std::mt19937 twister(global_seed);
+
+    m_fnl_variation = fnlCreateState();
+    m_fnl_variation.seed = static_cast<int>(twister());
+    m_fnl_variation.noise_type = FNL_NOISE_PERLIN;
+    m_fnl_variation.frequency = 0.001f;
+
+    m_fnl_terrain = fnlCreateState();
+    m_fnl_terrain.seed = static_cast<int>(twister());
+    m_fnl_terrain.noise_type = FNL_NOISE_OPENSIMPLEX2S;
+    m_fnl_terrain.fractal_type = FNL_FRACTAL_FBM;
+    m_fnl_terrain.frequency = 0.005f;
+    m_fnl_terrain.octaves = 4;
+
+    m_fnl_caves_a = fnlCreateState();
+    m_fnl_caves_a.seed = static_cast<int>(twister());
+    m_fnl_caves_a.noise_type = FNL_NOISE_PERLIN;
+    m_fnl_caves_a.fractal_type = FNL_FRACTAL_RIDGED;
+    m_fnl_caves_a.frequency = 0.0125f;
+    m_fnl_caves_a.octaves = 1;
+
+    m_fnl_caves_b = fnlCreateState();
+    m_fnl_caves_b.seed = static_cast<int>(twister());
+    m_fnl_caves_b.noise_type = FNL_NOISE_OPENSIMPLEX2S;
+    m_fnl_caves_b.fractal_type = FNL_FRACTAL_RIDGED;
+    m_fnl_caves_b.frequency = 0.0125f;
+    m_fnl_caves_b.octaves = 1;
+
+    m_fnl_nvdi = fnlCreateState();
+    m_fnl_nvdi.seed = static_cast<int>(twister());
+    m_fnl_nvdi.noise_type = FNL_NOISE_OPENSIMPLEX2S;
+    m_fnl_nvdi.frequency = 1.0f;
+
+    m_metamap.clear();
+}
+
+bool world::Overworld::generate(const chunk_pos& cpos, VoxelStorage& voxels)
+{
+    if(cpos.y <= m_bottommost_chunk.get_value()) {
+        // If the player asks the generator
+        // to generate a lot of stuff below
+        // the surface, it will happily chew
+        // through all the server threads
+        return false;
+    }
+
+    voxels.fill(NULL_VOXEL_ID);
+
+    m_mutex.lock();
+    generate_terrain(cpos, voxels);
+    m_mutex.unlock();
+
+    m_mutex.lock();
+    generate_surface(cpos, voxels);
+    m_mutex.unlock();
+
+    m_mutex.lock();
+    generate_caves(cpos, voxels);
+    m_mutex.unlock();
+
+    m_mutex.lock();
+    generate_features(cpos, voxels);
+    m_mutex.unlock();
+
+    return true;
+}
+
+bool world::Overworld::is_inside_cave(const voxel_pos& vpos)
+{
+    auto noise_a = fnlGetNoise3D(&m_fnl_caves_a, vpos.x, vpos.y * 2.0f, vpos.z);
+    auto noise_b = fnlGetNoise3D(&m_fnl_caves_b, vpos.x, vpos.y * 2.0f, vpos.z);
+    return (noise_a > 0.95f) && (noise_b > 0.85f);
+}
+
+bool world::Overworld::is_inside_terrain(const voxel_pos& vpos)
+{
+    auto variation_noise = fnlGetNoise3D(&m_fnl_terrain, vpos.x, vpos.y, vpos.z);
+    auto variation = m_terrain_variation.get_value() * (1.0f - (variation_noise * variation_noise));
+    auto noise = variation * fnlGetNoise3D(&m_fnl_terrain, vpos.x, vpos.y, vpos.z) - vpos.y;
+    return noise > 0.0f;
+}
+
+const world::Overworld_Metadata& world::Overworld::get_or_create_metadata(const chunk_pos_xz& cpos)
+{
+    auto it = m_metamap.find(cpos);
+
+    if(it != m_metamap.cend()) {
+        // Metadata is present
+        return it->second;
+    }
+
+    auto& metadata = m_metamap.insert_or_assign(cpos, Overworld_Metadata()).first->second;
+    metadata.entropy.fill(std::numeric_limits<std::uint64_t>::max());
+    metadata.heightmap.fill(std::numeric_limits<voxel_pos::value_type>::min());
+
+    auto twister = std::mt19937_64(std::hash<chunk_pos_xz>()(cpos));
+    auto variation = m_terrain_variation.get_value();
+
+    // Generator might need some randomness
+    // that depends on 2D coordinates, so we
+    // generate this entropy ahead of time
+    for(int i = 0; i < CHUNK_AREA; ++i) {
+        metadata.entropy[i] = twister();
+    }
+
+    // Generate speculative heightmap;
+    // Cave generation might have issues with placing
+    // surface features such as trees but I genuinely don't give a shit
+    for(int lx = 0; lx < CHUNK_SIZE; lx += 1) {
+        for(int lz = 0; lz < CHUNK_SIZE; lz += 1) {
+            auto hdx = static_cast<std::size_t>(lx + lz * CHUNK_SIZE);
+            auto vpos = coord::to_voxel(chunk_pos(cpos.x, 0, cpos.y), local_pos(lx, 0, lz));
+
+            for(vpos.y = variation; vpos.y >= -variation; vpos.y -= 1) {
+                if(is_inside_terrain(vpos)) {
+                    metadata.heightmap[hdx] = vpos.y;
+                    break;
+                }
+            }
+        }
+    }
+
+    auto nvdi_value = 0.5f + 0.5f * fnlGetNoise2D(&m_fnl_nvdi, cpos.x, cpos.y);
+    auto tree_density = (nvdi_value >= 0.33f) ? math::floor<unsigned int>(nvdi_value * 4.0f) : 0U;
+
+    for(unsigned int i = 0U; i < tree_density; ++i) {
+        auto lpos = local_pos((twister() % CHUNK_SIZE), (twister() % OW_NUM_TREES), (twister() % CHUNK_SIZE));
+        auto is_unique = true;
+
+        for(const auto& check_lpos : metadata.trees) {
+            if(math::distance2(check_lpos, lpos) <= 9) {
+                is_unique = false;
+                break;
+            }
+        }
+
+        if(is_unique) {
+            metadata.trees.push_back(lpos);
+        }
+    }
+
+    return metadata;
+}
+
+void world::Overworld::generate_terrain(const chunk_pos& cpos, VoxelStorage& voxels)
+{
+    auto& metadata = get_or_create_metadata(chunk_pos_xz(cpos.x, cpos.z));
+    auto variation = m_terrain_variation.get_value();
+
+    for(unsigned long i = 0; i < CHUNK_VOLUME; ++i) {
+        auto lpos = coord::to_local(i);
+        auto vpos = coord::to_voxel(cpos, lpos);
+
+        if(vpos.y > variation) {
+            voxels[i] = NULL_VOXEL_ID;
+            continue;
+        }
+
+        if(vpos.y < -variation) {
+            voxels[i] = game_voxels::stone;
+            continue;
+        }
+
+        if(is_inside_terrain(vpos)) {
+            voxels[i] = game_voxels::stone;
+            continue;
+        }
+    }
+}
+
+void world::Overworld::generate_surface(const chunk_pos& cpos, VoxelStorage& voxels)
+{
+    auto& metadata = get_or_create_metadata(chunk_pos_xz(cpos.x, cpos.z));
+    auto variation = m_terrain_variation.get_value();
+
+    for(unsigned long i = 0; i < CHUNK_VOLUME; ++i) {
+        auto lpos = coord::to_local(i);
+        auto vpos = coord::to_voxel(cpos, lpos);
+        auto hdx = static_cast<std::size_t>(lpos.x + lpos.z * CHUNK_SIZE);
+
+        if((vpos.y > variation) || (vpos.y < -variation)) {
+            // Speculative optimization
+            continue;
+        }
+
+        if(voxels[i] == NULL_VOXEL_ID) {
+            // Surface voxel checks only apply for solid voxels;
+            // it's kind of obvious you can't replace air with grass
+            continue;
+        }
+
+        unsigned int depth = 0U;
+
+        for(unsigned int dy = 0U; dy < 5U; dy += 1U) {
+            auto d_lpos = local_pos(lpos.x, lpos.y + dy + 1, lpos.z);
+            auto d_vpos = coord::to_voxel(cpos, d_lpos);
+            auto d_index = coord::to_index(d_lpos);
+
+            if(d_lpos.y >= CHUNK_SIZE) {
+                if(!is_inside_terrain(d_vpos)) {
+                    break;
+                }
+
+                depth += 1U;
+            }
+            else {
+                if(voxels[d_index] == NULL_VOXEL_ID) {
+                    break;
+                }
+
+                depth += 1U;
+            }
+        }
+
+        if(depth < 5U) {
+            if(depth == 0U) {
+                voxels[i] = game_voxels::grass;
+            }
+            else {
+                voxels[i] = game_voxels::dirt;
+            }
+        }
+    }
+}
+
+void world::Overworld::generate_caves(const chunk_pos& cpos, VoxelStorage& voxels)
+{
+    auto& metadata = get_or_create_metadata(chunk_pos_xz(cpos.x, cpos.z));
+    auto variation = m_terrain_variation.get_value();
+
+    for(unsigned long i = 0U; i < CHUNK_VOLUME; ++i) {
+        auto lpos = coord::to_local(i);
+        auto vpos = coord::to_voxel(cpos, lpos);
+
+        if(vpos.y > variation) {
+            // Speculative optimization - there's no solid
+            // terrain above variation to carve caves out from
+            continue;
+        }
+
+        if(is_inside_cave(vpos)) {
+            voxels[i] = NULL_VOXEL_ID;
+            continue;
+        }
+    }
+}
+
+void world::Overworld::generate_features(const chunk_pos& cpos, VoxelStorage& voxels)
+{
+    const chunk_pos_xz tree_chunks[] = {
+        chunk_pos_xz(cpos.x - 0, cpos.z - 1),
+        chunk_pos_xz(cpos.x - 1, cpos.z - 1),
+        chunk_pos_xz(cpos.x - 1, cpos.z + 0),
+        chunk_pos_xz(cpos.x - 1, cpos.z + 1),
+        chunk_pos_xz(cpos.x + 0, cpos.z + 0),
+        chunk_pos_xz(cpos.x + 0, cpos.z + 1),
+        chunk_pos_xz(cpos.x + 1, cpos.z - 1),
+        chunk_pos_xz(cpos.x + 1, cpos.z + 0),
+        chunk_pos_xz(cpos.x + 1, cpos.z + 1),
+    };
+
+    for(unsigned int i = 0U; i < math::array_size(tree_chunks); ++i) {
+        const auto& cpos_xz = tree_chunks[i];
+        const auto& metadata = get_or_create_metadata(cpos_xz);
+
+        for(const auto& tree_info : metadata.trees) {
+            auto hdx = static_cast<std::size_t>(tree_info.x + tree_info.z * CHUNK_SIZE);
+            auto height = metadata.heightmap[hdx];
+
+            if(height == std::numeric_limits<voxel_pos::value_type>::min()) {
+                // What happened? Cave happened
+                continue;
+            }
+
+            auto cpos_xyz = chunk_pos(cpos_xz.x, 0, cpos_xz.y);
+            auto lpos_xyz = local_pos(tree_info.x, 0, tree_info.z);
+
+            auto vpos = coord::to_voxel(cpos_xyz, lpos_xyz);
+            vpos.y = height;
+
+            if(is_inside_cave(vpos)) {
+                // Cave is in the way
+                continue;
+            }
+
+            m_feat_tree[tree_info.y].place(vpos + DIR_UP<voxel_pos::value_type>, cpos, voxels);
+        }
+    }
+}
diff --git a/game/server/world/overworld.hh b/game/server/world/overworld.hh
index f3fc8cf..a8112cf 100644
--- a/game/server/world/overworld.hh
+++ b/game/server/world/overworld.hh
@@ -1,68 +1,68 @@
-#pragma once
-
-#include "core/config/number.hh"
-
-#include "core/io/config_map.hh"
-
-#include "shared/world/dimension.hh"
-#include "shared/world/feature.hh"
-
-#include "shared/const.hh"
-
-constexpr static unsigned int OW_NUM_TREES = 4U;
-
-namespace world
-{
-struct Overworld_Metadata final {
-    world::dimension_entropy_map entropy;
-    world::dimension_height_map heightmap;
-    std::vector<local_pos> trees;
-};
-} // namespace world
-
-namespace world
-{
-class Overworld final : public Dimension {
-public:
-    explicit Overworld(std::string_view name);
-    virtual ~Overworld(void) = default;
-
-public:
-    virtual void init(io::ConfigMap& config) override;
-    virtual void init_late(std::uint64_t global_seed) override;
-    virtual bool generate(const chunk_pos& cpos, VoxelStorage& voxels) override;
-
-private:
-    bool is_inside_cave(const voxel_pos& vpos);
-    bool is_inside_terrain(const voxel_pos& vpos);
-
-private:
-    const Overworld_Metadata& get_or_create_metadata(const chunk_pos_xz& cpos);
-
-private:
-    void generate_terrain(const chunk_pos& cpos, VoxelStorage& voxels);
-    void generate_surface(const chunk_pos& cpos, VoxelStorage& voxels);
-    void generate_caves(const chunk_pos& cpos, VoxelStorage& voxels);
-    void generate_features(const chunk_pos& cpos, VoxelStorage& voxels);
-
-private:
-    config::Int m_terrain_variation;
-    config::Int m_bottommost_chunk;
-
-private:
-    emhash8::HashMap<chunk_pos_xz, Overworld_Metadata> m_metamap;
-
-private:
-    fnl_state m_fnl_variation;
-    fnl_state m_fnl_terrain;
-    fnl_state m_fnl_caves_a;
-    fnl_state m_fnl_caves_b;
-    fnl_state m_fnl_nvdi;
-
-private:
-    Feature m_feat_tree[OW_NUM_TREES];
-
-private:
-    std::mutex m_mutex;
-};
-} // namespace world
+#pragma once
+
+#include "core/config/number.hh"
+
+#include "core/io/config_map.hh"
+
+#include "shared/world/dimension.hh"
+#include "shared/world/feature.hh"
+
+#include "shared/const.hh"
+
+constexpr static unsigned int OW_NUM_TREES = 4U;
+
+namespace world
+{
+struct Overworld_Metadata final {
+    world::dimension_entropy_map entropy;
+    world::dimension_height_map heightmap;
+    std::vector<local_pos> trees;
+};
+} // namespace world
+
+namespace world
+{
+class Overworld final : public Dimension {
+public:
+    explicit Overworld(std::string_view name);
+    virtual ~Overworld(void) = default;
+
+public:
+    virtual void init(io::ConfigMap& config) override;
+    virtual void init_late(std::uint64_t global_seed) override;
+    virtual bool generate(const chunk_pos& cpos, VoxelStorage& voxels) override;
+
+private:
+    bool is_inside_cave(const voxel_pos& vpos);
+    bool is_inside_terrain(const voxel_pos& vpos);
+
+private:
+    const Overworld_Metadata& get_or_create_metadata(const chunk_pos_xz& cpos);
+
+private:
+    void generate_terrain(const chunk_pos& cpos, VoxelStorage& voxels);
+    void generate_surface(const chunk_pos& cpos, VoxelStorage& voxels);
+    void generate_caves(const chunk_pos& cpos, VoxelStorage& voxels);
+    void generate_features(const chunk_pos& cpos, VoxelStorage& voxels);
+
+private:
+    config::Int m_terrain_variation;
+    config::Int m_bottommost_chunk;
+
+private:
+    emhash8::HashMap<chunk_pos_xz, Overworld_Metadata> m_metamap;
+
+private:
+    fnl_state m_fnl_variation;
+    fnl_state m_fnl_terrain;
+    fnl_state m_fnl_caves_a;
+    fnl_state m_fnl_caves_b;
+    fnl_state m_fnl_nvdi;
+
+private:
+    Feature m_feat_tree[OW_NUM_TREES];
+
+private:
+    std::mutex m_mutex;
+};
+} // namespace world
diff --git a/game/server/world/universe.cc b/game/server/world/universe.cc
index 278d0a9..2dd6053 100644
--- a/game/server/world/universe.cc
+++ b/game/server/world/universe.cc
@@ -1,221 +1,221 @@
-#include "server/pch.hh"
-
-#include "server/world/universe.hh"
-
-#include "core/config/number.hh"
-#include "core/config/string.hh"
-
-#include "core/io/buffer.hh"
-#include "core/io/config_map.hh"
-
-#include "core/utils/epoch.hh"
-
-#include "shared/world/chunk.hh"
-#include "shared/world/dimension.hh"
-
-#include "server/world/inhabited.hh"
-#include "server/world/overworld.hh"
-
-#include "server/globals.hh"
-
-struct DimensionMetadata final {
-    std::string config_path;
-    std::string zvox_dir;
-    io::ConfigMap config;
-};
-
-static config::String universe_name("save");
-
-static io::ConfigMap universe_config;
-static config::Unsigned64 universe_config_seed;
-static config::String universe_spawn_dimension("world");
-
-static std::string universe_config_path;
-static std::unordered_map<world::Dimension*, DimensionMetadata*> metadata_map;
-
-static std::string make_chunk_filename(const DimensionMetadata* metadata, const chunk_pos& cpos)
-{
-    const auto unsigned_x = static_cast<std::uint32_t>(cpos.x);
-    const auto unsigned_y = static_cast<std::uint32_t>(cpos.y);
-    const auto unsigned_z = static_cast<std::uint32_t>(cpos.z);
-    return std::format("{}/{:08X}-{:08X}-{:08X}.zvox", metadata->zvox_dir, unsigned_x, unsigned_y, unsigned_z);
-}
-
-static void add_new_dimension(world::Dimension* dimension)
-{
-    if(globals::dimensions.count(std::string(dimension->get_name()))) {
-        spdlog::critical("universe: dimension named {} already exists", dimension->get_name());
-        std::terminate();
-    }
-
-    auto dimension_dir = std::format("{}/{}", universe_name.get(), dimension->get_name());
-
-    if(!PHYSFS_mkdir(dimension_dir.c_str())) {
-        spdlog::critical("universe: {}: {}", dimension_dir, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
-        std::terminate();
-    }
-
-    auto metadata = new DimensionMetadata;
-    metadata->config_path = std::format("{}/dimension.conf", dimension_dir);
-    metadata->zvox_dir = std::format("{}/chunk", dimension_dir);
-
-    if(!PHYSFS_mkdir(metadata->zvox_dir.c_str())) {
-        spdlog::critical("universe: {}: {}", metadata->zvox_dir, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
-        std::terminate();
-    }
-
-    globals::dimensions.insert_or_assign(std::string(dimension->get_name()), dimension);
-
-    auto& mapped_metadata = metadata_map.insert_or_assign(dimension, metadata).first->second;
-
-    dimension->init(mapped_metadata->config);
-
-    mapped_metadata->config.load_file(mapped_metadata->config_path.c_str());
-
-    dimension->init_late(universe_config_seed.get_value());
-}
-
-static void internal_save_chunk(const DimensionMetadata* metadata, const world::Dimension* dimension, const chunk_pos& cpos,
-    const world::Chunk* chunk)
-{
-    auto path = make_chunk_filename(metadata, cpos);
-
-    io::WriteBuffer buffer;
-    chunk->get_voxels().serialize(buffer);
-
-    if(auto file = buffer.to_file(path.c_str())) {
-        PHYSFS_close(file);
-        return;
-    }
-}
-
-void world::universe::init(void)
-{
-    // If the world is newly created, the seed will
-    // be chosed based on the current system's view on UNIX time
-    universe_config_seed.set_value(utils::unix_microseconds());
-
-    // We're going to read files from directory named with
-    // the value of this config value. Since config is also
-    // read from command line, the [--universe <name>] parameter still works
-    globals::server_config.add_value("universe", universe_name);
-
-    universe_config.add_value("global_seed", universe_config_seed);
-    universe_config.add_value("spawn_dimension", universe_spawn_dimension);
-}
-
-void world::universe::init_late(void)
-{
-    const auto universe_dir = std::string(universe_name.get());
-
-    if(!PHYSFS_mkdir(universe_dir.c_str())) {
-        spdlog::critical("universe: {}: {}", universe_dir, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
-        std::terminate();
-    }
-
-    universe_config_path = std::format("{}/universe.conf", universe_dir);
-    universe_config.load_file(universe_config_path.c_str());
-
-    add_new_dimension(new Overworld("world"));
-
-    // UNDONE: lua scripts to setup dimensions
-    if(globals::dimensions.empty()) {
-        spdlog::critical("universe: no dimensions");
-        std::terminate();
-    }
-
-    auto spawn_dimension = globals::dimensions.find(universe_spawn_dimension.get_value());
-
-    if(spawn_dimension == globals::dimensions.cend()) {
-        spdlog::critical("universe: {} is not a valid dimension name", universe_spawn_dimension.get());
-        std::terminate();
-    }
-
-    globals::spawn_dimension = spawn_dimension->second;
-}
-
-void world::universe::shutdown(void)
-{
-    for(const auto metadata : metadata_map) {
-        metadata.second->config.save_file(metadata.second->config_path.c_str());
-        delete metadata.second;
-    }
-
-    metadata_map.clear();
-
-    for(const auto dimension : globals::dimensions) {
-        world::universe::save_all_chunks(dimension.second);
-        delete dimension.second;
-    }
-
-    globals::dimensions.clear();
-    globals::spawn_dimension = nullptr;
-
-    universe_config.save_file(universe_config_path.c_str());
-}
-
-world::Chunk* world::universe::load_chunk(Dimension* dimension, const chunk_pos& cpos)
-{
-    if(auto chunk = dimension->find_chunk(cpos)) {
-        // Just return the existing chunk which is
-        // most probable to be up to date compared to
-        // whatever the hell is currently stored on disk
-        return chunk;
-    }
-
-    auto metadata = metadata_map.find(dimension);
-
-    if(metadata == metadata_map.cend()) {
-        // The dimension is for sure a weird one
-        return nullptr;
-    }
-
-    if(auto file = PHYSFS_openRead(make_chunk_filename(metadata->second, cpos).c_str())) {
-        VoxelStorage voxels;
-        io::ReadBuffer buffer(file);
-        voxels.deserialize(buffer);
-
-        PHYSFS_close(file);
-
-        auto chunk = dimension->create_chunk(cpos);
-        chunk->set_voxels(voxels);
-
-        // Make sure we're going to save it later
-        dimension->chunks.emplace_or_replace<Inhabited>(chunk->get_entity());
-
-        return chunk;
-    }
-
-    return nullptr;
-}
-
-void world::universe::save_chunk(Dimension* dimension, const chunk_pos& cpos)
-{
-    auto metadata = metadata_map.find(dimension);
-
-    if(metadata == metadata_map.cend()) {
-        // Cannot save a chunk in a dimension
-        // that doesn't have a metadata struct
-        return;
-    }
-
-    if(auto chunk = dimension->find_chunk(cpos)) {
-        internal_save_chunk(metadata->second, dimension, cpos, chunk);
-    }
-}
-
-void world::universe::save_all_chunks(Dimension* dimension)
-{
-    auto group = dimension->chunks.group(entt::get<ChunkComponent, Inhabited>);
-    auto metadata = metadata_map.find(dimension);
-
-    if(metadata == metadata_map.cend()) {
-        // Cannot save a chunk in a dimension
-        // that doesn't have a metadata struct
-        return;
-    }
-
-    for(auto [entity, chunk] : group.each()) {
-        internal_save_chunk(metadata->second, dimension, chunk.cpos, chunk.chunk);
-    }
-}
+#include "server/pch.hh"
+
+#include "server/world/universe.hh"
+
+#include "core/config/number.hh"
+#include "core/config/string.hh"
+
+#include "core/io/buffer.hh"
+#include "core/io/config_map.hh"
+
+#include "core/utils/epoch.hh"
+
+#include "shared/world/chunk.hh"
+#include "shared/world/dimension.hh"
+
+#include "server/world/inhabited.hh"
+#include "server/world/overworld.hh"
+
+#include "server/globals.hh"
+
+struct DimensionMetadata final {
+    std::string config_path;
+    std::string zvox_dir;
+    io::ConfigMap config;
+};
+
+static config::String universe_name("save");
+
+static io::ConfigMap universe_config;
+static config::Unsigned64 universe_config_seed;
+static config::String universe_spawn_dimension("world");
+
+static std::string universe_config_path;
+static std::unordered_map<world::Dimension*, DimensionMetadata*> metadata_map;
+
+static std::string make_chunk_filename(const DimensionMetadata* metadata, const chunk_pos& cpos)
+{
+    const auto unsigned_x = static_cast<std::uint32_t>(cpos.x);
+    const auto unsigned_y = static_cast<std::uint32_t>(cpos.y);
+    const auto unsigned_z = static_cast<std::uint32_t>(cpos.z);
+    return std::format("{}/{:08X}-{:08X}-{:08X}.zvox", metadata->zvox_dir, unsigned_x, unsigned_y, unsigned_z);
+}
+
+static void add_new_dimension(world::Dimension* dimension)
+{
+    if(globals::dimensions.count(std::string(dimension->get_name()))) {
+        spdlog::critical("universe: dimension named {} already exists", dimension->get_name());
+        std::terminate();
+    }
+
+    auto dimension_dir = std::format("{}/{}", universe_name.get(), dimension->get_name());
+
+    if(!PHYSFS_mkdir(dimension_dir.c_str())) {
+        spdlog::critical("universe: {}: {}", dimension_dir, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
+        std::terminate();
+    }
+
+    auto metadata = new DimensionMetadata;
+    metadata->config_path = std::format("{}/dimension.conf", dimension_dir);
+    metadata->zvox_dir = std::format("{}/chunk", dimension_dir);
+
+    if(!PHYSFS_mkdir(metadata->zvox_dir.c_str())) {
+        spdlog::critical("universe: {}: {}", metadata->zvox_dir, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
+        std::terminate();
+    }
+
+    globals::dimensions.insert_or_assign(std::string(dimension->get_name()), dimension);
+
+    auto& mapped_metadata = metadata_map.insert_or_assign(dimension, metadata).first->second;
+
+    dimension->init(mapped_metadata->config);
+
+    mapped_metadata->config.load_file(mapped_metadata->config_path.c_str());
+
+    dimension->init_late(universe_config_seed.get_value());
+}
+
+static void internal_save_chunk(const DimensionMetadata* metadata, const world::Dimension* dimension, const chunk_pos& cpos,
+    const world::Chunk* chunk)
+{
+    auto path = make_chunk_filename(metadata, cpos);
+
+    io::WriteBuffer buffer;
+    chunk->get_voxels().serialize(buffer);
+
+    if(auto file = buffer.to_file(path.c_str())) {
+        PHYSFS_close(file);
+        return;
+    }
+}
+
+void world::universe::init(void)
+{
+    // If the world is newly created, the seed will
+    // be chosed based on the current system's view on UNIX time
+    universe_config_seed.set_value(utils::unix_microseconds());
+
+    // We're going to read files from directory named with
+    // the value of this config value. Since config is also
+    // read from command line, the [--universe <name>] parameter still works
+    globals::server_config.add_value("universe", universe_name);
+
+    universe_config.add_value("global_seed", universe_config_seed);
+    universe_config.add_value("spawn_dimension", universe_spawn_dimension);
+}
+
+void world::universe::init_late(void)
+{
+    const auto universe_dir = std::string(universe_name.get());
+
+    if(!PHYSFS_mkdir(universe_dir.c_str())) {
+        spdlog::critical("universe: {}: {}", universe_dir, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
+        std::terminate();
+    }
+
+    universe_config_path = std::format("{}/universe.conf", universe_dir);
+    universe_config.load_file(universe_config_path.c_str());
+
+    add_new_dimension(new Overworld("world"));
+
+    // UNDONE: lua scripts to setup dimensions
+    if(globals::dimensions.empty()) {
+        spdlog::critical("universe: no dimensions");
+        std::terminate();
+    }
+
+    auto spawn_dimension = globals::dimensions.find(universe_spawn_dimension.get_value());
+
+    if(spawn_dimension == globals::dimensions.cend()) {
+        spdlog::critical("universe: {} is not a valid dimension name", universe_spawn_dimension.get());
+        std::terminate();
+    }
+
+    globals::spawn_dimension = spawn_dimension->second;
+}
+
+void world::universe::shutdown(void)
+{
+    for(const auto metadata : metadata_map) {
+        metadata.second->config.save_file(metadata.second->config_path.c_str());
+        delete metadata.second;
+    }
+
+    metadata_map.clear();
+
+    for(const auto dimension : globals::dimensions) {
+        world::universe::save_all_chunks(dimension.second);
+        delete dimension.second;
+    }
+
+    globals::dimensions.clear();
+    globals::spawn_dimension = nullptr;
+
+    universe_config.save_file(universe_config_path.c_str());
+}
+
+world::Chunk* world::universe::load_chunk(Dimension* dimension, const chunk_pos& cpos)
+{
+    if(auto chunk = dimension->find_chunk(cpos)) {
+        // Just return the existing chunk which is
+        // most probable to be up to date compared to
+        // whatever the hell is currently stored on disk
+        return chunk;
+    }
+
+    auto metadata = metadata_map.find(dimension);
+
+    if(metadata == metadata_map.cend()) {
+        // The dimension is for sure a weird one
+        return nullptr;
+    }
+
+    if(auto file = PHYSFS_openRead(make_chunk_filename(metadata->second, cpos).c_str())) {
+        VoxelStorage voxels;
+        io::ReadBuffer buffer(file);
+        voxels.deserialize(buffer);
+
+        PHYSFS_close(file);
+
+        auto chunk = dimension->create_chunk(cpos);
+        chunk->set_voxels(voxels);
+
+        // Make sure we're going to save it later
+        dimension->chunks.emplace_or_replace<Inhabited>(chunk->get_entity());
+
+        return chunk;
+    }
+
+    return nullptr;
+}
+
+void world::universe::save_chunk(Dimension* dimension, const chunk_pos& cpos)
+{
+    auto metadata = metadata_map.find(dimension);
+
+    if(metadata == metadata_map.cend()) {
+        // Cannot save a chunk in a dimension
+        // that doesn't have a metadata struct
+        return;
+    }
+
+    if(auto chunk = dimension->find_chunk(cpos)) {
+        internal_save_chunk(metadata->second, dimension, cpos, chunk);
+    }
+}
+
+void world::universe::save_all_chunks(Dimension* dimension)
+{
+    auto group = dimension->chunks.group(entt::get<ChunkComponent, Inhabited>);
+    auto metadata = metadata_map.find(dimension);
+
+    if(metadata == metadata_map.cend()) {
+        // Cannot save a chunk in a dimension
+        // that doesn't have a metadata struct
+        return;
+    }
+
+    for(auto [entity, chunk] : group.each()) {
+        internal_save_chunk(metadata->second, dimension, chunk.cpos, chunk.chunk);
+    }
+}
diff --git a/game/server/world/universe.hh b/game/server/world/universe.hh
index 285911e..966ac70 100644
--- a/game/server/world/universe.hh
+++ b/game/server/world/universe.hh
@@ -1,25 +1,25 @@
-#pragma once
-
-#include "shared/types.hh"
-
-namespace world
-{
-class Chunk;
-class Dimension;
-} // namespace world
-
-class Session;
-
-namespace world::universe
-{
-void init(void);
-void init_late(void);
-void shutdown(void);
-} // namespace world::universe
-
-namespace world::universe
-{
-Chunk* load_chunk(Dimension* dimension, const chunk_pos& cpos);
-void save_chunk(Dimension* dimension, const chunk_pos& cpos);
-void save_all_chunks(Dimension* dimension);
-} // namespace world::universe
+#pragma once
+
+#include "shared/types.hh"
+
+namespace world
+{
+class Chunk;
+class Dimension;
+} // namespace world
+
+class Session;
+
+namespace world::universe
+{
+void init(void);
+void init_late(void);
+void shutdown(void);
+} // namespace world::universe
+
+namespace world::universe
+{
+Chunk* load_chunk(Dimension* dimension, const chunk_pos& cpos);
+void save_chunk(Dimension* dimension, const chunk_pos& cpos);
+void save_all_chunks(Dimension* dimension);
+} // namespace world::universe
diff --git a/game/server/world/unloader.cc b/game/server/world/unloader.cc
index 4a3f4e1..371a96f 100644
--- a/game/server/world/unloader.cc
+++ b/game/server/world/unloader.cc
@@ -1,78 +1,78 @@
-#include "server/pch.hh"
-
-#include "server/world/unloader.hh"
-
-#include "core/config/number.hh"
-
-#include "shared/entity/player.hh"
-#include "shared/entity/transform.hh"
-
-#include "shared/world/chunk.hh"
-#include "shared/world/chunk_aabb.hh"
-#include "shared/world/dimension.hh"
-
-#include "server/world/inhabited.hh"
-#include "server/world/universe.hh"
-
-#include "server/game.hh"
-#include "server/globals.hh"
-
-static void on_chunk_update(const world::ChunkUpdateEvent& event)
-{
-    event.dimension->chunks.emplace_or_replace<world::Inhabited>(event.chunk->get_entity());
-}
-
-static void on_voxel_set(const world::VoxelSetEvent& event)
-{
-    event.dimension->chunks.emplace_or_replace<world::Inhabited>(event.chunk->get_entity());
-}
-
-void world::unloader::init(void)
-{
-    globals::dispatcher.sink<world::ChunkUpdateEvent>().connect<&on_chunk_update>();
-    globals::dispatcher.sink<world::VoxelSetEvent>().connect<&on_voxel_set>();
-}
-
-void world::unloader::init_late(void)
-{
-}
-
-void world::unloader::fixed_update_late(Dimension* dimension)
-{
-    auto group = dimension->entities.group(entt::get<entity::Player, entity::Transform>);
-    auto boxes = std::vector<ChunkAABB>();
-
-    for(const auto [entity, transform] : group.each()) {
-        ChunkAABB aabb;
-        aabb.min = transform.chunk - static_cast<chunk_pos::value_type>(server_game::view_distance.get_value());
-        aabb.max = transform.chunk + static_cast<chunk_pos::value_type>(server_game::view_distance.get_value());
-        boxes.push_back(aabb);
-    }
-
-    auto view = dimension->chunks.view<ChunkComponent>();
-    auto chunk_in_view = false;
-
-    for(const auto [entity, chunk] : view.each()) {
-        chunk_in_view = false;
-
-        for(const auto& aabb : boxes) {
-            if(aabb.contains(chunk.cpos)) {
-                chunk_in_view = true;
-                break;
-            }
-        }
-
-        if(chunk_in_view) {
-            // The chunk is within view box of at least
-            // a single player; we shouldn't unload it now
-            continue;
-        }
-
-        if(dimension->chunks.any_of<Inhabited>(entity)) {
-            // Only store inhabited chunks on disk
-            world::universe::save_chunk(dimension, chunk.cpos);
-        }
-
-        dimension->remove_chunk(entity);
-    }
-}
+#include "server/pch.hh"
+
+#include "server/world/unloader.hh"
+
+#include "core/config/number.hh"
+
+#include "shared/entity/player.hh"
+#include "shared/entity/transform.hh"
+
+#include "shared/world/chunk.hh"
+#include "shared/world/chunk_aabb.hh"
+#include "shared/world/dimension.hh"
+
+#include "server/world/inhabited.hh"
+#include "server/world/universe.hh"
+
+#include "server/game.hh"
+#include "server/globals.hh"
+
+static void on_chunk_update(const world::ChunkUpdateEvent& event)
+{
+    event.dimension->chunks.emplace_or_replace<world::Inhabited>(event.chunk->get_entity());
+}
+
+static void on_voxel_set(const world::VoxelSetEvent& event)
+{
+    event.dimension->chunks.emplace_or_replace<world::Inhabited>(event.chunk->get_entity());
+}
+
+void world::unloader::init(void)
+{
+    globals::dispatcher.sink<world::ChunkUpdateEvent>().connect<&on_chunk_update>();
+    globals::dispatcher.sink<world::VoxelSetEvent>().connect<&on_voxel_set>();
+}
+
+void world::unloader::init_late(void)
+{
+}
+
+void world::unloader::fixed_update_late(Dimension* dimension)
+{
+    auto group = dimension->entities.group(entt::get<entity::Player, entity::Transform>);
+    auto boxes = std::vector<ChunkAABB>();
+
+    for(const auto [entity, transform] : group.each()) {
+        ChunkAABB aabb;
+        aabb.min = transform.chunk - static_cast<chunk_pos::value_type>(server_game::view_distance.get_value());
+        aabb.max = transform.chunk + static_cast<chunk_pos::value_type>(server_game::view_distance.get_value());
+        boxes.push_back(aabb);
+    }
+
+    auto view = dimension->chunks.view<ChunkComponent>();
+    auto chunk_in_view = false;
+
+    for(const auto [entity, chunk] : view.each()) {
+        chunk_in_view = false;
+
+        for(const auto& aabb : boxes) {
+            if(aabb.contains(chunk.cpos)) {
+                chunk_in_view = true;
+                break;
+            }
+        }
+
+        if(chunk_in_view) {
+            // The chunk is within view box of at least
+            // a single player; we shouldn't unload it now
+            continue;
+        }
+
+        if(dimension->chunks.any_of<Inhabited>(entity)) {
+            // Only store inhabited chunks on disk
+            world::universe::save_chunk(dimension, chunk.cpos);
+        }
+
+        dimension->remove_chunk(entity);
+    }
+}
diff --git a/game/server/world/unloader.hh b/game/server/world/unloader.hh
index 9682de6..a5b1da1 100644
--- a/game/server/world/unloader.hh
+++ b/game/server/world/unloader.hh
@@ -1,13 +1,13 @@
-#pragma once
-
-namespace world
-{
-class Dimension;
-} // namespace world
-
-namespace world::unloader
-{
-void init(void);
-void init_late(void);
-void fixed_update_late(Dimension* dimension);
-} // namespace world::unloader
+#pragma once
+
+namespace world
+{
+class Dimension;
+} // namespace world
+
+namespace world::unloader
+{
+void init(void);
+void init_late(void);
+void fixed_update_late(Dimension* dimension);
+} // namespace world::unloader
diff --git a/game/server/world/worldgen.cc b/game/server/world/worldgen.cc
index 8b02b52..3d8154c 100644
--- a/game/server/world/worldgen.cc
+++ b/game/server/world/worldgen.cc
@@ -1,151 +1,151 @@
-#include "server/pch.hh"
-
-#include "server/world/worldgen.hh"
-
-#include "core/io/cmdline.hh"
-
-#include "core/threading.hh"
-
-#include "shared/world/chunk.hh"
-#include "shared/world/dimension.hh"
-
-#include "shared/protocol.hh"
-
-#include "server/world/inhabited.hh"
-
-#include "server/globals.hh"
-#include "server/sessions.hh"
-
-static bool aggressive_caching;
-
-static emhash8::HashMap<world::Dimension*, emhash8::HashMap<chunk_pos, std::unordered_set<Session*>>> active_tasks;
-
-class WorldgenTask final : public Task {
-public:
-    explicit WorldgenTask(world::Dimension* dimension, const chunk_pos& cpos);
-    virtual ~WorldgenTask(void) = default;
-    virtual void process(void) override;
-    virtual void finalize(void) override;
-
-private:
-    world::Dimension* m_dimension;
-    world::VoxelStorage m_voxels;
-    chunk_pos m_cpos;
-};
-
-WorldgenTask::WorldgenTask(world::Dimension* dimension, const chunk_pos& cpos)
-{
-    m_dimension = dimension;
-    m_voxels.fill(rand()); // trolling
-    m_cpos = cpos;
-}
-
-void WorldgenTask::process(void)
-{
-    if(!m_dimension->generate(m_cpos, m_voxels)) {
-        set_status(task_status::CANCELLED);
-    }
-}
-
-void WorldgenTask::finalize(void)
-{
-    auto dim_tasks = active_tasks.find(m_dimension);
-
-    if(dim_tasks == active_tasks.cend()) {
-        // Normally this should never happen but
-        // one can never be sure about anything
-        // when that anything is threaded out
-        return;
-    }
-
-    auto it = dim_tasks->second.find(m_cpos);
-
-    if(it == dim_tasks->second.cend()) {
-        // Normally this should never happen but
-        // one can never be sure about anything
-        // when that anything is threaded out
-        return;
-    }
-
-    auto chunk = m_dimension->create_chunk(m_cpos);
-    chunk->set_voxels(m_voxels);
-
-    if(aggressive_caching) {
-        // Marking the chunk with InhabitedComponent makes
-        // it so that it is saved regardles of whether it was
-        // modified by players or not. This isn't particularly
-        // good for server-side disk usage but it might improve performance
-        m_dimension->chunks.emplace<world::Inhabited>(chunk->get_entity());
-    }
-
-    protocol::ChunkVoxels response;
-    response.voxels = m_voxels;
-    response.chunk = m_cpos;
-
-    auto packet = protocol::encode(response);
-
-    for(auto session : it->second) {
-        if(session->peer) {
-            // Respond with the voxels to every session
-            // that has requested this specific chunk for this dimension
-            enet_peer_send(session->peer, protocol::CHANNEL, packet);
-        }
-    }
-
-    dim_tasks->second.erase(it);
-
-    if(dim_tasks->second.empty()) {
-        // There are no more requests
-        // to generate a chunk for that
-        // dimension, at least for now
-        active_tasks.erase(dim_tasks);
-    }
-}
-
-void world::worldgen::init(void)
-{
-    aggressive_caching = io::cmdline::contains("aggressive-caching");
-}
-
-bool world::worldgen::is_generating(Dimension* dimension, const chunk_pos& cpos)
-{
-    auto dim_tasks = active_tasks.find(dimension);
-
-    if(dim_tasks == active_tasks.cend()) {
-        // No tasks for this dimension
-        return false;
-    }
-
-    auto it = dim_tasks->second.find(cpos);
-
-    if(it == dim_tasks->second.cend()) {
-        // Not generating this chunk
-        return false;
-    }
-
-    return true;
-}
-
-void world::worldgen::request_chunk(Session* session, const chunk_pos& cpos)
-{
-    if(session->dimension) {
-        auto dim_tasks = active_tasks.find(session->dimension);
-
-        if(dim_tasks == active_tasks.cend()) {
-            dim_tasks = active_tasks.emplace(session->dimension, emhash8::HashMap<chunk_pos, std::unordered_set<Session*>>()).first;
-        }
-
-        auto it = dim_tasks->second.find(cpos);
-
-        if(it == dim_tasks->second.cend()) {
-            auto& sessions = dim_tasks->second.insert_or_assign(cpos, std::unordered_set<Session*>()).first->second;
-            sessions.insert(session);
-
-            threading::submit<WorldgenTask>(session->dimension, cpos);
-
-            return;
-        }
-
-        it->second.insert(session);
-    }
-}
+#include "server/pch.hh"
+
+#include "server/world/worldgen.hh"
+
+#include "core/io/cmdline.hh"
+
+#include "core/threading.hh"
+
+#include "shared/world/chunk.hh"
+#include "shared/world/dimension.hh"
+
+#include "shared/protocol.hh"
+
+#include "server/world/inhabited.hh"
+
+#include "server/globals.hh"
+#include "server/sessions.hh"
+
+static bool aggressive_caching;
+
+static emhash8::HashMap<world::Dimension*, emhash8::HashMap<chunk_pos, std::unordered_set<Session*>>> active_tasks;
+
+class WorldgenTask final : public Task {
+public:
+    explicit WorldgenTask(world::Dimension* dimension, const chunk_pos& cpos);
+    virtual ~WorldgenTask(void) = default;
+    virtual void process(void) override;
+    virtual void finalize(void) override;
+
+private:
+    world::Dimension* m_dimension;
+    world::VoxelStorage m_voxels;
+    chunk_pos m_cpos;
+};
+
+WorldgenTask::WorldgenTask(world::Dimension* dimension, const chunk_pos& cpos)
+{
+    m_dimension = dimension;
+    m_voxels.fill(rand()); // trolling
+    m_cpos = cpos;
+}
+
+void WorldgenTask::process(void)
+{
+    if(!m_dimension->generate(m_cpos, m_voxels)) {
+        set_status(task_status::CANCELLED);
+    }
+}
+
+void WorldgenTask::finalize(void)
+{
+    auto dim_tasks = active_tasks.find(m_dimension);
+
+    if(dim_tasks == active_tasks.cend()) {
+        // Normally this should never happen but
+        // one can never be sure about anything
+        // when that anything is threaded out
+        return;
+    }
+
+    auto it = dim_tasks->second.find(m_cpos);
+
+    if(it == dim_tasks->second.cend()) {
+        // Normally this should never happen but
+        // one can never be sure about anything
+        // when that anything is threaded out
+        return;
+    }
+
+    auto chunk = m_dimension->create_chunk(m_cpos);
+    chunk->set_voxels(m_voxels);
+
+    if(aggressive_caching) {
+        // Marking the chunk with InhabitedComponent makes
+        // it so that it is saved regardles of whether it was
+        // modified by players or not. This isn't particularly
+        // good for server-side disk usage but it might improve performance
+        m_dimension->chunks.emplace<world::Inhabited>(chunk->get_entity());
+    }
+
+    protocol::ChunkVoxels response;
+    response.voxels = m_voxels;
+    response.chunk = m_cpos;
+
+    auto packet = protocol::encode(response);
+
+    for(auto session : it->second) {
+        if(session->peer) {
+            // Respond with the voxels to every session
+            // that has requested this specific chunk for this dimension
+            enet_peer_send(session->peer, protocol::CHANNEL, packet);
+        }
+    }
+
+    dim_tasks->second.erase(it);
+
+    if(dim_tasks->second.empty()) {
+        // There are no more requests
+        // to generate a chunk for that
+        // dimension, at least for now
+        active_tasks.erase(dim_tasks);
+    }
+}
+
+void world::worldgen::init(void)
+{
+    aggressive_caching = io::cmdline::contains("aggressive-caching");
+}
+
+bool world::worldgen::is_generating(Dimension* dimension, const chunk_pos& cpos)
+{
+    auto dim_tasks = active_tasks.find(dimension);
+
+    if(dim_tasks == active_tasks.cend()) {
+        // No tasks for this dimension
+        return false;
+    }
+
+    auto it = dim_tasks->second.find(cpos);
+
+    if(it == dim_tasks->second.cend()) {
+        // Not generating this chunk
+        return false;
+    }
+
+    return true;
+}
+
+void world::worldgen::request_chunk(Session* session, const chunk_pos& cpos)
+{
+    if(session->dimension) {
+        auto dim_tasks = active_tasks.find(session->dimension);
+
+        if(dim_tasks == active_tasks.cend()) {
+            dim_tasks = active_tasks.emplace(session->dimension, emhash8::HashMap<chunk_pos, std::unordered_set<Session*>>()).first;
+        }
+
+        auto it = dim_tasks->second.find(cpos);
+
+        if(it == dim_tasks->second.cend()) {
+            auto& sessions = dim_tasks->second.insert_or_assign(cpos, std::unordered_set<Session*>()).first->second;
+            sessions.insert(session);
+
+            threading::submit<WorldgenTask>(session->dimension, cpos);
+
+            return;
+        }
+
+        it->second.insert(session);
+    }
+}
diff --git a/game/server/world/worldgen.hh b/game/server/world/worldgen.hh
index 8ffec36..eeb3e19 100644
--- a/game/server/world/worldgen.hh
+++ b/game/server/world/worldgen.hh
@@ -1,21 +1,21 @@
-#pragma once
-
-#include "shared/types.hh"
-
-namespace world
-{
-class Dimension;
-} // namespace world
-
-class Session;
-
-namespace world::worldgen
-{
-void init(void);
-} // namespace world::worldgen
-
-namespace world::worldgen
-{
-bool is_generating(Dimension* dimension, const chunk_pos& cpos);
-void request_chunk(Session* session, const chunk_pos& cpos);
-} // namespace world::worldgen
+#pragma once
+
+#include "shared/types.hh"
+
+namespace world
+{
+class Dimension;
+} // namespace world
+
+class Session;
+
+namespace world::worldgen
+{
+void init(void);
+} // namespace world::worldgen
+
+namespace world::worldgen
+{
+bool is_generating(Dimension* dimension, const chunk_pos& cpos);
+void request_chunk(Session* session, const chunk_pos& cpos);
+} // namespace world::worldgen