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

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

@@ -10,166 +10,118 @@
  */
 import type { SfxType } from "audio/IAudio";
 import EventEmitter from "event/EventEmitter";
-import type Creature from "game/entity/creature/Creature";
-import type { IDamageInfo } from "game/entity/creature/ICreature";
+import type { TileUpdateType } from "game/IGame";
+import { FireType } from "game/IGame";
+import type Doodad from "game/doodad/Doodad";
+import type EntityMovable from "game/entity/EntityMovable";
+import type EntityWithStats from "game/entity/EntityWithStats";
 import type Human from "game/entity/Human";
-import type { EntityTag, IEntityEvents, IProperties, IStatus, Property, StatusEffectChangeReason } from "game/entity/IEntity";
-import { DamageType, EntityType, MoveType, StatusType } from "game/entity/IEntity";
-import { Delay, MovingClientSide } from "game/entity/IHuman";
-import type { IStats } from "game/entity/IStats";
+import type { IEntityConstructorOptions, IEntityEvents } from "game/entity/IEntity";
+import { EntityType } from "game/entity/IEntity";
+import type { IHumanBound } from "game/entity/IEntityManager";
+import type Creature from "game/entity/creature/Creature";
+import type Corpse from "game/entity/creature/corpse/Corpse";
 import type NPC from "game/entity/npc/NPC";
 import type Player from "game/entity/player/Player";
-import Stats from "game/entity/Stats";
-import type StatusEffect from "game/entity/status/StatusEffect";
-import type { FireType, IMovementTime, TileUpdateType } from "game/IGame";
 import type { IInspector } from "game/inspection/IInfoProvider";
 import type { IslandId } from "game/island/IIsland";
-import type { ItemType, RecipeLevel } from "game/item/IItem";
-import type { IReferenceable } from "game/reference/IReferenceManager";
+import type Item from "game/item/Item";
+import type { IReferenceable, Reference } from "game/reference/IReferenceManager";
 import type { ITemperatureSource } from "game/temperature/ITemperature";
-import type { ITile } from "game/tile/ITerrain";
+import type Tile from "game/tile/Tile";
+import type TileEvent from "game/tile/TileEvent";
 import type { ISerializedTranslation } from "language/ITranslation";
 import type Translation from "language/Translation";
-import type { IRendererOrigin } from "renderer/context/RendererOrigin";
-import FieldOfView from "renderer/fieldOfView/FieldOfView";
-import type { CanASeeBType } from "renderer/fieldOfView/IFieldOfView";
+import type { RenderSource, UpdateRenderFlag } from "renderer/IRenderer";
 import type { INotificationLocation, ItemNotifierType, StatNotificationType } from "renderer/notifier/INotifier";
-import { Direction } from "utilities/math/Direction";
-import type { IVector2, IVector3 } from "utilities/math/IVector";
-import Vector2 from "utilities/math/Vector2";
+import type { IVector3 } from "utilities/math/IVector";
 import type { IVector4 } from "utilities/math/Vector4";
