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

package/definitions/game/game/tile/Tile.d.ts

@@ -0,0 +1,311 @@
+/*!
+ * 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 Stream from "@wayward/goodstream";
+import { SfxType } from "audio/IAudio";
+import { FireType } from "game/IGame";
+import { Quality } from "game/IObject";
+import { WorldZ } from "game/WorldZ";
+import type Doodad from "game/doodad/Doodad";
+import type Human from "game/entity/Human";
+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 { IMessageManager } from "game/entity/player/IMessageManager";
+import type { IslandId } from "game/island/IIsland";
+import type Island from "game/island/Island";
+import type Item from "game/item/Item";
+import type { IMaybeTileContainer, IOverlayInfo, ITerrainDescription, ITileContainer, ITileData } from "game/tile/ITerrain";
+import { TerrainType } from "game/tile/ITerrain";
+import type TileEvent from "game/tile/TileEvent";
+import Translation from "language/Translation";
+import Message from "language/dictionary/Message";
+import FieldOfView from "renderer/fieldOfView/FieldOfView";
+import type { IFieldOfViewOrigin } from "renderer/fieldOfView/IFieldOfView";
+import { CanASeeBType } from "renderer/fieldOfView/IFieldOfView";
+import type { IRGB } from "utilities/Color";
+import type { IVector2, IVector3 } from "utilities/math/IVector";
+import type { IVector4 } from "utilities/math/Vector4";
+export interface ICanSailAwayResult {
+    canSailAway: boolean;
+    message?: Message;
+    distanceFromEdge?: number;
+    blockedTilesChecked?: Set<Tile>;
+    path?: IVector2[];
+}
+/**
+ * Tile class
+ */
+export default class Tile implements IVector4, Partial<ITileContainer>, IFieldOfViewOrigin {
+    readonly id: number;
+    static is(value: any): value is Tile;
+    readonly island: Island;
+    /**
+     * IVector4
+     */
+    readonly islandId: IslandId;
+    readonly x: number;
+    readonly y: number;
+    readonly z: WorldZ;
+    /**
+     * Data associated with the tile
+     */
+    rendererData: number;
+    quality?: Quality;
+    /**
+     * Entities on the tile
+     */
+    creature?: Creature;
+    doodad?: Doodad;
+    npc?: NPC;
+    /**
+     * Note: corpses must be ordered by id asc
+     */
+    corpses?: Corpse[];
+    /**
+     * Note: tile events must be ordered by id asc
+     */
+    events?: TileEvent[];
+    /**
+     * ITileContainer
+     */
+    containedItems?: Item[];
+    private _description;
+    /**
+     * Creates a fake tile
+     */
+    static createFake(island: Island): Tile;
+    /**
+     * Constructed during map gen
+     */
+    constructor(island: Island, x: number, y: number, z: number, id: number);
+    get point(): IVector3;
+    get description(): ITerrainDescription | undefined;
+    toString(): string;
+    getName(): Translation;
+    get type(): TerrainType;
+    /**
+     * Use game.changeTile or game.removeTopTile when modifying tiles.
+     * This should only be called if you know what you're doing.
+     * Otherwise the game state could get out of sync.
+     */
+    set type(value: number);
+    get isTilled(): boolean;
+    /**
+     * This should only be called if you know what you're doing
+     * Ensure a tile data with tilled is created
+     * Otherwise the game state could get out of sync
+     */
+    get doodadOverHidden(): boolean;
+    set doodadOverHidden(value: boolean);
+    get doodadAnimationDisabled(): boolean;
+    set doodadAnimationDisabled(value: boolean);
+    get variation(): number;
+    get isMapEdge(): boolean;
+    /**
+     * Check if this Tile containers some items
+     */
+    get hasTileContainer(): boolean;
+    /**
+     * Gets/creates tile container
+     */
+    get tileContainer(): ITileContainer;
+    /**
+     * Gets a tile container.
+     * It will not create one when called.
+     */
+    get maybeTileContainer(): IMaybeTileContainer;
+    /**
+     * Checks for:
+     * Passable
+     * No doodads
+     * No tile items
+     * No creatures
+     * No corpses
+     * No tile events
+     * No girls
+     */
+    get isEmpty(): boolean;
+    /**
+     * Checks if the tile is full of items
+     */
+    get isFull(): boolean;
+    /**
+     * Check if the tile is blocked (impassable terrain / creatures / npcs / players / doodads that cause blocked movement).
+     */
+    get isTileBlocked(): boolean;
+    /**
+     * Check is a tile is open
+     */
+    get isOpenTile(): boolean;
+    get isOnFire(): FireType;
+    /**
+     * Check if the tile can be lit on fire (has terrain/doodad/items that are flammable)
+     */
+    get isFlammable(): boolean;
+    /**
+     * Checks if a tile is dangerous for a human
+     */
+    isDangerous(human: Human): {
+        message: Message;
+        object: Translation;
+    } | false;
+    isPlayerOnTile(includeGhosts?: boolean, includeConnecting?: boolean): boolean;
+    getPlayersOnTile(includeGhosts?: boolean, includeConnecting?: boolean): Human[];
+    getPlayersThatSeeTile(): Human[];
+    /**
+     * Gets the nearest player based.
+     * @param canSee If set to true, check if the player can see the x/y/z coords. Defaults to false.
+     */
+    getNearestPlayer(canSee?: boolean, includeGhosts?: boolean, includeConnecting?: boolean): {
+        player?: Human;
+        distance?: number;
+    };
+    getTileData(): ITileData[] | undefined;
+    getOrCreateTileData(): ITileData[];
+    changeTile(newTileInfo: TerrainType | ITileData, stackTiles: boolean, dropTiles?: boolean): void;
+    /**
+     * Removes the top tiledata (index 0) from the tile
+     * If there is no remaining tile data, a new tile data will be added with the newTileTypeWhenEmpty type
+     */
+    removeTopTile(newTileTypeWhenEmpty: TerrainType | ((tile: Tile) => TerrainType)): void;
+    /**
+     * Pack or set the ground as untilled
+     */
+    packGround(): void;
+    /**
+     * Checks if this tile can be used for sailing.
+     * Ensures it's connected to the edge of the map.
+     */
+    canSailAwayFrom(): ICanSailAwayResult;
+    /**
+     * Used to spawn a random item on the current biome type based on spawnOnWorldGen properties in item descriptions.
+     * @param terrainType Optional terrain type for overriding the biome item types
+     */
+    spawnRandomItem(terrainType?: TerrainType): 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 Optional terrain type for overriding the biome item types
+     */
+    spawnRandomDoodad(terrainType?: TerrainType): void;
+    /**
+     * Plants a random seed at the given coordinates based on what can grow on that tile naturally. This will replace any doodad that is there.
+     * @returns True if a seed was planted.
+     */
+    plantRandomSeed(): boolean;
+    /**
+     * Possibly collapses or opens up a cave (on both sides) and breaks any doodads.
+     * @param checkType TerrainType to check if the tile point equals this before switching.
+     */
+    switchCave(checkType?: TerrainType): void;
+    /**
+     * Checks to see if there is a cave and if it can be switched to collapsed from open or vice versa.
+     * @param terrainType TerrainType to get the description of.
+     * @param checkType TerrainType to check if the tile point equals this before switching.
+     * @returns TerrainType that we should switch the tile into.
+     */
+    private canSwitchCave;
+    queueSoundEffect(type: SfxType, delay?: number, speed?: number): void;
+    createParticles(particle: IRGB | undefined, count?: number, intensity?: number): void;
+    /**
+     * Finds either lava or water ajacent to either lava or water, and cools the lava down based its findings.
+     */
+    coolLava(): void;
+    /**
+     * Cools the tile (such as lava) and reveals to any in-LOS players about it.
+     */
+    coolTile(): void;
+    /**
+     * Contaminate water sources when new ones are created based on the surrounding water.
+     */
+    contaminateWater(): void;
+    /**
+     * Converts shallow single bodies of fresh/swamp water into seawater
+     */
+    contaminateNonSeawater(): void;
+    clearBlood(executor: Human): boolean;
+    /**
+     * Clears all the water puddles on the tile.
+     * @param executor The player to send the message to.
+     */
+    clearPuddles(executor: Human): boolean;
+    clearWaste(): void;
+    checkForHiddenMob(human: Human): void;
+    /**
+     * Decrease the depth of a water tile if under 6 connected tiles
+     */
+    consumeWaterTile(): void;
+    /**
+     * Used to check if lava exists below, then create a passage above
+     * @returns True if it created a lava passage
+     */
+    makeLavaPassage(source: Human | undefined): boolean;
+    /**
+     * Used to genererate and find appropriate cave entrances
+     * @returns True if it created cave entrances
+     */
+    makeCaveEntrance(source: Human | undefined, chance?: number): boolean;
+    /**
+     * Create puddles around a point and limit them (so they can't expand infinitely)
+     */
+    createPuddles(): void;
+    addOrUpdateOverlay(overlay: IOverlayInfo): void;
+    removeOverlay(overlay: IOverlayInfo): void;
+    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;
+    messageIfVisible(callback: (manager: IMessageManager) => boolean): void;
+    /**
+     * Check if a tile is a suitable spawn point
+     */
+    isSuitableSpawnPointTile(): boolean;
+    /**
+     * Check if a tile is a suitable spawn point
+     */
+    isSuitableSpawnPointTileForMultiplayer(disallowWater?: boolean): boolean;
+    /**
+     * Check if a tile is a suitable spawn point for a creature
+     */
+    isSuitableSpawnPointTileForTamedCreature(): boolean;
+    /**
+     * Check if a tile is a suitable spawn point
+     */
+    isSuitableSpawnPointTileForIslandTravel(ensureConnectedToOcean: boolean): boolean;
+    isAdjacent(otherTile: Tile): boolean;
+    isAround(otherTile: Tile): boolean;
+    getVariation(noTileDataOffset?: boolean): number;
+    tilesInRange(range: number, includeCurrentTile?: boolean): Stream<Tile>;
+    openTileInRange(range: number, includeCurrentTile?: boolean): Tile | undefined;
+    /**
+     * Array version of tilesAround
+     */
+    getTilesAround(includeCurrentTile?: boolean, includeCorners?: boolean): Tile[];
+    /**
+     * IterableIterator version of TileHelpers.getTilesAround
+     */
+    tilesAround(includeCurrentTile?: boolean, includeCorners?: boolean): Generator<Tile, void, unknown>;
+    findMatchingTile(isMatchingTile: (tile: Tile) => boolean, options?: {
+        maxTilesChecked?: number;
+        canVisitTile?: (tile: Tile) => boolean;
+    }): Tile | undefined;
+    findMatchingTiles(isMatchingTile: (tile: Tile) => boolean, options?: {
+        maxTiles?: number;
+        maxTilesChecked?: number;
+        canVisitTile?: (tile: Tile) => boolean;
+    }): Tile[];
+    findPath(target: Tile, isTileBlocked: (tile: Tile) => boolean, getTilePenalty?: (tile: Tile) => number, maxNodesChecked?: number): Tile[] | undefined;
+    /**
+     * Returns whether the tile is blocked (completely impassible) for the human
+     */
+    isWalkToTileBlocked(human: Human, clientSide: boolean): boolean;
+}

