@wayward/types 2.12.1-beta.dev.20221027.1 → 2.12.1-beta.dev.20221028.1

package/definitions/game/game/entity/creature/corpse/Corpse.d.ts

@@ -69,6 +69,7 @@ export default class Corpse extends EventEmitter.Host<ICorpseEvents> implements
     getTile(): ITile;
     isValid(): boolean;
     getDecayAtStart(): number;
+    addToTile(tile: ITile): void;
     update(): void;
     getResources(clientSide?: boolean): ItemType[];
     protected onCreated(): void;

package/definitions/game/game/entity/player/IPlayer.d.ts

@@ -99,6 +99,13 @@ export interface IPlayerEvents extends Events<Human> {
      * @param newId The new id for the player
      * @param isAbsentPlayer True if the player is absent
      */
+    idChanging(currentId: number, newId: number, isAbsentPlayer: boolean): any;
+    /**
+     * Called when the players id has changed
+     * @param currentId The players current id
+     * @param newId The new id for the player
+     * @param isAbsentPlayer True if the player is absent
+     */
     idChanged(currentId: number, newId: number, isAbsentPlayer: boolean): any;
 }
 export declare enum TurnTypeFlag {

package/definitions/game/game/entity/player/Player.d.ts

@@ -64,6 +64,7 @@ export default class Player extends Human implements IUnserializedCallback {
     addMilestone(milestone: Milestone, data?: number | string, update?: boolean): void;
     updateMovementIntent(movementIntent: IMovementIntent): boolean;
     load(): void;
+    unload(): void;
     setup(spawnPoint: IVector3): void;
     protected onNoInput(): void;
     updateTables(source: string, options?: Partial<{

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

@@ -65,18 +65,12 @@ interface IMagicalPropertyOld {
     stat?: Stat;
 }
 export declare const SYMBOL_CONTAINER_CACHED_REFERENCE: unique symbol;
-export declare const SYMBOL_CONTAINER_TEMPERATURE: unique symbol;
-export declare const SYMBOL_CONTAINER_ITEMS_TEMPERATURE: unique symbol;
-export declare const SYMBOL_CONTAINER_TILE_TEMPERATURE: unique symbol;
 export interface IContainable {
     containedWithin?: IContainer;
     containerType?: ContainerType;
     [SYMBOL_CONTAINER_CACHED_REFERENCE]?: ContainerReference;
 }
 export interface IContainer extends IContainable {
-    [SYMBOL_CONTAINER_TEMPERATURE]?: number;
-    [SYMBOL_CONTAINER_ITEMS_TEMPERATURE]?: number;
-    [SYMBOL_CONTAINER_TILE_TEMPERATURE]?: number;
     containedItems: Item[];
     transientItems?: Item[];
     itemOrders?: number[];

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

@@ -128,7 +128,7 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
     resolveContainer(container?: IContainer): Doodad | Item | Player | NPC | IContainer | ITile | undefined;
     getContainerReference(containable: IContainable | undefined, source: ContainerReferenceSource | undefined): ContainerReference;
     derefenceContainerReference(containerReference: ContainerReference, showWarnings?: boolean): IContainable | undefined;
-    hashContainer(containable: IContainable): string;
+    hashContainer(containable: IContainable, containerReferenceSource?: ContainerReferenceSource): string;
     hashContainerReference(containerReference: ContainerReference): string;
     updateContainedWithin(containable: IContainable, containedWithin: IContainer | undefined): void;
     addToContainerInternal(item: Item, container: IContainer, options?: IAddToContainerOptions): boolean;

package/definitions/game/game/temperature/TemperatureManager.d.ts

@@ -12,6 +12,7 @@ import EventEmitter from "event/EventEmitter";
 import type Doodad from "game/doodad/Doodad";
 import type { DoodadType } from "game/doodad/IDoodad";
 import type Entity from "game/entity/Entity";
+import type Player from "game/entity/player/Player";
 import type Island from "game/island/Island";
 import type { IContainer } from "game/item/IItem";
 import type Item from "game/item/Item";
@@ -32,15 +33,30 @@ export default class TemperatureManager extends EventEmitter.Host<ITempManagerEv
     private readonly island;
     encodedCalculatedCache: Map<number, Map<number, Uint32Array>>;
     encodedProducedCache: Map<number, Map<number, Uint32Array>>;
+    private readonly containerTemperatureCache;
+    private readonly containerTileTemperatureCache;
+    private readonly containerItemsTemperatureCache;
     private readonly scheduledUpdates;
     private readonly scheduledContainerInvalidations;
     private readonly cacheCalculated;
     private readonly cacheProduced;
     constructor(island: Island);
+    /**
+     * Clears all container caches
+     */
+    clearContainerCaches(): void;
     addLayer(z: WorldZ): void;
     delete(): void;
     preSerializeObject(): void;
     onUnserialized(): void;
+    /**
+     * Clears temperature caching for the container
+     */
+    clearContainerCache(container: IContainer): void;
+    /**
+     * Clears temperature caching for the container
+     */
+    clearContainerCacheByHash(containerHash: string): void;
     /**
      * Returns the current temperature for a container, calculated by combining the tile temperature and the combined temperature of the items inside
      */
@@ -51,11 +67,11 @@ export default class TemperatureManager extends EventEmitter.Host<ITempManagerEv
      * containers with no insulation return the exact temperature they produce, while containers with maximum insulation return
      * `Temperature.Neutral`
      */
-    getContainerProducedTemperature(container: IContainer, applyInsulation?: boolean): number;
+    getContainerProducedTemperature(container: IContainer, containerHash?: string, applyInsulation?: boolean): number;
     /**
      * Get the combined temperature of the items in the container.
      */
-    getContainerItemsTemperature(container: IContainer): number;
+    getContainerItemsTemperature(container: IContainer, containerHash?: string): number;
     private getContainerBaseTemperature;
     private getContainerInsulation;
     /**
@@ -104,6 +120,8 @@ export default class TemperatureManager extends EventEmitter.Host<ITempManagerEv
     protected onDpodadFireUpdate(object: Doodad, tile: ITile, stage?: FireStage): void;
     protected onTileEventFireUpdate(object: TileEvent, tile: ITile, stage?: FireStage): void;
     protected onDoodadTransformed(object: Doodad, newType: DoodadType, oldType: DoodadType): void;
+    protected onPlayerSpawnOrRemove(_: any, player: Player): void;
+    protected onPlayerIdChanged(player: Player): void;
     protected onCreateOrRemoveObject(_: any, object: Doodad | TileEvent | Entity): void;
     protected onEntityMove(object: Entity, lastX: number, lastY: number, lastZ: number, lastTile: ITile, x: number, y: number, z: number, tile: ITile): void;
     protected onUpdateTile(island: Island, x: number, y: number, z: number, tile: ITile, oldType: TerrainType): void;

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

@@ -148,10 +148,16 @@ export interface ITerrainDescription extends IModdable {
     useDoodadLikeAdaptor?: boolean;
 }
 export interface ITile extends Partial<ITileContainer> {
+    /**
+     * Note: corpses must be ordered by id asc
+     */
     corpses?: Corpse[];
     creature?: Creature;
     data: number;
     doodad?: Doodad;
+    /**
+     * Note: tile events must be ordered by id asc
+     */
     events?: TileEvent[];
     npc?: NPC;
     overlays?: IOverlayInfo[];

package/definitions/game/multiplayer/Multiplayer.d.ts

@@ -57,7 +57,7 @@ export default class Multiplayer extends EventEmitter.Host<IMultiplayerEvents> {
     private _syncCheckStack;
     private _disconnectingFromSyncIssue;
     private _reportedSyncHashMismatch;
-    private readonly _autojoinEnabled;
+    private readonly _autoJoinOptions;
     private _ipAddress;
     private readonly _matchmakingSecret;
     constructor();

package/definitions/game/steamworks/Steamworks.d.ts

@@ -12,7 +12,7 @@
 import type { IMatchmakingServer, INapiDiscordPresenceInfo, IRemoteFile, ISteamFriend, ISteamId, ISteamworksNetworking, IWaywardPreload, IWorkshopItem, LobbyType } from "@hosts/shared/interfaces";
 import EventEmitter from "event/EventEmitter";
 import { ModType } from "mod/IModInfo";
-import type { ServerInfo } from "multiplayer/IMultiplayer";
+import type { IJoinServerOptions, ServerInfo } from "multiplayer/IMultiplayer";
 import type { IBuild, IDedicatedServerInfo, IModPath, ISteamworksEvents } from "steamworks/ISteamworks";
 export default class Steamworks extends EventEmitter.Host<ISteamworksEvents> {
     protected initialized: boolean;
@@ -134,9 +134,9 @@ export default class Steamworks extends EventEmitter.Host<ISteamworksEvents> {
     saveFile(fileName: string, blob: Blob): Promise<void>;
     hasServerToJoin(): boolean;
     getServerToJoin(): ServerInfo | undefined;
-    setServerToJoin(serverToJoin: ServerInfo, automatic?: boolean): void;
+    setServerToJoin(serverToJoin: ServerInfo, automatic?: Partial<IJoinServerOptions>): void;
     clearServerToJoin(): void;
-    shouldAutomaticallyJoinServer(): boolean | undefined;
+    shouldAutomaticallyJoinServer(): Partial<IJoinServerOptions> | undefined;
     processDedicatedServerBackups(force?: boolean): Promise<boolean>;
     protected onGlobalSlotLoaded(): void;
     writeBackup(slot: number, data: Uint8Array): Promise<string | undefined>;

package/definitions/hosts/shared/interfaces.d.ts

@@ -94,6 +94,7 @@ export interface ISteamworks {
     showFloatingGamepadTextInput(nTextFieldXPosition: number, nTextFieldYPosition: number, nTextFieldWidth: number, nTextFieldHeight: number): boolean;
     dismissFloatingGamepadTextInput(): boolean;
     setFloatingGamepadTextInputDismissedCallback(cb: () => void): void;
+    getInputType(): SteamInputType;
 }
 export interface ISteamworksNetworking {
     initRelayNetworkAccess(): undefined;
@@ -263,3 +264,22 @@ export declare enum LobbyType {
     Public = 2,
     Invisible = 3
 }
+export declare enum SteamInputType {
+    k_ESteamInputType_Unknown = 0,
+    k_ESteamInputType_SteamController = 1,
+    k_ESteamInputType_XBox360Controller = 2,
+    k_ESteamInputType_XBoxOneController = 3,
+    k_ESteamInputType_GenericGamepad = 4,
+    k_ESteamInputType_PS4Controller = 5,
+    k_ESteamInputType_AppleMFiController = 6,
+    k_ESteamInputType_AndroidController = 7,
+    k_ESteamInputType_SwitchJoyConPair = 8,
+    k_ESteamInputType_SwitchJoyConSingle = 9,
+    k_ESteamInputType_SwitchProController = 10,
+    k_ESteamInputType_MobileTouch = 11,
+    k_ESteamInputType_PS3Controller = 12,
+    k_ESteamInputType_PS5Controller = 13,
+    k_ESteamInputType_SteamDeckController = 14,
+    k_ESteamInputType_Count = 15,
+    k_ESteamInputType_MaximumPossibleValue = 255
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@wayward/types",
 	"description": "TypeScript declarations for Wayward, used for modding.",
-	"version": "2.12.1-beta.dev.20221027.1",
+	"version": "2.12.1-beta.dev.20221028.1",
 	"license": "MIT",
 	"repository": {
 		"type": "git",