-export default abstract class Entity extends EventEmitter.Host<IEntityEvents> implements IReferenceable, IInspector, ITemperatureSource, INotificationLocation, IRendererOrigin, IVector3 {
-    readonly stat: Stats<this>;
-    entityType: EntityType;
+export default abstract class Entity<DescriptionType = unknown, TypeType extends number = number, TagType = unknown, CounterType = unknown> extends EventEmitter.Host<IEntityEvents> implements IReferenceable, IInspector, ITemperatureSource, INotificationLocation, IVector4 {
+    abstract readonly entityType: EntityType;
+    abstract readonly tileUpdateType: TileUpdateType;
     id: number;
+    type: TypeType;
     referenceId?: number;
     renamed?: string | ISerializedTranslation;
-    z: number;
     x: number;
     y: number;
-    /**
-     * 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;
-    /**
-     * Not guaranteed to be synced between the server and client for Human entities
-     */
-    isMoving: boolean;
-    /**
-     * Only used for Human entities
-     */
-    movementCompleteZ: number | undefined;
-    moveType: MoveType | undefined;
-    anim: number;
-    stopNextMovement: boolean;
-    direction: Vector2;
-    facingDirection: Direction.Cardinal | Direction.None;
-    stats: IStats;
-    status: IStatus;
-    properties: IProperties | undefined;
+    z: number;
     private _tags?;
-    get tags(): Set<EntityTag>;
     islandId: IslandId;
-    spawnAnimationTime: IMovementTime | undefined;
-    attackAnimationType: DamageType | undefined;
-    attackAnimationTime: IMovementTime | undefined;
+    preventRendering?: boolean;
+    private _humansWithinBound;
     /**
-     * The state of what the client thinks is happening to this entity (regarding movement)
+     * Cached tile the entity is on.
+     * This should be cleared when x,y,z is changing.
      */
-    movingClientside: MovingClientSide;
-    allowSmartMovementClientside: boolean;
-    protected _movementTime: {
-        start: number;
-        end: number;
-    } | undefined;
-    private _inFov;
-    private readonly statusHandlers;
-    constructor();
-    get island(): import("../island/Island").default;
-    abstract getName(): Translation;
-    toString(): string;
-    getInspectionId(): string;
+    private _tile;
     /**
-     * Returns whether the entity has the given `StatusType`
-     * @param status The status to check
+     * Cached tiles around the entity (does not include current / corner tiles)
+     * This should be cleared when x,y,z is changing.
      */
-    hasStatus(status: StatusType): number;
+    private _tilesAround;
+    protected _description?: DescriptionType;
+    constructor(entityOptions?: IEntityConstructorOptions<TypeType>);
+    get island(): import("../island/Island").default;
+    get reference(): Reference | undefined;
     /**
-     * Sets whether the entity has the given `StatusType`.
-     * Emits `EntityEvent.StatusChange`.
-     * @param status The status to change
-     * @param level Whether the entity will have the status.
-     *              If given false/0, removes the status. If given true/1+, raises the status to the given level.
-     * @param reason The reason for the change
-     * @param force Forces the status to be set to the given value, even if the current effect is being lowered.
+     * Get the entities description
      */
-    setStatus(status: StatusType, level: number | boolean, reason: StatusEffectChangeReason, force?: boolean): boolean;
+    get description(): DescriptionType | undefined;
     /**
-     * Returns the handler for this status effect, whether or not this entity currently has the effect.
+     * Adds a referenceId to the entity if it doesn't already have one
      */
-    getStatus<S extends StatusEffect = StatusEffect>(status: StatusType): S | undefined;
+    addReferenceId(): void;
+    abstract getName(): Translation;
     /**
-     * Generator for status effects on the entity.
+     * Called when filling out the entities description for the first time
      */
-    getStatuses(): StatusEffect[];
+    protected abstract getDescription(): DescriptionType | undefined;
+    toString(): string;
+    getInspectionId(): string;
     /**
-     * Generator for status effects on the entity.
+     * Location of the entity on the world.
+     * Parent classes will probably mark this as always defined
      */
-    getActiveStatuses(): StatusEffect[];
-    abstract damage(damageInfoOrAmount: IDamageInfo | number): number | undefined;
-    getCraftingDifficulty(level: RecipeLevel): number;
-    getTile(): ITile;
-    getPoint(): IVector3;
-    getFacingPoint(): IVector3;
-    getFacingTile(): ITile;
-    getMovementDelay(): number;
-    moveTo(x: number, y: number, z: number, allowCancelation?: boolean, movementDelay?: Delay | number): boolean;
-    isNearby(entity: Entity): boolean;
+    get point(): IVector3 | undefined;
     /**
-     * Faces the target and animates a bump into effect
+     * Tile the entity is on in the world.
+     * Parent classes will probably mark this as always defined
      */
-    animateBumpTowards(x: number, y: number): void;
-    protected setMoving(delay: Delay, fromX: number, fromY: number, toZ?: number): void;
-    animateSpawn(): void;
-    animateAttack(damageType: DamageType[] | undefined): void;
-    getMovementPoint(timeStamp: number): IVector2;
+    get tile(): Tile | undefined;
+    get tilesAround(): Tile[] | undefined;
+    protected setCachedTile(tile: Tile): void;
+    clearTileCache(): void;
+    isNearby(entity: Entity<DescriptionType>): boolean;
     /**
-     * Gets movement progress and moves the state machine forward when the movement is completed
+     * Checks if the entity is within the viewport bounds of one or more humans
      */
-    getMovementProgress(timeStamp: number): number;
-    protected onMovementCompleted(): void;
-    getMoveType(): MoveType;
-    setMoveType(moveType: MoveType): void;
-    isInFov(): boolean;
-    setInFov(inFov: boolean): void;
+    isWithinHumanBounds(): boolean;
+    setHumansWithinBound(humansWithinBound: IHumanBound[]): void;
+    humansVisible(): Human[];
     isOnFire(): FireType;
-    canSeeObject(type: CanASeeBType, object: IVector4 & {
-        fromX: number;
-        fromY: number;
-    }, fieldOfView?: FieldOfView, customRadius?: number): boolean;
-    canSeePosition(type: CanASeeBType, islandId: IslandId, x: number, y: number, z: number, fieldOfView?: FieldOfView | undefined, customRadius?: number): boolean;
-    queueSoundEffect(type: SfxType, delay?: number, speed?: number, noPosition?: boolean): void;
-    queueSoundEffectInFront(type: SfxType, delay?: number, speed?: number, noPosition?: boolean): void;
-    notifyItem(itemNotifierType: ItemNotifierType, type: ItemType): void;
+    queueSoundEffect(type: SfxType, delay?: number, speed?: number): void;
+    updateRender(source: RenderSource, flag: UpdateRenderFlag): void;
+    updateView(source: RenderSource, updateFov?: boolean | UpdateRenderFlag.FieldOfView | UpdateRenderFlag.FieldOfViewSkipTransition): void;
+    notifyItem(itemNotifierType: ItemNotifierType, item: Item): void;
     notifyStat(type: StatNotificationType, value: number): void;
-    hasProperty(property: Property): boolean;
-    addProperty(property: Property, value: any): void;
-    getProperty<T>(property: Property): T | undefined;
-    removeProperty(property: Property): boolean;
     getProducedTemperature(): number | undefined;
-    abstract readonly tileUpdateType: TileUpdateType;
-    get asEntity(): Entity;
+    setName(renamed: string | ISerializedTranslation | undefined): void;
+    canInspect(human: Human): boolean;
+    hasTag(tag: TagType): boolean;
+    addTag(tag: TagType): void;
+    removeTag(tag: TagType): void;
+    abstract isValid(): boolean;
+    get asEntity(): Entity<DescriptionType, TypeType, TagType>;
+    get asEntityMovable(): EntityMovable<DescriptionType, TypeType, TagType> | undefined;
+    get asEntityWithStats(): EntityWithStats<DescriptionType, TypeType, TagType> | undefined;
+    abstract get asCorpse(): Corpse | undefined;
     abstract get asCreature(): Creature | undefined;
+    abstract get asDoodad(): Doodad | undefined;
     abstract get asHuman(): Human | undefined;
+    abstract get asLocalPlayer(): Player | undefined;
     abstract get asNPC(): NPC | undefined;
     abstract get asPlayer(): Player | undefined;
-    abstract get asLocalPlayer(): Player | undefined;
-    protected abstract getApplicableStatusEffects(): Set<StatusType>;
-    refreshStatusEffects(): void;
-    private initializeStatusEffects;
-    private initializeStatusHandler;
+    abstract get asTileEvent(): TileEvent | undefined;
+    abstract get asItem(): Item | undefined;
 }

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

@@ -11,17 +11,10 @@
 import type Entity from "game/entity/Entity";
 import type { IEntityManager, IHumanBound } from "game/entity/IEntityManager";
 import { ObjectManager } from "game/ObjectManager";
+import type Tile from "game/tile/Tile";
 export interface IEntityManagerEvents<T extends Entity> {
     spawn(entity: T): any;
     remove(entity: T): any;
-    /**
-     * Called when a player-like human (player / special npc) is spawned
-     */
-    addPlayingEntity(entity: T): any;
-    /**
-     * Called when a player-like human (player / special npc) is removed
-     */
-    removePlayingEntity(entity: T): any;
 }
 export interface IEntityCanCreateOptions {
     allowEdgeSpawning?: boolean;
@@ -36,5 +29,5 @@ export default abstract class EntityManager<T extends Entity> extends ObjectMana
     /**
      * Checks if the target position is a good spot for a new entity
      */
-    protected canCreateEntity(x: number, y: number, z: number, options?: IEntityCanCreateOptions): boolean;
+    protected canCreateEntity(tile: Tile, options?: IEntityCanCreateOptions): boolean;
 }

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

@@ -0,0 +1,121 @@
+/*!
+ * 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 { SfxType } from "audio/IAudio";
+import type { IEventEmitter } from "event/EventEmitter";
+import Entity from "game/entity/Entity";
+import type { IEntityConstructorOptions, IEntityEvents, IMoveToOptions } from "game/entity/IEntity";
+import { MoveFlag } from "game/entity/IEntity";
+import { DamageType, MoveType } from "game/entity/IEntity";
+import { MovingClientSide } from "game/entity/IHuman";
+import type { IMovementTime } from "game/IGame";
+import type { IslandId } from "game/island/IIsland";
+import type Tile from "game/tile/Tile";
+import type { IRendererOrigin } from "renderer/context/RendererOrigin";
+import FieldOfView from "renderer/fieldOfView/FieldOfView";
+import type { CanASeeBType } from "renderer/fieldOfView/IFieldOfView";
+import type { Direction } from "utilities/math/Direction";
+import type { IVector2 } from "utilities/math/IVector";
+import type Vector2 from "utilities/math/Vector2";
+import type { IVector4 } from "utilities/math/Vector4";
+export interface IEntityMovableEvents extends IEntityEvents {
+    /**
+     * 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(fromTile: Tile, toTile: Tile, isMoving: boolean): boolean | undefined | void;
+    /**
+     * Called after moving.
+     */
+    postMove(fromTile: Tile, toTile: Tile, flags: MoveFlag): void;
+}
+/**
+ * Entity class that allows movement
+ */
+export default abstract class EntityMovable<DescriptionType = unknown, TypeType extends number = number, TagType = unknown, CounterType = unknown> extends Entity<DescriptionType, TypeType, TagType, CounterType> implements IRendererOrigin {
+    event: IEventEmitter<this, IEntityMovableEvents>;
+    /**
+     * Not guaranteed to be synced between the server and client for Human entities
+     */
+    fromX?: number;
+    fromY?: number;
+    isMoving?: boolean;
+    /**
+     * Only used for Human entities
+     */
+    movementCompleteZ?: number;
+    anim?: number;
+    moveType?: MoveType;
+    stopNextMovement?: boolean;
+    /**
+     * undefined = Vector2.ZERO for this
+     */
+    direction?: Vector2;
+    /**
+     * undefined = Direction.None for this
+     */
+    facingDirection?: Direction.Cardinal;
+    /**
+     * The state of what the client thinks is happening to this entity (regarding movement)
+     */
+    movingClientside: MovingClientSide;
+    movingOptions?: IMoveToOptions;
+    allowSmartMovementClientside?: boolean;
+    attackAnimationType?: DamageType;
+    attackAnimationTime?: IMovementTime;
+    protected _movementTime?: {
+        start: number;
+        end: number;
+    };
+    constructor(entityOptions?: IEntityConstructorOptions<TypeType>);
+    /**
+     * Called when the entity is about to move to another tile.
+     * This should update relevant properties on the tile and return true
+     * @param fromTile Tile the entity was on
+     * @param toTile Tile the entity is moving onto
+     * @returns False to block the move
+     */
+    protected abstract updateTile(fromTile: Tile, toTile: Tile): boolean;
+    get asEntityMovable(): EntityMovable<DescriptionType, TypeType, TagType>;
+    /**
+     * Regular entities don't have a direction so this will be the same as getTile()
+     */
+    get facingTile(): Tile;
+    canSeeObject(type: CanASeeBType, object: IVector4 & {
+        fromX: number;
+        fromY: number;
+    }, fieldOfView?: FieldOfView, customRadius?: number): boolean;
+    canSeeTile(type: CanASeeBType, tile: Tile, fieldOfView?: FieldOfView, customRadius?: number): boolean;
+    canSeePosition(type: CanASeeBType, islandId: IslandId, x: number, y: number, z: number, fieldOfView?: FieldOfView | undefined, customRadius?: number): boolean;
+    queueSoundEffectInFront(type: SfxType, delay?: number, speed?: number): void;
+    getMovementDelay(): number;
+    moveTo(tile: Tile, options?: IMoveToOptions): boolean;
+    /**
+     * Faces the target tile
+     */
+    updateDirection(tile: Tile): void;
+    /**
+     * Faces the target and animates a bump into effect
+     */
+    animateBumpTowards(tile: Tile): void;
+    protected setMoving(fromX: number, fromY: number, toZ?: number, options?: IMoveToOptions): void;
+    animateAttack(damageType: DamageType[] | undefined): void;
+    getMovementPoint(timeStamp: number): IVector2;
+    /**
+     * Gets movement progress and moves the state machine forward when the movement is completed
+     */
+    getMovementProgress(timeStamp: number): number;
+    protected onMovementCompleted(): void;
+    get isFlying(): boolean;
+    getMoveType(): MoveType;
+    setMoveType(moveType: MoveType): void;
+    canSwapWith(entity: EntityMovable, source: string | undefined): boolean;
+}

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