package/definitions/game/game/tile/TileBits.d.ts

@@ -0,0 +1,28 @@
+/*!
+ * 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 { TerrainType } from "game/tile/ITerrain";
+declare module TileBits {
+    const maskGfx = 31;
+    const maskType = 131040;
+    const maskTypeShift = 5;
+    const maskTilled = 131072;
+    const maskTilledShift: number;
+    const maskDoodadOverHidden = 262144;
+    const maskDoodadOverHiddenShift: number;
+    const maskDoodadAnimationDisabled = 524288;
+    const maskDoodadAnimationDisabledShift: number;
+    function getTypeRaw(data: number): number;
+    function setTypeRaw(data: number, value: TerrainType): number;
+    function setTilledRaw(data: number, value: number): number;
+    function setDoodadOverHiddenRaw(data: number, value: number): number;
+    function setDoodadAnimationDisabledRaw(data: number, value: number): number;
+}
+export default TileBits;

package/definitions/game/game/tile/TileEvent.d.ts

@@ -8,39 +8,36 @@
  * 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 { CreationId } from "game/IGame";
+import type { IEventEmitter } from "event/EventEmitter";
+import type { IEntityMovableEvents } from "game/entity/EntityMovable";
+import EntityMovable from "game/entity/EntityMovable";
+import type { IEntityConstructorOptions } from "game/entity/IEntity";
+import { EntityType } from "game/entity/IEntity";
+import { TileUpdateType } from "game/IGame";
 import type { IObject } from "game/IObject";
-import type { IslandId } from "game/island/IIsland";
-import type { IReferenceable } from "game/reference/IReferenceManager";
-import type { ITemperatureSource } from "game/temperature/ITemperature";
 import { FireStage } from "game/tile/events/IFire";
-import type { ITile } from "game/tile/ITerrain";
 import type { ITileEventDescription } from "game/tile/ITileEvent";
 import { TileEventType } from "game/tile/ITileEvent";
-import type { ISerializedTranslation } from "language/ITranslation";
+import type Tile from "game/tile/Tile";
+import type { Article } from "language/Translation";
 import type { IVector3 } from "utilities/math/IVector";
-export interface ITileEventEvents {
+export interface ITileEventEvents extends IEntityMovableEvents {
     /**
      * Emitted when the fire stage of this tile event changes.
      * Note: The fire stage of tile event is not saved, so when the tile event'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;
 }
-export default class TileEvent extends EventEmitter.Host<ITileEventEvents> implements IReferenceable, IObject<TileEventType>, IVector3, ITemperatureSource {
+export default class TileEvent extends EntityMovable<ITileEventDescription, TileEventType> implements IObject<TileEventType> {
     static is(value: any): value is TileEvent;
-    readonly objectType: CreationId;
-    type: TileEventType;
-    id: number;
-    referenceId?: number;
-    z: number;
-    x: number;
-    y: number;
-    renamed?: string | ISerializedTranslation;
-    decay?: number;
+    get entityType(): EntityType.TileEvent;
+    get tileUpdateType(): TileUpdateType;
+    readonly event: IEventEmitter<this, ITileEventEvents>;
+    anim: number;
     fromX: number;
     fromY: number;
+    decay?: number;
     gfx?: number;
     maxDur?: number;
     minDur?: number;
@@ -52,20 +49,26 @@ export default class TileEvent extends EventEmitter.Host<ITileEventEvents> imple
      */
     fuel?: number;
     private fireStage?;
