@wayward/types 2.11.1-beta.dev.20211227.1 → 2.11.1-beta.dev.20211231.1

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/entity/action/actions/Navigate.d.ts

@@ -12,3 +12,4 @@ import { Action } from "game/entity/action/Action";
 import { ActionArgument } from "game/entity/action/IAction";
 declare const _default: Action<[[ActionArgument.ItemInventory, ActionArgument.Undefined]], import("../../player/Player").default, void, [(import("../../../item/Item").default | undefined)?]>;
 export default _default;
+export declare function getCoordinatesTranslationArgs(x: number, y: number): any[];

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;