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

package/definitions/game/game/item/IItem.d.ts

@@ -11,15 +11,17 @@
 import type { SfxType } from "audio/IAudio";
 import type { BiomeType } from "game/biome/IBiome";
 import type { DoodadType, DoodadTypeGroup } from "game/doodad/IDoodad";
+import type { IActionApi } from "game/entity/action/IAction";
 import { ActionType } from "game/entity/action/IAction";
+import type Creature from "game/entity/creature/Creature";
 import type { CreatureType, TileGroup } from "game/entity/creature/ICreature";
 import type { DamageType, Defense, MoveType, StatusType } from "game/entity/IEntity";
 import type { Delay, EquipType, SkillType } from "game/entity/IHuman";
-import type { Stat } from "game/entity/IStats";
+import { Stat } from "game/entity/IStats";
 import type { IDecayTemperatureRange } from "game/IGame";
 import type { IObjectDescription, Quality } from "game/IObject";
 import type { IslandId } from "game/island/IIsland";
-import type { IAddToContainerOptions } from "game/item/IItemManager";
+import type { IMoveItemOptions } from "game/item/IItemManager";
 import type Item from "game/item/Item";
 import type Recipe from "game/item/recipe/Recipe";
 import type MagicalPropertyManager from "game/magic/MagicalPropertyManager";
@@ -28,7 +30,11 @@ import type { MagicalPropertyType } from "game/magic/MagicalPropertyType";
 import type { IInsulationDescription, ITemperatureDescription } from "game/temperature/ITemperature";
 import type { TerrainType } from "game/tile/ITerrain";
 import type { TileEventType } from "game/tile/ITileEvent";
+import type Tile from "game/tile/Tile";
 import type Message from "language/dictionary/Message";
+import type TranslationImpl from "language/impl/TranslationImpl";
+import type Translation from "language/Translation";
+import type { Article } from "language/Translation";
 import type { IModdable } from "mod/ModRegistry";
 import type { IRGB } from "utilities/Color";
 import type { IVector3 } from "utilities/math/IVector";
@@ -70,11 +76,16 @@ export interface IContainable {
     containerType?: ContainerType;
     [SYMBOL_CONTAINER_CACHED_REFERENCE]?: ContainerReference;
 }
