@wayward/types 2.12.3-beta.dev.20221230.1 → 2.13.0-beta

package/definitions/game/renderer/notifier/Notifier.d.ts

@@ -11,7 +11,7 @@
 import type { CreatureType } from "game/entity/creature/ICreature";
 import { StatusEffectChangeReason } from "game/entity/IEntity";
 import type StatusEffect from "game/entity/status/StatusEffect";
-import type { ItemType } from "game/item/IItem";
+import type { DisplayableItemType } from "game/item/IItem";
 import type { INotificationLocation } from "renderer/notifier/INotifier";
 import { CreatureNotifierType, ItemNotifierType, NotifierIconType, StatNotificationType } from "renderer/notifier/INotifier";
 import type RendererContext from "renderer/context/RendererContext";
@@ -19,19 +19,20 @@ import type { IResourceContainer } from "resource/IResourceLoader";
 export default class Notifier {
     private readonly context;
     private readonly capacity;
+    private readonly spriteBatch;
+    private spriteAtlas;
+    private count;
     private mostRecent;
     private mostRecentLife;
-    private count;
-    private notificationCount;
-    private readonly notifications;
-    private readonly spriteBatch;
     private nextUpdate;
+    private notificationCount;
+    private notifications;
     private suspended;
-    private spriteAtlas;
     constructor(context: RendererContext, capacity: number);
     setResources(resourceContainer: IResourceContainer): void;
+    clear(): void;
     delete(): void;
-    addItem(location: INotificationLocation, itemNotifierType: ItemNotifierType, type: ItemType): void;
+    addItem(location: INotificationLocation, itemNotifierType: ItemNotifierType, type: DisplayableItemType): void;
     addCreature(location: INotificationLocation, creatureNotifierType: CreatureNotifierType, type: CreatureType, aberrant?: boolean): void;
     addStat(location: INotificationLocation, type: StatNotificationType, value: number): void;
     addStatusEffect(location: INotificationLocation, statusEffect: StatusEffect, reason: StatusEffectChangeReason): void;
@@ -39,7 +40,7 @@ export default class Notifier {
     suspend(): void;
     resume(): void;
     update(timeStamp: number): void;
-    render(timeStamp: number, x: number, y: number, tileScale: number, viewWidth: number, viewHeight: number): boolean;
+    render(timeStamp: number, x: number, y: number, tileScale: number): boolean;
     private addNotification;
     private renderNotification;
 }

package/definitions/game/renderer/overlay/GenericOverlay.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { IOverlayInfo } from "game/tile/ITerrain";
+import type Tile from "game/tile/Tile";
+export default abstract class GenericOverlay<OVERLAY extends IOverlayInfo = IOverlayInfo, PARAMS extends any[] = []> {
+    protected readonly overlay: Map<Tile, OVERLAY>;
+    protected alpha: number;
+    constructor(hideByDefault?: boolean);
+    get isHidden(): boolean;
+    getDefaultAlpha(): number;
+    show(): void;
+    hide(): void;
+    addOrUpdate(tile: Tile, ...params: PARAMS): void;
+    protected abstract generateOverlayInfo(tile: Tile, ...params: PARAMS): OVERLAY | undefined;
+    protected updateOverlayAlpha(tile: Tile, overlay: OVERLAY, alpha: number): OVERLAY | undefined;
+    clear(): void;
+    private updateAlpha;
+}

package/definitions/game/renderer/particle/ParticleRenderer1.d.ts

@@ -9,10 +9,11 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type RendererContext from "renderer/context/RendererContext";
+import type { IParticleRenderer } from "renderer/particle/IParticleRenderer";
 /**
  * Particle renderer for webgl 1
  */
-export declare class ParticleRenderer1 {
+export declare class ParticleRenderer1 implements IParticleRenderer {
     private readonly context;
     private readonly positionSizeData;
     private readonly colorData;

package/definitions/game/renderer/particle/ParticleRenderer2.d.ts

@@ -9,10 +9,11 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type RendererContext from "renderer/context/RendererContext";
+import type { IParticleRenderer } from "renderer/particle/IParticleRenderer";
 /**
  * Particle renderer for webgl 2
  */
-export declare class ParticleRenderer2 {
+export declare class ParticleRenderer2 implements IParticleRenderer {
     private readonly context;
     private readonly dataArray;
     private readonly colorArray;

package/definitions/game/renderer/particle/ParticleSystem.d.ts

@@ -8,19 +8,19 @@
  * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
  * https://github.com/WaywardGame/types/wiki
  */
-import type Island from "game/island/Island";
 import type RendererContext from "renderer/context/RendererContext";
 import type WebGlContext from "renderer/WebGlContext";
 import type WorldRenderer from "renderer/world/WorldRenderer";
 import type { IRGB } from "utilities/Color";
+import type Tile from "game/tile/Tile";
 export default class ParticleSystem {
     private readonly context;
     private readonly worldRenderer;
     private readonly maxParticles;
-    private readonly particles;
+    readonly particles: Float32Array;
+    readonly dataPerParticle = 10;
     private readonly positionSizeData;
     private readonly colorData;
-    private readonly dataPerParticle;
     private count;
     private lastUsedParticle;
     private nextUpdate;
@@ -28,8 +28,7 @@ export default class ParticleSystem {
     static initializePrograms(webGlContext: WebGlContext): Promise<void>;
     constructor(context: RendererContext, worldRenderer: WorldRenderer, maxParticles?: number);
     delete(): void;
-    create(island: Island, tileX: number, tileY: number, tileZ: number, particle: IRGB): void;
-    createMultiple(island: Island, tileX: number, tileY: number, tileZ: number, particle: IRGB, count: number, intensity?: number): void;
+    create(tile: Tile, particle: IRGB, count?: number, intensity?: number): number[] | undefined;
     clear(): void;
     update(timeStamp: number): void;
     render(x: number, y: number): boolean;

package/definitions/game/renderer/spriteBatch/ISpriteBatch.d.ts

@@ -12,7 +12,9 @@ export default interface ISpriteBatch {
     readonly capacity: number;
     delete(): void;
     begin(): void;
-    add(tileX: number, tileY: number, spriteSize: number, sourceX: number, sourceY: number, sourceSize: number, offsetX?: number, offsetY?: number, red?: number, green?: number, blue?: number, alpha?: number): void;
     end(): number;
+    add(tileX: number, tileY: number, spriteSize: number, sourceX: number, sourceY: number, sourceSize: number, offsetX?: number, offsetY?: number, red?: number, green?: number, blue?: number, alpha?: number): number | undefined;
+    update(index: number, tileX: number, tileY: number, spriteSize: number, sourceX: number, sourceY: number, sourceSize: number, offsetX?: number, offsetY?: number, red?: number, green?: number, blue?: number, alpha?: number): void;
+    remove(index: number): boolean;
     render(x: number, y: number, tileScale: number, viewportWidth: number, viewportHeight: number): void;
 }

package/definitions/game/renderer/spriteBatch/PersistantSpriteBatch.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type ISpriteBatch from "renderer/spriteBatch/ISpriteBatch";
+/**
+ * A sprite batch that doesn't reset on each frame.
+ * Works similar to tile layers (tile / doodad rendering)
+ */
+export declare class PersistantSpriteBatch implements ISpriteBatch {
+    readonly spriteBatch: ISpriteBatch;
+    private _dirty;
+    private readonly _freeIndexes;
+    constructor(spriteBatch: ISpriteBatch);
+    get capacity(): number;
+    delete(): void;
+    begin(): void;
+    end(): number;
+    add(tileX: number, tileY: number, spriteSize: number, sourceX: number, sourceY: number, sourceSize: number, offsetX?: number | undefined, offsetY?: number | undefined, red?: number | undefined, green?: number | undefined, blue?: number | undefined, alpha?: number | undefined): number | undefined;
+    update(index: number, tileX: number, tileY: number, spriteSize: number, sourceX: number, sourceY: number, sourceSize: number, offsetX?: number, offsetY?: number, red?: number, green?: number, blue?: number, alpha?: number): void;
+    remove(index: number): boolean;
+    render(x: number, y: number, tileScale: number, viewportWidth: number, viewportHeight: number): void;
+}

package/definitions/game/renderer/spriteBatch/SpriteBatch1.d.ts

@@ -8,35 +8,12 @@
  * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
  * https://github.com/WaywardGame/types/wiki
  */
-import type ISpriteBatch from "renderer/spriteBatch/ISpriteBatch";
-import type Vector2 from "utilities/math/Vector2";
-import type WebGlContext from "renderer/WebGlContext";
-import type RendererContext from "renderer/context/RendererContext";
+import { SpriteBatchBase } from "renderer/spriteBatch/SpriteBatchBase";
 /**
  * SpriteBatch for WebGl 1
  */
-export default class SpriteBatch1 implements ISpriteBatch {
-    private readonly context;
-    readonly capacity: number;
-    private readonly depthOffset;
-    private readonly yOffset;
-    private readonly shaderProgram;
-    texSprites: WebGLTexture | undefined;
-    inverseSpriteTextureSize: Vector2 | undefined;
-    private count;
-    private readonly buffer;
-    private readonly colorBuffer;
-    private array;
-    private colorArray;
-    private begun;
-    private _setup;
-    static initializePrograms(webGlContext: WebGlContext): Promise<void>;
-    constructor(context: RendererContext, capacity: number, depthOffset?: number, yOffset?: number);
+export default class SpriteBatch1 extends SpriteBatchBase {
     setup(): void;
-    delete(): void;
-    clear(): void;
-    begin(): void;
-    add(tileX: number, tileY: number, spriteSize: number, sourceX: number, sourceY: number, sourceSize: number, offsetX?: number, offsetY?: number, red?: number, green?: number, blue?: number, alpha?: number): void;
-    end(): number;
+    bindBuffers(): void;
     render(x: number, y: number, tileScale: number, viewportWidth: number, viewportHeight: number): void;
 }

package/definitions/game/renderer/spriteBatch/SpriteBatch2.d.ts

@@ -8,41 +8,16 @@
  * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
  * https://github.com/WaywardGame/types/wiki
  */
-import type ISpriteBatch from "renderer/spriteBatch/ISpriteBatch";
-import type Vector2 from "utilities/math/Vector2";
-import type WebGlContext from "renderer/WebGlContext";
 import type RendererContext from "renderer/context/RendererContext";
+import { SpriteBatchBase } from "renderer/spriteBatch/SpriteBatchBase";
 /**
  * SpriteBatch for WebGl 2
  */
-export default class SpriteBatch2 implements ISpriteBatch {
-    private readonly context;
-    readonly capacity: number;
-    private readonly depthOffset;
-    private readonly yOffset;
-    private readonly shaderProgram;
-    texSprites: WebGLTexture | undefined;
-    inverseSpriteTextureSize: Vector2 | undefined;
-    private spriteCount;
-    private readonly texCordBuffer;
-    private readonly dataBuffer;
-    private dataArray;
-    private readonly colorBuffer;
-    private colorArray;
-    private begun;
-    private readonly vertexArray;
-    private _setup;
-    static initializePrograms(webGlContext: WebGlContext): Promise<void>;
-    constructor(context: RendererContext, capacity: number, depthOffset?: number, yOffset?: number);
+export default class SpriteBatch2 extends SpriteBatchBase {
+    protected readonly vertexArray: WebGLVertexArrayObject;
+    constructor(context: RendererContext, capacity: number, depthOffset: number, yOffset: number, enableAlphaMultiplcation: boolean, enforceBeginAndEnd: boolean);
     setup(): void;
     delete(): void;
-    clear(): void;
-    begin(): void;
-    add(tileX: number, tileY: number, spriteSize: number, sourceX: number, sourceY: number, sourceSize: number, offsetX?: number, offsetY?: number, red?: number, green?: number, blue?: number, alpha?: number): void;
-    /**
-     * Binds sprites to be included in the next render
-     * @returns number of sprites being rendered
-     */
-    end(): number;
+    bindBuffers(): void;
     render(x: number, y: number, tileScale: number, viewportWidth: number, viewportHeight: number): void;
 }

package/definitions/game/renderer/spriteBatch/SpriteBatchBase.d.ts

@@ -0,0 +1,54 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type CompiledProgram from "renderer/CompiledProgram";
+import type WebGlContext from "renderer/WebGlContext";
+import type RendererContext from "renderer/context/RendererContext";
+import type ISpriteBatch from "renderer/spriteBatch/ISpriteBatch";
+import type Vector2 from "utilities/math/Vector2";
+export declare const dataLengthPerSprite = 8;
+export declare const colorLengthPerSprite = 4;
+/**
+ * Base class for sprite batches
+ */
+export declare abstract class SpriteBatchBase implements ISpriteBatch {
+    protected readonly context: RendererContext;
+    readonly capacity: number;
+    protected readonly depthOffset: number;
+    protected readonly yOffset: number;
+    protected readonly enableAlphaMultiplcation: boolean;
+    protected readonly enforceBeginAndEnd: boolean;
+    protected readonly shaderProgram: CompiledProgram;
+    texSprites: WebGLTexture | undefined;
+    inverseSpriteTextureSize: Vector2 | undefined;
+    protected spriteCount: number;
+    protected readonly texCordBuffer: WebGLBuffer;
+    protected readonly dataBuffer: WebGLBuffer;
+    protected dataArray: Float32Array;
+    protected readonly colorBuffer: WebGLBuffer;
+    protected colorArray: Uint8Array;
+    protected begun: boolean;
+    protected _setup: boolean;
+    static initializePrograms(webGlContext: WebGlContext): Promise<void>;
+    constructor(context: RendererContext, capacity: number, depthOffset: number, yOffset: number, enableAlphaMultiplcation: boolean, enforceBeginAndEnd: boolean);
+    abstract setup(): void;
+    protected abstract bindBuffers(): void;
+    abstract render(x: number, y: number, tileScale: number, viewportWidth: number, viewportHeight: number): void;
+    delete(): void;
+    begin(): void;
+    add(tileX: number, tileY: number, spriteSize: number, sourceX: number, sourceY: number, sourceSize: number, offsetX?: number, offsetY?: number, red?: number, green?: number, blue?: number, alpha?: number): number | undefined;
+    update(index: number, tileX: number, tileY: number, spriteSize: number, sourceX: number, sourceY: number, sourceSize: number, offsetX?: number, offsetY?: number, red?: number, green?: number, blue?: number, alpha?: number): void;
+    remove(index: number): boolean;
+    /**
+     * Binds sprites to be included in the next render
+     * @returns number of sprites being rendered
+     */
+    end(): number;
+}

package/definitions/game/renderer/tile/TileLayer.d.ts

@@ -32,6 +32,14 @@ export default class TileLayer {
     static initializePrograms(webGlContext: WebGlContext): Promise<void>;
     private readonly texTileSprites;
     private readonly inverseTileSpriteTextureSize;
+    /**
+     * Flag for marking that there are changes that need to be rendered
+     */
+    dirty: boolean;
+    /**
+     * Allow overriding the tile layer ticks, used for animation frames
+     */
+    ticks?: number;
     readonly renderLayerFlag: RenderLayerFlag;
     private readonly tileShaderProgram;
     private readonly singleTileData;

package/definitions/game/renderer/tile/atlas/TileAtlas.d.ts

@@ -10,7 +10,7 @@
  */
 import type { BiomeType } from "game/biome/IBiome";
 import type DoodadInfo from "game/doodad/DoodadInfo";
-import type { DoodadType } from "game/doodad/IDoodad";
+import type { DisplayableDoodadType } from "game/doodad/IDoodad";
 import type { ItemType } from "game/item/IItem";
 import { TerrainType } from "game/tile/ITerrain";
 import type { TerrainDecoration } from "renderer/Decorations";
@@ -18,25 +18,26 @@ import type { TerrainTileInfo } from "renderer/tile/TerrainTileInfo";
 import { TileType } from "renderer/tile/atlas/ITileAtlas";
 import type Vector2 from "utilities/math/Vector2";
 export default class TileAtlas {
+    readonly doodadItems: Map<ItemType, DoodadInfo>;
+    readonly doodads: Map<DisplayableDoodadType, DoodadInfo>;
+    readonly mounds: Map<TerrainType, DoodadInfo>;
+    readonly terrainDecoration: Map<TerrainDecoration, DoodadInfo>;
     private readonly terrain;
     private readonly terrainTilled;
-    terrainDecoration: OptionalDescriptions<TerrainDecoration, DoodadInfo>;
-    doodads: OptionalDescriptions<DoodadType, DoodadInfo>;
-    doodadItems: OptionalDescriptions<ItemType, DoodadInfo>;
-    mounds: OptionalDescriptions<TerrainType, DoodadInfo>;
-    private mountainTypes;
-    private mountainGroundTypes;
-    private oreTypes;
-    private renderOverMountainTypes;
-    private waterTypes;
-    private iceTypes;
-    private freshWaterTypes;
-    private swampWaterTypes;
-    private baseWaterTypes;
+    private readonly baseWaterTypes;
+    private readonly freshWaterTypes;
+    private readonly iceTypes;
+    private readonly mountainGroundTypes;
+    private readonly mountainTypes;
+    private readonly oreTypes;
+    private readonly renderOverMountainTypes;
+    private readonly swampWaterTypes;
+    private readonly waterTypes;
     getTerrain(terrainType: TerrainType, biomeType: BiomeType | undefined): TerrainTileInfo | undefined;
     getTerrainTilled(terrainType: TerrainType, biomeType: BiomeType | undefined): TerrainTileInfo | undefined;
     setTerrain(terrainType: TerrainType, terrainTileInfo: TerrainTileInfo, biomeType: BiomeType | undefined): void;
     setTerrainTilled(terrainType: TerrainType, terrainTileInfo: TerrainTileInfo, biomeType: BiomeType | undefined): void;
+    clearCaches(): void;
     generateLookups(): void;
     isMountain(type: TerrainType): boolean;
     isMountainGround(type: TerrainType): boolean;

package/definitions/game/renderer/world/IWorldLayer.d.ts

@@ -11,6 +11,7 @@
 import type DoodadInfo from "game/doodad/DoodadInfo";
 import type { DoodadType, IDoodadDescription } from "game/doodad/IDoodad";
 import type { TerrainType } from "game/tile/ITerrain";
+import type ExploreMap from "renderer/exploreMap/ExploreMap";
 export interface ITileUpdate {
     terrainType: TerrainType;
     terrainMasks: TerrainMask;
@@ -26,8 +27,8 @@ export interface IDoodadUpdate {
     hasGraphicVariation: boolean;
     terrainMasks: TerrainMask;
 }
-export type onTileUpdateDelegate = (x: number, y: number, flushImmediate: boolean, debug?: boolean) => void;
-export type onDoodadUpdateDelegate = (x: number, y: number, flushImmediate: boolean, doodadUpdate: IDoodadUpdate) => void;
+export type onTileUpdateDelegate = (x: number, y: number, flushTileImmediately: boolean, debug?: boolean) => void;
+export type onDoodadUpdateDelegate = (x: number, y: number, flushTileImmediately: boolean, doodadUpdate: IDoodadUpdate) => void;
 export type TerrainData = number;
 export declare enum TerrainMask {
     None = 0,
@@ -38,4 +39,7 @@ export declare enum TerrainMask {
     Wall = 1073741824,
     Fence = 2147483648
 }
+export interface IWorldLayerOld {
+    exploredMap?: ExploreMap;
+}
 export declare const stillContainerOrder: Record<number, number>;

package/definitions/game/renderer/world/IWorldLayerRenderer.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type RendererContext from "renderer/context/RendererContext";
+import type { RenderLayerFlag } from "renderer/world/IWorldRenderer";
+export declare const jitRenderingExtraRenderRange = 2;
+export declare const jitRenderingMaxTileUpdates = 4096;
+export interface IWorldLayerRendererEvents {
+    /**
+     * Called when rendering the world
+     * @returns Flags indicating what layers to render
+     */
+    getRenderFlags(): RenderLayerFlag;
+    /**
+     * Called when tile layers are created
+     * Custom tile layers can be added to it
+     */
+    createTileLayers(context: RendererContext, width: number, height: number, positionBuffer: WebGLBuffer): void;
+}

package/definitions/game/renderer/world/IWorldRenderer.d.ts

@@ -8,6 +8,7 @@
  * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
  * https://github.com/WaywardGame/types/wiki
  */
+import type { IBound3 } from "utilities/math/Bound3";
 export declare enum SpriteBatchLayer {
     Corpse = 0,
     Item = 1,
@@ -54,3 +55,10 @@ export declare enum TileLayerType {
     Doodad = 3,
     DoodadOver = 4
 }
+export interface IBounds {
+    viewportBounds: IBound3;
+    startX: number;
+    endX: number;
+    startY: number;
+    endY: number;
+}

package/definitions/game/renderer/world/World.d.ts

@@ -11,21 +11,21 @@
 import EventEmitter from "event/EventEmitter";
 import { TileUpdateType } from "game/IGame";
 import type Island from "game/island/Island";
-import type { ITile } from "game/tile/ITerrain";
+import type Tile from "game/tile/Tile";
 import type { WorldZ } from "game/WorldZ";
 import WorldLayer from "renderer/world/WorldLayer";
 import type { ISerializable, ISerializer } from "save/serializer/ISerializer";
 export interface IWorldEvents {
-    updateTile(x: number, y: number, z: number, tile: ITile, tileUpdateType: TileUpdateType): any;
+    updateTile(tile: Tile, tileUpdateType: TileUpdateType): any;
 }
 export default class World extends EventEmitter.Host<IWorldEvents> implements ISerializable {
     readonly island: Island;
     width: number;
     height: number;
     layers: Record<number, WorldLayer>;
-    _loaded: boolean;
     private batchTileUpdate;
     private layerUpdatesSuspended;
+    private _loaded;
     constructor(island: Island, width: number, height: number);
     delete(): void;
     get loaded(): boolean;
@@ -34,8 +34,8 @@ export default class World extends EventEmitter.Host<IWorldEvents> implements IS
     load(): void;
     suspendLayerUpdates(): void;
     resumeLayerUpdates(): void;
-    updateTile(x: number, y: number, z: number, tile: ITile, tileUpdateType: TileUpdateType, updateNeighbors?: boolean, flush?: boolean): void;
-    updateTileLayer(x: number, y: number, z: number, tile: ITile, updateNeighbors?: boolean, flush?: boolean): void;
+    updateTile(tile: Tile, tileUpdateType: TileUpdateType, updateNeighbors?: boolean, skipFlowFieldUpdate?: boolean): void;
+    updateTileLayer(tile: Tile, updateNeighbors: boolean | undefined, flushTileImmediately: boolean): void;
     startUpdateTileBatch(): void;
     endUpdateTileBatch(): void;
     serializeObject(_serializer: ISerializer): undefined;

package/definitions/game/renderer/world/WorldLayer.d.ts

@@ -9,27 +9,32 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type Island from "game/island/Island";
-import type { ITile } from "game/tile/ITerrain";
 import { TerrainType } from "game/tile/ITerrain";
 import { WorldZ } from "game/WorldZ";
-import type ExploreMap from "renderer/exploreMap/ExploreMap";
 import type { IByteGrid } from "renderer/fieldOfView/IByteGrid";
 import type { ITileUpdate, onDoodadUpdateDelegate, onTileUpdateDelegate, TerrainData } from "renderer/world/IWorldLayer";
 import { TerrainMask } from "renderer/world/IWorldLayer";
 import type { IColorGrid, IWorldLayerCPP } from "@cplusplus/index";
+import type Tile from "game/tile/Tile";
 export default class WorldLayer {
     readonly island: Island;
     readonly width: number;
     readonly height: number;
-    readonly level: WorldZ;
+    readonly z: WorldZ;
+    /**
+     * Light level for the renderer.
+     * Updated in FieldOfView.computeLightMap
+     */
     readonly lightLevelMap: IColorGrid;
+    /**
+     * Light blocks - changed via tileUpdate event
+     */
     readonly lightBlockMap: IByteGrid;
-    exploredMap: ExploreMap | undefined;
     onTileUpdates: Map<number, onTileUpdateDelegate>;
     onDoodadUpdates: Map<number, onDoodadUpdateDelegate>;
     private readonly terrainMap;
     readonly instance: IWorldLayerCPP;
-    constructor(island: Island, width: number, height: number, level: WorldZ);
+    constructor(island: Island, width: number, height: number, z: WorldZ);
     delete(): void;
     getTileType(x: number, y: number): TerrainType;
     getTile(x: number, y: number): TerrainData;
@@ -46,8 +51,8 @@ export default class WorldLayer {
      * Updates the rendered tile.
      * All neighbors are updated by default, but the neighbor tile update is only done when updateNeighbors is true
      */
-    updateTile(x: number, y: number, tile: ITile, shouldUpdate: boolean, updateNeighbors: boolean, flushImmediate: boolean, isUpdatingNeighbors?: boolean, debug?: boolean): void;
-    getTileUpdate(x: number, y: number, tile?: ITile): ITileUpdate;
+    updateTile(x: number, y: number, tile: Tile, shouldUpdate: boolean, updateNeighbors: boolean, flushTileImmediately: boolean, isUpdatingNeighbors?: boolean, debug?: boolean): void;
+    getTileUpdate(tile: Tile): ITileUpdate;
     private setTileInternal;
     /**
      * This must be synced with the loop in WorldLayer::BatchUpdateLightBlockValues c++

package/definitions/game/renderer/world/WorldLayerRenderer.d.ts

@@ -17,18 +17,8 @@ import type WorldLayer from "renderer/world/WorldLayer";
 import type WorldRenderer from "renderer/world/WorldRenderer";
 import type { IBound3 } from "utilities/math/Bound3";
 import type RendererContext from "renderer/context/RendererContext";
-export interface IWorldLayerRendererEvents {
-    /**
-     * Called when rendering the world
-     * @returns Flags indicating what layers to render
-     */
-    getRenderFlags(): RenderLayerFlag;
-    /**
-     * Called when tile layers are created
-     * Custom tile layers can be added to it
-     */
-    createTileLayers(context: RendererContext, width: number, height: number, positionBuffer: WebGLBuffer): void;
-}
+import type ExploredMapClientData from "save/clientStore/clientData/ExploredMap";
+import type { IWorldLayerRendererEvents } from "renderer/world/IWorldLayerRenderer";
 export default class WorldLayerRenderer extends EventEmitter.Host<IWorldLayerRendererEvents> {
     readonly context: RendererContext;
     protected readonly worldRenderer: WorldRenderer;
@@ -38,12 +28,18 @@ export default class WorldLayerRenderer extends EventEmitter.Host<IWorldLayerRen
     texLightBlock: WebGLTexture;
     texLightLevel: WebGLTexture;
     texExplored: WebGLTexture;
+    private exploredMap;
+    /**
+     * Flag for marking that there are changes that need to be rendered in one or more tile layers
+     */
     private dirty;
     private dirtyTiles;
     private dirtyDoodads;
     private readonly dirtyDoodadUpdates;
     private readonly tileLayers;
     private readonly tileLayerMap;
+    private readonly tilesToFlush;
+    private readonly doodadsToFlush;
     private terrainLayer;
     private terrainOverLayer;
     private terrainDecorationsLayer;
@@ -54,10 +50,15 @@ export default class WorldLayerRenderer extends EventEmitter.Host<IWorldLayerRen
     delete(): void;
     private deleteTileLayers;
     reset(): void;
-    setWorldLayer(worldLayer: WorldLayer): void;
+    setWorldLayer(worldLayer: WorldLayer, exploredMapClientData: ExploredMapClientData): void;
     addTileLayer(tileLayer: TileLayer): void;
     updateAll(): void;
-    updateDoodad(x: number, y: number, flushImmediate: boolean, { doodadDescription, doodadType, doodadInfo, doodadVariationX, doodadVariationY, terrainMasks }: IDoodadUpdate): void;
+    /**
+     * Sets the alpha of a tile in the explored data
+     * Note: You must call bind the texture before calling this
+     */
+    setExploredAlpha(x: number, y: number, alpha: Uint8Array): void;
+    updateDoodad(x: number, y: number, flushTileImmediately: boolean, { doodadDescription, doodadType, doodadInfo, doodadVariationX, doodadVariationY, terrainMasks }: IDoodadUpdate): void;
     renderFullbright(x: number, y: number, tileScale: number, viewWidth: number, viewHeight: number, renderFixedDepth: boolean, flags?: RenderLayerFlag): void;
     getDataIndex(x: number, y: number): number;
     setLayer(layer: TileLayer, dataIndex: number, tileAdaptation: TileAdaptor.ITileAdaptation): void;
@@ -70,9 +71,14 @@ export default class WorldLayerRenderer extends EventEmitter.Host<IWorldLayerRen
     /**
      * Ensures tiles in the view are rendered/flushed
      * Tiles & doodads are flushed the first time they are visible within the fov
+     * @returns True when there's more rendering to be done
+     */
+    ensureRendered({ min, max }: IBound3): boolean;
+    /**
+     * Processes pending tile/doodad updates
      */
-    ensureRendered({ min, max }: IBound3): void;
-    updateTile(x: number, y: number, flushImmediate?: boolean, debug?: boolean): void;
+    private processUpdates;
+    updateTile(x: number, y: number, flushTileImmediately?: boolean, debug?: boolean): void;
     private computeDoodad;
     private computeTilled;
     private computeDecorations;