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

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

@@ -8,34 +8,37 @@
  * 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 EventEmitter from "event/EventEmitter";
-import type { DoodadTag, DoorOrientation, IDoodadDescription, IDoodadOptions, IHasBuilder } from "game/doodad/IDoodad";
+import type { IEventEmitter } from "event/EventEmitter";
+import type { DisplayableDoodadType, DoodadTag, DoodadTypeExtra, DoorOrientation, IDoodadDescription, IDoodadOptions, IHasBuilder } from "game/doodad/IDoodad";
 import { DoodadType, DoodadTypeGroup, GrowingStage } from "game/doodad/IDoodad";
 import { ActionType } from "game/entity/action/IAction";
 import type Creature from "game/entity/creature/Creature";
+import Entity from "game/entity/Entity";
 import type Human from "game/entity/Human";
+import type { IEntityConstructorOptions, IEntityEvents } from "game/entity/IEntity";
+import { EntityType } from "game/entity/IEntity";
+import type { SkillType } from "game/entity/IHuman";
 import { EquipType } from "game/entity/IHuman";
 import type Player from "game/entity/player/Player";
-import { CreationId, TileUpdateType } from "game/IGame";
+import { TileUpdateType } from "game/IGame";
 import type { IObject } from "game/IObject";
 import { Quality } from "game/IObject";
-import type { IslandId, IWell } from "game/island/IIsland";
+import type { IWell } from "game/island/IIsland";
 import { LiquidType } from "game/island/IIsland";
