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

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

@@ -12,25 +12,27 @@ import type { IEventEmitter } from "event/EventEmitter";
 import Doodad from "game/doodad/Doodad";
 import type Creature from "game/entity/creature/Creature";
 import type { IDamageInfo } from "game/entity/creature/ICreature";
-import Entity from "game/entity/Entity";
-import type { IAttack, ICausesDamage } from "game/entity/IEntity";
-import { AttackType, IStatChangeInfo, StatusEffectChangeReason, StatusType } from "game/entity/IEntity";
-import type { ICanSailAwayResult, ICheckUnderOptions, ICrafted, ICustomizations, IHumanEvents, IRestData, IVoyageInfo } from "game/entity/IHuman";
+import { CreatureType } from "game/entity/creature/ICreature";
+import EntityWithStats from "game/entity/EntityWithStats";
+import type { IAttack, ICausesDamage, IEntityConstructorOptions } from "game/entity/IEntity";
+import { AttackType, DamageType, IStatChangeInfo, StatusEffectChangeReason, StatusType } from "game/entity/IEntity";
+import type { ICheckUnderOptions, ICrafted, ICustomizations, IHumanEvents, ILoadOnIslandOptions, IRestData, IVoyageInfo } from "game/entity/IHuman";
 import { EquipType, RestCancelReason, SkillType } from "game/entity/IHuman";
 import type { IStat } from "game/entity/IStats";
 import { Stat } from "game/entity/IStats";
 import type { IMessageManager } from "game/entity/player/IMessageManager";
-import type { ILoadOnIslandOptions, IMobCheck, IMovementIntent, IWalkPath } from "game/entity/player/IPlayer";
+import type { IMovementIntent, IWalkPath } from "game/entity/player/IPlayer";
 import { PlayerState, TurnTypeFlag, WeightStatus } from "game/entity/player/IPlayer";
 import type { INoteManager } from "game/entity/player/note/NoteManager";
 import PlayerDefense from "game/entity/player/PlayerDefense";
 import type { IQuestManager } from "game/entity/player/quest/QuestManager";
+import type { ISkillAttribute } from "game/entity/skill/ISkills";
 import SkillManager from "game/entity/skill/SkillManager";
 import type { StatChangeTimerFactory } from "game/entity/StatFactory";
 import { StatChangeCurrentTimerStrategy } from "game/entity/StatFactory";
 import { FireType } from "game/IGame";
 import type { Quality } from "game/IObject";
-import type { IMoveToIslandOptions, IslandId } from "game/island/IIsland";
+import type { IMobCheck, IMoveToIslandOptions, IslandId } from "game/island/IIsland";
 import type Island from "game/island/Island";
 import type { EquipEffectByType, EquipEffects, IContainer, IRanged, RecipeLevel } from "game/item/IItem";
 import { EquipEffect, ItemType, ItemTypeGroup } from "game/item/IItem";
@@ -39,73 +41,92 @@ import ItemReference from "game/item/ItemReference";
 import { MagicalPropertyType } from "game/magic/MagicalPropertyType";
 import { Milestone } from "game/milestones/IMilestone";
 import type { IGameOptionsPlayer } from "game/options/IGameOptions";
+import type { Reference } from "game/reference/IReferenceManager";
 import type { IHasInsulation } from "game/temperature/ITemperature";
 import { TempType } from "game/temperature/ITemperature";
+import type Tile from "game/tile/Tile";
+import type { ICanSailAwayResult } from "game/tile/Tile";
 import type TileEvent from "game/tile/TileEvent";
 import Message from "language/dictionary/Message";
+import type { ISerializedTranslation } from "language/ITranslation";
 import Translation from "language/Translation";
 import type FieldOfView from "renderer/fieldOfView/FieldOfView";
 import { CanASeeBType } from "renderer/fieldOfView/IFieldOfView";
 import type { IOptions } from "save/data/ISaveDataGlobal";