@@ -0,0 +1,73 @@
+/*!
+ * 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 { IEventEmitter } from "event/EventEmitter";
+import { StatusType } from "game/entity/IEntity";
+import type { IStatus, StatusEffectChangeReason, IEntityConstructorOptions } from "game/entity/IEntity";
+import type { IStatEvents, IStats } from "game/entity/IStats";
+import type { IStatHost } from "game/entity/Stats";
+import Stats from "game/entity/Stats";
+import type StatusEffect from "game/entity/status/StatusEffect";
+import type { IEntityMovableEvents } from "game/entity/EntityMovable";
+import EntityMovable from "game/entity/EntityMovable";
+export interface IEntityWithStatsEvents extends IEntityMovableEvents, IStatEvents {
+    /**
+     * 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;
+}
+/**
+ * Entity class that includes stats/status system.
+ * Note: We're assuming something with stats is also movable!
+ */
+export default abstract class EntityWithStats<DescriptionType = unknown, TypeType extends number = number, TagType = unknown> extends EntityMovable<DescriptionType, TypeType, TagType> implements IStatHost {
+    event: IEventEmitter<this, IEntityWithStatsEvents>;
+    stats: IStats;
+    status: IStatus;
+    readonly stat: Stats<this>;
+    private readonly statusHandlers;
+    constructor(entityOptions?: IEntityConstructorOptions<TypeType>);
+    protected getApplicableStatusEffects(): Set<StatusType> | undefined;
+    get asEntityWithStats(): EntityWithStats<DescriptionType, TypeType, TagType>;
+    /**
+     * Returns whether the entity has the given `StatusType`
+     * @param status The status to check
+     */
+    hasStatus(status: StatusType): number;
+    /**
+     * Sets whether the entity has the given `StatusType`.
+     * Emits `EntityEvent.StatusChange`.
+     * @param status The status to change
+     * @param level Whether the entity will have the status.
+     *              If given false/0, removes the status. If given true/1+, raises the status to the given level.
+     * @param reason The reason for the change
+     * @param force Forces the status to be set to the given value, even if the current effect is being lowered.
+     */
+    setStatus(status: StatusType, level: number | boolean, reason: StatusEffectChangeReason, force?: boolean): boolean;
+    /**
+     * Returns the handler for this status effect, whether or not this entity currently has the effect.
+     */
+    getStatus<S extends StatusEffect = StatusEffect>(status: StatusType): S | undefined;
+    /**
+     * Generator for status effects on the entity.
+     */
+    getStatuses(): StatusEffect[];
+    /**
+     * Generator for status effects on the entity.
+     */
+    getActiveStatuses(): StatusEffect[];
+    refreshStatusEffects(): void;
+    private initializeStatusEffects;
+    private initializeStatusHandler;
+}