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

package/definitions/cplusplus/index.d.ts

@@ -17,21 +17,17 @@ export interface IWaywardCPP {
     DijkstraMap: IDijkstraMapConstructor;
     FieldOfView: any;
     FlowField: IFlowFieldConstructor;
-    Game: IWaywardCPPGame;
     KDTree: IKDTreeConstructor;
     Navigation: INavigationConstructor;
     WorldLayer: IWorldLayerConstructor;
 }
-export type IFlowFieldConstructor = new (x: number, y: number, size: number, z: number, moveType: number) => IWaywardCPPFlowField;
+export type IFlowFieldConstructor = new (x: number, y: number, mapSize: number, size: number, z: number, moveType: number) => IWaywardCPPFlowField;
 export type IByteGridConstructor = new (width: number, height: number) => IByteGrid;
 export type IBitGridConstructor = new (count: number) => IBitGrid;
-export type IDijkstraMapConstructor = new () => IDijkstraMap;
-export type IKDTreeConstructor = new () => IKDTree;
-export type INavigationConstructor = new (autoConnect: boolean) => INavigation;
-export type IWorldLayerConstructor = new (width: number, height: number, level: number) => IWorldLayerCPP;
-export interface IWaywardCPPGame {
-    setMapSize(size: number): void;
-}
+export type IDijkstraMapConstructor = new (mapSize: number) => IDijkstraMap;
+export type IKDTreeConstructor = new (mapSize: number) => IKDTree;
+export type INavigationConstructor = new (mapSize: number, autoConnect: boolean) => INavigation;
+export type IWorldLayerConstructor = new (islandX: number, islandY: number, width: number, height: number, level: number) => IWorldLayerCPP;
 export interface IWaywardCPPFlowField {
     delete(): void;
     reset(): void;

package/definitions/game/IGlobal.d.ts

@@ -12,22 +12,17 @@ import "@cplusplus/index";
 import "@hosts/shared/globalTypes";
 import "@wayward/goodstream/apply";
 import type WAudio from "audio/Audio";
-import type CommandManager from "command/CommandManager";
 import type Player from "game/entity/player/Player";
-import type PlayerManager from "game/entity/player/PlayerManager";
 import type { Game } from "game/Game";
 import type Island from "game/island/Island";
 import type { ItemType } from "game/item/IItem";
 import type LanguageManager from "language/LanguageManager";
-import type ModManager from "mod/ModManager";
 import type { IMultiplayerNetworkingOptions } from "multiplayer/IMultiplayer";
 import type Multiplayer from "multiplayer/Multiplayer";
 import type Renderer from "renderer/Renderer";
 import type Renderers from "renderer/Renderers";
 import type SaveData from "save/data/SaveData";
 import type SaveDataGlobal from "save/data/SaveDataGlobal";
-import type SaveManager from "save/SaveManager";
-import type Steamworks from "steamworks/Steamworks";
 import "typings/jquery";
 import "typings/jqueryui";
 import type { ISortable, ISortableOptions } from "ui/old/functional/IFunctionalSortable";
@@ -42,25 +37,18 @@ import "utilities/typesglobal/Misc";
 import "utilities/typesglobal/Objects";
 import "utilities/typesglobal/Types";
 declare global {
-    let absentPlayers: Array<Player | undefined>;
     let audio: WAudio | undefined;
-    let commandManager: CommandManager;
     let game: Game;
     let languageManager: LanguageManager;
     let localIsland: Island;
     let localPlayer: Player;
-    let modManager: ModManager;
     let multiplayer: Multiplayer;
     let multiplayerNetworkingOptions: IMultiplayerNetworkingOptions;
     let oldui: OldUi;
-    let playerManager: PlayerManager;
-    let players: Array<Player | undefined>;
     let renderer: Renderer | undefined;
     let renderers: Renderers;
     let saveData: SaveData;
     let saveDataGlobal: SaveDataGlobal;
-    let saveManager: SaveManager;
-    let steamworks: Steamworks;
     let ui: Ui;
     const gameVersion: string;
     const gameVersionStage: string;

package/definitions/game/Uninit.d.ts

@@ -8,8 +8,14 @@
  * 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 function onBeforeUnloadAsynchronous(event?: {
-    preventDefault?: () => void;
-    returnValue?: boolean | string;
-}): Promise<void>;
-export declare function onBeforeUnloadSynchronous(event: Event): void;
+import type { Game } from "game/Game";
+export declare class Uninit {
+    private readonly game;
+    private unloading;
+    constructor(game: Game);
+    onBeforeUnloadAsynchronous(event?: {
+        preventDefault?: () => void;
+        returnValue?: boolean | string;
+    }): Promise<void>;
+    onBeforeUnloadSynchronous(event: Event): void;
+}

package/definitions/game/command/ICommand.d.ts

@@ -22,10 +22,11 @@ export declare enum Command {
     Banned = 2,
     Commands = 3,
     Kick = 4,
-    Pause = 5,
-    Ping = 6,
-    Players = 7,
-    Save = 8,
-    Sync = 9,
-    Unban = 10
+    Noclip = 5,
+    Pause = 6,
+    Ping = 7,
+    Players = 8,
+    Save = 9,
+    Sync = 10,
+    Unban = 11
 }

package/definitions/game/{game/entity/npc/npcs/IMerchant.d.ts → command/commands/Noclip.d.ts}

@@ -8,5 +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 type ICreditProperty = Map<string, number | undefined>;
-export type ITalkedProperty = Map<string, boolean | undefined>;
+import type { ICommand } from "command/ICommand";
+export declare const command: ICommand;
+export default command;

package/definitions/game/event/EventBuses.d.ts

@@ -18,6 +18,7 @@ import type Creature from "game/entity/creature/Creature";
 import type CreatureManager from "game/entity/creature/CreatureManager";
 import type Entity from "game/entity/Entity";
 import type EntityManager from "game/entity/EntityManager";
+import type EntityMovable from "game/entity/EntityMovable";
 import type Human from "game/entity/Human";
 import type NPC from "game/entity/npc/NPC";
 import type NPCManager from "game/entity/npc/NPCManager";
@@ -50,75 +51,81 @@ export declare enum EventBus {
     DoodadManager = 6,
     Doodads = 7,
     Entities = 8,
-    EntityManager = 9,
-    Game = 10,
-    Humans = 11,
-    Island = 12,
-    ItemManager = 13,
-    Items = 14,
-    Language = 15,
-    Loading = 16,
-    LocalIsland = 17,
-    LocalPlayer = 18,
-    Mods = 19,
-    Multiplayer = 20,
-    NPCManager = 21,
-    NPCs = 22,
-    PlayerManager = 23,
-    Players = 24,
-    Prompt = 25,
-    SaveManager = 26,
-    ScreenManager = 27,
-    Steamworks = 28,
-    TileEventManager = 29,
-    TileEvents = 30,
-    Ui = 31,
-    UiActionBar = 32,
-    UiMovementHandler = 33,
-    WorldRenderer = 34
+    EntitiesMovable = 9,
+    EntityManager = 10,
+    Game = 11,
+    Humans = 12,
+    Island = 13,
+    ItemManager = 14,
+    Items = 15,
+    Language = 16,
+    Loading = 17,
+    LocalIsland = 18,
+    LocalPlayer = 19,
+    Mods = 20,
+    Multiplayer = 21,
+    NPCManager = 22,
+    NPCs = 23,
+    PlayerManager = 24,
+    Players = 25,
+    Prompt = 26,
+    SaveManager = 27,
+    ScreenManager = 28,
+    Steamworks = 29,
+    TileEventManager = 30,
+    TileEvents = 31,
+    Ui = 32,
+    UiActionBar = 33,
+    UiMovementHandler = 34,
+    WorldRenderer = 35
 }
 declare const eventBuses: {
-    [EventBus.Actions](): typeof ActionExecutor;
-    [EventBus.Audio](): typeof Audio;
-    [EventBus.CorpseManager](): typeof CorpseManager;
-    [EventBus.Corpses](): typeof Corpse;
-    [EventBus.CreatureManager](): typeof CreatureManager;
-    [EventBus.Creatures](): typeof Creature;
-    [EventBus.DoodadManager](): typeof DoodadManager;
-    [EventBus.Doodads](): typeof Doodad;
-    [EventBus.Entities](): typeof Entity;
-    [EventBus.EntityManager](): typeof EntityManager;
-    [EventBus.Game](): typeof Game;
-    [EventBus.Humans](): typeof Human;
-    [EventBus.Island](): typeof Island;
-    [EventBus.ItemManager](): typeof ItemManager;
-    [EventBus.Items](): typeof Item;
-    [EventBus.Language](): typeof LanguageManager;
-    [EventBus.Loading](): typeof Loading.Events;
+    [EventBus.Actions](): ActionExecutor<any, any, any, any, any>;
+    [EventBus.Audio](): Audio;
+    [EventBus.CorpseManager](): CorpseManager;
+    [EventBus.Corpses](): Corpse;
+    [EventBus.CreatureManager](): CreatureManager;
+    [EventBus.Creatures](): Creature;
+    [EventBus.DoodadManager](): DoodadManager;
+    [EventBus.Doodads](): Doodad;
+    [EventBus.Entities](): Entity;
+    [EventBus.EntitiesMovable](): EntityMovable;
+    [EventBus.EntityManager](): EntityManager<any>;
+    [EventBus.Game](): Game;
+    [EventBus.Humans](): Human;
+    [EventBus.Island](): Island;
+    [EventBus.ItemManager](): ItemManager;
+    [EventBus.Items](): Item;
+    [EventBus.Language](): LanguageManager;
+    [EventBus.Loading](): Loading.Events;
     [EventBus.LocalIsland](): Island;
     [EventBus.LocalPlayer](): Player;
-    [EventBus.Mods](): typeof ModManager;
-    [EventBus.Multiplayer](): typeof Multiplayer;
-    [EventBus.NPCManager](): typeof NPCManager;
-    [EventBus.NPCs](): typeof NPC;
-    [EventBus.PlayerManager](): typeof PlayerManager;
-    [EventBus.Players](): typeof Player;
-    [EventBus.Prompt](): typeof Prompts.Events;
-    [EventBus.SaveManager](): typeof SaveManager;
-    [EventBus.ScreenManager](): typeof ScreenManager;
-    [EventBus.Steamworks](): typeof Steamworks;
-    [EventBus.TileEventManager](): typeof TileEventManager;
-    [EventBus.TileEvents](): typeof TileEvent;
+    [EventBus.Mods](): ModManager;
+    [EventBus.Multiplayer](): Multiplayer;
+    [EventBus.NPCManager](): NPCManager;
+    [EventBus.NPCs](): NPC;
+    [EventBus.PlayerManager](): PlayerManager;
+    [EventBus.Players](): Player;
+    [EventBus.Prompt](): Prompts.Events;
+    [EventBus.SaveManager](): SaveManager;
+    [EventBus.ScreenManager](): ScreenManager;
+    [EventBus.Steamworks](): Steamworks;
+    [EventBus.TileEventManager](): TileEventManager;
+    [EventBus.TileEvents](): TileEvent;
     [EventBus.Ui](): typeof ui;
-    [EventBus.UiActionBar](): typeof ActionBar;
-    [EventBus.UiMovementHandler](): typeof MovementHandler;
-    [EventBus.WorldRenderer](): typeof WorldRenderer;
+    [EventBus.UiActionBar](): ActionBar;
+    [EventBus.UiMovementHandler](): MovementHandler;
+    [EventBus.WorldRenderer](): WorldRenderer;
 };
+export interface IEventBusRegistration {
+    subscribe: NullaryFunction;
+    unsubscribe: NullaryFunction;
+}
 export default eventBuses;
 export declare module EventBus {
     function register<E extends EventBus>(eventBus: E, classOrHost: ReturnType<(typeof eventBuses)[E]>): void;
     function register(eventBus: EventBus): (constructor: AbstractNullaryClass<any>) => void;
     function unregister(eventBus: EventBus): void;
-    function onEventBusRegistration(eventBus: EventBus, handler: NullaryFunction): void;
+    function onEventBusRegistration(eventBus: EventBus, registration: IEventBusRegistration): void;
 }
 export type EventBusHost<E extends EventBus> = ReturnType<(typeof eventBuses)[E]>;

package/definitions/game/event/EventEmitter.d.ts

@@ -8,7 +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
  */
-import type Stream from "@wayward/goodstream";
 import { PriorityMap } from "utilities/collection/map/PriorityMap";
 export declare enum Priority {
     Lowest = -2000,
@@ -29,9 +28,10 @@ export interface IEventEmitterHost<E> {
 }
 export type IEventEmitterHostClass<E> = ClassOrAbstractClass<IEventEmitterHost<E>>;
 export type Events<T> = T extends IEventEmitterHost<infer E> ? E : T extends IEventEmitterHostClass<infer E> ? E : never;
+export type EventPriorityMap = PriorityMap<Set<ReadonlyArray<string | Handler<any, any>>>>;
 export interface ITrueEventEmitterHostClass<E> extends Class<any> {
     [SYMBOL_SUPERCLASSES]: Array<ITrueEventEmitterHostClass<E>>;
-    [SYMBOL_SUBSCRIPTIONS]: Map<any, Map<keyof E, PriorityMap<Set<Iterable<string | Handler<any, any>>>>>>;
+    [SYMBOL_SUBSCRIPTIONS]: Map<any, Map<keyof E, EventPriorityMap>>;
 }
 export interface ISelfSubscribedEmitter<E> {
     [SYMBOL_SUBSCRIPTIONS]: Array<[ISelfSubscribedEmitter<any>, keyof E, string | number | symbol, number?]>;
@@ -45,9 +45,12 @@ export interface IEventEmitter<H = any, E = any> {
     emit<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): H;
     emitFirst<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): UndefinedFromVoid<ReturnOf<E[K]>> | undefined;
     emitFirstDefault<K extends keyof E, D>(event: K, generateDefault: () => D, ...args: ArgsOf<E[K]>): Exclude<ReturnOf<E[K]>, null | undefined> | D;
-    emitStream<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Stream<ReturnOf<E[K]>>;
+    emitCollect<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Array<ReturnOf<E[K]>>;
     emitReduce<K extends keyof E, A extends ReturnOf<E[K]> & Head<ArgsOf<E[K]>>>(event: K, arg: A, ...args: Tail<ArgsOf<E[K]>>): Extract<ReturnOf<E[K]> & Head<ArgsOf<E[K]>>, undefined> extends undefined ? (undefined extends A ? ReturnOf<E[K]> : A) : ReturnOf<E[K]>;
-    emitAsync<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Promise<Stream<(Extract<ReturnOf<E[K]>, Promise<any>> extends Promise<infer R> ? R : never) | Exclude<ReturnOf<E[K]>, Promise<any>>>> & {
+    emitAsync<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Promise<Array<(Extract<ReturnOf<E[K]>, Promise<any>> extends Promise<infer R> ? R : never) | Exclude<ReturnOf<E[K]>, Promise<any>>>> & {
+        isResolved?: true;
+    };
+    emitAsyncParallel<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Promise<Array<(Extract<ReturnOf<E[K]>, Promise<any>> extends Promise<infer R> ? R : never) | Exclude<ReturnOf<E[K]>, Promise<any>>>> & {
         isResolved?: true;
     };
     subscribe<K extends ArrayOr<keyof E>>(event: K, handler: IterableOr<Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>>, priority?: number): H;
@@ -75,9 +78,10 @@ declare class EventEmitter<H, E> implements IEventEmitter<H, E> {
     emit<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): H;
     emitFirst<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): any;
     emitFirstDefault<K extends keyof E, D>(event: K, generateDefault: () => D, ...args: ArgsOf<E[K]>): any;
-    emitStream<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Stream<ReturnOf<E[K]>>;
+    emitCollect<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Array<ReturnOf<E[K]>>;
     emitReduce<K extends keyof E, A extends ReturnOf<E[K]> & Head<ArgsOf<E[K]>>>(event: K, arg: A, ...args: Tail<ArgsOf<E[K]>>): Extract<ReturnOf<E[K]> & Head<ArgsOf<E[K]>>, undefined> extends undefined ? (undefined extends A ? ReturnOf<E[K]> : A) : ReturnOf<E[K]>;
-    emitAsync<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): any;
+    emitAsync<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Promise<any[]>;
+    emitAsyncParallel<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Promise<any[]>;
     subscribe<K extends ArrayOr<keyof E>>(events: K, handler: keyof H | IterableOr<Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>>, priority?: number): H;
     unsubscribe<K extends ArrayOr<keyof E>>(events: K, handler: keyof H | IterableOr<Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>>, priority?: number): boolean;
     waitFor<K extends ArrayOr<keyof E>>(events: K, priority?: number): Promise<ArgsOf<K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>>;
@@ -86,7 +90,6 @@ declare class EventEmitter<H, E> implements IEventEmitter<H, E> {
     hasHandlersForEvent(...events: Array<keyof E>): boolean;
     private copyFrom;
     private handlersForEvent;
-    private handlers;
 }
 declare module EventEmitter {
     class Host<E> implements IEventEmitterHost<E> {

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

@@ -9,21 +9,26 @@
  * https://github.com/WaywardGame/types/wiki
  */
 /// <reference types="node" />
+import CommandManager from "command/CommandManager";
 import EventEmitter from "event/EventEmitter";
 import type { BiomeTypes } from "game/biome/IBiome";
+import { BiomeType } from "game/biome/IBiome";
 import type Entity from "game/entity/Entity";
 import type Human from "game/entity/Human";
 import type { Defense } from "game/entity/IEntity";
 import { DamageType } from "game/entity/IEntity";
 import type { Delay } from "game/entity/IHuman";
 import type { TurnTypeFlag } from "game/entity/player/IPlayer";
+import PlayerManager from "game/entity/player/PlayerManager";
 import type { IGameEvents, IMovementTime, IPlayOptions, ISynchronizeState } from "game/IGame";
 import { PauseSource, SaveType, TickFlag, TurnMode } from "game/IGame";
 import type Island from "game/island/Island";
 import IslandManager from "game/island/IslandManager";
+import { AutoSave } from "game/meta/AutoSave";
 import type { MultiplayerLoadingDescription } from "game/meta/Loading";
-import SaveLoad from "game/meta/SaveLoad";
-import type { Milestone } from "game/milestones/IMilestone";
+import { SaveLoad } from "game/meta/SaveLoad";
+import { Milestone } from "game/milestones/IMilestone";
+import { MilestoneManager } from "game/milestones/MilestoneManager";
 import type { IGameOptions } from "game/options/IGameOptions";
 import { GameMode } from "game/options/IGameOptions";
 import type { ChallengeModifiersCollection } from "game/options/modifiers/challenge/ChallengeModifiers";
@@ -31,63 +36,74 @@ import type { GameplayModifiersCollection } from "game/options/modifiers/Gamepla
 import type MilestoneModifier from "game/options/modifiers/milestone/MilestoneModifier";
 import ReferenceManager from "game/reference/ReferenceManager";
 import TimeManager from "game/time/TimeManager";
-import VotingManager from "game/VotingManager";
-import type ITextureDebugRenderer from "renderer/ITextureDebugRenderer";
+import ModManager from "mod/ModManager";
+import type { IRendererOrigin } from "renderer/context/RendererOrigin";
 import type WebGlContext from "renderer/WebGlContext";
 import ReplayManager from "replay/ReplayManager";
 import type { IOptions } from "save/data/ISaveDataGlobal";
+import SaveManager from "save/SaveManager";
 import type StringTokenizer from "save/serializer/StringTokenizer";
+import Steamworks from "steamworks/Steamworks";
 import ItemStylesheetHandler from "ui/screen/screens/game/util/item/ItemStylesheet";
+import { Uninit } from "Uninit";
 import type { IVector2 } from "utilities/math/IVector";
 import type { Random } from "utilities/random/Random";
 import type { IVersionInfo } from "utilities/Version";
+import { WebWorkerManager } from "webWorker/WebWorkerManager";
 export declare class Game extends EventEmitter.Host<IGameEvents> {
     get isChallenge(): boolean;
-    islands: IslandManager;
+    private difficultyOptions;
     customMilestoneModifiersAllowed: boolean;
     difficulty: GameMode;
+    replay: ReplayManager | undefined;
+    saveVersion: string;
     shouldUpdateTablesAndWeight: boolean;
     tickSpeed: number;
-    turnMode: TurnMode;
     time: TimeManager;
-    references: ReferenceManager;
-    replay: ReplayManager | undefined;
-    originalPlayOptions: Partial<IPlayOptions>;
-    saveVersion: string;
+    turnMode: TurnMode;
     upgrades: string[];
+    originalPlayOptions: Partial<IPlayOptions>;
+    worldId: string;
     /**
      * The version the save was originally created on
      */
     version: string;
-    worldId: string;
-    private difficultyOptions;
     readonly interval = 16.6666;
-    slot: number | undefined;
+    readonly autoSave: AutoSave;
+    readonly commandManager: CommandManager;
+    readonly milestoneManager: MilestoneManager;
+    readonly modManager: ModManager;
+    readonly saveLoad: SaveLoad;
+    readonly saveManager: SaveManager;
+    readonly steamworks: Steamworks;
+    readonly uninit: Uninit;
+    readonly webWorkerManager: WebWorkerManager;
+    readonly islands: IslandManager;
+    readonly playerManager: PlayerManager;
+    readonly references: ReferenceManager;
     absoluteTime: number;
+    challengeCollection?: ChallengeModifiersCollection;
+    initialThumbnailTimeout: NodeJS.Timer | undefined;
+    lastTickTime: number | undefined;
+    milestonesCollection?: GameplayModifiersCollection<MilestoneModifier, Milestone>;
+    nextTickTime: number | undefined;
     paused: Set<PauseSource>;
     playing: boolean;
-    nextTickTime: number | undefined;
-    lastTickTime: number | undefined;
+    previousSaveVersion: IVersionInfo;
     saveClear: boolean;
+    saveSize?: string;
+    slot: number | undefined;
     tileDecorations: Uint16Array;
-    initialThumbnailTimeout: NodeJS.Timer | undefined;
-    mapSize: number;
-    mapSizeSq: number;
+    protected stringTokenizer: StringTokenizer | undefined;
+    private gameOptionsCached?;
+    private synchronizeStateId;
     readonly itemStylesheetHandler: ItemStylesheetHandler | undefined;
-    readonly voting: VotingManager;
-    milestonesCollection?: GameplayModifiersCollection<MilestoneModifier, Milestone>;
-    challengeCollection?: ChallengeModifiersCollection;
-    debugRenderer: ITextureDebugRenderer | undefined;
-    webGlContext: WebGlContext | undefined;
     visible: boolean;
-    previousSaveVersion: IVersionInfo;
-    saveSize?: string;
-    canvas: HTMLCanvasElement | undefined;
+    webGlContext: WebGlContext | undefined;
+    canvasElement: HTMLCanvasElement | undefined;
     private gameLoopLogicTimer;
-    private gameOptionsCached?;
-    private synchronizeStateId;
-    protected stringTokenizer: StringTokenizer | undefined;
-    readonly saveLoad: typeof SaveLoad;
+    initialize(): Promise<void>;
+    uninitialize(): Promise<void>;
     toString(): string;
     get isPaused(): boolean;
     /**
@@ -103,6 +119,9 @@ export declare class Game extends EventEmitter.Host<IGameEvents> {
     getPlayingHumans(includeGhosts?: boolean, includeConnecting?: boolean, includeDedicatedServer?: boolean, includeAbsent?: boolean): Human[];
     getNonPlayerHumans(): Human[];
     initializeRenderer(): void;
+    /**
+     * It's important that this is lowest, so that it happens after modManager's globalSlotReady event
+     */
     globalSlotReady(): void;
     /**
      * Initializes WebGl
@@ -171,8 +190,12 @@ export declare class Game extends EventEmitter.Host<IGameEvents> {
     /**
      * Collection of things to perform on each tick
      */
-    tickAsync(island: Island, ticks: number, playingHumans: Human[] | undefined, tickFlag: TickFlag | undefined, onProgress: (progess: number) => Promise<void>, dueToAction?: boolean): Promise<void>;
-    createRenderer(entity: Entity): void;
+    tickAsync(island: Island, ticks: number, playingHumans: Human<number>[] | undefined, tickFlag: TickFlag | undefined, onProgress: (progess: number) => Promise<void>, dueToAction?: boolean): Promise<void>;
+    /**
+     * Creates the renderer.
+     * Should only be called once when starting / loading a save
+     */
+    createRenderer(origin: IRendererOrigin): void;
     /**
      * Resets the game state. This should be called when returning to the main menu from a game and/or right before starting/joining a game.
      * This method should be able to be called multiple times in a row and nothing unexpected should occur.
@@ -182,4 +205,6 @@ export declare class Game extends EventEmitter.Host<IGameEvents> {
      */
     reset(saveType?: SaveType | false, shouldDisconnect?: boolean, hasDisconnected?: boolean): Promise<void>;
     fastForwardIsland(island: Island, ticks: number, multiplayerLoadingDescription?: MultiplayerLoadingDescription): Promise<void>;
+    testFastForwardSpeed(ticks?: number, biomeType?: BiomeType): Promise<void>;
+    unlockAllMilestones(): void;
 }

package/definitions/game/game/IGame.d.ts

@@ -9,6 +9,7 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { BiomeTypes } from "game/biome/IBiome";
+import type { ITemplateBiomeOptions } from "game/biome/template/Template";
 import type Doodad from "game/doodad/Doodad";
 import type Corpse from "game/entity/creature/corpse/Corpse";
 import type Creature from "game/entity/creature/Creature";
@@ -16,7 +17,7 @@ import type { ICharacter, ICrafted } from "game/entity/IHuman";
 import type NPC from "game/entity/npc/NPC";
 import type { PlayerState } from "game/entity/player/IPlayer";
 import type { Game } from "game/Game";
-import type { ISeeds, IslandId, IWell } from "game/island/IIsland";
+import type { ILegacySeeds, IslandId, IWell } from "game/island/IIsland";
 import type Item from "game/item/Item";
 import type { Milestone } from "game/milestones/IMilestone";
 import type { GameMode, IGameOptions } from "game/options/IGameOptions";
@@ -144,7 +145,7 @@ export type IGameOld = Partial<Game> & Partial<{
     mapGenVersion: string;
     npcs: SaferArray<NPC>;
     saveVersion: string;
-    seeds: ISeeds;
+    seeds: ILegacySeeds;
     tileContainers: ITileContainer[];
     tileData: Record<number, Record<number, Record<number, ITileData[]>>>;
     tileEvents: SaferArray<TileEvent>;
@@ -159,16 +160,21 @@ export interface IPlayOptions {
     difficultyOptions?: IGameOptions;
     milestoneModifiers: Set<Milestone>;
     character: ICharacter;
-    multiplayer: IMultiplayerOptions | true | undefined;
+    multiplayer: IMultiplayerOptions | boolean | undefined;
     multiplayerServerToJoin: ServerInfo | undefined;
     turnMode: TurnMode;
     realTimeTickSpeed: number;
     customMilestoneModifiersAllowed: boolean;
-    mapSize: number | undefined;
     recordReplay: boolean;
     multiplayerWorld?: IMultiplayerWorldData;
     replayLog?: IReplayLogEntry[];
     replyCompletedMilestoneCount?: number;
+    skipServerOpen?: boolean;
+    template?: IIslandTemplate;
+}
+export interface IIslandTemplate {
+    mapSize: number;
+    options: ITemplateBiomeOptions;
 }
 export interface IPlayerOptions {
     id?: number;
@@ -198,38 +204,33 @@ export declare enum SaveType {
 }
 export declare enum TileUpdateType {
     Batch = 0,
-    CorpseManager = 1,
-    Creature = 2,
-    CreatureSpawn = 3,
-    DoodadAttachStillContainer = 4,
-    DoodadChangeType = 5,
-    DoodadCreate = 6,
-    DoodadDetachStillContainer = 7,
-    DoodadEmbers = 8,
-    DoodadGatherReady = 9,
-    DoodadGrowingStage = 10,
-    DoodadOrientation = 11,
-    DoodadOverHidden = 12,
-    DoodadRemove = 13,
-    Item = 14,
-    ItemDrop = 15,
-    ItemMovement = 16,
-    Mod = 17,
-    NPC = 18,
-    NPCSpawn = 19,
-    Player = 20,
-    Terrain = 21,
-    TileEventManager = 22,
-    Tilled = 23
-}
-export declare enum CreationId {
-    Doodad = 0,
-    Creature = 1,
-    Corpse = 2,
-    NPC = 3,
-    Item = 4,
-    TileEvent = 5,
-    Player = 6
+    Corpse = 1,
+    CorpseManager = 2,
+    Creature = 3,
+    CreatureRestore = 4,
+    CreatureSpawn = 5,
+    Doodad = 6,
+    DoodadAttachStillContainer = 7,
+    DoodadChangeType = 8,
+    DoodadCreate = 9,
+    DoodadDetachStillContainer = 10,
+    DoodadEmbers = 11,
+    DoodadGatherReady = 12,
+    DoodadGrowingStage = 13,
+    DoodadOrientation = 14,
+    DoodadOverHidden = 15,
+    DoodadRemove = 16,
+    Item = 17,
+    ItemDrop = 18,
+    ItemMovement = 19,
+    Mod = 20,
+    NPC = 21,
+    NPCSpawn = 22,
+    Player = 23,
+    Terrain = 24,
+    TileEvent = 25,
+    TileEventManager = 26,
+    Tilled = 27
 }
 export declare enum PauseSource {
     /**
@@ -279,8 +280,6 @@ export interface IMovementTime {
     start: number;
     end: number;
 }
-export declare const DEFAULT_MAP_SIZE = 512;
-export declare const DEFAULT_MAP_SIZE_SQUARED: number;
 export declare const LINE_OF_SIGHT_RADIUS = 15;
 export declare const LINE_OF_SIGHT_RADIUS_MAX = 20;
 export declare const LINE_OF_SIGHT_DETAIL = 4;

package/definitions/game/game/IObject.d.ts

@@ -10,21 +10,31 @@
  */
 import type { BiomeType } from "game/biome/IBiome";
 import type { SkillType } from "game/entity/IHuman";
-import type { CreationId } from "game/IGame";
 import type { TerrainType } from "game/tile/ITerrain";
 import type { WorldZ } from "game/WorldZ";
 import type { ISerializedTranslation } from "language/ITranslation";
 export interface IObject<T> {
-    objectType: CreationId;
     type: T;
     id: number;
     renamed?: string | ISerializedTranslation;
 }
 export interface IObjectDescription extends IHasImagePath {
+    /**
+     * Set to true if we want to store decay, but not have it active (in the case of torches)
+     */
     storeDecay?: boolean;
+    /**
+     * number of game ticks until decay
+     */
     decayMax?: number;
     skillUse?: SkillType;
+    /**
+     * container maximum weight
+     */
     weightCapacity?: number;
+    /**
+     * Chance that things will decay inside it
+     */
     preservationChance?: number;
     spawnOnWorldGen?: OptionalDescriptions<BiomeType, OptionalDescriptions<WorldZ, OptionalDescriptions<TerrainType, number>>>;
 }