-    islandId: IslandId;
-    private _description;
-    private _movementTime;
-    constructor(type?: TileEventType, islandId?: `${number},${number}`, x?: number, y?: number, z?: number);
-    get island(): import("../island/Island").default;
+    constructor(entityOptions?: IEntityConstructorOptions<TileEventType>);
+    isValid(): boolean;
+    get asCorpse(): undefined;
+    get asCreature(): undefined;
+    get asDoodad(): undefined;
+    get asHuman(): undefined;
+    get asLocalPlayer(): undefined;
+    get asNPC(): undefined;
+    get asPlayer(): undefined;
+    get asTileEvent(): TileEvent | undefined;
+    get asItem(): undefined;
+    get point(): IVector3;
+    get tile(): Tile;
     toString(): string;
-    description(): ITileEventDescription | undefined;
-    getName(article?: false | "definite" | "indefinite", count?: number): import("../../language/impl/TranslationImpl").default;
-    getTile(): ITile;
+    protected getDescription(): ITileEventDescription | undefined;
+    getName(article?: Article, count?: number): import("../../language/impl/TranslationImpl").default;
     getProducedTemperature(): number | undefined;
-    updateFire(tile: ITile): void;
-    moveTo(x: number, y: number, z: number): void;
-    addToTile(tile: ITile): void;
+    updateFire(tile: Tile): void;
+    protected updateTile(fromTile: Tile, toTile: Tile): boolean;
+    addToTile(tile: Tile): void;
     removeFromTile(updateTile: boolean): void;
