@divinevoxel/vlox 0.0.4 → 0.0.5

package/Voxels/{Voxel.types.js → Types/Voxel.types.js}

@@ -1,7 +1,25 @@
+export class PaintVoxelData {
+    id;
+    mod;
+    state;
+    level;
+    levelState;
+    secondaryVoxelId;
+    static Create(data) {
+        return new PaintVoxelData(data.id, data.mod, data.state, data.level, data.levelState, data.secondaryVoxelId);
+    }
+    constructor(id = "dve_air", mod = 0, state = 0, level = 0, levelState = 0, secondaryVoxelId = "dve_air") {
+        this.id = id;
+        this.mod = mod;
+        this.state = state;
+        this.level = level;
+        this.levelState = levelState;
+        this.secondaryVoxelId = secondaryVoxelId;
+    }
+}
 export var VoxelStructIds;
 (function (VoxelStructIds) {
     VoxelStructIds["substance"] = "dve_substance";
-    VoxelStructIds["shapeID"] = "dve_shape_id";
     VoxelStructIds["renderedMaterial"] = "dve_rendered_material";
     VoxelStructIds["voxelMaterial"] = "dve_voxel_material";
     VoxelStructIds["hardness"] = "dve_hardness";

package/Voxels/Types/VoxelModelCompiledData.types.d.ts

@@ -0,0 +1,93 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelAOResultsIndexData } from "../../Models/Indexing/VoxelAOResultsIndex";
+import { VoxelFaceCullResultsIndexData } from "../../Models/Indexing/VoxelFaceCullResultsIndex";
+import { VoxelFaceTransparentResultsIndexData } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
+import { VoxelModelStateSchemaData, StateLogicStatement } from "../State/State.types";
+import { VoxelGeometryData, VoxelGeometryNodes } from "../../Models/VoxelModel.types";
+import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
+import { VoxelTagStatesData } from "../State/VoxelTagStates";
+import { BinaryStructData } from "@amodx/binary";
+export type CompiledVoxelData = {
+    models: FinalCompiledVoxelModelData;
+    data: {
+        struct: BinaryStructData;
+        index: Uint16Array;
+        palette: string[];
+        nameToIdMap: Record<string, string>;
+        idToNameMap: Record<string, string>;
+        stringMaps: Record<string, string[]>;
+        objectMaps: Record<string, any[]>;
+    };
+    substances: {
+        struct: BinaryStructData;
+        palette: string[];
+        stringMaps: Record<string, string[]>;
+        objectMaps: Record<string, any[]>;
+    };
+    materials: {
+        palette: string[];
+    };
+};
+export interface CompiledVoxelGeometryNodes {
+    node: VoxelGeometryNodes;
+    tranform: VoxelGeometryTransform;
+}
+export interface VoxelGeometryTransform {
+    position?: Vec3Array;
+    scale?: Vec3Array;
+    rotation?: Vec3Array;
+    rotationPivot?: Vec3Array;
+    lockUVs?: true;
+    flip?: [flipX: 0 | 1, flipY: 0 | 1, flipZ: 0 | 1];
+}
+export interface CompiledVoxelGeometryData {
+    id: string;
+    ogData: VoxelGeometryData;
+    nodes: CompiledVoxelGeometryNodes[];
+}
+export type CompiledVoxelGeometrySyncData = {
+    id: string;
+    nodes: CompiledVoxelGeometryNodes[];
+    faceCullMap?: number[][];
+    vertexHitMap?: number[][];
+    aoIndex?: VoxelAOResultsIndexData;
+    cullIndex?: VoxelFaceCullResultsIndexData;
+};
+export interface CompiledVoxelGeometryRulessData {
+    id: string;
+    nodes: CompiledVoxelGeometryNodes[];
+    ruleless: true;
+}
+export interface CompiledVoxelModelData {
+    id: string;
+    schema: VoxelModelStateSchemaData[];
+    effects: VoxelEffectSyncData[];
+    geoLinkMap: number[];
+    shapeStateTree: any[];
+    shapeStateMap: number[][];
+    shapeStateGeometryMap: number[][];
+    shapeStateRelativeGeometryMap: number[][];
+    relativeGeometryByteIndexMap: number[];
+    condiotnalStatements: StateLogicStatement[];
+    condiotnalStateMap: number[][];
+    condiotnalShapeStateMap: number[][][];
+    condiotnalShapeStateGeometryMap: number[][][];
+    condiotnalShapeStateRelativeGeometryMap: number[][];
+    condiotnalStateTree: any[];
+}
+export interface CompiledVoxelModelInputData {
+    id: string;
+    modelId: string;
+    transparentFaceIndex: VoxelFaceTransparentResultsIndexData;
+    modSchema: VoxelModelStateSchemaData[];
+    modStateTree: any[];
+    baseGeometryInputMap: any[][];
+    condiotnalGeometryInputMap: any[][];
+}
+export interface FinalCompiledVoxelModelData {
+    geometryPalette: string[];
+    geometry: (CompiledVoxelGeometrySyncData | CompiledVoxelGeometryRulessData)[];
+    models: CompiledVoxelModelData[];
+    voxels: CompiledVoxelModelInputData[];
+    tagState: VoxelTagStatesData;
+}

package/Voxels/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./Voxel.types";
-export * from "./VoxelMaterial.types";
-export * from "./VoxelSubstances.types";
+export * from "./Types/Voxel.types";
+export * from "./Types/VoxelMaterial.types";
+export * from "./Types/VoxelSubstances.types";

package/Voxels/index.js

@@ -1,3 +1,3 @@
-export * from "./Voxel.types";
-export * from "./VoxelMaterial.types";
-export * from "./VoxelSubstances.types";
+export * from "./Types/Voxel.types";
+export * from "./Types/VoxelMaterial.types";
+export * from "./Types/VoxelSubstances.types";

package/World/Archive/Archive.types.d.ts

@@ -0,0 +1,159 @@
+import { Vec3Array } from "@amodx/math";
+import { LocationData } from "../../Math";
+/**
+ * Interface for an archived sector.
+ */
+export interface ArchivedSectorData {
+    /** The version of vlox the data was stored in. */
+    version: string;
+    /** The location of the sector in the world. */
+    location: LocationData;
+    /** Record of the sector's state, storing dynamic or user-defined data. */
+    sectorState: Record<string, any>;
+    /** The palette data used within the sector. */
+    palettes: ArchivedSectorPaletteData;
+    /** Placeholder for future buffer data. */
+    buffers: ArchivedSectorBuffersData;
+    /** Keys associated with section states and other objects. */
+    keys: ArchivedSectorKeysData;
+    /** Array of archived section data within the sector. */
+    sections: ArchivedSectionData[];
+}
+/**
+ * Interface for the palettes of an archived sector.
+ */
+export interface ArchivedSectorPaletteData {
+    id: string[];
+    secondaryId?: string[];
+    level?: Uint8Array;
+    stateMap: Record<number, any[]>;
+    modMap: Record<number, any[]>;
+    state: Uint16Array;
+    mod: Uint16Array;
+    light?: Uint16Array;
+    secondaryState?: Uint16Array;
+}
+/**
+ * Interface for the keys of an archived sector.
+ */
+export interface ArchivedSectorKeysData {
+    /** Array of strings that are the keys for the section state struct.  */
+    sectionState: string[];
+}
+/**
+ * Placeholder interface for future buffer data in a sector.
+ */
+export interface ArchivedSectorBuffersData {
+}
+/**
+ * Interface for an archived section.
+ */
+export interface ArchivedSectionData {
+    /** Array representing the section's state, holding dynamic or user-defined data. */
+    state: any[];
+    /** Palette data used within the section. */
+    palettes: ArchivedSectionPaletteData;
+    /** Buffer data for the section, holding voxel type identifiers, light data, state, and secondary state. */
+    buffers: ArchivedSectionBuffers;
+}
+/**
+ * Interface representing the palette data for a single section in the voxel engine.
+ */
+export interface ArchivedSectionPaletteData {
+    id?: Uint16Array;
+    light?: Uint16Array;
+    level?: Uint8Array;
+    secondaryId?: Uint16Array;
+    state?: Uint16Array;
+    mod?: Uint16Array;
+    secondaryState?: Uint16Array;
+}
+/**
+ * Interface representing the buffer data for a section.
+ */
+export interface ArchivedSectionBuffers {
+    id: Uint16Array | Uint8Array | number;
+    light: Uint16Array | Uint8Array | number;
+    level: Uint8Array | number;
+    state: Uint16Array | Uint8Array | number;
+    mod: Uint16Array | Uint8Array | number;
+    secondary: Uint16Array | Uint8Array | number;
+}
+/**
+ * Interface for an archived area.
+ */
+export interface ArchivedAreaData {
+    /** The version of vlox the data was stored in. */
+    version: string;
+    /** String representing the dimension or world type the area belongs to. */
+    dimension: string;
+    /** The palette maps for the area, including voxel, light, and state data. */
+    maps: ArchivedAreaMapData;
+    /** Keys associated with sector and section states and other objects. */
+    keys: ArchivedAreaKeysData;
+    /** Array of archived sector data within the area. */
+    sectors: ArchivedAreaSectorData[];
+}
+/**
+ * Interface for an archived area maps.
+ */
+export interface ArchivedAreaMapData {
+    /** Record mapping voxel IDs to string identifiers. */
+    id: Record<string, string>;
+    /** Record mapping string IDs to arrays of voxel identifiers. */
+    idPalette: Record<string, string[]>;
+    /** Record mapping string IDs to Uint16Arrays of light data. */
+    lightPalette: Record<string, Uint16Array>;
+    /** Record mapping string IDs to Uint8Arrays of level data. */
+    levelPalette: Record<string, Uint8Array>;
+    /** Record mapping string IDs to Uint16Arrays of voxel states. */
+    statePalette: Record<string, Uint16Array>;
+    /** Record mapping string IDs to Uint16Arrays of voxel mods. */
+    modPalette: Record<string, Uint16Array>;
+    /** Record mapping string IDs to arrays of secondary voxel identifiers. */
+    secondaryIdPalette: Record<string, string[]>;
+    /** Record mapping string IDs to Uint16Arrays of secondary voxel states. */
+    secondaryStatePalette: Record<string, Uint16Array>;
+    /** Record mapping section identifiers to `ArchivedSectionData`. */
+    section: Record<string, ArchivedSectionData>;
+    /** Record mapping sector state identifiers to arrays of state data. */
+    sectorState: Record<string, any[]>;
+}
+/**
+ * Interface representing the keys associated with sector and section states within an area.
+ */
+export interface ArchivedAreaKeysData {
+    /** Array of strings that are the keys for the sector state struct.  */
+    sectorState: string[];
+    /** Array of strings that are the keys for the section state struct.  */
+    sectionState: string[];
+}
+/**
+ * Interface representing the palette data for a sector.
+ */
+export interface ArchivedAreaSectorPaletteData {
+    id: string[];
+    light?: Uint16Array;
+    level?: Uint8Array;
+    state?: Uint16Array;
+    mod?: Uint16Array;
+    stateMap: Record<number, any[]>;
+    modMap: Record<number, any[]>;
+    secondaryId?: string[];
+    secondaryState?: Uint16Array;
+}
+/**
+ * Interface representing the archived data for a sector within an area.
+ */
+export interface ArchivedAreaSectorData {
+    /** A Vec3Array representing the position of the sector within the area. */
+    position: Vec3Array;
+    /** The state data for the sector, either as an array or a reference string. */
+    sectorState: any[] | string;
+    /** Buffer data for the sector. */
+    buffers: ArchivedSectorBuffersData;
+    /** The palette data used within the sector. */
+    palettes: ArchivedAreaSectorPaletteData;
+    /** Array of archived section data or references to section data. */
+    sections: (ArchivedSectionData | string)[];
+}

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

@@ -0,0 +1,10 @@
+import { ArchivedAreaSectorData, ArchivedAreaData, ArchivedSectorData } from "../Archive.types";
+type RunData = {
+    dimension: string;
+    sectors: ArchivedSectorData[];
+    version?: number;
+};
+export default function CreateArchiveArea(archiveData: RunData): ArchivedAreaData;
+export declare function CreateSectorFromArea(area: ArchivedAreaData, sector: ArchivedAreaSectorData): ArchivedSectorData;
+export declare function CreateSectorsFromArea(area: ArchivedAreaData): Generator<ArchivedSectorData>;
+export {};

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 ArchiveColumn(archiveData: ArchiveColumnProps): ArchivedSectorData;
+export {};