feat: incomplete Infdev 624 world writing

PhoenixVX · PhoenixVX · commit 60c70d478a8b · 2026-04-05T04:00:38.000-06:00
diff --git a/projects/Converters/Minecraft/Java/include/Lodestone.Minecraft.Java/conversion/infdev/InfdevWorldIo.h b/projects/Converters/Minecraft/Java/include/Lodestone.Minecraft.Java/conversion/infdev/InfdevWorldIo.h
@@ -15,8 +15,6 @@
 #include <Lodestone.Conversion/io/ObjectIOs.h>
 #include <Lodestone.Conversion/registry/RegistryRelations.h>
 #include "Lodestone.Minecraft.Java/Identifiers.h"
-#include "Lodestone.Minecraft.Java/conversion/alpha/AlphaPlayerIo.h"
-#include "Lodestone.Minecraft.Java/conversion/mcregion/McRegionChunkIo.h"
 #include "Lodestone.Minecraft.Java/conversion/infdev/InfdevZoneIo.h"
 
 namespace lodestone::minecraft::java::infdev::world {
diff --git a/projects/Converters/Minecraft/Java/include/Lodestone.Minecraft.Java/conversion/infdev/InfdevZoneIo.h b/projects/Converters/Minecraft/Java/include/Lodestone.Minecraft.Java/conversion/infdev/InfdevZoneIo.h
@@ -20,6 +20,7 @@
 
 namespace lodestone::minecraft::java::infdev::zone {
     constexpr uint32_t EXPECTED_MAGIC = 0x13737000;
+    constexpr uint16_t EXPECTED_VERSION = 0;
 
     class InfdevZoneIo : public conversion::io::LevelIO<&identifiers::INF_624_ZONE_IO, const
                              common::conversion::io::options::OptionPresets::CommonChunkReadOptions, const
diff --git a/projects/Converters/Minecraft/Java/src/infdev/chunk/InfdevChunkIo.cpp b/projects/Converters/Minecraft/Java/src/infdev/chunk/InfdevChunkIo.cpp
@@ -13,11 +13,11 @@
 #include <BinaryIO/stream/BinaryInputStream.h>
 #include <Lodestone.Common/Indexing.h>
 #include <Lodestone.Conversion/block/data/NumericBlockData.h>
+
+#include <BinaryIO/stream/BinaryOutputStream.h>
 #include "Lodestone.Minecraft.Java/LodestoneJava.h"
 #include "Lodestone.Minecraft.Java/infdev/InfdevChunk.h"
 
-#include "Lodestone.Minecraft.Java/Identifiers.h"
-
 namespace lodestone::minecraft::java::infdev::chunk {
     std::unique_ptr<level::chunk::Chunk> InfdevChunkIO::read(
         const common::conversion::io::options::OptionPresets::CommonReadOptions &options) const {
@@ -87,6 +87,86 @@ bio::stream::BinaryInputStream bis(options.input);
     void InfdevChunkIO::write(level::chunk::Chunk *c,
                               const common::conversion::io::options::OptionPresets::CommonChunkWriteOptions &options)
     const {
-        throw std::runtime_error("Not implemented");
+        bio::stream::BinaryOutputStream bos(options.output);
+
+        const std::unique_ptr<conversion::block::version::BlockIO>
+            bio = LodestoneJava::getInstance()->io.getIo(options.version);
+
+        const level::types::Vec2i coords = c->getCoords().value();
+        bos.writeBE<int32_t>(coords.x);
+        bos.writeBE<int32_t>(coords.y); // Z
+
+        // Write padding
+        for (int i = 0; i < 232; i++) {
+            bos.writeBE<int8_t>(0);
+        }
+
+        std::vector<int8_t> blocks(
+    CHUNK_WIDTH * CHUNK_HEIGHT *
+    CHUNK_DEPTH);
+        std::vector<int8_t> data((CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH) /
+                                 2);
+        std::vector<int8_t> skyLight(
+            (CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH) / 2);
+        std::vector<int8_t> blockLight(
+            (CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH) / 2);
+        std::vector<int8_t> heightMap(CHUNK_WIDTH * CHUNK_DEPTH);
+        // todo wiki says there's tileticks which is gonna be pain
+
+        int8_t *blockData = blocks.data(); // avoid the annoying bounds checks
+        // and just write directly
+        int8_t *dataData = data.data();    // welcome back 4J
+        int8_t *skyLightData = skyLight.data();
+        int8_t *blockLightData = blockLight.data();
+        int8_t *heightMapData = heightMap.data();
+
+        for (int cx = 0; cx < CHUNK_WIDTH; cx++) {
+            for (int cz = 0; cz < CHUNK_DEPTH; cz++) {
+                for (int cy = 0; cy < CHUNK_HEIGHT; cy++) {
+                    const size_t idx =
+                        INDEX_XZY(cx, cy, cz, InfdevChunkIO::CHUNK_HEIGHT, InfdevChunkIO::CHUNK_DEPTH);
+                    const level::block::instance::BlockInstance &b =
+                        c->getBlock(cx, cy, cz);
+#ifdef USE_RISKY_OPTIMIZATIONS
+                    if (b.getBlock() !=
+                        level::block::BlockRegistry::s_defaultBlock) {
+#endif
+                        uint8_t id = 0;
+                        uint8_t dat = 0;
+
+                        if (const conversion::block::data::NumericBlockData *bl =
+                                    bio->convertBlockFromInternal(&b)->as<conversion::block::data::NumericBlockData>()) {
+                            id = bl->getId();
+                            dat = bl->getData();
+                                    }
+
+                        blockData[idx] = id;
+
+                        SET_NIBBLE(dataData, idx, dat);
+#ifdef USE_RISKY_OPTIMIZATIONS
+                        }
+#endif
+
+                    level::chunk::section::Section *s = c->getSection(cy >> 4);
+
+                    SET_NIBBLE(skyLightData, idx,
+                               s ? s->getSkyLight()->getNibble(cx, cy & 15, cz)
+                                 : 15);
+                    SET_NIBBLE(
+                        blockLightData, idx,
+                        s ? s->getBlockLight()->getNibble(cx, cy & 15, cz)
+                          : 15);
+                }
+
+                heightMapData[INDEX_YX(cx, cz, CHUNK_WIDTH)] =
+                    c->getHeightAt(cx, cz);
+            }
+
+            bos.writeBytes(reinterpret_cast<uint8_t*>(blockData), 32768);
+            bos.writeBytes(reinterpret_cast<uint8_t*>(dataData), 16384);
+            bos.writeBytes(reinterpret_cast<uint8_t*>(skyLightData), 16384);
+            bos.writeBytes(reinterpret_cast<uint8_t*>(blockLightData), 16384);
+            bos.writeBytes(reinterpret_cast<uint8_t*>(heightMapData), 256);
+        }
     }
 }
diff --git a/projects/Converters/Minecraft/Java/src/infdev/world/InfdevWorldIo.cpp b/projects/Converters/Minecraft/Java/src/infdev/world/InfdevWorldIo.cpp
@@ -17,6 +17,10 @@
 #include <libnbt++/nbt_tags.h>
 
 #include <Lodestone.Level/world/World.h>
+
+#include <libnbt++/io/ozlibstream.h>
+
+#include "Lodestone.Minecraft.Java/conversion/anvil/jungle/JungleAnvilChunkIo.h"
 #include "Lodestone.Minecraft.Java/conversion/infdev/InfdevZoneIo.h"
 #include "Lodestone.Minecraft.Java/infdev/InfdevWorld.h"
 #include "Lodestone.Minecraft.Java/infdev/InfdevZone.h"
@@ -114,6 +118,98 @@ namespace lodestone::minecraft::java::infdev::world {
 
     void InfdevWorldIo::write(level::world::World *w,
                               const common::conversion::io::options::OptionPresets::CommonFilesystemOptions &options) const {
-        throw new std::runtime_error("Not implemented");
+        if (!std::filesystem::exists(options.path)) {
+            std::filesystem::create_directories(options.path);
+        }
+
+        // Create level.dat
+        {
+            std::ofstream ofs(options.path / "level.dat", std::ifstream::binary);
+            zlib::ozlibstream strm(ofs, Z_DEFAULT_COMPRESSION, true);
+
+            nbt::io::stream_writer writer(strm);
+            nbt::tag_compound root{};
+            nbt::tag_compound data{};
+
+            // Not the cleanest solution, but it definitely works.
+            auto lastPlayed = w->getProperty("lastPlayed");
+            data["LastPlayed"] =
+                lastPlayed
+                    ? lastPlayed
+                          ->as<
+                              level::properties::TemplatedProperty<int64_t>>()
+                          ->getValue()
+                    : static_cast<int64_t>(0);
+
+            auto seed = w->getProperty("seed");
+            data["RandomSeed"] =
+                seed
+                    ? seed->as<
+                              level::properties::TemplatedProperty<int64_t>>()
+                          ->getValue()
+                    : static_cast<int64_t>(0);
+
+            // TODO: Write default player tag here
+
+            level::types::Vec3i sp = w->getDefaultLevel()->getSpawnPos();
+            data["SpawnX"] = sp.x;
+            data["SpawnY"] = sp.y;
+            data["SpawnZ"] = sp.z;
+
+            auto time = w->getProperty("time");
+            data["Time"] =
+                time
+                    ? time->as<
+                              level::properties::TemplatedProperty<int64_t>>()
+                          ->getValue()
+                    : static_cast<int64_t>(0);
+
+            data["SizeOnDisk"] = static_cast<int64_t>(0);
+
+            root["Data"] = std::move(data);
+            writer.write_tag("", root);
+        }
+
+        // Write zones out
+        const zone::InfdevZoneIo *io = this->getAsByRelation<const zone::InfdevZoneIo, &conversion::identifiers::LEVEL_IO>();
+
+        std::filesystem::path p = options.path;
+
+        std::filesystem::path dataDir = p / "data";
+        if (!std::filesystem::exists(dataDir))
+            std::filesystem::create_directory(dataDir);
+
+
+        auto lvl = w->getDefaultLevel();
+        level::types::Bounds3i bounds = lvl->getChunkBounds();
+
+        for (int cX = 0; cX = bounds.min.x / chunk::InfdevChunkIO::CHUNK_WIDTH; cX++) {
+
+        }
+
+        for (int rx = bounds.min.x >> 5; rx <= bounds.max.x >> 5; rx++) {
+            for (int rz = bounds.min.z >> 5; rz <= bounds.max.z >> 5; rz++) {
+                auto zoneX = lodestone::common::util::Math::encodeBase36(rx);
+                auto zoneZ = lodestone::common::util::Math::encodeBase36(rz);
+                std::ofstream o(dataDir / ("zone_" + zoneX + "_" +
+                                     zoneZ + ".dat"));
+
+                io->write(lvl, common::conversion::io::options::OptionPresets::CommonChunkWriteOptions {
+                              common::conversion::io::options::ChunkOptions {
+                                      {rx, rz}
+                              },
+                              common::conversion::io::options::OptionPresets::CommonWriteOptions {
+                                  conversion::io::options::fs::file::FileWriterOptions {
+                                      o
+                                  },
+                                  conversion::io::options::versioned::VersionedOptions {
+                                  options.version
+                                  }
+                              }
+                });
+
+                o.close();
+            }
+        }
     }
 }
diff --git a/projects/Converters/Minecraft/Java/src/infdev/zone/InfdevZoneIo.cpp b/projects/Converters/Minecraft/Java/src/infdev/zone/InfdevZoneIo.cpp
@@ -18,6 +18,7 @@
 
 #include <Lodestone.Conversion/registry/RegistryRelations.h>
 
+#include <BinaryIO/stream/BinaryOutputStream.h>
 #include "Lodestone.Minecraft.Java/infdev/InfdevChunk.h"
 
 namespace lodestone::minecraft::java::infdev::zone {
@@ -29,13 +30,12 @@ namespace lodestone::minecraft::java::infdev::zone {
         const chunk::InfdevChunkIO *chunkIo = this->getAsByRelation<const chunk::InfdevChunkIO, &
             conversion::identifiers::CHUNK_IO>();
 
-
-        if (const uint32_t magic = bis.readBE<uint32_t>(); magic != 0x13737000) {
+        if (const uint32_t magic = bis.readBE<uint32_t>(); magic != EXPECTED_MAGIC) {
             throw std::runtime_error{std::format("Invalid magic value! Expected: {}, read: {}", EXPECTED_MAGIC, magic)};
         }
 
-        if (const uint16_t version = bis.readBE<uint16_t>(); version != 0) {
-            throw std::runtime_error{std::format("Unexpected world version! Expected: {}, read: {}", 0, version)};
+        if (const uint16_t version = bis.readBE<uint16_t>(); version != EXPECTED_VERSION) {
+            throw std::runtime_error{std::format("Unexpected world version! Expected: {}, read: {}", EXPECTED_VERSION, version)};
         }
 
         // Read slot indices
@@ -74,5 +74,62 @@ namespace lodestone::minecraft::java::infdev::zone {
     void InfdevZoneIo::write(level::Level *c,
                              const common::conversion::io::options::OptionPresets::CommonChunkWriteOptions &options)
     const {
+        bio::stream::BinaryOutputStream bos(options.output);
+        const level::types::Vec2i zoneCoordinates = options.coords;
+
+        // Write zone header
+        bos.writeBE<uint32_t>(EXPECTED_MAGIC);
+
+        bos.writeBE<uint16_t>(EXPECTED_VERSION);
+
+        const int idx = bos.getOffset();
+
+        // Write chunk data
+        auto *chunkIo = this->getAsByRelation<const chunk::InfdevChunkIO, &conversion::identifiers::CHUNK_IO>();
+
+        int slotCount = 0;
+        int slots[1024];
+        for (char x = 0; x < 32; x++) {
+            for (char z = 0; z < 32; z++) {
+                const int cx = zoneCoordinates.x * 32 + x;
+                const int cz = zoneCoordinates.y * 32 + z;
+
+                level::chunk::Chunk *ch = c->getChunk(cx, cz);
+                if (ch != nullptr) {
+                    slotCount++;
+
+                    // TODO: Refactor to separate function
+                    const int v5 = cx - (zoneCoordinates.x << 5);
+                    const int v6 = cz - (zoneCoordinates.y << 5);
+                    const int slotIdx = v5 + v6 * 32;
+                    slots[slotCount] = slotIdx;
+
+                    const uint64_t writePos = static_cast<uint64_t>(slotIdx) * (32768 * 3 + 256) + 4096;
+                    bos.seek(writePos);
+                    chunkIo->write(ch, common::conversion::io::options::OptionPresets::CommonChunkWriteOptions {
+                       common::conversion::io::options::ChunkOptions {
+                               {cx, cz}
+                       },
+                        common::conversion::io::options::OptionPresets::CommonWriteOptions {
+                            conversion::io::options::fs::file::FileWriterOptions {
+                                bos.getStream(),
+                            },
+                            conversion::io::options::versioned::VersionedOptions {
+                                options.version
+                            }
+                        }
+    });
+                }
+            }
+        }
+
+        // Seek back to header to write slot information
+        bos.seek(idx);
+
+        // TODO: Refactor this
+        bos.writeBE<uint16_t>(slotCount);
+        for (int i = 0; i < slotCount; i++) {
+            bos.writeBE<uint16_t>(slots[i]);
+        }
     }
 }
diff --git a/projects/Utilities/Tests/CMakeLists.txt b/projects/Utilities/Tests/CMakeLists.txt
@@ -71,6 +71,8 @@ target_compile_definitions(Lodestone.Tests PRIVATE
         READ_MINEV2_WORLD=false
         READ_ALPHA_WORLD=false
         WRITE_ALPHA_WORLD=false
+        READ_INFDEV_624_WORLD=true
+        WRITE_INFDEV_624_WORLD=true
 )
 
 setupLinter(Lodestone.Tests)
diff --git a/projects/Utilities/Tests/include/Lodestone.Tests/tests/MainTests.h b/projects/Utilities/Tests/include/Lodestone.Tests/tests/MainTests.h
@@ -11,6 +11,10 @@ namespace lodestone::tests::test {
       public:
         static void add();
 
+        static tfw::test::result::TestResult readInfdev624World(tfw::test::logging::loggers::ITestLogger &logger);
+
+        static tfw::test::result::TestResult writeInfdev624World(tfw::test::logging::loggers::ITestLogger &logger);
+
         static tfw::test::result::TestResult generateWaterChunk(tfw::test::logging::loggers::ITestLogger &logger);
 
         static tfw::test::result::TestResult readAnvilWorld(tfw::test::logging::loggers::ITestLogger &logger);
diff --git a/projects/Utilities/Tests/src/tests/MainTests.cpp b/projects/Utilities/Tests/src/tests/MainTests.cpp

Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,8 @@ target_compile_definitions(Lodestone.Tests PRIVATE`
`71`	`71`	`READ_MINEV2_WORLD=false`
`72`	`72`	`READ_ALPHA_WORLD=false`
`73`	`73`	`WRITE_ALPHA_WORLD=false`
	`74`	`+ READ_INFDEV_624_WORLD=true`
	`75`	`+ WRITE_INFDEV_624_WORLD=true`
`74`	`76`	`)`
`75`	`77`
`76`	`78`	`setupLinter(Lodestone.Tests)`