@wayward/types 2.11.1-beta.dev.20211228.1 → 2.11.1-beta.dev.20211231.2

package/definitions/game/IGlobal.d.ts

@@ -61,7 +61,6 @@ declare global {
     let saveManager: SaveManager;
     let steamworks: Steamworks;
     let ui: Ui;
-    const gc: ((options?: any) => Promise<void> | void) | undefined;
     const gameVersion: string;
     const gameVersionStage: string;
     const gameVersionMajor: number;

package/definitions/game/game/Game.d.ts

@@ -165,7 +165,8 @@ export declare class Game extends EventEmitter.Host<IGameEvents> {
      * This method should be able to be called multiple times in a row and nothing unexpected should occur.
      * @param saveType Saves the game with the specified save type. Set to false to not save. Defaults to BackToMainMenu.
      * @param shouldDisconnect Marks if the game should disconnect from multiplayer. Defaults to true.
+     * @param hasDisconnected Marks if the game just disconnected from multiplayer. Defaults to false.
      */
-    reset(saveType?: SaveType | false, shouldDisconnect?: boolean): Promise<void>;
+    reset(saveType?: SaveType | false, shouldDisconnect?: boolean, hasDisconnected?: boolean): Promise<void>;
     fastForwardIsland(island: Island, ticks: number, multiplayerLoadingDescription?: MultiplayerLoadingDescription): Promise<void>;
 }

package/definitions/game/game/doodad/DoodadManager.d.ts

@@ -39,10 +39,10 @@ export interface IDoodadManagerEvents {
     remove(doodad: Doodad): any;
 }
 export default class DoodadManager extends ObjectManager<Doodad, IDoodadManagerEvents> {
-    private readonly scarecrows;
     private static cachedBestDoodadForTier;
     private static cachedGroups;
     private static cachedDoodadSpawns;
+    private readonly scarecrows;
     static getBestDoodadForTier(doodad: DoodadType | DoodadTypeGroup): DoodadType | undefined;
     static generateLookups(): void;
     static isGroup(doodadType: DoodadType | DoodadTypeGroup): doodadType is DoodadTypeGroup;
@@ -50,7 +50,10 @@ export default class DoodadManager extends ObjectManager<Doodad, IDoodadManagerE
     static getGroupDoodads(doodadGroup: DoodadTypeGroup): Set<DoodadType>;
     static getDoodadTypeGroupName(doodadType: DoodadType | DoodadTypeGroup, article?: boolean, count?: number): Translation;
     delete(): void;
-    load(): void;
+    /**
+     * Note: This can be called multiple times in the same game depending on loading/unloading of islands
+     */
+    load(hasLoadedBefore: boolean): void;
     isGroup(doodadType: DoodadType | DoodadTypeGroup): doodadType is DoodadTypeGroup;
     isInGroup(doodadType: DoodadType, doodadGroup: DoodadTypeGroup | DoodadType): boolean;
     getBestDoodadForTier(doodad: DoodadType | DoodadTypeGroup): DoodadType | undefined;

package/definitions/game/game/island/Island.d.ts

@@ -86,6 +86,11 @@ export default class Island extends EventEmitter.Host<IIslandEvents> implements
     loadCount: number;
     seeds: ISeeds;
     readonly seededRandom: Random<SeededGenerator>;
+    /**
+     * Random for milestone modifiers. You should only use the one in the default island
+     * todo: remove since this is no longer used
+     */
+    readonly seededMilestoneModifiersRandom: Random<SeededGenerator>;
     /**
      * Set of players on this island
      */
@@ -106,6 +111,7 @@ export default class Island extends EventEmitter.Host<IIslandEvents> implements
     get id(): `${number},${number}`;
     get biome(): import("game/biome/IBiome").IBiomeDescription;
     get isLoaded(): boolean;
+    get hasLoadedItemReferences(): boolean;
     get isLocalIsland(): boolean;
     get world(): World;
     /**

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

@@ -184,6 +184,10 @@ export interface IItemDescription extends IObjectDescription, IModdable, ITemper
     plural?: string;
     hideHelmet?: boolean;
     worth?: number;
+    /**
+     * 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.
+     */
     burnsLike?: ItemType[];
     spawnableTiles?: TileGroup;
     gather?: ILiquid;
@@ -279,10 +283,13 @@ export interface IMoveToTileOptions {
     fromPoint?: IVector3;
     toPoint: IVector3;
     toContainer?: IContainer;
+    beforeMovement?: IMoveToTileBeforeMovementOptions;
     afterMovement?: IMoveToTileAfterMovementOptions;
 }
-export interface IMoveToTileAfterMovementOptions {
+export interface IMoveToTileBeforeMovementOptions {
     remove?: boolean;
+}
+export interface IMoveToTileAfterMovementOptions {
     soundEffect?: SfxType;
     particles?: IRGB;
 }

package/definitions/game/game/meta/Loading.d.ts

@@ -128,17 +128,19 @@ declare module Loading {
          */
         progress(load: Load, progress: number): any;
         /**
-         * Emitted when a thing has finished loading
+         * Emitted when a load has finished loading.
+         * Either this or "cancel" will be called when a load is done
          */
         step(...loaded: Load[]): any;
         /**
-         * Emitted when all things have finished loading
+         * Emitted when a load has been cancelled.
+         * Either this or "step"" will be called when a load is done
          */
-        end(...loaded: Load[]): any;
+        cancel(load: Load): any;
         /**
-         * Emitted when a load has been cancelled
+         * Emitted when all things have finished loading
          */
-        cancel(load: Load): any;
+        end(...loaded: Load[]): any;
     }
     const currently: Map<Load, any[]>;
     class Events extends EventEmitter.Host<ILoadingEvents> {
@@ -161,7 +163,10 @@ declare module Loading {
      * Returns a promise that will resolve when the load is complete, and reject if the load is cancelled.
      */
     function waitFor(load: Load): Promise<void>;
+    /**
+     * Returns a promise that will resolve when all running loads are complete.
+     */
+    function waitForAll(): Promise<void>;
     function progress(load: Load, progress: number): Promise<void>;
-    function done(): Promise<void>;
 }
 export default Loading;

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

@@ -28,11 +28,11 @@ export interface IMultiplayerEvents {
     checkConnection(webRtcWorks: boolean, webSocketWorks: boolean): any;
 }
 export declare enum MultiplayerSyncCheckLevel {
-    None = 0,
-    Normal = 1,
-    Extended = 2,
-    Verbose = 3,
-    All = 4
+    None = "none",
+    Normal = "normal",
+    Extended = "extended",
+    Verbose = "verbose",
+    All = "all"
 }
 export declare enum MultiplayerSyncCheck {
     Action = 0,

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

@@ -12,7 +12,7 @@ import EventEmitter from "event/EventEmitter";
 import Player from "game/entity/player/Player";
 import type Island from "game/island/Island";
 import type { IJoinServerOptions, IMultiplayerEvents, IMultiplayerOptions, PacketTarget, ServerInfo } from "multiplayer/IMultiplayer";
-import { DisconnectReason, JoinServerRetryReason, MultiplayerSyncCheck, UnableToJoinReason } from "multiplayer/IMultiplayer";
+import { DisconnectReason, JoinServerRetryReason, MultiplayerSyncCheck, UnableToJoinReason, MultiplayerSyncCheckLevel } from "multiplayer/IMultiplayer";
 import type { IMatchmakingInfo } from "multiplayer/matchmaking/IMatchmaking";
 import type { IConnection } from "multiplayer/networking/IConnection";
 import type { IPacket } from "multiplayer/packets/IPacket";
@@ -65,6 +65,13 @@ export default class Multiplayer extends EventEmitter.Host<IMultiplayerEvents> {
     getOptions(): IMultiplayerOptions;
     setOptions(options: IMultiplayerOptions, updateGame?: boolean): void;
     updateOptions(updates: Partial<IMultiplayerOptions>): void;
+    /**
+     * Helper method for updating sync checks
+     * multiplayer.updateSyncChecks("normal")
+     * multiplayer.updateSyncChecks("verbose")
+     */
+    updateSyncChecks(syncChecks: boolean | MultiplayerSyncCheckLevel | MultiplayerSyncCheck[]): void;
+    private parseSyncChecks;
     enableSteamNetworkConnections(enable: boolean): void;
     getConnectedMatchmakingInfo(): IMatchmakingInfo | undefined;
     /**

package/definitions/game/multiplayer/networking/Connection.d.ts

@@ -47,7 +47,6 @@ export declare abstract class Connection implements IConnection {
     sendKeepAlive(): void;
     getState(): ConnectionState;
     setState(state: ConnectionState): void;
-    serializePacket(packet: IPacket): ArrayBuffer;
     /**
      * Queues a packet to be sent soon
      * Note: packets are serialized when queued
@@ -56,7 +55,7 @@ export declare abstract class Connection implements IConnection {
     /**
      * Queues data to be sent soon
      */
-    protected queuePacketData(data: ArrayBuffer): void;
+    protected queuePacketData(data: ArrayBuffer, packetNumber?: number): void;
     /**
      * Clears queued packets
      */
@@ -73,6 +72,7 @@ export declare abstract class Connection implements IConnection {
      * Sends queued data to the connection w/ flow control
      */
     private _processQueuedData;
+    private _serializePacket;
     abstract readonly maxMessageSize: number;
     abstract isConnected(): boolean;
     protected abstract onClosing(): void;

package/definitions/game/multiplayer/networking/IConnection.d.ts

@@ -69,5 +69,6 @@ export interface IConnection {
 export interface IQueuedData {
     data: ArrayBuffer;
     byteOffset: number;
+    packetNumber?: number;
     retries?: number;
 }

package/definitions/game/multiplayer/packets/IPacket.d.ts

@@ -31,7 +31,8 @@ export interface IPacket<T = any> {
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): T;
-    processData(dataView: DataView): void;
+    processSerializedData(dataView: DataView): void;
+    serializeData(): void;
 }
 export declare enum NetworkPropertyType {
     Bool = 0,

package/definitions/game/multiplayer/packets/Packet.d.ts

@@ -15,13 +15,15 @@ import type { IPacket, ISynchronizationCheckData } from "multiplayer/packets/IPa
 export declare abstract class Packet<T = void> extends IndexedPacket implements IPacket<T> {
     protected synchronizationCheckData: ISynchronizationCheckData;
     private _arrayBuffer;
-    getDebugInfo(): string;
+    private _serializedDataByteOffset;
+    abstract getDebugInfo(): string;
     getAllowedStates(): ConnectionState;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     getSynchronizationCheckData(): ISynchronizationCheckData;
     getArrayBuffer(id?: number): ArrayBuffer;
-    processData(dataView: DataView): void;
+    serializeData(): number;
+    processSerializedData(dataView: DataView): void;
     abstract process(): T;
     send(exclude?: PacketTarget): void;
     sendTo(to: PacketTarget, force?: boolean): void;

package/definitions/game/multiplayer/packets/client/AddPlayerPacket.d.ts

@@ -12,5 +12,6 @@ import type { IPlayerOptions } from "game/IGame";
 import ClientPacket from "multiplayer/packets/ClientPacket";
 export default class AddPlayerPacket extends ClientPacket<number> {
     playerOptions: IPlayerOptions;
+    getDebugInfo(): string;
     process(): number;
 }

package/definitions/game/multiplayer/packets/client/CaughtUpPacket.d.ts

@@ -14,5 +14,6 @@ import ClientPacket from "multiplayer/packets/ClientPacket";
  * Tell the server to mark us as ready
  */
 export default class CaughtUpPacket extends ClientPacket {
+    getDebugInfo(): string;
     process(): void;
 }

package/definitions/game/multiplayer/packets/client/ClearSyncPacketWaitingPacket.d.ts

@@ -11,6 +11,7 @@
 import ClientPacket from "multiplayer/packets/ClientPacket";
 export default class ClearSyncPacketWaitingPacket extends ClientPacket {
     waitId: string;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/client/DisplayInterruptPacket.d.ts

@@ -14,5 +14,6 @@ export default class DisplayInterruptPacket extends ClientPacket {
     prompt: Prompt;
     args: any[];
     extraData: any;
+    getDebugInfo(): string;
     process(): Promise<void>;
 }

package/definitions/game/multiplayer/packets/client/EmitPlayerEventPacket.d.ts

@@ -15,5 +15,6 @@ export declare enum EmitPlayerEventType {
 }
 export default class EmitPlayerEventPacket extends PlayerTargetedClientPacket {
     type: EmitPlayerEventType;
+    getDebugInfo(): string;
     process(): void;
 }

package/definitions/game/multiplayer/packets/client/HideLoadingScreenPacket.d.ts

@@ -12,6 +12,7 @@ import type { Load } from "game/meta/Loading";
 import ClientPacket from "multiplayer/packets/ClientPacket";
 export default class HideLoadingScreenPacket extends ClientPacket {
     load: Load;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     process(): void;
 }

package/definitions/game/multiplayer/packets/client/LoadIslandPacket.d.ts

@@ -12,6 +12,7 @@ import type { IslandId } from "game/island/IIsland";
 import ClientPacket from "multiplayer/packets/ClientPacket";
 export default class LoadIslandPacket extends ClientPacket<Promise<void>> {
     islandId: IslandId;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     process(): Promise<void>;
 }

package/definitions/game/multiplayer/packets/client/PausePacket.d.ts

@@ -12,5 +12,6 @@ import ClientPacket from "multiplayer/packets/ClientPacket";
 export default class PausePacket extends ClientPacket {
     paused: boolean;
     showChatMessage: boolean;
+    getDebugInfo(): string;
     process(): void;
 }

package/definitions/game/multiplayer/packets/client/PongPacket.d.ts

@@ -11,5 +11,6 @@
 import ClientPacket from "multiplayer/packets/ClientPacket";
 export default class PongPacket extends ClientPacket {
     sendTime: number;
+    getDebugInfo(): string;
     process(): void;
 }

package/definitions/game/multiplayer/packets/client/ReadyPlayerPacket.d.ts

@@ -10,5 +10,6 @@
  */
 import PlayerTargetedClientPacket from "multiplayer/packets/PlayerTargetedClientPacket";
 export default class ReadyPlayerPacket extends PlayerTargetedClientPacket {
+    getDebugInfo(): string;
     process(): void;
 }

package/definitions/game/multiplayer/packets/client/RemovePlayerPacket.d.ts

@@ -12,5 +12,6 @@ import { DisconnectReason } from "multiplayer/IMultiplayer";
 import PlayerTargetedClientPacket from "multiplayer/packets/PlayerTargetedClientPacket";
 export default class RemovePlayerPacket extends PlayerTargetedClientPacket {
     reason: DisconnectReason;
+    getDebugInfo(): string;
     process(): void;
 }

package/definitions/game/multiplayer/packets/client/SendMessagePacket.d.ts

@@ -15,5 +15,6 @@ export default class SendMessagePacket extends ClientPacket {
     source: Source;
     message: Message;
     args: any[];
+    getDebugInfo(): string;
     process(): Promise<void>;
 }

package/definitions/game/multiplayer/packets/client/SetPlayerZPacket.d.ts

@@ -11,5 +11,6 @@
 import PlayerTargetedClientPacket from "multiplayer/packets/PlayerTargetedClientPacket";
 export default class SetPlayerZPacket extends PlayerTargetedClientPacket {
     z: number;
+    getDebugInfo(): string;
     process(): void;
 }

package/definitions/game/multiplayer/packets/client/ShowLoadingScreenPacket.d.ts

@@ -14,6 +14,7 @@ import { ScreenId } from "ui/screen/IScreen";
 export default class ShowLoadingScreenPacket extends ClientPacket {
     load: Load;
     hideScreens?: ScreenId[];
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     process(): void;
 }

package/definitions/game/multiplayer/packets/client/SynchronizeGameStatePacket.d.ts

@@ -11,6 +11,7 @@
 import ClientPacket from "multiplayer/packets/ClientPacket";
 export default class SynchronizeGameStatePacket extends ClientPacket {
     serverGameState: Uint8Array;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     process(): void;
     protected getInitialBufferSize(): number;

package/definitions/game/multiplayer/packets/client/SynchronizeStatesPacket.d.ts

@@ -12,5 +12,6 @@ import type { ISynchronizeState } from "game/IGame";
 import ClientPacket from "multiplayer/packets/ClientPacket";
 export default class SynchronizeStatesPacket extends ClientPacket {
     state: ISynchronizeState;
+    getDebugInfo(): string;
     process(): void;
 }

package/definitions/game/multiplayer/packets/client/WorldPacket.d.ts

@@ -13,6 +13,7 @@ import { ConnectionState } from "multiplayer/networking/IConnection";
 import ClientPacket from "multiplayer/packets/ClientPacket";
 export default class WorldPacket extends ClientPacket<Promise<void>> {
     data: IMultiplayerWorldData;
+    getDebugInfo(): string;
     getAllowedStates(): ConnectionState;
     process(): Promise<void>;
     protected getInitialBufferSize(): number;

package/definitions/game/multiplayer/packets/server/AddMessageHistoryPacket.d.ts

@@ -12,6 +12,7 @@ import type { IMessageHistoryItem } from "game/entity/player/IMessageManager";
 import PlayerTargetedServerPacket from "multiplayer/packets/PlayerTargetedServerPacket";
 export default class AddMessageHistoryPacket extends PlayerTargetedServerPacket {
     messageHistoryItem: IMessageHistoryItem;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/server/ConnectPacket.d.ts

@@ -13,6 +13,7 @@ import { ConnectionState } from "multiplayer/networking/IConnection";
 import ServerPacket from "multiplayer/packets/ServerPacket";
 export default class ConnectPacket extends ServerPacket {
     playerOptions: IPlayerOptions;
+    getDebugInfo(): string;
     getAllowedStates(): ConnectionState;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/server/ConnectedPacket.d.ts

@@ -15,6 +15,7 @@ import ServerPacket from "multiplayer/packets/ServerPacket";
  * They probably still have packets to catch up on
  */
 export default class ConnectedPacket extends ServerPacket {
+    getDebugInfo(): string;
     getAllowedStates(): ConnectionState;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/server/DesyncPacket.d.ts

@@ -14,6 +14,7 @@ import ServerPacket from "multiplayer/packets/ServerPacket";
  */
 export default class DesyncPacket extends ServerPacket {
     logs: string;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/server/KeepAlivePacket.d.ts

@@ -14,6 +14,7 @@ import ServerPacket from "multiplayer/packets/ServerPacket";
  * If the server hasn't received this message for 15 seconds, the player is disconnected
  */
 export default class KeepAlivePacket extends ServerPacket {
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/server/LogsPacket.d.ts

@@ -12,6 +12,7 @@ import PlayerTargetedServerPacket from "multiplayer/packets/PlayerTargetedServer
 export default class LogsPacket extends PlayerTargetedServerPacket {
     logs: string;
     containsServerGameState: boolean | undefined;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/server/PingPacket.d.ts

@@ -11,6 +11,7 @@
 import ServerPacket from "multiplayer/packets/ServerPacket";
 export default class PingPacket extends ServerPacket {
     sendTime: number;
+    getDebugInfo(): string;
     isAllowedWhenPaused(): boolean;
     process(): void;
 }

package/definitions/game/multiplayer/packets/server/ReadyPacket.d.ts

@@ -15,6 +15,7 @@ import ServerPacket from "multiplayer/packets/ServerPacket";
  * We can now mark the player as ready
  */
 export default class ReadyPacket extends ServerPacket {
+    getDebugInfo(): string;
     getAllowedStates(): ConnectionState;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/server/UiDataUpdatePacket.d.ts

@@ -13,5 +13,6 @@ import PlayerTargetedServerPacket from "multiplayer/packets/PlayerTargetedServer
 export default class UiDataUpdatePacket extends PlayerTargetedServerPacket {
     static create(player: Player, updates: Map<string | number, Record<string, any>>): UiDataUpdatePacket;
     updates: Map<string | number, Record<string, any>>;
+    getDebugInfo(): string;
     process(): void;
 }

package/definitions/game/multiplayer/packets/server/UpdateDialogInfoPacket.d.ts

@@ -13,6 +13,7 @@ import type { IDialogInfo } from "ui/old/IOldUi";
 export default class UpdateDialogInfoPacket extends PlayerTargetedServerPacket {
     index: string | number;
     info: IDialogInfo;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/server/UpdateQuickSlotInfoPacket.d.ts

@@ -13,6 +13,7 @@ import type { IQuickSlotInfo } from "ui/old/IOldUi";
 export default class UpdateQuickSlotInfoPacket extends PlayerTargetedServerPacket {
     quickSlot: number;
     quickSlotInfo: IQuickSlotInfo | undefined;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/shared/ChatMessagePacket.d.ts

@@ -11,6 +11,7 @@
 import PlayerTargetedSharedPacket from "multiplayer/packets/PlayerTargetedSharedPacket";
 export default class ChatMessagePacket extends PlayerTargetedSharedPacket {
     message: string;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/shared/DisconnectPacket.d.ts

@@ -12,6 +12,7 @@ import { DisconnectReason } from "multiplayer/IMultiplayer";
 import SharedPacket from "multiplayer/packets/SharedPacket";
 export default class DisconnectPacket extends SharedPacket {
     reason: DisconnectReason;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/shared/DiscoverRecipePacket.d.ts

@@ -14,6 +14,7 @@ export default class DiscoverRecipePacket extends PlayerTargetedSharedPacket {
     recipeType: ItemType;
     newUnlock: boolean;
     unlockTime: number;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/multiplayer/packets/shared/MarkAsExploredPacket.d.ts

@@ -12,6 +12,7 @@ import PlayerTargetedSharedPacket from "multiplayer/packets/PlayerTargetedShared
 import type { IVector2 } from "utilities/math/IVector";
 export default class MarkAsExploredPacket extends PlayerTargetedSharedPacket {
     points: IVector2[];
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     process(): void;
 }

package/definitions/game/multiplayer/packets/shared/UpdateMovementIntentPacket.d.ts

@@ -12,6 +12,7 @@ import type { IMovementIntent } from "game/entity/player/IPlayer";
 import PlayerTargetedSharedPacket from "multiplayer/packets/PlayerTargetedSharedPacket";
 export default class UpdateMovementIntentPacket extends PlayerTargetedSharedPacket {
     intent: IMovementIntent;
+    getDebugInfo(): string;
     isAllowedWhenPaused(): boolean;
     process(): void;
 }

package/definitions/game/multiplayer/packets/shared/UpdateMultiplayerOptionsPacket.d.ts

@@ -12,6 +12,7 @@ import type { IMultiplayerOptions } from "multiplayer/IMultiplayer";
 import SharedPacket from "multiplayer/packets/SharedPacket";
 export default class UpdateMultiplayerOptionsPacket extends SharedPacket {
     options: IMultiplayerOptions;
+    getDebugInfo(): string;
     isAllowedWhenPaused(): boolean;
     process(): void;
 }

package/definitions/game/multiplayer/packets/shared/UpdateWalkPathPacket.d.ts

@@ -13,6 +13,7 @@ import type { IVector2 } from "utilities/math/IVector";
 export default class UpdateWalkPathPacket extends PlayerTargetedSharedPacket {
     path: IVector2[] | undefined;
     force: boolean | undefined;
+    getDebugInfo(): string;
     isSyncCheckEnabled(): boolean;
     isAllowedWhenPaused(): boolean;
     process(): void;

package/definitions/game/ui/component/dropdown/EnumDropdown.d.ts

@@ -9,6 +9,7 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type Dictionary from "language/Dictionary";
+import type Button from "ui/component/Button";
 import type { IDropdownOption } from "ui/component/Dropdown";
 import Dropdown from "ui/component/Dropdown";
 export default class EnumDropdown<ENUM_OBJECT, OTHER_OPTIONS extends string | never = never, VALUES = ENUM_OBJECT[keyof ENUM_OBJECT]> extends Dropdown<VALUES | OTHER_OPTIONS> {
@@ -23,5 +24,5 @@ export default class EnumDropdown<ENUM_OBJECT, OTHER_OPTIONS extends string | ne
     setExcluded(...excluded: VALUES[]): this;
     protected getTranslation(id: VALUES): import("../../../language/impl/TranslationImpl").default;
     protected filterEnum?(id: VALUES): boolean;
-    private getOptions;
+    protected getOptions(enumObject: any): [VALUES, (option: Button) => Button][];
 }

package/definitions/game/ui/component/dropdown/PlayerDropdown.d.ts

@@ -8,9 +8,10 @@
  * 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 { IDropdownOption } from "ui/component/Dropdown";
-import EnumDropdown from "ui/component/dropdown/EnumDropdown";
-export default class PlayerDropdown<OTHER_OPTIONS extends string = never> extends EnumDropdown<Record<string, string>, OTHER_OPTIONS> {
-    constructor(defaultOption: string | OTHER_OPTIONS, options?: Iterable<IDropdownOption<OTHER_OPTIONS>>);
-    protected getTranslation(playerIdentifier: string): import("../../../language/impl/TranslationImpl").default;
+import type Button from "ui/component/Button";
+import Dropdown from "ui/component/Dropdown";
+export default class PlayerDropdown extends Dropdown<string> {
+    constructor(defaultOption: string);
+    get selectedPlayer(): import("../../../game/entity/player/Player").default | undefined;
+    protected getOptions(): [string, (option: Button) => Button][];
 }

package/definitions/game/utilities/Log.d.ts

@@ -37,49 +37,50 @@ export declare enum LogSource {
     ItemReference = 24,
     ItemStylesheet = 25,
     Languages = 26,
-    LocalStorageDataStorage = 27,
-    MapGen = 28,
-    Matchmaking = 29,
-    MatchmakingServer = 30,
-    MemoryLeakDetector = 31,
-    Message = 32,
-    Mod = 33,
-    Mods = 34,
-    Multiplayer = 35,
-    NPC = 36,
-    NPCManager = 37,
-    OldUi = 38,
-    Packet = 39,
-    Player = 40,
-    PlayerManager = 41,
-    Prompts = 42,
-    Reflow = 43,
-    Renderer = 44,
-    ReplayManager = 45,
-    ResourceLoader = 46,
-    SaveManager = 47,
-    Serializer = 48,
-    Shaders = 49,
-    SoundEffect = 50,
-    SpritePack = 51,
-    SshCommandManager = 52,
-    SshServer = 53,
-    Steamworks = 54,
-    StringTokenizer = 55,
-    TemperatureManager = 56,
-    TileEventManager = 57,
-    TileUpdate = 58,
-    Timer = 59,
-    Trello = 60,
-    Ui = 61,
-    Utilities = 62,
-    WebAssembly = 63,
-    WebGlContext = 64,
-    WebRTCConnection = 65,
-    WebSocketConnection = 66,
-    World = 67,
-    WorldLayerRenderer = 68,
-    WorldRenderer = 69
+    Loading = 27,
+    LocalStorageDataStorage = 28,
+    MapGen = 29,
+    Matchmaking = 30,
+    MatchmakingServer = 31,
+    MemoryLeakDetector = 32,
+    Message = 33,
+    Mod = 34,
+    Mods = 35,
+    Multiplayer = 36,
+    NPC = 37,
+    NPCManager = 38,
+    OldUi = 39,
+    Packet = 40,
+    Player = 41,
+    PlayerManager = 42,
+    Prompts = 43,
+    Reflow = 44,
+    Renderer = 45,
+    ReplayManager = 46,
+    ResourceLoader = 47,
+    SaveManager = 48,
+    Serializer = 49,
+    Shaders = 50,
+    SoundEffect = 51,
+    SpritePack = 52,
+    SshCommandManager = 53,
+    SshServer = 54,
+    Steamworks = 55,
+    StringTokenizer = 56,
+    TemperatureManager = 57,
+    TileEventManager = 58,
+    TileUpdate = 59,
+    Timer = 60,
+    Trello = 61,
+    Ui = 62,
+    Utilities = 63,
+    WebAssembly = 64,
+    WebGlContext = 65,
+    WebRTCConnection = 66,
+    WebSocketConnection = 67,
+    World = 68,
+    WorldLayerRenderer = 69,
+    WorldRenderer = 70
 }
 export declare enum LogLineType {
     Debug = 0,

package/definitions/game/utilities/random/Random.d.ts

@@ -132,7 +132,6 @@ export declare module RandomReference {
 export declare function getRandom(randomInstance: RandomInstance, islandId?: IslandId): Random<SeededGenerator>;
 export declare function createSeededRandom(seed?: number, addMultiplayerSyncChecks?: boolean): Random<SeededGenerator>;
 export declare const mapGenRandom: Random<SeededGenerator>;
-export declare const randomMilestoneModifiers: Random<SeededGenerator>;
 export declare const generalRandom: Random<{
     get: () => number;
 }>;

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

@@ -8,4 +8,6 @@
  * 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
  */
+export declare const gameVersionStage = "beta", gameVersionMajor = 2, gameVersionMinor = 11, gameVersionPatch = 1, gameVersionName = "Horizons";
+export declare const gameVersion: string;
 export declare function registerGlobals(globalObject: any): void;

package/definitions/test/core/applicationDom.d.ts

@@ -23,7 +23,7 @@ export default class ApplicationDom {
     clickIfVisibleElement(selector: string): Promise<WebdriverIO.Element | undefined>;
     getVisibleElements(selector: string): Promise<WebdriverIO.Element[] | undefined>;
     getVisibleAndClickableElement(selector: string): Promise<WebdriverIO.Element | undefined>;
-    waitForVisibleThenClick(selector: string, timeout?: number, indent?: boolean): Promise<void>;
+    waitForVisibleThenClick(selector: string, timeout?: number, indent?: boolean, clickOnce?: boolean): Promise<void>;
     waitForVisibleElements(selector: string, timeout?: number): Promise<WebdriverIO.Element[]>;
     waitForNotVisible(selector: string, timeout?: number): Promise<void>;
     waitUntil(executor: () => Promise<boolean>, options: webdriverio.WaitUntilOptions): Promise<true | void>;

package/definitions/test/core/applicationInteractions.d.ts

@@ -12,8 +12,7 @@
 import type { Stat } from "../../game/game/entity/IStats";
 import { Direction } from "../../game/utilities/math/Direction";
 import type { Random, SeededGenerator } from "../../game/utilities/random/Random";
-import type { INewGameOptions } from "../interfaces";
-import { GameMode } from "../interfaces";
+import type { IDedicatedServerGameOptions, INewGameOptions } from "../interfaces";
 import type { IslandId } from "../../game/game/island/IIsland";
 import ApplicationDom from "./applicationDom";
 import ApplicationLogger from "./applicationLogger";
@@ -26,12 +25,15 @@ export default class ApplicationInteractions {
     private readonly savedStates;
     constructor(additionalArgs: string[], random: Random<SeededGenerator>);
     waitForInitialStartup(expectedInitialScreen: "title" | "mp_gameplay_modifiers"): Promise<void>;
-    waitUntilLoadingIsFinished(): Promise<void>;
-    playDedicatedServer(gameMode?: GameMode): Promise<void>;
+    waitUntilLoadingIsFinished(expectedMultiplayerMenu?: boolean): Promise<void>;
+    playDedicatedServer(options: IDedicatedServerGameOptions): Promise<void>;
     playNewGame(options: INewGameOptions): Promise<void>;
+    private setupCommonOptions;
+    unlockMilestoneModifiers(): Promise<void>;
     playImportedGame(savePath: string): Promise<void>;
     playContinueGame(): Promise<void>;
     quitGame(): Promise<void>;
+    clickOptions(): Promise<void>;
     clickNewGame(): Promise<void>;
     clickLoadGame(): Promise<void>;
     clickConfirm(): Promise<void>;
@@ -41,7 +43,11 @@ export default class ApplicationInteractions {
     clickJoinServer(): Promise<void>;
     clickDailyChallenge(): Promise<void>;
     clickBack(timeout?: number): Promise<void>;
-    clickButton(name: string, timeout?: number): Promise<void>;
+    clickButton(name: string, options?: Partial<{
+        force: boolean;
+        clickOnce: boolean;
+        timeout: number;
+    }>): Promise<void>;
     clickYesIfVisible(): Promise<boolean>;
     clickButtonIfVisible(name: string): Promise<boolean>;
     clickUnpauseIconIfVisible(): Promise<void>;
@@ -71,13 +77,19 @@ export default class ApplicationInteractions {
     saveStateAndVerifyWithPrevious(): Promise<void>;
     clearSavedStates(): void;
     waitUntilPauseMenuIsShown(): Promise<void>;
-    waitUntilGameIsLoaded(isJoiningServer?: boolean): Promise<void>;
+    waitUntilGameIsLoaded(options?: Partial<{
+        isJoiningServer: boolean;
+        isCreatingServer: boolean;
+    }>): Promise<void>;
     isTitleScreenVisible(): Promise<WebdriverIO.Element[] | undefined>;
     isButtonVisible(text: string): Promise<WebdriverIO.Element[] | undefined>;
     isOverlayVisible(): Promise<WebdriverIO.Element[] | undefined>;
     waitUntilTitleScreenIsVisible(): Promise<void>;
     waitUntilGameEndMenuIsVisible(): Promise<void>;
-    waitForVisibleButtonThenClick(name: string, timeout?: number): Promise<void>;
+    waitForVisibleButtonThenClick(name: string, options?: Partial<{
+        clickOnce: boolean;
+        timeout: number;
+    }>): Promise<void>;
     increaseStat(stat: Stat, value: number): Promise<void>;
     randomInput(count: number): Promise<void>;
     pressKey(key: string, modifier?: string): Promise<void>;

package/definitions/test/core/applicationManager.d.ts

@@ -10,7 +10,7 @@
  */
 import type Player from "../../game/game/entity/player/Player";
 import { Direction } from "../../game/utilities/math/Direction";
-import type { GameMode } from "../interfaces";
+import type { INewGameOptions } from "../interfaces";
 import type { IDifferences } from "../../game/utilities/object/JsonHelper";
 import type Application from "./application";
 import type { ITestState } from "./application";
@@ -62,7 +62,7 @@ export declare class Apps {
     getLog(): string[];
     compileDifferences(client: string | number, differences: IDifferences): string;
     verifyGameStates(): Promise<void>;
-    createMultiplayerGame(gameMode: GameMode): Promise<void>;
+    createMultiplayerGame(options: Omit<INewGameOptions, "playMode">): Promise<void>;
     setClientJoinIsland(x: number, y: number): Promise<void>;
     getServerGameCode(): Promise<string>;
     joinServer(...apps: Application[]): Promise<void>;

package/definitions/test/interfaces.d.ts

@@ -8,12 +8,16 @@
  * 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
  */
-export interface INewGameOptions {
+export interface ICommonGameOptions {
     gameMode: GameMode;
+    seed?: string | number;
+    enableAllMilestoneModifiers?: boolean;
+}
+export interface INewGameOptions extends ICommonGameOptions {
     playMode: GamePlayMode;
     reuseCharacter?: boolean;
-    seed?: string | number;
 }
+export declare type IDedicatedServerGameOptions = ICommonGameOptions;
 export declare enum GameMode {
     Hardcore = "Hardcore Mode",
     Casual = "Casual Mode",

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@wayward/types",
 	"description": "TypeScript declarations for Wayward, used for modding.",
-	"version": "2.11.1-beta.dev.20211228.1",
+	"version": "2.11.1-beta.dev.20211231.2",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -14,6 +14,8 @@
 		"watch": "tsc --build"
 	},
 	"dependencies": {
+		"@types/fs-extra": "^9.0.13",
+		"@types/node": "^17.0.5",
 		"@wayward/goodstream": "0.7.1"
 	},
 	"devDependencies": {