@divinevoxel/vlox 0.0.4 → 0.0.6

package/World/Archive/Functions/ArchiveArea.js

@@ -0,0 +1,350 @@
+import { BinaryObject } from "@amodx/binary";
+import { Sector } from "../../../World/index";
+const charset = "0123456789ABCDEF";
+function uint16To4CharString(value) {
+    if (value < 0 || value > 0xffff) {
+        throw new RangeError("Value must be a 16-bit unsigned integer.");
+    }
+    const chars = [];
+    for (let i = 0; i < 4; i++) {
+        const charCode = (value >> (i * 4)) & 0x0f;
+        chars.unshift(charset[charCode]);
+    }
+    const result = chars.join("").replace(/^0+(?!$)/, "");
+    return result;
+}
+let sectorStructInstance;
+const processPalettes = (archiveData) => {
+    const allRegistered = new Set();
+    for (const sector of archiveData.sectors) {
+        for (const id of sector.palettes.id) {
+            allRegistered.add(id);
+        }
+        if (!sector.palettes.secondaryId)
+            continue;
+        for (const id of sector.palettes.secondaryId) {
+            allRegistered.add(id);
+        }
+    }
+    let count = 0;
+    const idMap = {};
+    const idRecord = {};
+    for (const voxelId of allRegistered) {
+        const newId = uint16To4CharString(count);
+        idMap[voxelId] = newId;
+        idRecord[newId] = voxelId;
+        count++;
+    }
+    for (const sector of archiveData.sectors) {
+        for (let i = 0; i < sector.palettes.id.length; i++) {
+            sector.palettes.id[i] = idMap[sector.palettes.id[i]];
+        }
+        if (!sector.palettes.secondaryId)
+            continue;
+        for (let i = 0; i < sector.palettes.secondaryId.length; i++) {
+            sector.palettes.secondaryId[i] = idMap[sector.palettes.secondaryId[i]];
+        }
+    }
+    return idRecord;
+};
+const hashBuffer = (buffer) => {
+    const data = new Uint8Array(buffer);
+    let hash = "";
+    for (let i = 0; i < data.length; i++) {
+        hash += data[i].toString(16).padStart(2, "0");
+    }
+    return hash;
+};
+const processSections = (archiveData) => {
+    const chunMap = {};
+    const created = new Map();
+    const maped = new Map();
+    const binaryObjects = new Map();
+    let count = 0;
+    const process = (object) => {
+        if (typeof object == "string")
+            return object;
+        let binaryObject = binaryObjects.get(object);
+        if (!binaryObject) {
+            binaryObject = BinaryObject.objectToBuffer(object);
+            binaryObjects.set(object, binaryObject);
+        }
+        let hash = hashBuffer(binaryObject);
+        if (maped.has(hash))
+            return maped.get(hash);
+        if (created.has(hash) && created.get(hash) == 0) {
+            created.set(hash, 1);
+            const id = uint16To4CharString(count);
+            chunMap[id] = object;
+            maped.set(hash, id);
+            count++;
+            return id;
+        }
+        if (!created.has(hash)) {
+            created.set(hash, 0);
+        }
+        return object;
+    };
+    for (const sector of archiveData.sectors) {
+        for (let i = 0; i < sector.sections.length; i++) {
+            if (!sector.sections[i])
+                continue;
+            sector.sections[i] = process(sector.sections[i]);
+        }
+    }
+    created.clear();
+    for (const sector of archiveData.sectors) {
+        for (let i = 0; i < sector.sections.length; i++) {
+            if (!sector.sections[i])
+                continue;
+            sector.sections[i] = process(sector.sections[i]);
+        }
+    }
+    return chunMap;
+};
+const buildSectorState = (archiveData) => {
+    const sectorStateMap = {};
+    const maped = new Map();
+    const binaryObjects = new Map();
+    let count = 0;
+    const sectorStateKeys = sectorStructInstance.getKeys();
+    const created = new Map();
+    const processSectorState = (sector, sectorStateMap) => {
+        if (typeof sector.sectorState == "string")
+            return sector.sectorState;
+        if (!Array.isArray(sector.sectorState)) {
+            const sectorState = [];
+            for (let i = 0; i < sectorStateKeys.length; i++) {
+                sectorState[i] = sector.sectorState[sectorStateKeys[i]];
+            }
+            sector.sectorState = sectorState;
+        }
+        let binaryObject = binaryObjects.get(sector.sectorState);
+        if (!binaryObject) {
+            binaryObject = BinaryObject.objectToBuffer(sector.sectorState);
+            binaryObjects.set(sector.sectorState, binaryObject);
+        }
+        let hash = hashBuffer(binaryObject);
+        if (maped.has(hash)) {
+            sector.sectorState = maped.get(hash);
+            return;
+        }
+        if (created.has(hash) && created.get(hash) == 0) {
+            created.set(hash, 1);
+            const id = uint16To4CharString(count);
+            sectorStateMap[id] = sector.sectorState;
+            maped.set(hash, id);
+            count++;
+            sector.sectorState = id;
+            return id;
+        }
+        if (!created.has(hash)) {
+            created.set(hash, 0);
+        }
+        return sector.sectorState;
+    };
+    for (const sector of archiveData.sectors) {
+        processSectorState(sector, sectorStateMap);
+    }
+    created.clear();
+    for (const sector of archiveData.sectors) {
+        processSectorState(sector, sectorStateMap);
+    }
+    return sectorStateMap;
+};
+const createPaletteMaps = (archiveData, paletteType, paletteMap, paletteIdsMap) => {
+    const created = new Map();
+    let count = 0;
+    for (const sector of archiveData.sectors) {
+        const palette = sector.palettes[paletteType];
+        if (!palette)
+            continue;
+        if (typeof palette == "string")
+            continue;
+        const hash = paletteType === "id" || paletteType === "secondaryId"
+            ? JSON.stringify(palette)
+            : hashBuffer(palette);
+        if (paletteIdsMap.has(hash)) {
+            sector.palettes[paletteType] = paletteIdsMap.get(hash);
+            continue;
+        }
+        if (created.has(hash) && created.get(hash) === 0) {
+            created.set(hash, 1);
+            const id = uint16To4CharString(count);
+            paletteMap[id] = palette;
+            paletteIdsMap.set(hash, id);
+            count++;
+            sector.palettes[paletteType] = id;
+            continue;
+        }
+        if (!created.has(hash)) {
+            created.set(hash, 0);
+        }
+    }
+};
+const getPaletteMaps = (archiveData) => {
+    const lightPalette = {};
+    const paletteMap = new Map();
+    createPaletteMaps(archiveData, "light", lightPalette, paletteMap);
+    createPaletteMaps(archiveData, "light", lightPalette, paletteMap);
+    paletteMap.clear();
+    const levelPalette = {};
+    createPaletteMaps(archiveData, "level", levelPalette, paletteMap);
+    createPaletteMaps(archiveData, "level", levelPalette, paletteMap);
+    paletteMap.clear();
+    const statePalette = {};
+    createPaletteMaps(archiveData, "state", statePalette, paletteMap);
+    createPaletteMaps(archiveData, "state", statePalette, paletteMap);
+    paletteMap.clear();
+    const modPalette = {};
+    createPaletteMaps(archiveData, "mod", modPalette, paletteMap);
+    createPaletteMaps(archiveData, "mod", modPalette, paletteMap);
+    paletteMap.clear();
+    const secondaryStatePalette = {};
+    createPaletteMaps(archiveData, "secondaryState", secondaryStatePalette, paletteMap);
+    createPaletteMaps(archiveData, "secondaryState", secondaryStatePalette, paletteMap);
+    paletteMap.clear();
+    const idPalette = {};
+    createPaletteMaps(archiveData, "id", idPalette, paletteMap);
+    createPaletteMaps(archiveData, "id", idPalette, paletteMap);
+    paletteMap.clear();
+    const secondaryIdPalette = {};
+    createPaletteMaps(archiveData, "secondaryId", secondaryIdPalette, paletteMap);
+    createPaletteMaps(archiveData, "secondaryId", secondaryIdPalette, paletteMap);
+    paletteMap.clear();
+    return {
+        idPalette,
+        secondaryIdPalette,
+        levelPalette,
+        lightPalette,
+        statePalette,
+        secondaryStatePalette,
+        modPalette,
+    };
+};
+function SectorToArchivedAreaSector(sector) {
+    const palettes = {};
+    palettes.id = sector.palettes.id;
+    if (sector.palettes.secondaryId)
+        palettes.secondaryId = sector.palettes.secondaryId;
+    if (sector.palettes.light)
+        palettes.light = sector.palettes.light;
+    if (sector.palettes.secondaryState)
+        palettes.secondaryState = sector.palettes.secondaryState;
+    if (sector.palettes.state)
+        palettes.state = sector.palettes.state;
+    sector.palettes.stateMap = sector.palettes.stateMap;
+    if (sector.palettes.mod)
+        palettes.state = sector.palettes.mod;
+    sector.palettes.modMap = sector.palettes.modMap;
+    return {
+        position: [sector.location[1], sector.location[2], sector.location[3]],
+        sectorState: sector.sectorState,
+        buffers: sector.buffers,
+        palettes,
+        sections: sector.sections,
+    };
+}
+export default function CreateArchiveArea(archiveData) {
+    if (!sectorStructInstance)
+        sectorStructInstance = Sector.StateStruct.instantiate();
+    const sectorStateKeys = sectorStructInstance.getKeys();
+    const sectors = [];
+    for (const sector of archiveData.sectors) {
+        sectors.push(SectorToArchivedAreaSector(sector));
+    }
+    return {
+        dimension: archiveData.dimension,
+        version: "",
+        keys: {
+            sectorState: sectorStateKeys,
+            sectionState: archiveData.sectors[0].keys.sectionState,
+        },
+        maps: {
+            sectorState: buildSectorState(archiveData),
+            id: processPalettes(archiveData),
+            section: processSections(archiveData),
+            ...getPaletteMaps(archiveData),
+        },
+        sectors,
+    };
+}
+export function CreateSectorFromArea(area, sector) {
+    const sectorState = {};
+    const currentState = typeof sector.sectorState == "string"
+        ? area.maps.sectorState[sector.sectorState]
+        : sector.sectorState;
+    for (let i = 0; i < area.keys.sectorState.length; i++) {
+        sectorState[area.keys.sectorState[i]] = currentState[i];
+    }
+    const palettes = {};
+    let id;
+    if (typeof sector.palettes.id == "string") {
+        id = area.maps.idPalette[sector.palettes.id];
+    }
+    else {
+        id = sector.palettes.id;
+    }
+    for (let i = 0; i < id.length; i++) {
+        id[i] = area.maps.id[i];
+    }
+    palettes.id = id;
+    palettes.light =
+        typeof sector.palettes.light == "string"
+            ? area.maps.lightPalette[sector.palettes.light]
+            : sector.palettes.light;
+    palettes.level =
+        typeof sector.palettes.level == "string"
+            ? area.maps.levelPalette[sector.palettes.level]
+            : sector.palettes.level;
+    palettes.state =
+        typeof sector.palettes.state == "string"
+            ? area.maps.statePalette[sector.palettes.state]
+            : sector.palettes.state;
+    palettes.stateMap = sector.palettes.stateMap;
+    palettes.mod =
+        typeof sector.palettes.mod == "string"
+            ? area.maps.statePalette[sector.palettes.mod]
+            : sector.palettes.mod;
+    palettes.modMap = sector.palettes.modMap;
+    let secondaryId;
+    if (typeof sector.palettes.secondaryId == "string") {
+        secondaryId = area.maps.idPalette[sector.palettes.secondaryId];
+    }
+    else {
+        secondaryId = sector.palettes.secondaryId || [];
+    }
+    for (let i = 0; i < secondaryId.length; i++) {
+        secondaryId[i] = area.maps.id[i];
+    }
+    palettes.secondaryId = secondaryId;
+    palettes.secondaryState =
+        typeof sector.palettes.secondaryState == "string"
+            ? area.maps.secondaryStatePalette[sector.palettes.secondaryState]
+            : sector.palettes.secondaryState;
+    const sections = [];
+    for (let i = 0; i < sector.sections.length; i++) {
+        const section = sector.sections[i];
+        if (typeof section == "string") {
+            sections[i] = area.maps.section[section];
+            continue;
+        }
+        sections[i] = section;
+    }
+    return {
+        version: area.version,
+        location: [area.dimension, ...sector.position],
+        sectorState,
+        keys: {
+            sectionState: area.keys.sectionState,
+        },
+        palettes,
+        buffers: sector.buffers,
+        sections,
+    };
+}
+export function* CreateSectorsFromArea(area) {
+    for (const sector of area.sectors) {
+        yield CreateSectorFromArea(area, sector);
+    }
+}

package/World/Archive/Functions/ArchiveSector.d.ts

@@ -0,0 +1,7 @@
+import { LocationData } from "../../../Math";
+import { ArchivedSectorData } from "../Archive.types";
+type ArchiveColumnProps = {
+    location: LocationData;
+};
+export default function ArchiveSector(archiveData: ArchiveColumnProps): ArchivedSectorData;
+export {};