-    getMovementProgress(timeStamp: number): number;
     burn(fire: TileEvent): void;
 }

package/definitions/game/game/tile/TileEventManager.d.ts

@@ -10,24 +10,21 @@
  */
 import Stream from "@wayward/goodstream/Stream";
 import { CreatureType } from "game/entity/creature/ICreature";
-import type Human from "game/entity/Human";
-import { CreationId } from "game/IGame";
 import { ObjectManager } from "game/ObjectManager";
-import type { ITile } from "game/tile/ITerrain";
 import { TileEventType } from "game/tile/ITileEvent";
+import type Tile from "game/tile/Tile";
 import TileEvent from "game/tile/TileEvent";
 import type { TextContext } from "language/ITranslation";
+import { Article } from "language/Translation";
 import type { IVector3 } from "utilities/math/IVector";
 export interface ITileManagerEvents {
     /**
      * Called when a tile event is about to be created
      * @param type The type of tile event
-     * @param x The x coordinate where the tile event will be created
-     * @param y The y coordinate where the tile event will be created
-     * @param z The z coordinate where the tile event will be created
+     * @param tile The tile where the tile event will be created
      * @returns False if the creature cannot spawn, or undefined to use the default logic
      */
-    canCreate(type: TileEventType, x: number, y: number, z: number): boolean | undefined;
+    canCreate(type: TileEventType, tile: Tile): boolean | undefined;
     /**
      * Called when a tile event is created.
      */
@@ -36,47 +33,35 @@ export interface ITileManagerEvents {
      * Called when a tile event is removed.
      */
     remove(event: TileEvent): any;
-    /**
-     * Called when a tile event is moved.
-     */
-    move(event: TileEvent): any;
 }
 export default class TileEventManager extends ObjectManager<TileEvent, ITileManagerEvents> {
-    protected readonly creationId: CreationId;
     load(): void;
-    create(type: TileEventType, x: number, y: number, z: number): TileEvent | undefined;
-    createFake(type: TileEventType, x: number, y: number, z: number): TileEvent | undefined;
+    create(type: TileEventType, tile: Tile): TileEvent | undefined;
+    createFake(type: TileEventType, tile: Tile, id?: number): TileEvent | undefined;
     remove(tileEvent: TileEvent): void;
-    getFromTile(tile: ITile, type: TileEventType): TileEvent | undefined;
+    getFromTile(tile: Tile, type: TileEventType): TileEvent | undefined;
     /**
      * Gets an array of tile events that have the water property at a given tile.
-     * @param tile ITile that you want to look at.
+     * @param tile Tile that you want to look at.
      * @returns Array of tile events with water properties or undefined
      */
-    getPuddles(tile: ITile): TileEvent[] | undefined;
-    canGather(tile: ITile): TileEvent | undefined;
+    getPuddles(tile: Tile): TileEvent[] | undefined;
+    canGather(tile: Tile): TileEvent | undefined;
     updateAll(): void;
-    fireOverflow(x: number, y: number, z: number): boolean;
-    canPickUp(tile: ITile): TileEvent | undefined;
-    blocksTile(tile: ITile): boolean;
     /**
-     * Creates either blood or water blood
-     * @param x X-axis of the tile where you want to spawn around (can be any adjacent tile)
-     * @param y Y-axis of the tile where you want to spawn around (can be any adjacent tile)
-     * @param z Z-axis of the tile where you want to spawn around (can be any adjacent tile)
-     * @returns True if the blood was created, false if not
+     * Overflow fire around the tile
      */
-    createBlood(x: number, y: number, z: number): boolean;
-    clearBlood(position: IVector3, executor: Human): boolean;
+    fireOverflow(tile: Tile): boolean;
+    canPickUp(tile: Tile): TileEvent | undefined;
+    blocksTile(tile: Tile): boolean;
     /**
-     * Clears all the water puddles on a specified tile.
-     * @param point The point to check for water puddles at.
-     * @param executor The player to send the message to.
+     * Creates either blood or water blood
+     * @param origin The origin around where you want to spawn around (can be any adjacent tile)
+     * @returns True if the blood was created, false if not
      */
-    clearPuddles(point: IVector3, executor: Human): boolean;
-    moveExcrement(position: IVector3): void;
+    createBlood(origin: IVector3): boolean;
     containsDamagingTileEvents(events: TileEvent[] | undefined): boolean;
-    getName(typeOrEvent: CreatureType | TileEvent, article?: false | "definite" | "indefinite", count?: number, showCount?: boolean): import("../../language/impl/TranslationImpl").default;
-    getEventTranslations(events: TileEvent[], article?: false | "definite" | "indefinite", context?: TextContext): Stream<import("../../language/impl/TranslationImpl").default>;
-    getEventListTranslation(events: TileEvent[], article?: false | "definite" | "indefinite", context?: TextContext): import("../../language/impl/TranslationImpl").default;
+    getName(typeOrEvent: CreatureType | TileEvent, article?: Article, count?: number, showCount?: boolean): import("../../language/impl/TranslationImpl").default;
+    getEventTranslations(events: TileEvent[], article?: Article, context?: TextContext): Stream<import("../../language/impl/TranslationImpl").default>;
+    getEventListTranslation(events: TileEvent[], article?: Article, context?: TextContext): import("../../language/impl/TranslationImpl").default;
 }

package/definitions/game/game/tile/TileEvents.d.ts

@@ -10,5 +10,4 @@
  */
 import type { ITileEventDescription } from "game/tile/ITileEvent";
 import { TileEventType } from "game/tile/ITileEvent";
-declare const tileEventDescriptions: OptionalDescriptions<TileEventType, ITileEventDescription>;
-export default tileEventDescriptions;
+export declare const tileEventDescriptions: OptionalDescriptions<TileEventType, ITileEventDescription>;

package/definitions/game/game/tile/events/IFire.d.ts

@@ -11,10 +11,9 @@
 import type { ILootItem } from "game/ILoot";
 import type { Quality } from "game/IObject";
 import type Island from "game/island/Island";
-import type { IContainer } from "game/item/IItem";
 import { ItemType } from "game/item/IItem";
 import type Item from "game/item/Item";
-import type { ITileContainer } from "game/tile/ITerrain";
+import type Tile from "game/tile/Tile";
 import type TileEvent from "game/tile/TileEvent";
 export declare enum FireStage {
     Extinguished = 0,
@@ -33,7 +32,7 @@ export declare module FireStage {
     function getTemperature(stage: FireStage, min: number, max: number): number;
 }
 export declare module IFire {
-    function dissassemblyBurn(island: Island, item: Item, container: ITileContainer, disassembly: boolean): Item[];
-    function harvestGatherBurn(step: number, resources: ILootItem[] | undefined, container: IContainer, quality: Quality | undefined, tileEvent: TileEvent): void;
-    function burnsLike(burnsLikeItem: ItemType, tileEvent: TileEvent, tileContainer: IContainer, quality: Quality | undefined): Item[];
+    function dissassemblyBurn(island: Island, item: Item, tile: Tile, disassembly: boolean): Item[];
+    function harvestGatherBurn(step: number, resources: ILootItem[] | undefined, tile: Tile, quality: Quality | undefined, tileEvent: TileEvent): void;
+    function burnsLike(burnsLikeItem: ItemType, tileEvent: TileEvent, tile: Tile, quality: Quality | undefined): Item[];
 }

package/definitions/game/game/tile/events/MeltingTile.d.ts

@@ -9,21 +9,21 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type Island from "game/island/Island";
-import type { ITile, TerrainType } from "game/tile/ITerrain";
+import type { TerrainType } from "game/tile/ITerrain";
 import { TileEventType } from "game/tile/ITileEvent";
+import type Tile from "game/tile/Tile";
 import type TileEvent from "game/tile/TileEvent";
-import type { IVector3 } from "utilities/math/IVector";
 declare const _default: {
     internal: boolean;
     /**
      * Gets the decay rate of a terrain type based on the temperature (returns as a default of 0).
      * @param terrainType The terrain type to check.
-     * @param point The point of the terrain/tile.
+     * @param tile The tile.
      * @returns The number of decay reduction of the terrain given the temperature of the point.
      */
-    getMeltRate(island: Island, terrainType: TerrainType, point: IVector3): number;
-    canMelt(island: Island, terrainType: TerrainType, point: IVector3): boolean;
-    canCreate(island: Island, type: TileEventType, tile: ITile, tileType: TerrainType, x: number, y: number, z: number): boolean;
+    getMeltRate(island: Island, terrainType: TerrainType, tile: Tile): number;
+    canMelt(island: Island, terrainType: TerrainType, tile: Tile): boolean;
+    canCreate(island: Island, type: TileEventType, tile: Tile, tileType: TerrainType): boolean;
     update(tileEvent: TileEvent): void;
 };
 export default _default;