@wayward/types 2.11.6-beta.dev.20220502.1 → 2.12.0-beta.dev.20220821.1

package/definitions/game/IGlobal.d.ts

@@ -22,6 +22,7 @@ import type ModManager from "mod/ModManager";
 import type { IMultiplayerNetworkingOptions } from "multiplayer/IMultiplayer";
 import type Multiplayer from "multiplayer/Multiplayer";
 import type Renderer from "renderer/Renderer";
+import type Renderers from "renderer/Renderers";
 import type SaveData from "save/data/SaveData";
 import type SaveDataGlobal from "save/data/SaveDataGlobal";
 import type SaveManager from "save/SaveManager";
@@ -54,8 +55,9 @@ declare global {
     let multiplayerNetworkingOptions: IMultiplayerNetworkingOptions;
     let oldui: OldUi;
     let playerManager: PlayerManager;
-    let players: Player[];
+    let players: Array<Player | undefined>;
     let renderer: Renderer | undefined;
+    let renderers: Renderers;
     let saveData: SaveData;
     let saveDataGlobal: SaveDataGlobal;
     let saveManager: SaveManager;
@@ -68,6 +70,7 @@ declare global {
     const gameVersionPatch: number;
     const gameVersionName: string;
     const isNodeJs: boolean;
+    const isWebWorker: boolean;
     const overlayWorks: boolean | undefined;
     let webGlVersion: number;
     const VIEWPORT_MIN_WIDTH: number;

package/definitions/game/Init.d.ts

@@ -9,12 +9,10 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import { Game } from "game/Game";
+import "game/entity/action/ActionsRegistration";
+import "game/item/Items";
 export interface IInit {
     game: Game;
     onUnload(message?: string): Promise<void>;
 }
 export default function (): Promise<IInit | undefined>;
-export declare function onBeforeUnloadAsynchronous(event?: {
-    preventDefault?: () => void;
-    returnValue?: boolean | string;
-}): Promise<void>;

package/definitions/game/Uninit.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * 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
+ */
+export declare function onBeforeUnloadAsynchronous(event?: {
+    preventDefault?: () => void;
+    returnValue?: boolean | string;
+}): Promise<void>;
+export declare function onBeforeUnloadSynchronous(event: Event): void;

package/definitions/game/audio/Audio.d.ts

@@ -40,6 +40,7 @@ export default class WAudio extends EventEmitter.Host<IAudioEvents> implements I
     private _audioContext;
     private _musicGainNode;
     private _effectsGainNode;
+    private _suspended;
     private _musicSpeed;
     private _soundDelay;
     private _musicHandler;
@@ -56,6 +57,8 @@ export default class WAudio extends EventEmitter.Host<IAudioEvents> implements I
      * Resets the music handler to its original state.
      */
     resetMusicHandler(): Promise<void>;
+    suspendSoundEffects(): void;
+    resumeSoundEffects(): void;
     /**
      * Sets the current track to the first in the current music handler.
      */

package/definitions/game/audio/IAudio.d.ts

@@ -24,36 +24,42 @@ export interface IAudio {
 }
 export default IAudio;
 export declare enum SfxType {
-    Bow = 0,
-    Chat = 1,
-    Click = 2,
-    Craft = 3,
-    CreatureHit = 4,
-    CreatureNoise = 5,
-    Damaged = 6,
-    Death = 7,
-    Eating = 8,
-    Exceptional = 9,
-    Extinguish = 10,
-    Fail = 11,
-    Hit = 12,
-    Hurt = 13,
-    Miss = 14,
-    PickUp = 15,
-    RockHit = 16,
-    SandstoneHit = 17,
-    Swim = 18,
-    Throw = 19,
-    Trample = 20,
-    TreeHit = 21,
-    UiActivate = 22,
-    UiDisable = 23,
-    UiEnable = 24,
-    UiInput = 25,
-    UiSelect = 26,
-    Walk = 27,
-    Water = 28
+    Boat = 0,
+    Bow = 1,
+    Chat = 2,
+    Click = 3,
+    Craft = 4,
+    CreatureHit = 5,
+    CreatureNoise = 6,
+    Damaged = 7,
+    Death = 8,
+    Eating = 9,
+    Exceptional = 10,
+    Extinguish = 11,
+    Fail = 12,
+    GraniteHit = 13,
+    Hit = 14,
+    Hurt = 15,
+    Minecart = 16,
+    Miss = 17,
+    PickUp = 18,
+    SandstoneHit = 19,
+    Swim = 20,
+    Throw = 21,
+    Trample = 22,
+    TreeHit = 23,
+    UiActivate = 24,
+    UiClose = 25,
+    UiDisable = 26,
+    UiEnable = 27,
+    UiInput = 28,
+    UiInvalid = 29,
+    UiOpen = 30,
+    UiSelect = 31,
+    Walk = 32,
+    Water = 33
 }
+export declare type SfxUi = Extract<keyof typeof SfxType, `Ui${string}`> extends `Ui${infer RESULT}` ? Lowercase<RESULT> : never;
 export declare enum Music {
     Shipwrecked = 0,
     OpeningTheme = 1,

package/definitions/game/event/EventEmitter.d.ts

@@ -57,7 +57,7 @@ export interface IEventEmitter<H = any, E = any> {
     until(promise: Promise<any>): IUntilSubscriber<H, E>;
     hasHandlersForEvent(...events: Array<keyof E>): boolean;
 }
-interface IUntilSubscriber<H, E> {
+export interface IUntilSubscriber<H, E> {
     subscribe<K extends ArrayOr<keyof E>>(event: K, handler: IterableOr<Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>>, priority?: number): H;
 }
 interface IEventEmitterEvents<H, E> {

package/definitions/game/game/Game.d.ts

@@ -10,14 +10,15 @@
  */
 /// <reference types="node" />
 import EventEmitter from "event/EventEmitter";
+import type { BiomeTypes } from "game/biome/IBiome";
 import type Entity from "game/entity/Entity";
+import type Human from "game/entity/Human";
 import type { Defense } from "game/entity/IEntity";
 import { DamageType } from "game/entity/IEntity";
-import { Delay } from "game/entity/IHuman";
+import type { Delay } from "game/entity/IHuman";
 import type { TurnType } from "game/entity/player/IPlayer";
-import type Player from "game/entity/player/Player";
-import type { IGameEvents, IPlayOptions, ISynchronizeState } from "game/IGame";
-import { SaveType, TickFlag, TurnMode, PauseSource } from "game/IGame";
+import type { IGameEvents, IMovementTime, IPlayOptions, ISynchronizeState } from "game/IGame";
+import { PauseSource, SaveType, TickFlag, TurnMode } from "game/IGame";
 import type Island from "game/island/Island";
 import IslandManager from "game/island/IslandManager";
 import type { MultiplayerLoadingDescription } from "game/meta/Loading";
@@ -37,6 +38,8 @@ import ReplayManager from "replay/ReplayManager";
 import type { IOptions } from "save/data/ISaveDataGlobal";
 import type StringTokenizer from "save/serializer/StringTokenizer";
 import ItemStylesheetHandler from "ui/screen/screens/game/util/item/ItemStylesheet";
+import type { IVector2 } from "utilities/math/IVector";
+import type { Random } from "utilities/random/Random";
 import type { IVersionInfo } from "utilities/Version";
 export declare class Game extends EventEmitter.Host<IGameEvents> {
     get isChallenge(): boolean;
@@ -85,6 +88,8 @@ export declare class Game extends EventEmitter.Host<IGameEvents> {
     protected stringTokenizer: StringTokenizer | undefined;
     toString(): string;
     get isPaused(): boolean;
+    getPlayingHumans(includeGhosts?: boolean, includeConnecting?: boolean, includeServer?: boolean): Human[];
+    getNonPlayerHumans(): Human[];
     initializeRenderer(): void;
     globalSlotReady(): void;
     /**
@@ -100,34 +105,37 @@ export declare class Game extends EventEmitter.Host<IGameEvents> {
     setGlContextSize(): void;
     resizeRenderer(): void;
     setPaused(pause: boolean, source: PauseSource): void;
+    onPlayingEntityChange(_manager: any, entity: Entity): void;
     gameLogicLoop: () => void;
     isSimulatedOrRealTimeMode(): boolean;
     getTurnMode(): TurnMode;
     setTurnMode(turnMode: TurnMode): void;
+    /**
+     * Changes the turn mode if it's not correct
+     */
+    ensureTurnMode(): void;
+    isTurnModeAllowed(turnMode: TurnMode): boolean;
     getTickSpeed(): number;
     setTickSpeed(tickSpeed: number): void;
-    updateReputation(reputation: number): void;
+    selectBiome(position: IVector2, random: Random): BiomeTypes;
     getGameMode(): GameMode;
     getGameOptionsBeforeModifiers(): IGameOptions;
     getGameOptions(): IGameOptions;
     updateGameOptions(gameOptions: IGameOptions): void;
     initializeGameOptions(seed: string | number, mode?: GameMode, options?: IGameOptions, milestoneModifiers?: Set<Milestone>): void;
     initializeModifiers(): void;
-    getMovementFinishTime(delay?: Delay | number): number;
-    getMovementProgress(timeStamp: number, finishTime: number | undefined, delay?: Delay | number): number;
-    getAnimationProgress(timeStamp: number, finishTime: number | undefined, delay: Delay | number): number;
+    getMovementTime(delay: Delay | number): IMovementTime;
+    getMovementProgress(timeStamp: number, movementTime: IMovementTime | undefined): number;
     getSynchronizeState(identifier: string): ISynchronizeState;
     synchronizeState(synchronizeState: ISynchronizeState): void;
     /**
-     * Marks that the player had a turn
-     * In manual turn mode, it will tick the players stat timers & the game
-     * @param player
-     * @param turnType
+     * Marks that the human had a turn
+     * In manual turn mode, it will tick the humans stat timers & the game
      */
-    passTurn(player: Player, turnType?: TurnType): void;
+    passTurn(human: Human, turnType?: TurnType): void;
     tickRealtime(): void;
     updateView(source: RenderSource, updateFov?: boolean, computeSpritesNow?: boolean): void;
-    updateTablesAndWeight(deferTableUpdates?: boolean): void;
+    updateTablesAndWeight(): void;
     /**
      * Gets the largest damage type weaknesses of a human or creature based on a type and damage value
      * @param defense Defense of the human or creature
@@ -136,19 +144,19 @@ export declare class Game extends EventEmitter.Host<IGameEvents> {
      * @returns returns DamageType array or undefined if there are no weaknesses
      */
     getGreatestWeaknesses(defense: Defense, damageTypes: DamageType, damage: number): DamageType[];
-    updateOption(player: Player | undefined, id: keyof IOptions, value: boolean | number): void;
+    updateOption(human: Human | undefined, id: keyof IOptions, value: boolean | number): void;
     /**
      * Do not call this directly. Use updateOption instead
      */
-    updateOptionInternal(id: keyof IOptions, value: boolean | number, player?: Player): void;
+    updateOptionInternal(id: keyof IOptions, value: boolean | number, human?: Human): void;
     /**
      * Collection of things to perform on each tick
      */
-    tick(ticks?: number, realPlayers?: Player[], tickFlag?: TickFlag): void;
+    tick(ticks?: number, playingHumans?: Human[], tickFlag?: TickFlag): void;
     /**
      * Collection of things to perform on each tick
      */
-    tickAsync(island: Island, ticks: number, realPlayers: Player[] | undefined, tickFlag: TickFlag | undefined, onProgress: (progess: number) => Promise<void>): Promise<void>;
+    tickAsync(island: Island, ticks: number, playingHumans: Human[] | undefined, tickFlag: TickFlag | undefined, onProgress: (progess: number) => Promise<void>): Promise<void>;
     createRenderer(entity: Entity): void;
     /**
      * Resets the game state. This should be called when returning to the main menu from a game and/or right before starting/joining a game.

package/definitions/game/game/IGame.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 { BiomeTypes } from "game/biome/IBiome";
 import type Doodad from "game/doodad/Doodad";
 import type Corpse from "game/entity/creature/corpse/Corpse";
 import type Creature from "game/entity/creature/Creature";
@@ -25,7 +26,7 @@ import type TimeManager from "game/time/TimeManager";
 import type { IMultiplayerOptions, IMultiplayerWorldData, ServerInfo } from "multiplayer/IMultiplayer";
 import type { IReplayLogEntry } from "replay/IReplayLogEntry";
 import type { IHighscoreOld, IOptions } from "save/data/ISaveDataGlobal";
-import type { IVector3 } from "utilities/math/IVector";
+import type { IVector2, IVector3 } from "utilities/math/IVector";
 import type { IRange } from "utilities/math/Range";
 export interface IGameEvents {
     /**
@@ -55,10 +56,28 @@ export interface IGameEvents {
      * Called when all game state was reset
      */
     reset(): any;
+    /**
+     * Called when getting the biome type distribution for random biome selection
+     */
+    getBiomeTypeChances(): Array<[number, BiomeTypes]> | undefined;
+    /**
+     * Called when selecting the biome type for and island
+     * @param positon Island position
+     * @param biomeType Biome type
+     */
+    getBiomeType(positon: IVector2, biomeType: BiomeTypes): BiomeTypes | undefined;
     pause(): any;
     resume(): any;
     tickStart(tickFlag: TickFlag, ticks: number): any;
     tickEnd(tickFlag: TickFlag, ticks: number): any;
+    /**
+     * Called when the playing entity count changes
+     */
+    playingEntityChange(): any;
+    /**
+     * Called when the turn mode is set
+     */
+    setTurnMode(turnMode: TurnMode): any;
     glLostContext(): any;
     glSetup(restored: boolean): any;
     glInitialized(): any;
@@ -77,7 +96,7 @@ export declare enum TickFlag {
     Creatures = 32,
     NPCs = 64,
     RandomEvents = 128,
-    PlayerStatuses = 256,
+    StatusEffects = 256,
     FlowFields = 512,
     PlayerNotes = 1024,
     Items = 2048,
@@ -203,7 +222,8 @@ export declare enum CreationId {
     Corpse = 2,
     NPC = 3,
     Item = 4,
-    TileEvent = 5
+    TileEvent = 5,
+    Player = 6
 }
 export declare enum PauseSource {
     /**
@@ -249,6 +269,10 @@ export interface ISynchronizeState {
     id: string;
     state: Map<IslandId, number[]>;
 }
+export interface IMovementTime {
+    start: number;
+    end: number;
+}
 export declare const DEFAULT_MAP_SIZE = 512;
 export declare const DEFAULT_MAP_SIZE_SQUARED: number;
 export declare const LINE_OF_SIGHT_RADIUS = 15;

package/definitions/game/game/ObjectManager.d.ts

@@ -9,12 +9,16 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import EventEmitter from "event/EventEmitter";
+import type { CreationId } from "game/IGame";
 import type Island from "game/island/Island";
 import type { IUnserializedCallback } from "save/serializer/ISerializer";
 import type { StringableObject } from "utilities/object/Objects";
 export declare abstract class ObjectManager<ObjectType extends StringableObject, EventsType> extends EventEmitter.Host<EventsType> implements IUnserializedCallback {
     protected readonly island: Island;
     protected readonly objects: SaferArray<ObjectType>;
+    private lastUsedId;
+    private sparseIds;
+    protected abstract readonly creationId: CreationId;
     constructor(island: Island, objects?: SaferArray<ObjectType>);
     /**
      * Called when this object manager is not used anymore (after it was saved!)
@@ -26,6 +30,7 @@ export declare abstract class ObjectManager<ObjectType extends StringableObject,
     get(id: number): ObjectType | undefined;
     set(id: number, value: ObjectType | undefined): void;
     getObjects(): SaferArray<ObjectType>;
+    findUnusedId<T extends object>(): number;
     protected replaceNullsWithUndefined(): void;
-    private registerForMemoryLeakDetection;
+    protected registerForMemoryLeakDetection(object: SaferArray<ObjectType>): void;
 }

package/definitions/game/game/biome/IBiome.d.ts

@@ -58,7 +58,8 @@ export declare enum BiomeType {
     Coastal = 1,
     IceCap = 2,
     Arid = 3,
-    Volcanic = 4
+    Volcanic = 4,
+    Wetlands = 5
 }
 /**
  * @see {@link IFogDescription.ambientColorFogBrightness }

package/definitions/game/game/biome/arid/mapGen/2.12.0.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * 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 { IBiomeMapGen } from "game/mapgen/IMapGen";
+export declare const aridMapGen2120: IBiomeMapGen;

package/definitions/game/game/biome/coastal/mapGen/2.12.0.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * 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 { IBiomeMapGen } from "game/mapgen/IMapGen";
+export declare const coastalMapGen2120: IBiomeMapGen;

package/definitions/game/game/biome/iceCap/mapGen/2.12.0.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * 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 { IBiomeMapGen } from "game/mapgen/IMapGen";
+export declare const iceCapMapGen2120: IBiomeMapGen;

package/definitions/game/game/biome/volcanic/mapGen/2.12.0.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * 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 { IBiomeMapGen } from "game/mapgen/IMapGen";
+export declare const volcanicMapGen2120: IBiomeMapGen;

package/definitions/game/game/biome/wetlands/Wetlands.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * 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 { BiomeMapGen } from "game/biome/IBiome";
+import type { IBiomeTemperature } from "game/temperature/ITemperature";
+import { TerrainType } from "game/tile/ITerrain";
+declare const _default: {
+    readonly defaultTerrainBackground: TerrainType.Mud;
+    readonly defaultCaveEntranceFlooring: TerrainType.Mud;
+    readonly fog: {
+        color: import("utilities/Color").IRGB;
+    };
+    mapGen: BiomeMapGen;
+    temperature: IBiomeTemperature;
+};
+export default _default;

package/definitions/game/game/biome/wetlands/mapGen/2.12.0.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * 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 { IBiomeMapGen } from "game/mapgen/IMapGen";
+export declare const wetlandsMapGen2120: IBiomeMapGen;

package/definitions/game/game/doodad/Doodad.d.ts

@@ -9,9 +9,9 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import EventEmitter from "event/EventEmitter";
-import type { DoorOrientation, IDoodadDescription, IDoodadOptions, IHasOwner } from "game/doodad/IDoodad";
+import type { DoorOrientation, IDoodadDescription, IDoodadOptions, IHasBuilder } from "game/doodad/IDoodad";
 import { DoodadType, DoodadTypeGroup, GrowingStage } from "game/doodad/IDoodad";
-import type { ActionType } from "game/entity/action/IAction";
+import { ActionType } from "game/entity/action/IAction";
 import type Creature from "game/entity/creature/Creature";
 import type Human from "game/entity/Human";
 import { EquipType } from "game/entity/IHuman";
@@ -19,9 +19,9 @@ import type Player from "game/entity/player/Player";
 import { CreationId, TileUpdateType } from "game/IGame";
 import type { IObject } from "game/IObject";
 import { Quality } from "game/IObject";
-import type { IslandId } from "game/island/IIsland";
+import type { IslandId, IWell } from "game/island/IIsland";
 import { LiquidType } from "game/island/IIsland";
-import type { IContainer } from "game/item/IItem";
+import type { IContainer, ILiquidGather } from "game/item/IItem";
 import { ItemType } from "game/item/IItem";
 import type Item from "game/item/Item";
 import type { IHasMagic } from "game/magic/MagicalPropertyManager";
@@ -33,6 +33,7 @@ import type { ITile } from "game/tile/ITerrain";
 import type { ISerializedTranslation } from "language/ITranslation";
 import type { IUnserializedCallback } from "save/serializer/ISerializer";
 import type { IRGB } from "utilities/Color";
+import type { Direction } from "utilities/math/Direction";
 import type { IVector3 } from "utilities/math/IVector";
 export interface IDoodadEvents {
     /**
@@ -46,7 +47,7 @@ export interface IDoodadEvents {
      * @param human The human object
      * @returns False if the doodad cannot be picked up, or undefined to use the default logic
      */
-    canPickup(human: Human): boolean | undefined;
+    canPickUp(human: Human): boolean | undefined;
     /**
      * Emitted when the fire stage of this doodad changes.
      * Note: The fire stage of doodads is not saved, so when the doodad's fire stage is first checked on load, this event will be
@@ -66,7 +67,7 @@ export interface IDoodadEvents {
      */
     transformed(newType: DoodadType, oldType: DoodadType): any;
 }
-export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements IReferenceable, IUnserializedCallback, IObject<DoodadType>, IDoodadOptions, IVector3, Partial<IContainer>, ITemperatureSource, IHasInsulation, IHasOwner, IHasMagic {
+export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements IReferenceable, IUnserializedCallback, IObject<DoodadType>, IDoodadOptions, IVector3, Partial<IContainer>, ITemperatureSource, IHasInsulation, IHasBuilder, IHasMagic {
     static is(value: any): value is Doodad;
     /**
      * @deprecated
@@ -90,8 +91,9 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
     itemOrders?: number[];
     maxDur: number;
     minDur: number;
-    orientation?: DoorOrientation;
-    ownerIdentifier?: string;
+    orientation?: DoorOrientation | Direction.Cardinal;
+    crafterIdentifier?: string;
+    builderIdentifier?: string;
     quality?: Quality;
     renamed?: string | ISerializedTranslation;
     spread?: number;
@@ -125,7 +127,7 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
      * - `doodad.getName(false)` // "stone furnace"
      * - `doodad.getName(undefined, 3)` // "stone furnaces"
      */
-    getName(article?: boolean, count?: number): import("../../language/impl/TranslationImpl").default;
+    getName(article?: false | "definite" | "indefinite", count?: number): import("../../language/impl/TranslationImpl").default;
     description(): IDoodadDescription | undefined;
     updateTile(tileUpdateType: TileUpdateType): void;
     changeType(doodadType: DoodadType): void;
@@ -143,8 +145,9 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
      * @returns True if the doodad is tall
      */
     isTall(): boolean;
-    canPickup(human: Human): boolean;
-    getPickupTypes(): ItemType[] | undefined;
+    canPickUp(human: Human): boolean;
+    getPickUpTypes(): ItemType[] | undefined;
+    getAssociatedItem(): ItemType;
     getActions(): ActionType[] | undefined;
     /**
      * Can the doodad be gathered from in its current form?
@@ -155,6 +158,7 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
      */
     isGatherable(): boolean;
     isEmbers(): boolean;
+    isVehicle(): boolean;
     canHarvest(): boolean;
     /**
      * Returns whether the doodad can be trampled
@@ -164,13 +168,17 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
     isDangerous(human: Human): boolean;
     getDamage(human: Human, equipType?: EquipType): number;
     /**
-     * Gets the owner of this doodad, or `undefined` if the doodad is ownerless.
+     * Gets the crafter of this doodad, or `undefined` if the doodad is crafterless.
      */
-    getOwner(): Player | undefined;
+    getCrafter(): Player | undefined;
     /**
-     * Gets the owner of this doodad. If this doodad has no owner, and this is not a multiplayer server, returns the local player.
+     * Gets the crafter of this doodad. If this doodad has no crafter, and this is not a multiplayer server, returns the local player.
      */
-    getOwnerOrLocalPlayer(): Player | undefined;
+    getCrafterOrLocalPlayer(): Player | undefined;
+    /**
+     * Gets the builder of this doodad, or `undefined` if the doodad is builderless.
+     */
+    getBuilder(): Player | undefined;
     unhitch(): void;
     damage(forceBreak?: boolean, skipDropAsItem?: boolean, skipSound?: boolean, skipResources?: boolean): void;
     getDefaultDurability(): number;
@@ -178,9 +186,13 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
     attachStillContainer(item: Item): void;
     detachStillContainer(human?: Human): Item | undefined;
     blocksMove(): boolean;
-    update(ticks: number, realPlayers: Player[], updatesPerTick?: number): void;
+    update(ticks: number, playingHumans: Human[], updatesPerTick?: number): void;
     canCauseStatus(): boolean;
-    setOffTrap(human?: Human, withMessage?: boolean): void;
+    /**
+     * Potentially animates a skeleton (if it can spawn) and returns a message to all those who can see it.
+     */
+    animateSkeletalRemains(): void;
+    setOffTrap(human?: Human, withMessage?: boolean, damage?: boolean): void;
     getGrowthParticles(): IRGB | undefined;
     /**
      * Increased the fertility (spread) of a plant/growing doodad.
@@ -195,11 +207,15 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
     /**
      * Keep our wells up-to-date with what is happening underground
      */
-    setWellStatus(): void;
+    setWellStatus(well?: IWell): IWell;
     /**
      * Switch unlimited/limited water status based on underground water changes
      */
     switchWellStatus(): void;
+    /**
+     * Returns the type of liquid that can be gathered from this doodad
+     */
+    getLiquidGatherType(): keyof ILiquidGather | undefined;
     getProducedTemperature(): number | undefined;
     getInsulation(type: TempType): number | undefined;
     /**
@@ -224,14 +240,6 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
      */
     revert(): boolean;
     onUnserialized(): void;
-    /**
-     * @deprecated
-     */
-    protected getNameTranslation(article?: boolean, count?: number): import("../../language/impl/TranslationImpl").default;
-    /**
-     * @deprecated
-     */
-    protected getDescriptionTranslation(): import("../../language/impl/TranslationImpl").default;
     private setupDurabilityHandlers;
     private processSpecials;
     /**