-import type { IContainer, ILiquidGather } from "game/item/IItem";
+import type { DisplayableItemType, 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";
 import MagicalPropertyManager from "game/magic/MagicalPropertyManager";
-import type { IReferenceable } from "game/reference/IReferenceManager";
-import type { IHasInsulation, ITemperatureSource, TempType } from "game/temperature/ITemperature";
+import type { IHasInsulation, TempType } from "game/temperature/ITemperature";
 import { FireStage } from "game/tile/events/IFire";
-import type { ITile } from "game/tile/ITerrain";
-import type { ISerializedTranslation } from "language/ITranslation";
+import type Tile from "game/tile/Tile";
+import { Article } from "language/Translation";
 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 {
+export interface IDoodadEvents extends IEntityEvents {
     /**
      * Called when an doodad is being updated
      * @param tile The tile the doodad is on
@@ -53,7 +56,7 @@ export interface IDoodadEvents {
      * 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
      * emitted.
      */
-    fireUpdate(tile: ITile, stage: FireStage | undefined): any;
+    fireUpdate(tile: Tile, stage: FireStage | undefined): any;
     /**
      * Emitted when the doodad is created.
      */
@@ -69,52 +72,55 @@ export interface IDoodadEvents {
     durabilityChange(durability: number, oldDurability: number): any;
     durabilityMaxChange(durability: number, oldDurability: number): any;
 }
-export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements IReferenceable, IUnserializedCallback, IObject<DoodadType>, IDoodadOptions, IVector3, Partial<IContainer>, ITemperatureSource, IHasInsulation, IHasBuilder, IHasMagic {
+export default class Doodad extends Entity<IDoodadDescription, DoodadType, DoodadTag> implements IUnserializedCallback, IObject<DoodadType>, IDoodadOptions, Partial<IContainer>, IHasInsulation, IHasBuilder, IHasMagic {
     static is(value: any): value is Doodad;
     get constructorFunction(): typeof Doodad;
     static getRegistrarId(): number;
     static setRegistrarId(id: number): void;
     protected static registrarId: number;
-    readonly objectType = CreationId.Doodad;
-    containedItems: Item[];
+    get entityType(): EntityType.Doodad;
+    get tileUpdateType(): TileUpdateType;
+    readonly event: IEventEmitter<this, IDoodadEvents>;
+    maxDur: number;
+    minDur: number;
+    private fireStage?;
+    aberrant?: boolean;
+    bonusAttack?: number;
+    builderIdentifier?: string;
+    containedItems?: Item[];
+    crafterIdentifier?: string;
     decay?: number;
-    startingDecay?: number;
-    meltDecay?: number;
     disassembly?: Item[];
     gatherReady?: number;
-    stillContainer?: Item;
-    gfx?: number;
-    id: number;
-    referenceId?: number;
+    growth?: GrowingStage;
+    hitchedCreature?: number;
     itemOrders?: number[];
-    maxDur: number;
-    minDur: number;
+    magic?: MagicalPropertyManager;
+    meltDecay?: number;
     orientation?: DoorOrientation | Direction.Cardinal;
-    crafterIdentifier?: string;
-    builderIdentifier?: string;
     quality?: Quality;
-    renamed?: string | ISerializedTranslation;
     spread?: number;
-    type: DoodadType;
-    weight?: number;
-    readonly x: number;
-    readonly y: number;
-    readonly z: number;
-    step: number | undefined;
-    hitchedCreature?: number;
+    startingDecay?: number;
+    step?: number;
+    stillContainer?: Item;
     tradedFrom?: string[];
-    aberrant?: boolean;
-    private _tags?;
-    magic: MagicalPropertyManager;
-    private fireStage?;
-    get tags(): Set<DoodadTag>;
-    islandId: IslandId;
-    private _description;
-    private _tile;
-    private _tileId;
+    weight?: number;
+    private _tileId?;
+    /**
+     * Separate property just for wells because isInGroup is still expensive for processWell()
+     */
+    private _isWell?;
     private readonly _doodadGroupCache;
-    constructor(type?: DoodadType, islandId?: `${number},${number}`, x?: number, y?: number, z?: number, options?: IDoodadOptions);
-    get island(): import("../island/Island").default;
+    constructor(entityOptions?: IEntityConstructorOptions<DoodadType>, options?: IDoodadOptions);
+    get asCorpse(): undefined;
+    get asCreature(): undefined;
+    get asDoodad(): Doodad | undefined;
+    get asHuman(): undefined;
+    get asLocalPlayer(): undefined;
+    get asNPC(): undefined;
+    get asPlayer(): undefined;
+    get asTileEvent(): undefined;
+    get asItem(): undefined;
     toString(): string;
     getRegistrarId(): number;
     /**
@@ -126,18 +132,17 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
      * - `doodad.getName(false)` // "stone furnace"
      * - `doodad.getName(undefined, 3)` // "stone furnaces"
      */
-    getName(article?: false | "definite" | "indefinite", count?: number): import("../../language/impl/TranslationImpl").default;
-    description(): IDoodadDescription | undefined;
+    getName(article?: Article, count?: number): import("../../language/impl/TranslationImpl").default;
+    protected getDescription(): IDoodadDescription | undefined;
     updateTile(tileUpdateType: TileUpdateType): void;
     changeType(doodadType: DoodadType): void;
     isValid(): boolean;
     isInGroup(doodadTypeGroup: DoodadTypeGroup): boolean;
     updateGroupCache(doodadTypeGroup: DoodadTypeGroup): boolean;
-    getTile(ignoreCache?: boolean): ITile;
+    get point(): IVector3;
+    get tile(): Tile;
     getTileId(): number;
-    getPoint(): IVector3;
     canGrow(): boolean;
-    getGrowingStage(): GrowingStage | undefined;
     setGrowingStage(stage: GrowingStage): void;
     /**
      * Checks if the doodad will be rendered as tall (2 tiles)
@@ -146,7 +151,7 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
     isTall(): boolean;
     canPickUp(human: Human): boolean;
     getPickUpTypes(): ItemType[] | undefined;
-    getAssociatedItem(): ItemType;
+    getAssociatedItem(): ItemType | import("game/item/IItem").ItemTypeExtra;
     getActions(): ActionType[] | undefined;
     /**
      * Can the doodad be gathered from in its current form?
@@ -184,12 +189,16 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
     getBuilder(): Player | undefined;
     unhitch(): void;
     damage(forceBreak?: boolean, skipDropAsItem?: boolean, skipSound?: boolean, skipResources?: boolean): void;
-    getDefaultDurability(random?: import("../../utilities/random/Random").Random<import("../../utilities/random/Random").SeededGenerator>): number;
+    getDefaultDurability(random?: import("../../utilities/random/Random").Random<import("../../utilities/random/generators/LegacySeededGenerator").LegacySeededGenerator | import("../../utilities/random/generators/PCGSeededGenerator").PCGSeededGenerator>): number;
+    /**
+     * Gets the container to use for doodad executed actions
+     */
+    getTargetContainer(): IContainer | undefined;
     addTreasureChestLoot(): void;
     attachStillContainer(item: Item): void;
     detachStillContainer(human: Human): Item | undefined;
     blocksMove(): boolean;
-    update(ticks: number, playingHumans: Human[], updatesPerTick?: number): void;
+    update(ticks: number, playingHumans: Human[], playerHumanTiles: Set<Tile>, updatesPerTick?: number): void;
     canCauseStatus(): boolean;
     /**
      * Potentially animates a skeleton (if it can spawn) and returns a message to all those who can see it.
@@ -221,6 +230,7 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
     getLiquidGatherType(): keyof ILiquidGather | undefined;
     getProducedTemperature(): number | undefined;
     getInsulation(type: TempType): number | undefined;
+    isIslandPort(): boolean;
     /**
      * Refills solar stills when they are on shallow water automatically.
      */
@@ -247,6 +257,7 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
     set durability(value: number);
     get durabilityMax(): number;
     set durabilityMax(value: number);
+    canInspect(human: Human): boolean;
     private processSpecials;
     /**
      * Check for items on top of lit/fire doodads, set them on fire
@@ -273,10 +284,9 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
     /**
      * Gets the decay rate of a doodad based on the temperature (returns as a default of 0).
      * @param terrainType The doodad description to check.
-     * @param point The point of the tile the doodad is on.
      * @returns The number of melt reduction of the doodad given the temperature of the point.
      */
-    getMeltRate(description: IDoodadDescription, point: IVector3): number;
+    getMeltRate(description: IDoodadDescription): number;
     /**
      * Initialized the doodad's melting decay number
      */
@@ -285,6 +295,42 @@ export default class Doodad extends EventEmitter.Host<IDoodadEvents> implements
      * Gives civilization score based on how much is defined for this doodad.
      */
     changeCivilizationScore(add: boolean): void;
+    /**
+     * Updates a bookcase's graphics and civilization score (based on if books are added).
+     * @param item The item that is being added to the bookcase.
+     * @param add True if adding score, false if you are substracting.
+     */
+    updateBookcase(items: Item[], add: boolean): void;
+    /**
+     * Determines which graphic to show based on how full the bookcase is with books/text.
+     * @param item set to true if DisplayableItemType is to be returned.
+     * @returns DoodadTypeExtra or DisplayableItemType equal to which graphic it should show.
+     */
+    getBookcaseFullness(item?: boolean): DoodadTypeExtra | DisplayableItemType | undefined;
+    /**
+     * Gets if the doodad is set to display any extra graphics/assets.
+     * @returns DisplayableDoodadType or DoodadType (if no extra is set)
+     */
+    getDisplayDoodad(): DisplayableDoodadType;
+    /**
+     * Gets civilization score based on doodad's quality and type, but without the magical property values.
+     * @returns number of score (or 0 if no civilization score is set).
+     */
+    getCivilizationScore(excludeMagic?: boolean): number;
+    /**
+     * Gets a set of skill types and values from doodads that have "containedItemGroupProvidesSkill" set for items that provide adjacent skill bonuses.
+     * @returns Map of skill type and number (skill value).
+     */
+    getcontainedItemSkillBonuses(): Map<SkillType, number>;
+    /**
+     * Gets a set of skill types and values for magical adjacent skill bonuses from doodads.
+     * @returns Map of skill type and number (skill value).
+     */
+    getMagicalDoodadSkills(): Map<SkillType, number>;
+    /**
+     * Forces a boat to be drydocked (revert from doodad to an item if water was taken away for some reason).
+     */
+    dryDockBoat(human: Human): void;
     /**
      * Decay over time
      */

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

@@ -8,17 +8,17 @@
  * 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 { DoodadType } from "game/doodad/IDoodad";
+import type { DisplayableDoodadType } from "game/doodad/IDoodad";
 import type { TerrainType } from "game/tile/ITerrain";
 import type { TerrainDecoration } from "renderer/Decorations";
 import Vector2 from "utilities/math/Vector2";
 export default class DoodadInfo {
-    type: DoodadType | TerrainType | TerrainDecoration;
-    isTall: boolean;
-    isAnimated: boolean;
+    readonly type: DisplayableDoodadType | TerrainType | TerrainDecoration;
+    readonly isTall: boolean;
+    readonly isAnimated: boolean;
     topLeft: Vector2;
     topRight: Vector2;
     bottomLeft: Vector2;
     bottomRight: Vector2;
-    constructor(type: DoodadType | TerrainType | TerrainDecoration, isTall: boolean, xOffset: number, yOffset: number, isAnimated: boolean);
+    constructor(type: DisplayableDoodadType | TerrainType | TerrainDecoration, isTall: boolean, xOffset: number, yOffset: number, isAnimated: boolean);
 }

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

@@ -8,27 +8,27 @@
  * 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 { BiomeType } from "game/biome/IBiome";
 import Doodad from "game/doodad/Doodad";
 import type { IDoodadOptions } from "game/doodad/IDoodad";
-import { DoodadType, DoodadTypeGroup } from "game/doodad/IDoodad";
+import { DoodadType, DoodadTypeExtra, DoodadTypeGroup } from "game/doodad/IDoodad";
 import type Creature from "game/entity/creature/Creature";
 import type Human from "game/entity/Human";
-import { CreationId } from "game/IGame";
 import { ObjectManager } from "game/ObjectManager";
 import type { TerrainType } from "game/tile/ITerrain";
+import Tile from "game/tile/Tile";
+import type { WorldZ } from "game/WorldZ";
+import type { Article } from "language/Translation";
 import Translation from "language/Translation";
-import type Vector3 from "utilities/math/Vector3";
 export interface IDoodadManagerEvents {
     /**
      * Called when a doodad is about to be spawned
      * @param type The type of doodad
-     * @param x The x coordinate where the doodad will be spawned
-     * @param y The y coordinate where the doodad will be spawned
-     * @param z The z coordinate where the doodad will be spawned
+     * @param tile The tile where the doodad will be spawned
      * @param options The doodad spawn options
      * @returns False if the dooodad cannot spawn, or undefined to use the default logic
      */
-    canSpawn(type: DoodadType, x: number, y: number, z: number, options: IDoodadOptions): boolean | undefined;
+    canSpawn(type: DoodadType, tile: Tile, options: IDoodadOptions): boolean | undefined;
     /**
      * Called when a doodad is created.
      */
@@ -39,27 +39,39 @@ export interface IDoodadManagerEvents {
     remove(doodad: Doodad): any;
 }
 export default class DoodadManager extends ObjectManager<Doodad, IDoodadManagerEvents> {
-    protected readonly creationId: CreationId;
-    private static cachedBestDoodadForTier;
-    private static cachedGroups;
-    private static cachedDoodadSpawns;
+    private static readonly cachedBestDoodadForTier;
+    private static readonly cachedDoodadGroups;
+    static readonly cachedDoodadSpawns: Map<BiomeType, Map<WorldZ, Map<TerrainType, Set<DoodadType>>>>;
     private readonly scarecrows;
     static getBestDoodadForTier(doodad: DoodadType | DoodadTypeGroup): DoodadType | undefined;
     static generateLookups(): void;
     static clearCaches(): void;
     static isGroup(doodadType: DoodadType | DoodadTypeGroup): doodadType is DoodadTypeGroup;
     static isInGroup(doodadType: DoodadType, doodadGroup: DoodadTypeGroup | DoodadType): boolean;
-    static getGroupDoodads(doodadGroup: DoodadTypeGroup): Set<DoodadType>;
-    static getDoodadTypeGroupName(doodadType: DoodadType | DoodadTypeGroup, article?: false | "definite" | "indefinite", count?: number): Translation;
+    static getGroups(doodadType: DoodadType): DoodadTypeGroup[];
+    /**
+     * Checks if a number is a DoodadType or DoodadTypeExtra.
+     * @param type a number (DoodadType/DoodadTypeExtra enum).
+     * @returns true or false depending on if the number is a DoodadType or DoodadTypeExtra.
+     */
+    static isDoodadExtra(type: number): type is DoodadTypeExtra;
+    static getDoodadTypeGroupName(doodadType: DoodadType | DoodadTypeGroup, article?: Article, count?: number): Translation;
     /**
      * Note: This can be called multiple times in the same game depending on loading/unloading of islands
      */
     load(): void;
     isGroup(doodadType: DoodadType | DoodadTypeGroup): doodadType is DoodadTypeGroup;
     isInGroup(doodadType: DoodadType, doodadGroup: DoodadTypeGroup | DoodadType): boolean;
+    getGroups(doodad: DoodadType): DoodadTypeGroup[];
+    /**
+     * Checks if a number is a DoodadType or DoodadTypeExtra.
+     * @param type a number (DoodadType/DoodadTypeExtra enum).
+     * @returns true or false depending on if the number is a DoodadType or DoodadTypeExtra.
+     */
+    isDoodadExtra(type: number): type is DoodadTypeExtra;
     getBestDoodadForTier(doodad: DoodadType | DoodadTypeGroup): DoodadType | undefined;
-    createFake(type: DoodadType, options?: IDoodadOptions, x?: number, y?: number, z?: number): Doodad;
-    create(type: DoodadType, x: number, y: number, z: number, options?: IDoodadOptions, creator?: Human): Doodad | undefined;
+    createFake(type: DoodadType, options?: IDoodadOptions, tile?: Tile, id?: number): Doodad;
+    create(type: DoodadType, tile: Tile, options?: IDoodadOptions, creator?: Human): Doodad | undefined;
     /**
      * Removes a doodad from the world.
      * @param doodad The doodad to remove
@@ -72,22 +84,22 @@ export default class DoodadManager extends ObjectManager<Doodad, IDoodadManagerE
     /**
      * Runs a full gamut of updates on doodads including decaying items inside containers, spreading/growing plants/mushrooms, water distillation/desenation and more.
      */
-    updateAll(ticks: number, playingHumans: Human[], updatesPerTick?: number): void;
+    updateAll(ticks: number, playingHumans: Human[], playerHumanTiles: Set<Tile>, updatesPerTick?: number): void;
     /**
      * Runs a full gamut of updates on doodads including decaying items inside containers, spreading/growing plants/mushrooms, water distillation/desenation and more.
      */
-    updateAllAsync(ticks: number, playingHumans: Human[], updatesPerTick: number | undefined, onProgress: (progess: number) => Promise<void>): Promise<void>;
-    verifyAndFixItemWeights(allowFixesInMultiplayer?: boolean): void;
-    /**
-     * Used to spawn a random doodad on the current biome type and at a set location (and terrain type) based on spawnOnWorldGen properties in doodad descriptions.
-     * @param terrainType The terrain type to check.
-     * @param x The x coordinate to check.
-     * @param y The y coordinate to check.
-     * @param z The z coordinate to check.
-     */
-    spawn(terrainType: TerrainType, x: number, y: number, z: number): void;
-    getScarecrowInRange(position: Vector3, range: number): Doodad | undefined;
+    updateAllAsync(ticks: number, playingHumans: Human[], playerHumanTiles: Set<Tile>, updatesPerTick: number | undefined, onProgress: (progess: number) => Promise<void>): Promise<void>;
+    verifyAndFixItemWeights(): void;
+    getScarecrowInRange(tile: Tile, range: number): Doodad | undefined;
     getScarecrowInLineOfSight(creature: Creature, isClientside: boolean): Doodad | undefined;
     private addScarecrow;
     private removeScarecrow;
+    /**
+     * Handles doodad specific effects
+     */
+    private onSpawnOrRestore;
+    /**
+     * Handles doodad specific effects
+     */
+    private onRemove;
 }

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

@@ -11,5 +11,4 @@
 import type { IDoodadDescription, IDoodadGroupDescription } from "game/doodad/IDoodad";
 import { DoodadType, DoodadTypeGroup } from "game/doodad/IDoodad";
 export declare const doodadDescriptions: OptionalDescriptions<DoodadType, IDoodadDescription>;
-export default doodadDescriptions;
 export declare const doodadGroups: OptionalDescriptions<DoodadTypeGroup, IDoodadGroupDescription>;

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

@@ -18,13 +18,15 @@ import type { IDecayTemperatureRange } from "game/IGame";
 import type { ILootItem } from "game/ILoot";
 import type { IObjectDescription, IObjectOptions } from "game/IObject";
 import type Island from "game/island/Island";
-import type { IItemOld, ItemType } from "game/item/IItem";
+import type { IContainer, IItemOld, ItemType, ItemTypeExtra, ItemTypeGroup } from "game/item/IItem";
 import type Item from "game/item/Item";
 import type { LootGroupType } from "game/item/LootGroups";
 import type MagicalPropertyManager from "game/magic/MagicalPropertyManager";
 import type { IInsulationDescription, ITemperatureDescription } from "game/temperature/ITemperature";
-import type { ITile, TerrainType } from "game/tile/ITerrain";
+import type { TerrainType } from "game/tile/ITerrain";
 import type { TileEventType } from "game/tile/ITileEvent";
+import type Tile from "game/tile/Tile";
+import type Translation from "language/Translation";
 import type { IModdable } from "mod/ModRegistry";
 import type { ISpriteAnimation } from "renderer/ISpriteInfo";
 import type { TileLayerType } from "renderer/world/IWorldRenderer";
@@ -33,7 +35,7 @@ export interface IDoodadOptions extends IObjectOptions {
     force?: boolean;
     gatherReady?: number;
     stillContainer?: Item;
-    gfx?: number;
+    growth?: GrowingStage;
     spread?: number;
     weight?: number;
     disassembly?: Item[];
@@ -44,10 +46,12 @@ export interface IDoodadOptions extends IObjectOptions {
     aberrant?: boolean;
     meltDecay?: number;
     inheritMagic?: MagicalPropertyManager;
+    bonusAttack?: number;
 }
 type MagicalPropertyOld = Exclude<IItemOld["magicalProperties"], undefined> extends Array<infer T> ? T : never;
 export type IDoodadOld = Partial<Doodad> & {
     growInto?: DoodadType;
+    gfx?: number;
     legendary?: MagicalPropertyOld;
     magicalProperties?: MagicalPropertyOld[];
     ownerIdentifier?: string;
@@ -87,6 +91,7 @@ export interface IDoodadDescription extends IObjectDescription, IModdable, ICaus
     isDoor?: boolean;
     isFence?: boolean;
     isFlammable?: boolean;
+    containedItemsContributeToCivilizationScore?: boolean;
     usesSpores?: boolean;
     isGate?: boolean;
     adaptsToFence?: boolean;
@@ -97,6 +102,7 @@ export interface IDoodadDescription extends IObjectDescription, IModdable, ICaus
     isWaterSource?: boolean;
     isVehicle?: boolean;
     attackable?: true;
+    subTypes?: DoodadTypeExtra[];
     /**
      * When gathered completely, convert to a new DoodadType
      */
@@ -128,6 +134,7 @@ export interface IDoodadDescription extends IObjectDescription, IModdable, ICaus
     itemStackOffset?: number;
     itemStackRegion?: IItemStackRegion | ((doodad: Doodad) => IItemStackRegion | undefined);
     decayTemperatureRange?: IDecayTemperatureRange;
+    isIslandPort?: boolean;
     /**
      * Item that defines the decay amount when this doodad is melting.
      */
@@ -166,7 +173,28 @@ export interface IDoodadDescription extends IObjectDescription, IModdable, ICaus
          */
         columns: number;
     }>;
-    getVariation?(island: Island, tile: ITile, x: number, y: number, z: number, doodad: Doodad | undefined, existingVariationX: number, existingVariationY: number): [number, number] | undefined;
+    /**
+     * Called when the doodad is built via templates
+     * @param doodad Doodad
+     * @returns Name to set the doodad to or undefined to not name it.
+     */
+    getRandomNameOnTemplateSpawn?: (doodad: Doodad) => Translation | undefined;
+    /**
+     * The doodad type to display instead of the describe doodad type.
+     */
+    displayDoodad?: SupplierOr<DisplayableDoodadType | undefined, [Doodad]>;
+    /**
+     * Sets (and overwrites) the associated item that shows in the tooltip.
+     */
+    getAssociatedItem?(doodad: Doodad): ItemType | ItemTypeExtra | undefined;
+    getVariation?(island: Island, tile: Tile, doodad: Doodad | undefined, existingVariationX: number, existingVariationY: number): [number, number] | undefined;
+    onContainerItemAdd?(container: Doodad & IContainer, items: Item[]): void;
+    onContainerItemRemove?(container: Doodad & IContainer, items: Item[]): void;
+    /**
+     * Item groups of this type in the container will provide skill bonuses to adjacent players.
+     */
+    containedItemGroupProvidesSkill?: IProvidesSkill;
+    alwaysInspectable?: true;
 }
 export interface IItemStackRegion {
     xMin?: number;
@@ -196,6 +224,20 @@ export interface ILockedChest {
      */
     guardiansSpawned?: number;
 }
+export interface IProvidesSkill {
+    /**
+     * Skill type that is provided to the player.
+     */
+    skillType: SkillType;
+    /**
+     * Item group that triggers the skill bonus.
+     */
+    itemGroup: ItemTypeGroup;
+    /**
+     * How much each of that item provides.
+     */
+    skillValue: number;
+}
 export type IDoodadParticles = Record<number, IRGB>;
 export type IDoodadLoot = Record<number, ILootItem[] | undefined>;
 export declare enum DoodadType {
@@ -351,8 +393,25 @@ export declare enum DoodadType {
     WoodenTrackGateOpen = 149,
     Cattails = 150,
     WaterLilies = 151,
-    Spikerush = 152
+    Spikerush = 152,
+    WoodenBookcase = 153,
+    GraniteLighthouse = 154,
+    LitGraniteLighthouse = 155,
+    SandstoneLighthouse = 156,
+    LitSandstoneLighthouse = 157,
+    ClayLighthouse = 158,
+    LitClayLighthouse = 159,
+    BasaltLighthouse = 160,
+    LitBasaltLighthouse = 161
+}
+export declare enum DoodadTypeExtra {
+    None = 999,
+    WoodenBookcase_25 = 1000,
+    WoodenBookcase_50 = 1001,
+    WoodenBookcase_75 = 1002,
+    WoodenBookcase_100 = 1003
 }
+export type DisplayableDoodadType = DoodadType | DoodadTypeExtra;
 export declare enum DoodadTag {
     None = 0,
     ProppedOpen = 1
@@ -379,7 +438,9 @@ export declare enum DoodadTypeGroup {
     LitStructure = 413,
     LockedChest = 414,
     Scarecrow = 415,
-    Last = 416
+    Lighthouse = 416,
+    LitLighthouse = 417,
+    Last = 418
 }
 export declare enum DoorOrientation {
     Default = 0,

package/definitions/game/game/entity/CombatStrengthManager.d.ts

@@ -0,0 +1,68 @@
+/*!
+ * 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 Human from "game/entity/Human";
+import type Creature from "game/entity/creature/Creature";
+import { CreatureType } from "game/entity/creature/ICreature";
+export declare enum CombatStrength {
+    Tier0 = 0,
+    Tier1 = 1,
+    Tier2 = 2,
+    Tier3 = 3,
+    Tier4 = 4,
+    Tier5 = 5,
+    Tier6 = 6,
+    Tier7 = 7,
+    Tier8 = 8,
+    Tier9 = 9
+}
+export declare enum CombatDangerLevel {
+    Low = 0,
+    Medium = 1,
+    High = 2,
+    VeryHigh = 3,
+    Extreme = 4
+}
+export default class CombatStrengthManager {
+    readonly minimumCreatureValue: number;
+    readonly maximumCreatureValue: number;
+    constructor();
+    /**
+     * Given a combat strength decimal, from 0 to 1, returns a CombatStrength tier
+     */
+    getTier(strength: number): CombatStrength;
+    /**
+     * Given a combat strength decimal, from 0 to 1, returns a CombatDangerLevel
+     */
+    getDangerLevel(difficulty: number): CombatDangerLevel;
+    /**
+     * Calculates a float value between 0 and 1 representing a creature's difficulty.
+     */
+    getCreature(creature: Creature | CreatureType, aberrant?: boolean): number;
+    getCreatureDifficultyAgainstHuman(creature: Creature, human: Human): number;
+    private getEstimatedTurnsToKillHuman;
+    private getEstimatedTurnsToKillCreature;
+    /**
+     * Calculates a value representing a creature's combat strength.
+     *
+     * The following factors are included in the current calculation at time of writing:
+     * `+` The average of the current and maximum health of the creature.
+     * `+` The average attack value of the creature multiplied by 20.
+     * `+` The defense of the creature multiplied by 5.
+     * `+` The current health bonus from any taming or MP bonuses.
+     * `+` Any resist values multiplied by 5.
+     * `-` Any vulnerability values multiplied by 5.
+     * `*` A multiplier based on the status effects the creature can apply. Poison is the highest multiplier, then bleed, then burn.
+     * `*` The value is doubled if the creature is hostile.
+     * `/` The value is halved if the creature is scared.
+     * `*` The value is doubled if the creature is aberrant.
+     */
+    private calculateCreatureValue;
+}