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

package/definitions/game/multiplayer/packets/IndexedPacket.d.ts

@@ -17,6 +17,7 @@ import type NPC from "game/entity/npc/NPC";
 import type { IMovementIntent } from "game/entity/player/IPlayer";
 import type Player from "game/entity/player/Player";
 import type Item from "game/item/Item";
+import type TileEvent from "game/tile/TileEvent";
 import BasePacket from "multiplayer/packets/BasePacket";
 import type { IVector2, IVector3 } from "utilities/math/IVector";
 export default abstract class IndexedPacket extends BasePacket {
@@ -56,11 +57,13 @@ export default abstract class IndexedPacket extends BasePacket {
     protected writeIndexedPlayer(value?: Player): void;
     protected readIndexedDoodad(): Doodad | undefined;
     protected writeIndexedDoodad(value?: Doodad): void;
+    protected readIndexedTileEvent(): TileEvent | undefined;
+    protected writeIndexedTileEvent(value?: TileEvent): void;
     protected readIndexedNPC(): NPC | undefined;
     protected writeIndexedNPC(value?: NPC): void;
     protected readIndexedCorpse(): Corpse | undefined;
     protected writeIndexedCorpse(value?: Corpse): void;
-    protected readIndexedEntity(): Creature | NPC | Player | undefined;
+    protected readIndexedEntity(): Player | Creature | NPC | Doodad | TileEvent | Corpse | Item | undefined;
     protected writeIndexedEntity(value?: Entity): void;
     protected readIndexedHuman(): Human | undefined;
     protected writeIndexedHuman(value?: Human): void;

package/definitions/game/multiplayer/packets/Packets.d.ts

@@ -15,4 +15,4 @@ import Registrar from "utilities/Registrar";
 export interface IPacketClass extends IRegistrarItem {
     new (connection?: IConnection): IPacket;
 }
-export declare const registrar: Registrar<IPacketClass>;
+export declare const packetRegistrar: Registrar<IPacketClass>;

package/definitions/game/multiplayer/packets/client/LoadIslandPacket.d.ts

@@ -12,7 +12,7 @@ import type { IslandId } from "game/island/IIsland";
 import ClientPacket from "multiplayer/packets/ClientPacket";
 export default class LoadIslandPacket extends ClientPacket<Promise<void>> {
     islandId: IslandId;
-    allowItemFixes: boolean;
+    isSynced: boolean;
     getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     process(): Promise<void>;

package/definitions/game/multiplayer/packets/server/ConnectPacket.d.ts

@@ -16,5 +16,5 @@ export default class ConnectPacket extends ServerPacket {
     getDebugInfo(): string;
     getAllowedStates(): ConnectionState;
     isAllowedWhenPaused(): boolean;
-    process(): void;
+    process(): Promise<void>;
 }

package/definitions/game/multiplayer/packets/server/UpdateActionBarPacket.d.ts

@@ -11,8 +11,9 @@
 import PlayerTargetedServerPacket from "multiplayer/packets/PlayerTargetedServerPacket";
 import type { IActionBarSlotData } from "ui/screen/screens/game/static/actions/IActionBar";
 export default class UpdateActionBarPacket extends PlayerTargetedServerPacket {
-    slots: Uint8Array;
-    data: IActionBarSlotData[];
+    slots?: Uint8Array;
+    data?: IActionBarSlotData[];
+    enabled?: boolean;
     getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;

package/definitions/game/renderer/IRenderer.d.ts

@@ -8,7 +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 { IRendererOrigin } from "renderer/context/RendererOrigin";
+import type { IFieldOfViewOrigin } from "renderer/fieldOfView/IFieldOfView";
 import type { IVector2 } from "utilities/math/IVector";
 export interface IRendererEvents {
     /**
@@ -28,7 +28,20 @@ export interface IRendererEvents {
     /**
      * Called when setting the zoom level.
      */
-    getZoomLevel(): number | undefined;
+    getMinZoomLevel(): number | undefined;
+    /**
+     * Called when setting the zoom level.
+     */
+    getMaxZoomLevel(): number | undefined;
+    /**
+     * Called when setting the zoom level.
+     * @param zoomLevel The zoom level that will be used by default
+     */
+    getZoomLevel(zoomLevel: number): number | undefined;
+    /**
+     * Called when the renderer is initialized
+     */
+    initialized(): void;
     /**
      * Called when the renderer is deleted
      */
@@ -50,63 +63,70 @@ export declare enum RenderSource {
     ActionsMenu = 1,
     AmbientLightLevelUpdate = 2,
     AttackAnimationStart = 3,
-    FadeIn = 4,
-    FovTransition = 5,
-    FovUpdate = 6,
-    FovUpdateRadius = 7,
-    GameAnimating = 8,
-    GamePassTurn = 9,
-    GameResumed = 10,
-    GameTick = 11,
-    HiddenMob = 12,
-    InspectOverlay = 13,
-    IslandLoad = 14,
-    ItemEquip = 15,
-    ItemEquipEffect = 16,
-    ItemMovement = 17,
-    ItemUnequip = 18,
-    Loop = 19,
-    Mod = 20,
-    MovementCreature = 21,
-    MovementNPC = 22,
-    MovementPlayer = 23,
-    MovementPlayerPost = 24,
-    MovementPlayerZPost = 25,
-    MovementTileEvent = 26,
-    MultiplayerDisconnect = 27,
-    Notifier = 28,
-    NotifierAddCreature = 29,
-    NotifierAddItem = 30,
-    NotifierAddNotifierIcon = 31,
-    NotifierAddStat = 32,
-    NotifierAddStatusType = 33,
-    OptionEquipment = 34,
-    OptionVisionMode = 35,
-    OptionZoomLevel = 36,
-    Particles = 37,
-    ParticleSpawn = 38,
-    PlayerAdd = 39,
-    PlayerKill = 40,
-    PlayerProcessMovement = 41,
-    PlayerReady = 42,
-    PlayerRemove = 43,
-    PlayerRespawn = 44,
-    PlayerRest = 45,
-    PlayerRestStart = 46,
-    PlayerRestStop = 47,
-    PlayerSetPosition = 48,
-    PlayerVehicle = 49,
-    PlayerWalkToTilePath = 50,
-    PlayerWalkToTilePathOverburdened = 51,
-    PlayerWalkToTilePathPreview = 52,
-    PlayerWalkToTilePathReset = 53,
-    RemoveBlood = 54,
-    Resize = 55,
-    SetupGl = 56,
-    SpawnAnimationStart = 57,
-    StartGame = 58,
-    Steamworks = 59,
-    Thumbnail = 60,
-    WorldLayerRendererFlush = 61
+    DoodadChangeType = 4,
+    FadeIn = 5,
+    FovTransition = 6,
+    FovUpdate = 7,
+    FovUpdateRadius = 8,
+    GameAnimating = 9,
+    GamePassTurn = 10,
+    GameResumed = 11,
+    GameTick = 12,
+    GenericOverlay = 13,
+    HiddenMob = 14,
+    HumanRest = 15,
+    HumanRestStart = 16,
+    HumanRestStop = 17,
+    HumanSetPosition = 18,
+    HumanVehicle = 19,
+    InspectOverlay = 20,
+    IslandLoad = 21,
+    IslandTravel = 22,
+    ItemEquip = 23,
+    ItemEquipEffect = 24,
+    ItemMovement = 25,
+    ItemUnequip = 26,
+    Loop = 27,
+    Mod = 28,
+    MovementCreature = 29,
+    MovementNPC = 30,
+    MovementPlayer = 31,
+    MovementPlayerPost = 32,
+    MovementPlayerZPost = 33,
+    MovementTileEvent = 34,
+    MultiplayerDisconnect = 35,
+    Notifier = 36,
+    NotifierAddCreature = 37,
+    NotifierAddItem = 38,
+    NotifierAddNotifierIcon = 39,
+    NotifierAddStat = 40,
+    NotifierAddStatusType = 41,
+    OptionEquipment = 42,
+    OptionVisionMode = 43,
+    OptionZoomLevel = 44,
+    Particles = 45,
+    ParticleSpawn = 46,
+    PlayerAdd = 47,
+    PlayerKill = 48,
+    PlayerNoclip = 49,
+    PlayerProcessMovement = 50,
+    PlayerReady = 51,
+    PlayerRemove = 52,
+    PlayerRespawn = 53,
+    PlayerWalkToTilePath = 54,
+    PlayerWalkToTilePathOverburdened = 55,
+    PlayerWalkToTilePathPreview = 56,
+    PlayerWalkToTilePathReset = 57,
+    RemoveBlood = 58,
+    Resize = 59,
+    SetupGl = 60,
+    SpawnAnimationStart = 61,
+    StartGame = 62,
+    Steamworks = 63,
+    Thumbnail = 64,
+    WorldLayerRendererFlush = 65
 }
-export declare function calculateAmbientLightLevel(origin: IRendererOrigin, z: number): number;
+export declare function calculateAmbientLightLevel(origin: IFieldOfViewOrigin, z: number): number;
+export declare const ZOOM_LEVEL_MIN = 1;
+export declare const ZOOM_LEVEL_MAX = 16;
+export declare const ZOOM_LEVEL_ANIMATION_TIME = 400;

package/definitions/game/renderer/Overlays.d.ts

@@ -13,4 +13,4 @@ import type { OverlayType } from "game/tile/ITerrain";
 import type { IModdable } from "mod/ModRegistry";
 export interface IOverlayDescription extends IModdable, IHasImagePath {
 }
-export declare const overlayDescriptions: OptionalDescriptions<OverlayType, IOverlayDescription>;
+export declare const overlayDescriptions: Map<OverlayType, IOverlayDescription>;

package/definitions/game/renderer/Renderer.d.ts

@@ -11,6 +11,8 @@
 import EventEmitter from "event/EventEmitter";
 import type { IslandId } from "game/island/IIsland";
 import type Island from "game/island/Island";
+import type { IOverlayInfo } from "game/tile/ITerrain";
+import type Tile from "game/tile/Tile";
 import type { IRendererOrigin } from "renderer/context/RendererOrigin";
 import type { IRendererEvents } from "renderer/IRenderer";
 import { RenderSource, UpdateRenderFlag } from "renderer/IRenderer";
@@ -18,46 +20,78 @@ import WebGlContext from "renderer/WebGlContext";
 import WorldRenderer from "renderer/world/WorldRenderer";
 import type { IVector2 } from "utilities/math/IVector";
 import Vector2 from "utilities/math/Vector2";
+import type { IVector4 } from "utilities/math/Vector4";
 export default class Renderer extends EventEmitter.Host<IRendererEvents> {
+    private readonly canvasElement;
     readonly id: number;
-    readonly worldRenderer: WorldRenderer;
+    worldRenderer: WorldRenderer;
     private fadeInTime;
+    private targetZoomLevel;
     private thumbnailResolve;
     private ambientLightLevelCache;
     private updateRendering;
     private animationTimer;
     private renderingEnabled;
     private rendered;
+    private readonly states;
     private readonly context;
+    private canvasContext;
+    private readonly viewportSize;
+    private loadedIsland?;
     /**
      * Creates a WebGl context that can be used for rendering the game
-     * @param canvas The html canvas
+     * @param canvas The canvas
      * @param desiredWebGlVersion Desired webgl version. Defaults to 2
      * @param desiredPowerPreference Desired power preference
      * @returns
      */
     static createWebGlContext(canvas: HTMLCanvasElement, desiredWebGlVersion?: number, desiredPowerPreference?: WebGLPowerPreference): Promise<WebGlContext>;
-    constructor(webGlContext: WebGlContext, origin: IRendererOrigin);
-    delete(): Promise<void>;
+    constructor(canvasElement: HTMLCanvasElement);
+    reinitialize(): Promise<void>;
+    private initialize;
+    delete(reinitializing?: boolean): Promise<boolean>;
     get fieldOfView(): import("./fieldOfView/FieldOfView").default;
     get notifier(): import("./notifier/Notifier").default;
     get particle(): import("./particle/ParticleSystem").default;
     get isFadingIn(): boolean;
     get isUpdatingThumbnail(): boolean;
-    get island(): Island;
-    get islandId(): IslandId;
+    /**
+     * The island the renderer is rendering.
+     * Could be undefined if the renderer has not had it's origin set.
+     */
+    get island(): Island | undefined;
+    /**
+     * The island id the renderer is rendering.
+     * Could be undefined if the renderer has not had it's origin set.
+     */
+    get islandId(): IslandId | undefined;
     start(): void;
     stop(): void;
+    pushState(): void;
+    popState(): void;
     setOrigin(origin: IRendererOrigin): void;
-    load(island: Island): void;
-    setViewport(view?: Vector2): void;
+    /**
+     * Loads the island into the renderer
+     * @param island Island to load
+     * @returns True when the island is loaded. False if the island was already loaded
+     */
+    private load;
+    setViewportSize(width: number, height: number): void;
     getZoom(): number;
     addZoomLevel(amount: number): void;
     updateZoomLevel(): void;
     getCameraPosition(timeStamp: number): IVector2;
     getExactCameraPosition(timeStamp: number): Vector2;
     createFadeIn(duration?: number): void;
+    /**
+     * @returns a value between 0 and 1. 0 being full black
+     */
     getBlackness(timeStamp: number): number;
+    /**
+     * Determines if the renderer cares about an update
+     * based on the position of the update vs renderer origin
+     */
+    shouldUpdate(updateOrigin: IVector4 | undefined, flag?: UpdateRenderFlag): boolean;
     updateRender(source: RenderSource, flag: UpdateRenderFlag): void;
     /**
      * Note: Don't inject here. This gets called ten million times. If you want to override this functionality,
@@ -66,22 +100,30 @@ export default class Renderer extends EventEmitter.Host<IRendererEvents> {
     getAmbientLightLevel(z: number): number;
     updateAmbientLightLevel(z: number): number;
     updateView(source: RenderSource, updateFov: boolean | UpdateRenderFlag.FieldOfView | UpdateRenderFlag.FieldOfViewSkipTransition): void;
-    updateThumbnail(): Promise<boolean>;
+    addOrUpdateOverlay(tile: Tile, overlay: IOverlayInfo): void;
+    removeOverlay(tile: Tile, overlay: IOverlayInfo): void;
+    updateThumbnail(): Promise<string | undefined>;
     update(timeStamp: number): void;
     computeSpritesInViewport(): void;
     private getFadeInProgress;
+    private getZoomLevelProgress;
     private hasRenderFlag;
     private clearRenderFlag;
     private requestAnimationFrame;
     private cancelAnimationFrame;
+    protected renderLoop(timeStamp: number, viewportOffsetX: number): void;
     /**
-     * Game render loop
-     * Not executed for the host in dedicated servers
+     * Game render loop.
+     * Not executed for the host in dedicated servers.
+     * Only executed for the primary renderer.
      */
-    protected gameRenderLoop: (timeStamp: number) => void;
+    protected static gameRenderLoop: (timeStamp: number) => void;
     private render;
     private shouldUpdateWorldRender;
     private registerOriginEvents;
     private unregisterOriginEvents;
+    private registerIslandEvents;
+    private unregisterIslandEvents;
     private onOriginLoadedOnIsland;
+    private onIslandUnloaded;
 }

package/definitions/game/renderer/Renderers.d.ts

@@ -11,35 +11,45 @@
 import type { CreatureType } from "game/entity/creature/ICreature";
 import type { StatusEffectChangeReason } from "game/entity/IEntity";
 import type StatusEffect from "game/entity/status/StatusEffect";
+import type { IslandId } from "game/island/IIsland";
 import type Island from "game/island/Island";
-import type { ItemType } from "game/item/IItem";
+import type { DisplayableItemType } from "game/item/IItem";
+import type { IOverlayInfo } from "game/tile/ITerrain";
+import type Tile from "game/tile/Tile";
 import type { RenderSource, UpdateRenderFlag } from "renderer/IRenderer";
 import type { CreatureNotifierType, INotificationLocation, ItemNotifierType, NotifierIconType, StatNotificationType } from "renderer/notifier/INotifier";
 import type Renderer from "renderer/Renderer";
 import type { IRGB } from "utilities/Color";
+import type { IVector4 } from "utilities/math/Vector4";
 /**
  * Tracks active Renderer instances for the client
  */
 export default class Renderers {
-    private readonly renderers;
+    readonly renderers: Set<Renderer>;
     readonly notifier: {
         suspend: () => void;
         resume: () => void;
         addNotifierIcon: (location: INotificationLocation, type: NotifierIconType) => void;
         addStat: (location: INotificationLocation, type: StatNotificationType, value: number) => void;
         addStatusEffect: (location: INotificationLocation, statusEffect: StatusEffect, reason: StatusEffectChangeReason) => 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;
     };
     readonly particle: {
-        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) => void;
     };
+    getRenderersForObject(object: IVector4): Renderer[];
+    getRenderersForIslandId(islandId: IslandId): Renderer[];
     hasRendererForIsland(island: Island): boolean;
-    add(renderer: Renderer): void;
-    remove(renderer: Renderer): void;
-    computeSpritesInViewport(): void;
+    add(renderer: Renderer): boolean;
+    remove(renderer: Renderer): boolean;
+    stop(): void;
+    reinitialize(): Promise<void>;
+    delete(): Promise<void>;
     update(timeStamp: number): void;
-    updateView(/*island: Island,*/ source: RenderSource, updateFov?: boolean | UpdateRenderFlag.FieldOfView | UpdateRenderFlag.FieldOfViewSkipTransition): void;
-    updateRender(/*island: Island,*/ source: RenderSource, flag: UpdateRenderFlag): void;
+    computeSpritesInViewport(origin: IVector4): void;
+    addOrUpdateOverlay(tile: Tile, overlay: IOverlayInfo): void;
+    removeOverlay(tile: Tile, overlay: IOverlayInfo): void;
+    updateView(origin: IVector4 | undefined, source: RenderSource, updateFov?: boolean | UpdateRenderFlag.FieldOfView | UpdateRenderFlag.FieldOfViewSkipTransition): void;
+    updateRender(origin: IVector4 | undefined, source: RenderSource, flag: UpdateRenderFlag): void;
 }

package/definitions/game/renderer/WebGlContext.d.ts

@@ -12,12 +12,12 @@ import type { IProgramDescription } from "renderer/CompiledProgram";
 import CompiledProgram from "renderer/CompiledProgram";
 import ResourceLoader from "resource/ResourceLoader";
 export default class WebGlContext {
-    readonly id: number;
+    readonly canvas: HTMLCanvasElement;
     readonly gl: WebGL2RenderingContext;
     readonly version: number;
     private readonly programs;
     readonly resourceLoader: ResourceLoader;
-    constructor(id: number, gl: WebGL2RenderingContext, version: number);
+    constructor(canvas: HTMLCanvasElement, gl: WebGL2RenderingContext, version: number);
     delete(): void;
     /**
      * Initializes shaders and resource loader

package/definitions/game/renderer/context/BaseRendererContext.d.ts

@@ -10,9 +10,15 @@
  */
 import type { IRendererOrigin } from "renderer/context/RendererOrigin";
 import type WebGlContext from "renderer/WebGlContext";
+import type { IVector2 } from "utilities/math/IVector";
 export default class BaseRendererContext {
     readonly webGlContext: WebGlContext;
-    origin: IRendererOrigin;
     readonly gl: WebGL2RenderingContext;
-    constructor(webGlContext: WebGlContext, origin: IRendererOrigin);
+    readonly viewport: IVector2;
+    private _origin;
+    constructor(webGlContext: WebGlContext);
+    get maybeOrigin(): IRendererOrigin | undefined;
+    get origin(): IRendererOrigin;
+    set origin(origin: IRendererOrigin);
+    setWebGlContext(webGlContext: WebGlContext): void;
 }

package/definitions/game/renderer/context/RendererContext.d.ts

@@ -11,9 +11,11 @@
 import type BaseRendererContext from "renderer/context/BaseRendererContext";
 import type { IRendererOrigin } from "renderer/context/RendererOrigin";
 import type Renderer from "renderer/Renderer";
+import { PersistantSpriteBatch } from "renderer/spriteBatch/PersistantSpriteBatch";
 import SpriteBatch1 from "renderer/spriteBatch/SpriteBatch1";
 import SpriteBatch2 from "renderer/spriteBatch/SpriteBatch2";
 import type WebGlContext from "renderer/WebGlContext";
+import type { IVector2 } from "utilities/math/IVector";
 export default class RendererContext {
     readonly renderer: Renderer;
     private readonly baseRendererContext;
@@ -22,5 +24,7 @@ export default class RendererContext {
     constructor(renderer: Renderer, baseRendererContext: BaseRendererContext);
     get isWebGl2(): boolean;
     get origin(): IRendererOrigin;
-    createSpriteBatch(capacity: number, depthOffset?: number, yOffset?: number): SpriteBatch2 | SpriteBatch1;
+    get viewport(): IVector2;
+    createSpriteBatch(capacity: number, depthOffset?: number, yOffset?: number, enableAlphaMultiplcation?: boolean, enforceBeginAndEnd?: boolean): SpriteBatch1 | SpriteBatch2;
+    createPersistantSpriteBatch(depthOffset?: number, yOffset?: number, enableAlphaMultiplcation?: boolean): PersistantSpriteBatch;
 }

package/definitions/game/renderer/context/RendererOrigin.d.ts

@@ -15,19 +15,13 @@ import type Player from "game/entity/player/Player";
 import type { IslandId } from "game/island/IIsland";
 import type Island from "game/island/Island";
 import FieldOfView from "renderer/fieldOfView/FieldOfView";
-import type { CanASeeBType } from "renderer/fieldOfView/IFieldOfView";
-import type { IVector3 } from "utilities/math/IVector";
+import type { CanASeeBType, IFieldOfViewOrigin } from "renderer/fieldOfView/IFieldOfView";
 import type { IVector4 } from "utilities/math/Vector4";
-export interface IRendererOrigin {
-    readonly islandId: IslandId;
-    readonly island: Island;
-    readonly x: number;
-    readonly y: number;
-    readonly z: number;
-    readonly fromX: number;
-    readonly fromY: number;
+export interface IRendererOrigin extends IFieldOfViewOrigin {
+    readonly fromX?: number;
+    readonly fromY?: number;
     readonly movingClientside: MovingClientSide;
-    readonly asEntity: Entity | undefined;
+    readonly asEntity: Entity;
     readonly asPlayer: Player | undefined;
     readonly asHuman: Human | undefined;
     canSeeObject(type: CanASeeBType, object: IVector4 & {
@@ -43,11 +37,10 @@ export declare class RendererOrigin implements IRendererOrigin {
     readonly y: number;
     readonly z: number;
     static fromEntity(entity: Entity): IRendererOrigin;
-    static fromVector(island: Island, vector: IVector3): IRendererOrigin;
     readonly fromX: number;
     readonly fromY: number;
     readonly movingClientside: MovingClientSide;
-    readonly asEntity: Entity | undefined;
+    readonly asEntity: Entity;
     readonly asPlayer: Player | undefined;
     readonly asHuman: Human | undefined;
     private constructor();

package/definitions/game/renderer/fieldOfView/FieldOfView.d.ts

@@ -11,7 +11,7 @@
 import EventEmitter from "event/EventEmitter";
 import type Player from "game/entity/player/Player";
 import type CompiledProgram from "renderer/CompiledProgram";
-import type { IFieldOfViewEvents } from "renderer/fieldOfView/IFieldOfView";
+import type { IFieldOfViewEvents, IFieldOfViewOrigin } from "renderer/fieldOfView/IFieldOfView";
 import { CanASeeBType } from "renderer/fieldOfView/IFieldOfView";
 import type ITextureDebugRenderer from "renderer/ITextureDebugRenderer";
 import type RendererContext from "renderer/context/RendererContext";
@@ -20,7 +20,6 @@ import type WorldRenderer from "renderer/world/WorldRenderer";
 import type { IBound3 } from "utilities/math/Bound3";
 import type { IVector2, IVector3 } from "utilities/math/IVector";
 import Vector2 from "utilities/math/Vector2";
-import type { IRendererOrigin } from "renderer/context/RendererOrigin";
 import type { IslandId } from "game/island/IIsland";
 import type Human from "game/entity/Human";
 export default class FieldOfView extends EventEmitter.Host<IFieldOfViewEvents> {
@@ -50,16 +49,17 @@ export default class FieldOfView extends EventEmitter.Host<IFieldOfViewEvents> {
     texLightOld: WebGLTexture | undefined;
     private seed;
     private transitionFinishTime;
+    private readonly transitioningExploredMap;
     private lastComputedIslandId;
     static initializePrograms(webGlContext: WebGlContext): Promise<void>;
-    static canSeePosition(origin: IRendererOrigin, type: CanASeeBType, islandId: IslandId, tileX: number, tileY: number, tileZ: number, fieldOfView?: FieldOfView | undefined, customRadius?: number): boolean;
-    static getBounds(origin: IVector3, radius: number): IBound3;
+    static canSeePosition(origin: IFieldOfViewOrigin, type: CanASeeBType, islandId: IslandId, tileX: number, tileY: number, tileZ: number, fieldOfView?: FieldOfView | undefined, customRadius?: number): boolean;
+    static getBounds(origin: IVector3, mapSize: number, radius: number): IBound3;
     /**
      * Gets the field of view radius based on either the field of view object, player, or the default value
      */
     static getRadius(fieldOfView: FieldOfView | undefined, human: Human | undefined): number;
     /**
-     * Marks a set of tiles as exploreed
+     * Marks a set of tiles as explored
      */
     static markAsExplored(player: Player, tiles: IVector2[]): boolean;
     constructor(context: RendererContext, worldRenderer: WorldRenderer, radius: number, maxRadius: number, subdivisions?: number);
@@ -73,6 +73,7 @@ export default class FieldOfView extends EventEmitter.Host<IFieldOfViewEvents> {
     startTransition(timeStamp: number): void;
     updateTransitionProgress(timeStamp: number): boolean;
     resetTransitionProgress(): void;
+    private processExploredMapTransition;
     compute(timeStamp: number, force?: boolean, skipTransition?: boolean): boolean;
     createDebugRenderer(): ITextureDebugRenderer;
     /**
@@ -85,5 +86,5 @@ export default class FieldOfView extends EventEmitter.Host<IFieldOfViewEvents> {
      * This prevents clientside only seed changes
      */
     private processExploredMapBounds;
-    private computeLights;
+    private computeLightMap;
 }

package/definitions/game/renderer/fieldOfView/IFieldOfView.d.ts

@@ -8,19 +8,29 @@
  * 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 Human from "game/entity/Human";
 import type Player from "game/entity/player/Player";
+import type Island from "game/island/Island";
+import type { IVector4 } from "utilities/math/Vector4";
 export interface IFieldOfViewEvents {
     getPlayerFieldOfViewRadius(radius: number, player: Player): number;
 }
+export interface IFieldOfViewOrigin extends Readonly<IVector4> {
+    readonly island: Island;
+    readonly asHuman?: Human;
+}
 export declare enum CanASeeBType {
     ClientSide = 0,
-    CreatureRandomSpawn = 1,
-    CreatureScarecrow = 2,
-    CreatureTrapping = 3,
-    CreatureIslandTravel = 4,
-    FieldOfView = 5,
-    GetNearestPlayer = 6,
-    GetPlayersThatSeePosition = 7,
-    SkeletalMage = 8,
-    ZombieHorde = 9
+    CreatureInSightAttacking = 1,
+    CreatureIslandTravel = 2,
+    CreatureRandomSpawn = 3,
+    CreatureScarecrow = 4,
+    CreatureTrapping = 5,
+    EntityHumansVisible = 6,
+    FieldOfView = 7,
+    GetNearestPlayer = 8,
+    GetPlayersThatSeePosition = 9,
+    Shipper = 10,
+    SkeletalMage = 11,
+    ZombieHorde = 12
 }

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

@@ -9,10 +9,9 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { SfxType } from "audio/IAudio";
-import type { IslandId } from "game/island/IIsland";
-import type { IVector2, IVector3 } from "utilities/math/IVector";
-export interface INotificationLocation extends IVector3 {
-    readonly islandId: IslandId;
+import type { IVector2 } from "utilities/math/IVector";
+import type { IVector4 } from "utilities/math/Vector4";
+export interface INotificationLocation extends IVector4 {
     getMovementPoint?(timeStamp: number): IVector2;
     queueSoundEffect?(soundEffect: SfxType): void;
 }
@@ -33,7 +32,8 @@ export declare enum ItemNotifierType {
     Removed = 2,
     Broken = 3,
     Offer = 4,
-    Damaged = 5
+    Damaged = 5,
+    Decaying = 6
 }
 export declare enum CreatureNotifierType {
     Neutral = 0,
@@ -44,7 +44,9 @@ export declare enum NotifierIconType {
     Tame = 0,
     Untame = 1,
     Water = 2,
-    Warning = 3
+    Warning = 3,
+    Decay = 4,
+    Talk = 5
 }
 export declare const itemDamageNotifierThreshold = 3;
 export declare const doodadDamageNotifierThreshold = 5;