-import type { IContainerSortInfo, IDialogInfo } from "ui/old/IOldUi";
 import { Direction } from "utilities/math/Direction";
 import type { IVector2, IVector3 } from "utilities/math/IVector";
+import Vector2 from "utilities/math/Vector2";
 import type { IVector4 } from "utilities/math/Vector4";
 export declare const REPUTATION_MAX = 64000;
-export default abstract class Human extends Entity implements IHasInsulation {
+export default abstract class Human<TypeType extends number = number> extends EntityWithStats<unknown, TypeType> implements IHasInsulation {
     static getNameTranslation(): import("../../language/impl/TranslationImpl").default;
     event: IEventEmitter<this, IHumanEvents>;
+    anim: number;
+    direction: Vector2;
+    facingDirection: Direction.Cardinal;
+    /**
+     * Not guaranteed to be synced between the server and client for Human entities
+     */
+    fromX: number;
+    /**
+     * Not guaranteed to be synced between the server and client for Human entities
+     */
+    fromY: number;
     crafted: Record<number, ICrafted>;
     customization: ICustomizations;
-    deathBy: import("language/ITranslation").ISerializedTranslation;
+    deathBy: ISerializedTranslation;
     defense: PlayerDefense;
     defenses: number[];
-    equippedReferences: Map<EquipType, ItemReference>;
     equippedOffHandDisabled?: ItemReference;
+    equippedReferences: Map<EquipType, ItemReference>;
+    flyingDelay?: number;
     handEquippedToLast: EquipType.OffHand | EquipType.MainHand;
     inventory: IContainer;
     isConnecting: boolean;
+    lastAttackedByReference?: Reference;
+    manualTickActionDelay?: number;
     options: Readonly<IOptions>;
     islandId: IslandId;
     readonly equipEffects: Map<EquipEffect, EquipEffects>;
-    manualTickActionDelay: number | undefined;
     realTimeTickActionDelay: number;
     respawnPoint: IVector4 | undefined;
     restData: IRestData | undefined;
     score: number;
     state: PlayerState;
     swimming: boolean;
-    tamedCreatures: Map<`${number},${number}`, number[]>;
+    tamedCreatures: Map<`${number},${number}`, Set<number>>;
     ticksSpent: Map<`${number},${number}`, number>;
     turns: number;
     vehicleItemReference: ItemReference | undefined;
     walkSoundCounter: number;
-    containerSortInfo: Record<string, IContainerSortInfo | undefined>;
-    dialogContainerInfo: Record<number, IDialogInfo | undefined>;
     readonly movementIntent: IMovementIntent;
-    walkPath: IWalkPath | undefined;
+    walkPath?: IWalkPath;
     identifier: string;
-    lastAttackedBy: Human | Creature | undefined;
     skill: SkillManager;
     quests: IQuestManager;
     messages: IMessageManager;
     notes: INoteManager;
     private readonly privateStore;
     nextMoveTime: number;
-    nextMoveDirection: Direction.Cardinal | Direction.None | undefined;
-    private lastVehicleMoveDirection;
+    nextMoveDirection?: Direction.Cardinal | Direction.None;
+    private lastVehicleMoveDirection?;
+    /**
+     * Only tracked serverside for dangerous bouncing
+     */
+    private preventedBadMovement?;
     /**
      * Flag that will prevent a humans vehicle from showing up until the movement finishews
      */
     isMovingSuppressVehicleClientside: boolean;
-    protected readonly milestonesCollection: import("../options/modifiers/GameplayModifiersManager").GameplayModifiersCollection<import("../options/modifiers/milestone/MilestoneModifier").default, Milestone, import("../options/modifiers/milestone/MilestoneModifier").MilestoneModifierInstance, [(Human | undefined)?]>;
+    protected readonly milestonesCollection: import("../options/modifiers/GameplayModifiersManager").GameplayModifiersCollection<import("../options/modifiers/milestone/MilestoneModifier").default, Milestone, import("../options/modifiers/milestone/MilestoneModifier").MilestoneModifierInstance<any>, [(Human<number> | undefined)?]>;
     protected gameOptionsCached?: IGameOptionsPlayer;
     protected cachedMovementPenalty?: number;
-    constructor();
+    constructor(entityOptions?: IEntityConstructorOptions<TypeType>);
+    protected getDescription(): void;
     abstract createNoteManager(): INoteManager;
     abstract createMessageManager(): IMessageManager;
     abstract createQuestManager(): IQuestManager;
-    abstract addMilestone(milestone: Milestone, data?: number, update?: boolean): void;
+    abstract addMilestone(milestone: Milestone, data?: number | string, update?: boolean): void;
     createSkillManager(): SkillManager;
     isLocalPlayer(): boolean;
     getGameOptionsBeforeModifiers(): IGameOptionsPlayer;
@@ -128,6 +149,7 @@ export default abstract class Human extends Entity implements IHasInsulation {
      */
     isServer(): boolean;
     isHost(): boolean;
+    updateDirection(tile: Tile, updateVehicleDirection?: boolean): void;
     protected onMovementCompleted(): void;
     moveTowardsIsland(direction: Direction.Cardinal | Direction.None, options?: Partial<IMoveToIslandOptions>): Promise<void>;
     moveToIslandPosition(position: IVector2, options?: Partial<IMoveToIslandOptions>): Promise<void>;
@@ -135,25 +157,39 @@ export default abstract class Human extends Entity implements IHasInsulation {
      * Moves this player to another island
      */
     moveToIslandId(islandId: IslandId, options?: Partial<IMoveToIslandOptions>): Promise<void>;
+    /**
+     * Starts the travel animation for the player
+     * @param direction Direction they are traveling
+     * @returns A method that you should invoke to end the animation
+     */
+    private startTravelAnimation;
     /**
      * Loads the player onto an island
      * Called when the game is initially loading and moving a player to another island
      */
-    loadOnIsland(island: Island, options?: Partial<ILoadOnIslandOptions>): void;
-    protected abstract moveToIsland(island: Island, targetPosition: IVector3): void;
+    loadOnIsland(island: Island, options?: Partial<ILoadOnIslandOptions>, voyageInfo?: IVoyageInfo): void;
+    protected abstract moveToIsland(targetTile: Tile): void;
     /**
      * Loads ui. Should only be called if this player is local
      */
     loadUi(): void;
     startResting(restData: IRestData): void;
     cancelResting(reason: RestCancelReason): boolean;
+    findPathToPort(portId: number, options?: Partial<{
+        startReversed: boolean;
+        requireBoat: boolean;
+    }>): Tile[] | undefined;
+    addTamedCreature(creature: Creature): void;
+    removeTamedCreature(creature: Creature): boolean;
     resetMovementIntent(): void;
-    createItemInInventory(itemType: ItemType | ItemTypeGroup | Array<ItemType | ItemTypeGroup>, quality?: Quality, updateTables?: boolean, movingMultiple?: boolean): Item;
+    createItemInInventory(itemType: ItemType | ItemTypeGroup | Array<ItemType | ItemTypeGroup>, quality?: Quality, updateTables?: boolean): Item;
     damageRandomEquipment(): void;
     getDamageModifier(): number;
     calculateDamageAmount(attackType: AttackType, weapon?: Item, ammoItem?: Item): number;
     isDualWielding(): boolean;
     getAttack(attack?: AttackType, weapon?: Item): IAttack;
+    getSimplifiedCumulativeAttack(): number;
+    getCombatStrength(): number;
     private getAttackType;
     private getAttackSkillBonus;
     private getAttackSkill;
@@ -172,7 +208,6 @@ export default abstract class Human extends Entity implements IHasInsulation {
      */
     getMaxHealth(withBonus?: boolean): number;
     getCraftingDifficulty(level: RecipeLevel): number;
-    update(): void;
     updateStatsAndAttributes(): void;
     getMovementDelay(): number;
     /**
@@ -187,7 +222,7 @@ export default abstract class Human extends Entity implements IHasInsulation {
     processInput(timeStamp: number): IMovementIntent | undefined;
     staminaReduction(skill?: SkillType, level?: number): void;
     updateReputation(reputation: number): void;
-    protected checkReputationMilestones(): void;
+    protected checkOnLoadMilestones(): void;
     capReputation(): void;
     setVehicle(item: Item | undefined, extinguishTorches?: boolean): boolean;
     getWeightStatus(): WeightStatus;
@@ -206,7 +241,7 @@ export default abstract class Human extends Entity implements IHasInsulation {
      * Burn the player
      */
     burn(fireType: FireType, skipMessage?: boolean, skipParry?: boolean, equipType?: EquipType, fromCombat?: boolean, level?: number): number | undefined;
-    setPosition(point: IVector3): void;
+    setPosition(tile: Tile): void;
     /**
      * @param effects If true, adds a delay to the player, clears any particles, and updates the view. (Default: true)
      */
@@ -218,10 +253,14 @@ export default abstract class Human extends Entity implements IHasInsulation {
     checkUnder(inFacingDirection?: boolean, options?: ICheckUnderOptions): ICheckUnderOptions;
     damageByInteractingWith(thing: Doodad | TileEvent, options: ICheckUnderOptions | undefined, damageLocation: EquipType): ICheckUnderOptions;
     equip(item: Item, slot: EquipType, internal?: boolean): boolean;
+    /**
+     * Unequips an item.
+     * Note: This is safe to call even if the item isn't equipped. it'll do nothing in that case.
+     */
     unequip(item: Item, internal?: boolean, skipMessage?: boolean, skipRevertItem?: boolean): void;
     private updateOffHandState;
     unequipAll(): void;
-    canJump(): boolean;
+    getJumpTile(): Tile | undefined;
     hasDelay(): boolean;
     addDelay(delay: number, replace?: boolean, addStaminaDelay?: boolean): void;
     /**
@@ -232,7 +271,6 @@ export default abstract class Human extends Entity implements IHasInsulation {
     getConsumeBonus(item: Item | undefined, skillUse?: SkillType): number;
     getSkillBonus(skillUse?: SkillType): number;
     getQualityBonus(item: Item | undefined): number;
-    hasTamedCreature(creature: Creature): boolean;
     setTamedCreatureEnemy(enemy: Human | Creature): void;
     checkForGatherFire(): Translation | undefined;
     /**
@@ -279,9 +317,8 @@ export default abstract class Human extends Entity implements IHasInsulation {
     updateVehicle(): void;
     getWeightOrStaminaMovementPenalty(): number;
     canSailAway(): ICanSailAwayResult;
-    canSailAwayFromPosition(island: Island, position?: IVector3): ICanSailAwayResult;
     canSailTo(x: number, y: number): boolean;
-    canCombatTides(): true | "Swimming" | "Stamina";
+    canCombatTides(): true | Message.ActionSailToIslandCannotUseNotEnoughSwimmingSkill | Message.ActionSailToIslandCannotUseNotEnoughStamina;
     protected calculateVoyageInfo(destination?: Island, distanceFromEdge?: number): IVoyageInfo;
     /**
      * Applies traveling effects to the player
@@ -306,15 +343,15 @@ export default abstract class Human extends Entity implements IHasInsulation {
     getInsulation(type: TempType): number;
     resetStatTimers(type?: StatChangeCurrentTimerStrategy): void;
     private getBaseStatBonuses;
-    protected getApplicableStatusEffects(): Set<StatusType>;
+    protected getApplicableStatusEffects(): Set<StatusType> | undefined;
     private getSkillGainMultiplier;
     private canSkillGain;
-    protected onSkillGain(skill: SkillType, mod: number): void;
+    protected onSkillGain(skill: SkillType, fromValue: number, toValue: number, mod: number): void;
     setStatChangeTimerIgnoreDifficultyOptions(stat: Stat | IStat, timer: number, amt?: number): void;
     /**
      * Improve one of the core player stats
      */
-    protected statGain(stat: Stat, bypass: boolean): void;
+    protected statGain(stat: Stat | ISkillAttribute, bypass: boolean): void;
     protected calculateStats(): void;
     kill(): void;
     protected resetDefense(skipStatChangedEvent?: boolean): void;
@@ -354,16 +391,22 @@ export default abstract class Human extends Entity implements IHasInsulation {
      * Used internally for `Stat.Weight.max`
      */
     getMaxWeight(): number;
-    /**
-     * Get the strength of the player without any bonuses applied (ie custom game mode or debug tools).
-     */
-    getOriginalMaxWeight(): number;
     /**
      * Gets this human's current carried weight, scaled down to what it would be without any weight bonuses applied
      */
     getScaledWeight(): number;
+    hasDiscoveredVulnOrResist(creatureType: CreatureType, damageType: DamageType): boolean;
+    discoverVulnOrResist(creatureType: CreatureType, damageType: DamageType): void;
+    getDiscoveredVulnsAndResists(): Map<CreatureType, Set<DamageType>>;
+    getDiscoveredVulnsAndResists(creatureType: CreatureType): Set<DamageType>;
+    get asCorpse(): undefined;
     get asCreature(): undefined;
+    get asDoodad(): undefined;
     get asHuman(): Human;
+    get asTileEvent(): undefined;
+    get asItem(): undefined;
+    get point(): IVector3;
+    get tile(): Tile;
     /**
      * Moves inventory items to the target island
      * This should be called before switching islands

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

@@ -10,23 +10,15 @@
  */
 import type Doodad from "game/doodad/Doodad";
 import type Entity from "game/entity/Entity";
-import type { SkillType } from "game/entity/IHuman";
-import type { IStatEvents } from "game/entity/IStats";
+import type { Delay, SkillType } from "game/entity/IHuman";
 import type Item from "game/item/Item";
-import type { ITile } from "game/tile/ITerrain";
-export interface IEntityEvents extends IStatEvents {
+import type Tile from "game/tile/Tile";
+import type { IRGB } from "utilities/Color";
+export interface IEntityEvents {
     /**
      * Called when an entity is killed by another entity.
      */
     kill?(attacker: Entity | Doodad): void;
-    /**
-     * Called when this entity gets or loses a status effect
-     * @param entity The object this event is emitted from
-     * @param status The type of status effect that was gained or lost
-     * @param level Whether the entity now has the status effect
-     * @param reason The reason for the change
-     */
-    statusChange(status: StatusType, level: number, reason: StatusEffectChangeReason): void;
     /**
      * Called when the entity is created in the game
      * Also called for players that "rejoin" the game
@@ -40,13 +32,11 @@ export interface IEntityEvents extends IStatEvents {
      * Called when the entity is removed from the game
      */
     removed(): void;
-    /**
-     * Called before moving.
-     * Can be called twice for humans
-     * @param isMoving True the second time it's called, right as the entity is about to actually move
-     */
-    preMove(fromX: number, fromY: number, fromZ: number, fromTile: ITile, toX: number, toY: number, toZ: number, toTile: ITile, isMoving: boolean): boolean | undefined | void;
-    postMove(fromX: number, fromY: number, fromZ: number, fromTile: ITile, toX: number, toY: number, toZ: number, toTile: ITile): void;
+}
+export interface IEntityConstructorOptions<TypeType extends number> {
+    id: number;
+    type: TypeType;
+    tile: Tile;
 }
 export declare enum StatusEffectChangeReason {
     Gained = 0,
@@ -103,28 +93,87 @@ export interface ICausesDamage {
     damage?: number;
 }
 export declare enum Property {
-    Credit = 0,
-    Talked = 1
 }
 export type IProperties = Map<Property, any>;
 export declare enum EntityType {
     Player = 0,
     Creature = 1,
     NPC = 2,
-    Human = 3
+    Human = 3,
+    Doodad = 4,
+    TileEvent = 5,
+    Corpse = 6,
+    Item = 7
 }
 export declare enum AiType {
+    /**
+     * Doesn't attack
+     */
     Neutral = 0,
+    /**
+     * Attacks player
+     */
     Hostile = 1,
+    /**
+     * Move like neutral - become fleeing within 10 tiles of a player
+     */
     Scared = 2,
+    /**
+     * Moves in random direction
+     */
     Random = 4,
+    /**
+     * Doesn't move, can't be seen
+     */
     Hidden = 8,
+    /**
+     * Never scared
+     */
     Fearless = 16,
+    /**
+     * Monster is tamed
+     */
     Tamed = 32,
-    Follower = 64,
-    Defender = 128,
+    /**
+     * Follows the player at a close distance
+     */
+    FollowClose = 64,
+    /**
+     * Retaliates the player when attacked
+     */
+    Retaliate = 128,
+    /**
+     * Run away from the player
+     */
     Fleeing = 256,
-    Waiting = 512
+    /**
+     * Do nothing until there are no players next to the entity
+     */
+    Waiting = 512,
+    /**
+     * Follows the player at a far distance
+     */
+    FollowFar = 1024,
+    /**
+     * Never move
+     */
+    Stay = 2048,
+    /**
+     * Attacks adjacent enemies (creatures when tamed)
+     */
+    AttackAdjacent = 4096,
+    /**
+     * Attacks enemies in sight(creatures when tamed)
+     */
+    AttackInSight = 8192,
+    /**
+     * Stays in place and attacks things that pass by it
+     */
+    Defend = 6144,
+    /**
+     * Follows the owner and attacks enemies it sees
+     */
+    Attack = 8256
 }
 export declare enum MoveType {
     None = 0,
@@ -135,9 +184,10 @@ export declare enum MoveType {
     Mountain = 16,
     Fire = 32,
     BreakDoodads = 64,
-    WetLand = 128,
-    Void = 256,
-    LandBlind = 512,
+    BreakItems = 128,
+    WetLand = 256,
+    Void = 512,
+    LandBlind = 1024,
     Flying = 15
 }
 export declare enum AttackType {
@@ -170,12 +220,16 @@ export declare enum DamageType {
 export declare module DamageType {
     function getAll(...damageTypes: DamageType[]): DamageType[];
 }
+export declare const RESIST_IMMUNITY = 99;
+export declare const RESIST_REGEN = 100;
 export declare class Defense {
     base: number;
     resist: Attributes;
     vulnerable: Attributes;
     constructor(base: number);
     setResistance(damageTypes: DamageType, amount: number): this;
+    setImmunity(damageTypes: DamageType): this;
+    setRegen(damageTypes: DamageType): this;
     setVulnerability(damageTypes: DamageType, amount: number): this;
     copy(): Defense;
     equals(defense: Defense): boolean;
@@ -189,7 +243,11 @@ declare class AttributesImpl {
     reset(amount?: number): void;
     all(): [DamageType, number][];
     types(): DamageType[];
-    has(): boolean;
+    has(type?: DamageType): boolean;
+    /**
+     * Returns true if any of the given damage types are exactly the given value.
+     */
+    hasTypeAtValue(damage: DamageType, exactly: number): boolean;
     copy(): Attributes;
     equals(attrs: Attributes): boolean;
 }
@@ -221,4 +279,26 @@ export interface IAttackSkillBonus {
 export declare enum EntityTag {
     None = 0
 }
+export interface IMoveToOptions {
+    disallowCancelation?: boolean;
+    movementDelay?: Delay | number;
+    animation?: MoveAnimation;
+    onMoveCompletedParticles?: IRGB;
+    /**
+     * What caused the move?
+     */
+    flags?: MoveFlag;
+}
+export declare enum MoveAnimation {
+    Normal = 0,
+    Jump = 1,
+    Teleport = 2
+}
+export declare enum MoveFlag {
+    None = 0,
+    /**
+     * Skips damage due to movement
+     */
+    SkipEncumberedChecks = 1
+}
 export {};

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

@@ -11,11 +11,11 @@
 import type { Events } from "event/EventEmitter";
 import type Doodad from "game/doodad/Doodad";
 import type { ActionType } from "game/entity/action/IAction";
-import type { IDamageInfo } from "game/entity/creature/ICreature";
-import type Entity from "game/entity/Entity";
+import type { CreatureType, IDamageInfo } from "game/entity/creature/ICreature";
+import type EntityWithStats from "game/entity/EntityWithStats";
 import type Human from "game/entity/Human";
-import type { AttackType } from "game/entity/IEntity";
-import type { ILoadOnIslandOptions, IMovementIntent, WeightStatus } from "game/entity/player/IPlayer";
+import type { AttackType, DamageType } from "game/entity/IEntity";
+import type { IMovementIntent, WeightStatus } from "game/entity/player/IPlayer";
 import type { ISkillEvents } from "game/entity/skill/SkillManager";
 import type { IHasImagePath, Quality } from "game/IObject";
 import type { IslandId } from "game/island/IIsland";
@@ -24,7 +24,7 @@ import type { IContainer } from "game/item/IItem";
 import { ItemType, ItemTypeGroup, RecipeLevel } from "game/item/IItem";
 import type Item from "game/item/Item";
 import { TempType } from "game/temperature/ITemperature";
-import type { ITile } from "game/tile/ITerrain";
+import type Tile from "game/tile/Tile";
 import Message from "language/dictionary/Message";
 import type { IModdable } from "mod/ModRegistry";
 import type { IOptions } from "save/data/ISaveDataGlobal";
@@ -32,7 +32,7 @@ import type { IRGB } from "utilities/Color";
 import type { Direction } from "utilities/math/Direction";
 import type { IVector2 } from "utilities/math/IVector";
 import type { IRange } from "utilities/math/Range";
-export interface IHumanEvents extends Events<Entity>, ISkillEvents {
+export interface IHumanEvents extends Events<EntityWithStats>, ISkillEvents {
     /**
      * Called when the human is spawned. (At the end of `Player.setup` / `NPC.spawn`)
      */
@@ -49,23 +49,23 @@ export interface IHumanEvents extends Events<Entity>, ISkillEvents {
     restEnd(restData: IRestData): any;
     /**
      * Called when an item is added to the player's inventory
-     * @param item The item object
-     * @param container The container object the item was added to. This container might be inventory or a container within the inventory.
+     * @param item The items
+     * @param container The container object the items were added to. This container might be inventory or a container within the inventory.
      */
-    inventoryItemAdd(item: Item, container: IContainer): any;
+    inventoryItemAdd(items: Item[], container: IContainer): any;
     /**
      * Called when an item is removed from the players inventory
-     * @param item The item object
-     * @param container The container object the item was moved to.
+     * @param item The items
+     * @param container The container object the items were moved to.
      */
-    inventoryItemRemove(item: Item, container: IContainer): any;
+    inventoryItemRemove(items: Item[], container: IContainer): any;
     /**
      * Called when an item is moved from one container to another, while still in the players inventory.
-     * @param item The item object
-     * @param container The container object the item was moved to. This container might be inventory or a container within the inventory.
-     * @param previousContainer The container object the item was moved from. This container might be inventory or a container within the inventory.
+     * @param items The items
+     * @param container The container object the items were moved to. This container might be inventory or a container within the inventory.
+     * @param previousContainer The container object the items were moved from. This container might be inventory or a container within the inventory.
      */
-    inventoryItemUpdate(item: Item, container: IContainer, previousContainer?: IContainer): any;
+    inventoryItemUpdate(items: Item[], container: IContainer, previousContainer?: IContainer): any;
     /**
      * Called when the human equips an item to a slot
      * @param item The item being equipped
@@ -104,7 +104,7 @@ export interface IHumanEvents extends Events<Entity>, ISkillEvents {
      * @param dropAllQuality If not undefined, all items of this quality will be dropped
      * @returns True if the item can be dropped, false if the item can not be dropped, or undefined to use the default logic
      */
-    canDropItem(item: Item, tile: ITile, dropAll: boolean, dropAllQuality: Quality | undefined): boolean | undefined;
+    canDropItem(item: Item, tile: Tile, dropAll: boolean, dropAllQuality: Quality | undefined): boolean | undefined;
     /**
      * Called before an npc attacks
      * @param weapon The weapon used to attack
@@ -184,13 +184,18 @@ export interface IHumanEvents extends Events<Entity>, ISkillEvents {
      * @param tile The tile something was built on
      * @param doodad The doodad that was created on the tile
      */
-    build?(item: Item, tile: ITile, doodad: Doodad): void;
+    build?(item: Item, tile: Tile, doodad: Doodad): void;
     /**
      * Called when the human is damaged
      * @param damageInfo The damage info object
      * @returns The amount of damage the player should take (the player will take this damage)
      */
     damage(damageInfo: IDamageInfo): number | void;
+    /**
+     * Called when an doodad is picked up
+     * @param doodad The doodad object
+     */
+    pickUpDoodad?(doodad: Doodad): any;
     /**
      * Called when the player tick starts
      */
@@ -250,6 +255,14 @@ export interface IHumanEvents extends Events<Entity>, ISkillEvents {
      * @return `false` to stop the human from dying
      */
     shouldDie(): false | void;
+    /**
+     * Called when the human position is set, from a teleport type of movement
+     * @param tile Tile the human is now on
+     */
+    setPosition(tile: Tile): void;
+    discoverVulnOrResist(creatureType: CreatureType, damageType: DamageType): any;
+    hasDiscoveredVulnOrResist(creatureType: CreatureType, damageType: DamageType, defaultState: boolean): boolean | undefined;
+    getDiscoveredVulnsAndResists(): Map<CreatureType, Set<DamageType>>;
 }
 export interface IHairstyleDescription extends IModdable, IHasImagePath {
     name: string;
@@ -274,7 +287,8 @@ export declare enum Delay {
     Collision = 40,
     TurnDirection = 2,
     ReallyLongPause = 100,
-    AttackAnimation = 30
+    AttackAnimation = 30,
+    Jump = 18
 }
 export declare enum EquipType {
     None = 0,
@@ -418,15 +432,16 @@ export interface IHumanOld extends Partial<Human> {
  * Defaults to 90% (0.9)
  */
 export declare const WEIGHT_ENCUMBERED = 0.9;
-export interface ICanSailAwayResult {
-    canSailAway: boolean;
-    distanceFromEdge?: number;
-    blockedTilesChecked?: Set<ITile>;
+export interface ILoadOnIslandOptions {
+    spawnPosition: IVector2;
+    startingGame: boolean;
+    travelType?: "swimming" | "sailing";
 }
 export interface IVoyageInfo {
     time: number;
     boat?: Item;
     destination?: Island;
+    direction?: Direction.Cardinal;
     usedItems?: Item[];
     wantedItems?: ItemType[];
 }

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

@@ -155,7 +155,7 @@ export default class Stats<T extends IStatHost> {
      * @param amt The amount to increase the change timer by. Defaults to the stat's `changeTimerSpeed`.
      */
     increaseChangeTimer(stat: Stat | IStat, amt?: number): T;
-    getTimeUntilChange(stat: Stat | IStat): number | undefined;
+    getTimeUntilChange(stat: Stat | IStat, allowFailure?: boolean): number;
     removeChangeTimer(stat: Stat | IStat): T;
     /**
      * Passes the "turn" for stats, decrements their `changeTimer`s. If a stat's timer reaches `0`,