-export interface IContainer extends IContainable {
-    containedItems: Item[];
+interface IBaseContainer extends IContainable {
     transientItems?: Item[];
     itemOrders?: number[];
 }
+export interface IContainer extends IBaseContainer {
+    containedItems: Item[];
+}
+export interface IMaybeContainer extends IBaseContainer {
+    containedItems?: Item[];
+}
 export interface IItemDisassembleResult {
     items: IItemDisassembly[];
     itemsBroken: number;
@@ -85,10 +96,15 @@ export interface IItemDisassembly {
     minDur: number;
     maxDur: number;
     weight: number;
-    magic: MagicalPropertyManager;
+    magic: MagicalPropertyManager | undefined;
     disassembly: Item[];
     tradedFrom: string[] | undefined;
 }
+export declare enum ItemDamageResult {
+    NoDamage = 0,
+    Damaged = 1,
+    DamagedAndRemoved = 2
+}
 export interface IItemDescription extends IObjectDescription, IModdable, ITemperatureDescription {
     durability?: number;
     /**
@@ -127,6 +143,11 @@ export interface IItemDescription extends IObjectDescription, IModdable, ITemper
     use?: ActionType[];
     ranged?: IRanged;
     recipe?: IRecipe;
+    /**
+     * A list of groups the item should belong too.
+     * Do not use this during runtime - use itemManager.getGroups instead!
+     */
+    group?: ItemTypeGroup[];
     /**
      * A list of recipes that have this item as an output.
      *
@@ -148,6 +169,7 @@ export interface IItemDescription extends IObjectDescription, IModdable, ITemper
     dismantle?: IDismantleDescription;
     doodadContainer?: DoodadType;
     repairable?: boolean;
+    subTypes?: ItemTypeExtra[];
     /**
      * Set to false if you do not want the item to be reinforcable. Items with a durability property will be reinforcable by default.
      */
@@ -178,6 +200,8 @@ export interface IItemDescription extends IObjectDescription, IModdable, ITemper
     plural?: string;
     hideHelmet?: boolean;
     worth?: number;
+    lightSource?: boolean;
+    lightColor?: IRGB;
     /**
      * Array of items that the item is "made from" in cases where we can't use the disassembly items to burn into.
      * All items in array are required to have onBurn set in their description to function properly.
@@ -253,20 +277,49 @@ export interface IItemDescription extends IObjectDescription, IModdable, ITemper
      */
     reducedStoredItemsWeight?: number;
     /**
-     * The item type to display instead of the describe item type
+     * The amount of civilization score to give when placing item in a bookcase.
+     */
+    civilizationContainerScore?: number;
+    /**
+     * The item name to display instead of the item's default translation
+     */
+    getName?: (item: Item, article?: Article, count?: number, showCount?: boolean, showQuality?: boolean, showRenamedQuotes?: boolean, showMagicalType?: boolean) => TranslationImpl | {
+        translation: TranslationImpl;
+        noReference?: boolean;
+    } | undefined;
+    /**
+     * Extra arguments to pass to the item's name translation
+     */
+    getNameArgs?: (item: Item) => Translation[] | undefined;
+    /**
+     * The item type to display instead of the described item type
      */
     displayItem?: SupplierOr<DisplayableItemType | undefined, [Item]>;
     onEquip?(item: Item): void;
     onUnequip?(item: Item): void;
+    onContainerItemAdd?(container: Item & IContainer, items: Item[]): void;
+    onContainerItemRemove?(container: Item & IContainer, items: Item[]): void;
+    onCreate?(item: Item): void;
+    onChangeInto?(item: Item, fromItemType: ItemType): void;
+}
+export interface IConsumeItemStat {
+    stat: Stat;
+    amount: number;
+}
+export type ConsumeItemStatsTuple = [health: number, stamina: number, hunger: number, thirst: number, otherStats?: IConsumeItemStat[]];
+export type ConsumeItemStats = ConsumeItemStatsTuple | IConsumeItemStat[];
+export declare namespace ConsumeItemStats {
+    const DEFAULT_STATS: Stat[];
+    function resolve(stats?: number | ConsumeItemStats): Map<Stat, number>;
 }
-export type ConsumeItemStatsTuple = [health: number, stamina: number, hunger: number, thirst: number];
 export interface IItemOnUse {
-    [ActionType.Apply]?: ConsumeItemStatsTuple;
+    [ActionType.Apply]?: ConsumeItemStats;
     [ActionType.Build]?: IItemBuild;
-    [ActionType.Cure]?: ConsumeItemStatsTuple;
-    [ActionType.DrinkItem]?: ConsumeItemStatsTuple;
-    [ActionType.Eat]?: ConsumeItemStatsTuple;
-    [ActionType.Heal]?: ConsumeItemStatsTuple;
+    [ActionType.CageCreature]?: ItemType;
+    [ActionType.Cure]?: ConsumeItemStats;
+    [ActionType.DrinkItem]?: ConsumeItemStats;
+    [ActionType.Eat]?: ConsumeItemStats;
+    [ActionType.Heal]?: ConsumeItemStats;
     [ActionType.HealOther]?: number;
     [ActionType.PlaceDown]?: IItemBuild;
     [ActionType.Plant]?: DoodadType;
@@ -275,6 +328,8 @@ export interface IItemOnUse {
     [ActionType.SetDown]?: TerrainType;
     [ActionType.SmotherFire]?: TerrainType;
     [ActionType.StokeFire]?: number;
+    [ActionType.Summon]?: ISummon;
+    [ActionType.Uncage]?: ItemType;
 }
 export interface IItemBuild {
     /**
@@ -290,6 +345,16 @@ export interface IItemBuild {
      */
     allowedTileTypes?: Set<TerrainType>;
 }
+export interface ISummon {
+    /**
+     * Creature type to summon.
+     */
+    type: CreatureType;
+    /**
+     * Set to true if it should summon an aberrant version of the creature.
+     */
+    aberrant?: boolean;
+}
 /**
  * Describes a vehicle
  */
@@ -396,12 +461,12 @@ export interface IItemReturn {
     whenCrafted?: boolean;
 }
 export interface IMoveToTileOptions {
-    fromPoint?: IVector3;
-    fromPointApplyPlayerOffset?: boolean;
-    toPoint: IVector3;
-    toPointApplyPlayerOffset?: boolean;
+    fromTile?: Tile;
+    fromTileApplyPlayerOffset?: boolean;
+    toTile: Tile;
+    toTileApplyPlayerOffset?: boolean;
     toContainer?: IContainer;
-    toContainerOptions?: IAddToContainerOptions;
+    toContainerOptions?: IMoveItemOptions;
     beforeMovement?: IMoveToTileBeforeMovementOptions;
     extinguishTorches?: boolean;
     /**
@@ -416,6 +481,7 @@ export interface IMoveToTileAfterMovementOptions {
     soundEffect?: SfxType;
     particles?: IRGB;
     updateTileLayer?: boolean;
+    renderCreature?: Creature;
 }
 export interface IRecipe {
     baseComponent?: ItemType | ItemTypeGroup;
@@ -440,12 +506,23 @@ export interface ICreateOnBreak {
     tileEventType?: TileEventType;
 }
 export type IDismantleComponent = Record<number, number>;
+export interface IItemChangeIntoOptions {
+    disableNotify: boolean;
+    disableEmitTransformation: boolean;
+    addCreature: {
+        creature: Creature;
+        remainTamed: boolean;
+    };
+}
 export interface IRanged {
     range: number;
     attack: number;
-    ammunitionType?: ItemTypeGroup;
+    ammunitionType?: ItemType | ItemTypeGroup | ((action: IActionApi) => ItemType | ItemTypeGroup | undefined);
     requiredToFire?: ItemType;
     skillType?: SkillType;
+    unlimitedAmmunition?: boolean;
+    attackMessage?: Message;
+    particles?: IRGB | ((action: IActionApi) => IRGB | undefined);
 }
 export interface IMagicalPropertyInfo {
     /**
@@ -464,6 +541,10 @@ export interface IMagicalPropertyInfo {
      * Generates the random sub-property to use for this magical property, if this magical property is a magical property with subtypes.
      */
     subType?: MagicalSubPropertySubTypes | (() => MagicalSubPropertySubTypes);
+    /**
+     * Set to true if the value can be expanded beyond its normal maximum (in the case of relic items).
+     */
+    expandable?: boolean;
 }
 export interface IItemUsed {
     usedBy?: string[];
@@ -493,8 +574,11 @@ export interface IDismantleItemDescription {
     transferDecay?: boolean;
 }
 export interface IItemGroupDescription {
-    types: Array<ItemType | ItemTypeGroup>;
     default: ItemType | ItemTypeGroup;
+    /**
+     * An array of additional Item types / group's that should be added to this one during lookup generation.
+     */
+    types?: Array<ItemType | ItemTypeGroup>;
     /**
      * Whether this group is hidden to the player. Defaults to `false`
      */
@@ -603,7 +687,9 @@ export declare enum BookType {
     TheSlimeRancher = 15,
     DarknessCalls = 16,
     RemnantsOfCivilization = 17,
-    AndTheVoidAnswersBack = 18
+    AndTheVoidAnswersBack = 18,
+    ThePowerOfTheWrittenWord = 19,
+    TheAbnormals = 20
 }
 export declare enum ItemType {
     None = 0,
@@ -1327,16 +1413,63 @@ export declare enum ItemType {
     WaterLilies = 718,
     Mud = 719,
     SpikerushSheaths = 720,
-    SpikerushSeeds = 721
+    SpikerushSeeds = 721,
+    WoodenBookcase = 722,
+    GraniteLighthouse = 723,
+    SandstoneLighthouse = 724,
+    ClayLighthouse = 725,
+    BasaltLighthouse = 726,
+    WoodenCage = 727,
+    FullWoodenCage = 728,
+    TinCage = 729,
+    FullTinCage = 730,
+    CopperCage = 731,
+    FullCopperCage = 732,
+    WroughtIronCage = 733,
+    FullWroughtIronCage = 734,
+    IronCage = 735,
+    FullIronCage = 736,
+    BronzeCage = 737,
+    FullBronzeCage = 738,
+    Amber = 739,
+    Tourmaline = 740,
+    Topaz = 741,
+    Opal = 742,
+    Sapphire = 743,
+    WoodGolemFigure = 744,
+    ClayGolemFigure = 745,
+    GraniteGolemFigure = 746,
+    SandstoneGolemFigure = 747,
+    BasaltGolemFigure = 748,
+    AberrantWoodGolemFigure = 749,
+    AberrantClayGolemFigure = 750,
+    AberrantGraniteGolemFigure = 751,
+    AberrantSandstoneGolemFigure = 752,
+    AberrantBasaltGolemFigure = 753
 }
 export declare enum ItemTypeExtra {
     None = 999,
     TatteredMap_RolledUp = 1000,
-    TatteredMap_Completed = 1001
+    TatteredMap_Completed = 1001,
+    WoodenBookcase_25 = 1002,
+    WoodenBookcase_50 = 1003,
+    WoodenBookcase_75 = 1004,
+    WoodenBookcase_100 = 1005
 }
 export type DisplayableItemType = ItemType | ItemTypeExtra;
 export declare enum ItemTag {
-    None = 0
+    None = 0,
+    ShipperBoat = 1
+}
+export declare enum ItemCounter {
+    None = 0,
+    Repair = 1,
+    Reinforce = 2,
+    Refine = 3,
+    Enhance = 4,
+    En = 5,
+    Upgrade = 6,
+    Transmogrify = 7
 }
 export declare enum ItemTypeGroup {
     Invalid = 800,
@@ -1456,7 +1589,24 @@ export declare enum ItemTypeGroup {
     DualWield = 914,
     TwoHanded = 915,
     Boat = 916,
-    All = 917,
-    Last = 918
+    Text = 917,
+    ContainerWithLiquid = 918,
+    CraftingMaterial = 919,
+    MagicalComponent = 920,
+    Scarecrow = 921,
+    Well = 922,
+    Mapping = 923,
+    Terrain = 924,
+    Lighthouse = 925,
+    SeedBearer = 926,
+    Mushroom = 927,
+    Lockpick = 928,
+    WaterPurification = 929,
+    CreatureContainment = 930,
+    Gem = 931,
+    Golem = 932,
+    CreatureResource = 933,
+    All = 934,
+    Last = 935
 }
 export {};

package/definitions/game/game/item/IItemManager.d.ts

@@ -15,9 +15,9 @@ import type Creature from "game/entity/creature/Creature";
 import type { Quality } from "game/IObject";
 import type { IMoveToTileOptions, ItemType, ItemTypeGroup } from "game/item/IItem";
 import type Item from "game/item/Item";
+import type Tile from "game/tile/Tile";
 import type TileEvent from "game/tile/TileEvent";
 import type { Direction } from "utilities/math/Direction";
-import type { IVector3 } from "utilities/math/IVector";
 /**
  * Includes all protected items by default
  */
@@ -81,7 +81,7 @@ export interface IRequirementInfo {
     missingDoodads?: Set<DoodadType | DoodadTypeGroup>;
     fireSourceDoodad?: Doodad;
     fireSourceTileEvent?: TileEvent;
-    fireSourceLavaPosition?: IVector3;
+    fireSourceLavaTile?: Tile;
     faceDirection?: Direction.Cardinal;
     actionNotUsable?: IActionNotUsable;
 }
@@ -89,14 +89,22 @@ export interface IDoodadsUsed {
     doodad: Doodad;
     group: DoodadType | DoodadTypeGroup;
 }
-export interface IAddToContainerOptions {
-    movingMultiple?: boolean;
+export interface IMoveItemOptions {
+    onMoveItem?: (item: Item) => void;
+    filter?: {
+        itemType?: ItemType;
+        itemQuality?: Quality;
+        filterText?: string;
+    };
     skipMessage?: boolean;
-    skipUpdateTables?: boolean;
+    skipSound?: boolean;
     skipTileUpdate?: boolean;
+    skipUpdateTables?: boolean;
+    skipWeightChecks?: boolean;
+    suspendNotifier?: boolean;
+    moveToTileOptions?: IMoveToTileOptions;
 }
 export interface IPlaceOnTileOptions {
-    movingMultiple?: boolean;
     force?: boolean;
     skipMessage?: boolean;
     skipTileUpdate?: boolean;
@@ -104,7 +112,7 @@ export interface IPlaceOnTileOptions {
 }
 export declare enum ContainerReferenceSource {
     ContainerWeightReduction = 0,
-    GetContainerId = 1,
+    GetDialogIndex = 1,
     GetPoint = 2,
     GetWeightCapacity = 3,
     HashContainer = 4,
@@ -116,7 +124,8 @@ export declare enum ContainerReferenceSource {
     ScheduleContainerInvalidation = 10,
     Serializer = 11,
     WriteContainer = 12,
-    GetContainerName = 13
+    GetContainerName = 13,
+    Upgrade = 14
 }
 export interface ICraftResultChances {
     success: number;
@@ -125,3 +134,7 @@ export interface ICraftResultChances {
 export declare namespace ICraftResultChances {
     const NEVER: Readonly<ICraftResultChances>;
 }
+export interface IAddToContainerResult {
+    itemsMoved: Item[];
+    noMoreRoomForItems: Item[];
+}

package/definitions/game/game/item/Item.d.ts

@@ -8,36 +8,39 @@
  * 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 { IEventEmitter } from "event/EventEmitter";
 import type Doodad from "game/doodad/Doodad";
 import { ActionType } from "game/entity/action/IAction";
 import type Creature from "game/entity/creature/Creature";
 import type { CreatureType } from "game/entity/creature/ICreature";
 import type Entity from "game/entity/Entity";
+import type { IEntityMovableEvents } from "game/entity/EntityMovable";
+import EntityMovable from "game/entity/EntityMovable";
 import type Human from "game/entity/Human";
 import { AttackType, DamageType, EntityType } from "game/entity/IEntity";
 import type { EquipType } from "game/entity/IHuman";
 import { SkillType } from "game/entity/IHuman";
 import type Player from "game/entity/player/Player";
-import { CreationId } from "game/IGame";
+import { TileUpdateType } from "game/IGame";
 import type { IObject, IObjectOptions } from "game/IObject";
 import { Quality } from "game/IObject";
 import type { IslandId } from "game/island/IIsland";
-import type { ContainerReference, DisplayableItemType, IConstructedInfo, IContainable, IContainer, IItemDescription, IItemDisassembleResult, IItemUsed, IMagicalPropertyInfo, IMoveToTileOptions, ItemTag } from "game/item/IItem";
-import { BookType, ItemType, ItemTypeGroup, ItemWeightChange, SYMBOL_CONTAINER_CACHED_REFERENCE } from "game/item/IItem";
+import type { ContainerReference, DisplayableItemType, IConstructedInfo, IContainable, IContainer, IItemChangeIntoOptions, IItemDescription, IItemDisassembleResult, IItemUsed, IMagicalPropertyInfo, IMoveToTileOptions, ItemCounter, ItemTag, ItemTypeExtra } from "game/item/IItem";
+import { BookType, ItemDamageResult, ItemType, ItemTypeGroup, ItemWeightChange, SYMBOL_CONTAINER_CACHED_REFERENCE } from "game/item/IItem";
 import type { IPlaceOnTileOptions } from "game/item/IItemManager";
 import ItemMapManager from "game/item/ItemMapManager";
 import type { IHasMagic, MagicalSubPropertySubTypes } from "game/magic/MagicalPropertyManager";
 import MagicalPropertyManager from "game/magic/MagicalPropertyManager";
 import { MagicalPropertyType } from "game/magic/MagicalPropertyType";
-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 TranslationImpl from "language/impl/TranslationImpl";
+import { Article } from "language/Translation";
 import type { IUnserializedCallback } from "save/serializer/ISerializer";
 import type { Direction } from "utilities/math/Direction";
-export interface IItemEvents {
+import type { IVector3 } from "utilities/math/IVector";
+export interface IItemEvents extends IEntityMovableEvents {
     toggleProtected(isProtected: boolean): any;
     fireUpdate(stage?: FireStage): any;
     damage(): any;
@@ -68,15 +71,20 @@ export interface IItemEvents {
     durabilityChange(durability: number, oldDurability: number): any;
     durabilityMaxChange(durabilityMax: number, oldDurabilityMax: number): any;
 }
-export default class Item extends EventEmitter.Host<IItemEvents> implements IReferenceable, Partial<IContainer>, IContainable, IUnserializedCallback, IObject<ItemType>, IObjectOptions, IContainable, Partial<IContainer>, ITemperatureSource, IHasInsulation, IHasMagic {
-    readonly objectType = CreationId.Item;
+export default class Item extends EntityMovable<IItemDescription, ItemType, ItemTag, ItemCounter> implements Partial<IContainer>, IContainable, IUnserializedCallback, IObject<ItemType>, IObjectOptions, IContainable, Partial<IContainer>, IHasInsulation, IHasMagic {
+    get entityType(): EntityType.Item;
+    get tileUpdateType(): TileUpdateType;
+    readonly event: IEventEmitter<this, IItemEvents>;
     private maxDur;
     private minDur;
+    weight: number;
+    bonusAttack?: number;
+    bonusDefense?: number;
     book?: BookType;
     constructedFrom?: IConstructedInfo;
-    containedItems: Item[] | undefined;
-    containedWithin: IContainer | undefined;
-    containsCreature: Creature;
+    containedItems?: Item[];
+    containedWithin?: IContainer;
+    containsCreature?: Creature;
     crafterIdentifier?: string;
     decay?: number;
     disassembly?: Item[];
@@ -85,36 +93,34 @@ export default class Item extends EventEmitter.Host<IItemEvents> implements IRef
     equippedId?: number;
     equippedType?: EntityType;
     fireStage?: FireStage;
-    id: number;
     itemOrders?: number[];
-    pid: number | null | undefined;
+    magic?: MagicalPropertyManager;
+    map?: ItemMapManager;
+    pid?: number | null;
     protected?: boolean;
-    quality: Quality | undefined;
-    referenceId?: number;
-    renamed: string | ISerializedTranslation | undefined;
+    quality?: Quality;
     startingDecay?: number;
     tradedFrom?: string[];
-    type: ItemType;
     used?: IItemUsed;
     vehicleFacingDirection?: Direction.Cardinal;
-    weight: number;
+    weightCapacity?: number;
     weightFraction?: number;
-    private _tags?;
-    magic: MagicalPropertyManager;
-    map: ItemMapManager;
-    get tags(): Set<ItemTag>;
-    islandId: IslandId;
     offsetX?: number;
     offsetY?: number;
-    fromX?: number;
-    fromY?: number;
     [SYMBOL_CONTAINER_CACHED_REFERENCE]?: ContainerReference;
-    private _movementTime?;
     private _movementOptions?;
-    private _description;
     constructor(itemType?: ItemType | undefined, islandId?: IslandId, quality?: Quality, human?: Human);
-    get island(): import("../island/Island").default;
+    get asCorpse(): undefined;
+    get asCreature(): undefined;
+    get asDoodad(): undefined;
+    get asHuman(): undefined;
+    get asLocalPlayer(): undefined;
+    get asNPC(): undefined;
+    get asPlayer(): undefined;
+    get asTileEvent(): undefined;
+    get asItem(): Item | undefined;
     toString(): string;
+    protected updateTile(fromTile: Tile, toTile: Tile): boolean;
     get durability(): number;
     set durability(value: number);
     get durabilityMax(): number;
@@ -156,8 +162,8 @@ export default class Item extends EventEmitter.Host<IItemEvents> implements IRef
      * - `item.getName(false)` // "stone axe"
      * - `item.getName(undefined, 3)` // "stone axes"
      */
-    getName(article?: false | "definite" | "indefinite", count?: number, showCount?: boolean, showQuality?: boolean, showRenamedQuotes?: boolean, showMagicalType?: boolean): import("../../language/impl/TranslationImpl").default;
-    description(): IItemDescription | undefined;
+    getName(article?: Article, count?: number, showCount?: boolean, showQuality?: boolean, showRenamedQuotes?: boolean, showMagicalType?: boolean): TranslationImpl;
+    protected getDescription(): IItemDescription | undefined;
     isTransient(): boolean;
     isValid(): boolean;
     isProtected(): boolean;
@@ -197,12 +203,12 @@ export default class Item extends EventEmitter.Host<IItemEvents> implements IRef
      * @param modifier The amount of damage to take. Defaults to 1.
      * @param min The minimum durability that this item should have remaining. Defaults to n/a
      */
-    damage(source: string, modifier?: number, min?: number): void;
+    damage(source: string, modifier?: number, min?: number): ItemDamageResult;
     isInTradeContainer(): boolean;
     getEquippedHuman(): Human | undefined;
     isEquipped(includeDisabled?: true): boolean;
     getEquipSlot(includeDisabled?: true): EquipType | undefined;
-    changeInto(type: ItemType, disableNotify?: boolean, emitTransformation?: boolean): void;
+    changeInto(type: ItemType, options?: Partial<IItemChangeIntoOptions>): void;
     /**
      * Verifies an item has a proper weight combined with its magical item weight (featherweight) property and changes it if not.
      * @returns A type of change via ItemWeightChange for showing a new magical property was added or a new magical weight was added. If no change happened, it will return undefined.
@@ -215,20 +221,25 @@ export default class Item extends EventEmitter.Host<IItemEvents> implements IRef
      */
     returns(disableNotify?: boolean, craft?: boolean): boolean;
     setUsed(itemUse?: IItemUsed, human?: Human): void;
-    createOnBreak(x: number, y: number, z: number): void;
-    spawnOnDecay(): Creature | undefined;
-    spawnCreatureOnItem(creatureType: CreatureType | undefined, forceAberrant?: boolean, bypass?: boolean, preferFacingDirection?: Human): Creature | undefined;
-    getPoint(): import("../../utilities/math/Vector3").default | undefined;
-    dropInWater(human: Human, x?: number, y?: number, skipParticles?: boolean): void;
-    placeOnTile(x: number, y: number, z: number, options?: IPlaceOnTileOptions): boolean;
+    createOnBreak(tile: Tile): void;
+    spawnOnDecay(tile: Tile): Creature | undefined;
+    spawnCreatureOnItem(tile: Tile, creatureType: CreatureType | undefined, forceAberrant?: boolean, bypass?: boolean, preferFacingTile?: Human, maxTilesChecked?: number): Creature | undefined;
+    get point(): IVector3 | undefined;
+    get tile(): Tile | undefined;
+    dropInWater(human: Human, tile?: Tile, skipParticles?: boolean): void;
+    placeOnTile(tile: Tile, options?: IPlaceOnTileOptions): boolean;
+    /**
+     * Unsupported
+     */
+    moveTo(): boolean;
     /**
      * Moves an item to a target point / container while animating it
      * @param options Movement options
      * @returns True if the movement is happening, false if it wasn't able to move
      */
     moveToTile(options: IMoveToTileOptions): boolean;
-    isMoving(): IMoveToTileOptions | undefined;
-    getMovementProgress(timeStamp: number): number;
+    getMovementOptions(): IMoveToTileOptions | undefined;
+    protected onMovementCompleted(): void;
     setQuality(human: Human | undefined, quality?: Quality): void;
     getValidMagicalProperties(): MagicalPropertyType[];
     addMagicalProperties(count: number, source?: string): boolean;
@@ -285,6 +296,7 @@ export default class Item extends EventEmitter.Host<IItemEvents> implements IRef
      * Gets the inherit item type.
      */
     getInheritItemRecipeSkill(): SkillType;
+    getDamageType(): DamageType;
     /**
      * Returns the damage types associated with a skill with a fallback for whatever damage types the item normally provides
      * @param skillType The skill to get default damage types from
@@ -328,7 +340,46 @@ export default class Item extends EventEmitter.Host<IItemEvents> implements IRef
      */
     getCivilizationScore(actionType: ActionType.Build | ActionType.SetDown): number;
     getVehicle(): import("game/item/IItem").IItemVehicle | undefined;
-    isVehicleAllowedOnTile(tile: ITile): boolean;
+    isVehicleAllowedOnTile(tile: Tile): boolean;
+    addCreature(creature: Creature, remainTamed?: boolean): void;
+    /**
+     * Tries restoring the creature on the target tile and fans out to nearby tiles if it's occupied
+     */
+    tryRestoreCreature(tile: Tile, preventRendering?: boolean): Creature | undefined;
+    restoreCreature(tile: Tile, preventRendering?: boolean): Creature | undefined;
+    /**
+     * Update the item's display (in the case that its extras are used).
+     */
+    updateItemDisplay(): void;
+    /**
+     * Determines which graphic to show based on how full the bookcase is with books/text.
+     * @returns DisplayableItemType equal to which graphic it should show.
+     */
+    getBookcaseFullness(): ItemTypeExtra | undefined;
+    /**
+     * Gives bonus attack and defense to items with have quality.
+     * Example: Superior quality can get a bonus of 1-2; relics can get 5-10.
+     * @returns true if bonusDefense/Attack was set.
+     */
+    setAttackDefenseBonus(): boolean;
+    /**
+     * Gets the attack damage with its bonus value.
+     * Note: This does not get the value with any magical properties applied.
+     * @returns number The attack value with bonus applied.
+     */
+    getAttackWithBonus(): number;
+    /**
+     * Gets the ranged attack damage with its bonus value.
+     * Note: This does not get the value with any magical properties applied.
+     * @returns number The ranged attack value with bonus applied.
+     */
+    getRangedAttackWithBonus(): number;
+    /**
+     * Gets the base defense with its bonus value.
+     * Note: This does not get the value with any magical properties applied.
+     * @returns number The base defense value.
+     */
+    getBaseDefenseWithBonus(): number;
     private checkIfItemsMatch;
     private checkIfItemArraysMatch;
 }

package/definitions/game/game/item/ItemDescriptions.d.ts

@@ -8,8 +8,8 @@
  * 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 { IItemDescription, IItemGroupDescription, IRecipeComponent, ItemTypeGroup } from "game/item/IItem";
-import type { ItemType } from "game/item/IItem";
+import type { IItemDescription, IItemGroupDescription, IRecipeComponent } from "game/item/IItem";
+import type { ItemType, ItemTypeGroup } from "game/item/IItem";
 export declare const itemDescriptions: Descriptions<ItemType, IItemDescription>;
 export declare const itemGroupDescriptions: Descriptions<ItemTypeGroup, IItemGroupDescription>;
 export declare function RecipeComponent(type: ItemType | ItemTypeGroup, requiredAmount: number, consumedAmount: number, disassembleAmount?: number, ignoreWeight?: boolean, tileEventByProduct?: boolean): IRecipeComponent;