@wayward/types 2.10.9-beta.dev.20211004.1 → 2.11.0-beta

package/definitions/game/command/commands/Banned.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+export declare const command: ICommand;
+export default command;

package/definitions/game/command/commands/Commands.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+declare const _default: ICommand;
+export default _default;

package/definitions/game/command/commands/Kick.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+export declare const command: ICommand;
+export default command;

package/definitions/game/command/commands/Pause.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+export declare const command: ICommand;
+export default command;

package/definitions/game/command/commands/Ping.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+export declare const command: ICommand;
+export default command;

package/definitions/game/command/commands/Players.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+export declare const command: ICommand;
+export default command;

package/definitions/game/command/commands/Save.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+export declare const command: ICommand;
+export default command;

package/definitions/game/command/commands/Sync.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+export declare const command: ICommand;
+export default command;

package/definitions/game/command/commands/Unban.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+export declare const command: ICommand;
+export default command;

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

@@ -0,0 +1,115 @@
+/*!
+ * 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 Audio from "audio/Audio";
+import type Doodad from "game/doodad/Doodad";
+import type DoodadManager from "game/doodad/DoodadManager";
+import type ActionExecutor from "game/entity/action/ActionExecutor";
+import type Corpse from "game/entity/creature/corpse/Corpse";
+import type CorpseManager from "game/entity/creature/corpse/CorpseManager";
+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 Human from "game/entity/Human";
+import type NPC from "game/entity/npc/NPC";
+import type NPCManager from "game/entity/npc/NPCManager";
+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 Item from "game/item/Item";
+import type ItemManager from "game/item/ItemManager";
+import type Loading from "game/meta/Loading";
+import type Prompts from "game/meta/prompt/Prompts";
+import type TileEvent from "game/tile/TileEvent";
+import type TileEventManager from "game/tile/TileEventManager";
+import type LanguageManager from "language/LanguageManager";
+import type ModManager from "mod/ModManager";
+import type Multiplayer from "multiplayer/Multiplayer";
+import type WorldRenderer from "renderer/world/WorldRenderer";
+import type SaveManager from "save/SaveManager";
+import type Steamworks from "steamworks/Steamworks";
+export declare enum EventBus {
+    Actions = 0,
+    Audio = 1,
+    CorpseManager = 2,
+    Corpses = 3,
+    CreatureManager = 4,
+    Creatures = 5,
+    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,
+    Steamworks = 27,
+    TileEventManager = 28,
+    TileEvents = 29,
+    Ui = 30,
+    WorldRenderer = 31
+}
+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.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.Steamworks](): typeof Steamworks;
+    [EventBus.TileEventManager](): typeof TileEventManager;
+    [EventBus.TileEvents](): typeof TileEvent;
+    [EventBus.Ui](): typeof ui;
+    [EventBus.WorldRenderer](): typeof WorldRenderer;
+};
+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;
+}
+export declare type EventBusHost<E extends EventBus> = ReturnType<(typeof eventBuses)[E]>;

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

@@ -0,0 +1,95 @@
+/*!
+ * 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 { PriorityMap } from "utilities/collection/map/PriorityMap";
+export declare enum Priority {
+    Lowest = -2000,
+    Low = -1000,
+    Normal = 0,
+    High = 1000,
+    Highest = 2000
+}
+export declare const SYMBOL_SUBSCRIPTIONS: unique symbol;
+export declare const SYMBOL_SUPERCLASSES: unique symbol;
+declare type Abstract<T> = Function & {
+    prototype: T;
+};
+declare type Constructor<T> = new (...args: any[]) => T;
+declare type ClassOrAbstractClass<T> = Abstract<T> | Constructor<T>;
+export interface IEventEmitterHost<E> {
+    event: IEventEmitter<this, E>;
+}
+export declare type IEventEmitterHostClass<E> = ClassOrAbstractClass<IEventEmitterHost<E>>;
+export declare type Events<T> = T extends IEventEmitterHost<infer E> ? E : T extends IEventEmitterHostClass<infer E> ? E : never;
+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>>>>>>;
+}
+export interface ISelfSubscribedEmitter<E> {
+    [SYMBOL_SUBSCRIPTIONS]: Array<[ISelfSubscribedEmitter<any>, keyof E, string | number | symbol, number?]>;
+}
+declare type ArgsOf<F> = ArgumentsOf<Extract<F, AnyFunction>>;
+declare type ReturnOf<F> = ReturnType<Extract<F, AnyFunction>>;
+declare type Handler<H, F> = (host: H, ...args: ArgsOf<F>) => ReturnOf<F>;
+declare type UndefinedFromVoid<V> = V extends void ? undefined : V;
+export interface IEventEmitter<H = any, E = any> {
+    event: IEventEmitter<this, IEventEmitterEvents<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]>): 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]>>;
+    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>>>> & {
+        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;
+    unsubscribe<K extends ArrayOr<keyof E>>(event: K, handler: 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>]>>;
+    until<E2>(emitter: IEventEmitterHost<E2>, ...events: Array<keyof E2>): IUntilSubscriber<H, E>;
+    until(promise: Promise<any>): IUntilSubscriber<H, E>;
+    hasHandlersForEvent(...events: Array<keyof E>): boolean;
+}
+interface IUntilSubscriber<H, E> {
+    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;
+}
+interface IEventEmitterEvents<H, E> {
+    subscribe<K extends keyof E>(event: keyof E, handler: Iterable<(keyof H) | Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>>): any;
+    unsubscribe<K extends keyof E>(event: keyof E, handler: Iterable<(keyof H) | Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>>): any;
+}
+declare class EventEmitter<H, E> implements IEventEmitter<H, E> {
+    private readonly host;
+    private readonly hostClass;
+    private readonly subscriptions;
+    private eventEmitterMeta?;
+    get event(): IEventEmitter<this, IEventEmitterEvents<H, E>>;
+    constructor(host: H);
+    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]>>;
+    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;
+    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>]>>;
+    until<E2>(emitter: IEventEmitterHost<E2>, ...events: Array<keyof E2>): IUntilSubscriber<H, E>;
+    until(promise: Promise<any>): IUntilSubscriber<H, E>;
+    hasHandlersForEvent(...events: Array<keyof E>): boolean;
+    private copyFrom;
+    private handlersForEvent;
+    private handlers;
+}
+declare module EventEmitter {
+    class Host<E> implements IEventEmitterHost<E> {
+        readonly event: IEventEmitter<this, E>;
+    }
+}
+export default EventEmitter;

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

@@ -0,0 +1,45 @@
+/*!
+ * 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 { EventBusHost } from "event/EventBuses";
+import { EventBus } from "event/EventBuses";
+import type { Events, IEventEmitterHost, IEventEmitterHostClass } from "event/EventEmitter";
+declare type HostOrHostClass = IEventEmitterHost<any> | IEventEmitterHostClass<any>;
+declare type HostFromHostOrHostClass<H extends IEventEmitterHost<any> | IEventEmitterHostClass<any>> = H extends IEventEmitterHostClass<any> ? InstanceOf<H> : H;
+export declare type EmitterOrBus = EventBus | HostOrHostClass;
+export declare type Event<E extends EmitterOrBus> = keyof Events<E extends EventBus ? EventBusHost<E> : E>;
+declare type ArgsOf<F> = ArgumentsOf<Extract<F, AnyFunction>>;
+declare type ReturnOf<F> = ReturnType<Extract<F, AnyFunction>>;
+declare type HandlerInternal2<H, F> = (host: H, ...args: ArgsOf<F>) => ReturnOf<F>;
+declare type HandlerInternal1<E extends HostOrHostClass, K extends keyof Events<E>> = HandlerInternal2<HostFromHostOrHostClass<E>, Events<E>[K]>;
+export declare type Handler<E extends EmitterOrBus, K extends Event<E>> = HandlerInternal1<E extends EventBus ? EventBusHost<E> : E, K>;
+declare module EventManager {
+    export function subscribe<E extends EmitterOrBus, K extends Event<E>>(emitter: E, event: K, handler: IterableOr<Handler<E, K>>, priority?: number): void;
+    export function unsubscribe<E extends EmitterOrBus, K extends Event<E>>(emitter: E, event: K, handler: IterableOr<Handler<E, K>>, priority?: number): boolean | undefined;
+    export function waitFor<E extends EmitterOrBus, K extends Event<E>>(emitter: E, event: K, priority?: number): Promise<Parameters<Handler<E, K>>>;
+    interface IEventManagerUntil {
+        subscribe<E extends EmitterOrBus, K extends Event<E>>(emitter: E, event: K, handler: IterableOr<Handler<E, K>>, priority?: number): this;
+    }
+    export function until(promise: Promise<any>): IEventManagerUntil;
+    export function registerEventBusSubscriber(subscriber: object): void;
+    export function deregisterEventBusSubscriber(subscriber: object): void;
+    export {};
+}
+export default EventManager;
+/**
+ * Marks that this class, whenever instantiated, should be an event subscriber.
+ * **Note:** This decorator should only be used on classes with instances that will *always* need to be subscribed. IE don't use this on UI stuff. **Mods should never need this.**
+ * **Note:** This is incompatible with `@Bind` decorators.
+ */
+export declare function EventSubscriber<S extends Class<any>>(constructor: S): S;
+declare type ReturnTypeLenient<T extends AnyFunction> = ReturnType<T> extends void ? Promise<void> : ReturnType<T>;
+export declare type TypedPropertyDescriptorFunctionAnyNOfParams<T extends AnyFunction> = TypedPropertyDescriptor<(...args: ArgumentsOf<T>) => ReturnTypeLenient<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4], a5: ArgumentsOf<T>[5], a6: ArgumentsOf<T>[6], a7: ArgumentsOf<T>[7], a8: ArgumentsOf<T>[8], a9: ArgumentsOf<T>[9]) => ReturnTypeLenient<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4], a5: ArgumentsOf<T>[5], a6: ArgumentsOf<T>[6], a7: ArgumentsOf<T>[7], a8: ArgumentsOf<T>[8]) => ReturnTypeLenient<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4], a5: ArgumentsOf<T>[5], a6: ArgumentsOf<T>[6], a7: ArgumentsOf<T>[7]) => ReturnTypeLenient<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4], a5: ArgumentsOf<T>[5], a6: ArgumentsOf<T>[6]) => ReturnTypeLenient<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4], a5: ArgumentsOf<T>[5]) => ReturnTypeLenient<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4]) => ReturnTypeLenient<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3]) => ReturnTypeLenient<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2]) => ReturnTypeLenient<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1]) => ReturnTypeLenient<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0]) => ReturnTypeLenient<T>> | TypedPropertyDescriptor<() => ReturnTypeLenient<T>> | TypedPropertyDescriptor<T> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4], a5: ArgumentsOf<T>[5], a6: ArgumentsOf<T>[6], a7: ArgumentsOf<T>[7], a8: ArgumentsOf<T>[8], a9: ArgumentsOf<T>[9]) => ReturnType<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4], a5: ArgumentsOf<T>[5], a6: ArgumentsOf<T>[6], a7: ArgumentsOf<T>[7], a8: ArgumentsOf<T>[8]) => ReturnType<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4], a5: ArgumentsOf<T>[5], a6: ArgumentsOf<T>[6], a7: ArgumentsOf<T>[7]) => ReturnType<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4], a5: ArgumentsOf<T>[5], a6: ArgumentsOf<T>[6]) => ReturnType<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4], a5: ArgumentsOf<T>[5]) => ReturnType<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3], a4: ArgumentsOf<T>[4]) => ReturnType<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2], a3: ArgumentsOf<T>[3]) => ReturnType<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1], a2: ArgumentsOf<T>[2]) => ReturnType<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0], a1: ArgumentsOf<T>[1]) => ReturnType<T>> | TypedPropertyDescriptor<(a0: ArgumentsOf<T>[0]) => ReturnType<T>> | TypedPropertyDescriptor<() => ReturnType<T>>;
+export declare function OwnEventHandler<T extends IEventEmitterHostClass<any>, E extends keyof Events<T>>(cls: T, event: E, priority?: number): (host: InstanceOf<T>, property2: string | number | symbol, descriptor: TypedPropertyDescriptorFunctionAnyNOfParams<Events<T>[E]>) => void;
+export declare function EventHandler<E extends EmitterOrBus, K extends Event<E>>(emitter: E, event: K, priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptorFunctionAnyNOfParams<Handler<E, K>>) => void;

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

@@ -0,0 +1,171 @@
+/*!
+ * 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
+ */
+/// <reference types="node" />
+import EventEmitter from "event/EventEmitter";
+import type Entity from "game/entity/Entity";
+import type { Defense } from "game/entity/IEntity";
+import { DamageType } from "game/entity/IEntity";
+import { Delay, SkillType } from "game/entity/IHuman";
+import type { TurnType } from "game/entity/player/IPlayer";
+import type Player from "game/entity/player/Player";
+import type { IGameEvents, IPlayOptions, ISynchronizeState } from "game/IGame";
+import { SaveType, TickFlag, TurnMode } from "game/IGame";
+import type Island from "game/island/Island";
+import IslandManager from "game/island/IslandManager";
+import type { MultiplayerLoadingDescription } from "game/meta/Loading";
+import type { Milestone } from "game/milestones/IMilestone";
+import type { IGameOptions } from "game/options/IGameOptions";
+import { GameMode } from "game/options/IGameOptions";
+import type { ChallengeModifiersCollection } from "game/options/modifiers/challenge/ChallengeModifiers";
+import ReferenceManager from "game/reference/ReferenceManager";
+import TimeManager from "game/time/TimeManager";
+import VotingManager from "game/VotingManager";
+import { RenderSource } from "renderer/IRenderer";
+import type ITextureDebugRenderer from "renderer/ITextureDebugRenderer";
+import type WebGlContext from "renderer/WebGlContext";
+import ReplayManager from "replay/ReplayManager";
+import type { IOptions } from "save/data/ISaveDataGlobal";
+import type StringTokenizer from "save/serializer/StringTokenizer";
+import ItemStylesheetHandler from "ui/screen/screens/game/util/item/ItemStylesheet";
+import type { IVersionInfo } from "utilities/Version";
+export declare class Game extends EventEmitter.Host<IGameEvents> {
+    get isChallenge(): boolean;
+    islands: IslandManager;
+    customMilestoneModifiersAllowed: boolean;
+    difficulty: GameMode;
+    shouldUpdateTablesAndWeight: boolean;
+    tickSpeed: number;
+    turnMode: TurnMode;
+    time: TimeManager;
+    references: ReferenceManager;
+    replay: ReplayManager | undefined;
+    originalPlayOptions: Partial<IPlayOptions>;
+    saveVersion: string;
+    upgrades: string[];
+    /**
+     * The version the save was originally created on
+     */
+    version: string;
+    worldId: string;
+    private difficultyOptions;
+    readonly interval = 16.6666;
+    slot: number | undefined;
+    absoluteTime: number;
+    paused: boolean;
+    playing: boolean;
+    nextTickTime: number | undefined;
+    lastTickTime: number | undefined;
+    saveClear: boolean;
+    tileDecorations: Uint16Array;
+    initialThumbnailTimeout: NodeJS.Timer | undefined;
+    mapSize: number;
+    mapSizeSq: number;
+    readonly itemStylesheetHandler: ItemStylesheetHandler | undefined;
+    readonly voting: VotingManager;
+    readonly milestonesCollection: import("./options/modifiers/GameplayModifiersManager").GameplayModifiersCollection<import("./options/modifiers/milestone/MilestoneModifier").default, Milestone, import("./options/modifiers/milestone/MilestoneModifier").MilestoneModifierInstance, []>;
+    challengeCollection?: ChallengeModifiersCollection;
+    debugRenderer: ITextureDebugRenderer | undefined;
+    webGlContext: WebGlContext | undefined;
+    visible: boolean;
+    previousSaveVersion: IVersionInfo;
+    saveSize?: string;
+    canvas: HTMLCanvasElement | undefined;
+    private queueDedicatedServerFovUpdate?;
+    private gameOptionsCached?;
+    private synchronizeStateId;
+    protected stringTokenizer: StringTokenizer | undefined;
+    initializeRenderer(): void;
+    globalSlotReady(): void;
+    /**
+     * Initializes WebGl
+     * @param forceWebGlVersion Set to force a specific webgl version
+     */
+    initGl(forceWebGlVersion?: number): Promise<void>;
+    /**
+     * Compiles webgl programs / shaders and creates renderers
+     */
+    setupGl(restoring: boolean): Promise<void>;
+    resetWebGL(): void;
+    setGlContextSize(width: number, height: number): void;
+    resizeRenderer(): void;
+    setPaused(paused: boolean, showChatMessage?: boolean): void;
+    gameLogicLoop: () => void;
+    isSimulatedOrRealTimeMode(): boolean;
+    getTurnMode(): TurnMode;
+    setTurnMode(turnMode: TurnMode): void;
+    getTickSpeed(): number;
+    setTickSpeed(tickSpeed: number): void;
+    updateTablesAndWeightNextTick(): void;
+    updateReputation(reputation: number): void;
+    getGameMode(): GameMode;
+    getGameOptionsBeforeModifiers(): IGameOptions;
+    getGameOptions(): IGameOptions;
+    updateGameUpdates(gameOptions: IGameOptions): void;
+    initializeGameOptions(seed: string | number, mode?: GameMode, options?: IGameOptions, milestoneModifiers?: Set<Milestone>): void;
+    initializeModifiers(): void;
+    getReputation(): number;
+    getMalignity(): number;
+    getBenignity(): number;
+    getMaxHealth(): number;
+    getMaxWeight(): number;
+    getTactics(): number;
+    getSkillPercent(skill: SkillType): number;
+    getPlayerAverage(calc: (player: Player) => number | undefined, round?: boolean): number;
+    getMovementFinishTime(delay?: Delay | number): number;
+    getMovementProgress(timeStamp: number, finishTime: number | undefined, delay?: Delay | number): number;
+    getAnimationProgress(timeStamp: number, finishTime: number | undefined, delay: Delay | number): number;
+    getSynchronizeState(identifier: string): ISynchronizeState;
+    synchronizeState(synchronizeState: ISynchronizeState): void;
+    /**
+     * Marks that the player had a turn
+     * In manual turn mode, it will tick the players stat timers & the game
+     * @param player
+     * @param turnType
+     */
+    passTurn(player: Player, turnType?: TurnType): void;
+    tickRealtime(): void;
+    updateView(source: RenderSource, updateFov?: boolean, computeSpritesNow?: boolean): void;
+    /**
+     * AVOID USING THIS. USE updateTablesAndWeightNextTick INSTEAD!
+     * For most cases you don't need this
+     */
+    updateTablesAndWeight(deferTableUpdates?: boolean): void;
+    /**
+     * Gets the largest damage type weaknesses of a human or creature based on a type and damage value
+     * @param defense Defense of the human or creature
+     * @param damageTypes Measures the weaknesses compared to damage types passed
+     * @param damage The damage value given to the human or creature
+     * @returns returns DamageType array or undefined if there are no weaknesses
+     */
+    getGreatestWeaknesses(defense: Defense, damageTypes: DamageType, damage: number): DamageType[];
+    updateOption(player: Player | undefined, id: keyof IOptions, value: boolean | number): void;
+    /**
+     * Do not call this directly. Use updateOption instead
+     */
+    updateOptionInternal(id: keyof IOptions, value: boolean | number, player?: Player): void;
+    /**
+     * Collection of things to perform on each tick
+     */
+    tick(ticks?: number, realPlayers?: Player[], tickFlag?: TickFlag): void;
+    /**
+     * Collection of things to perform on each tick
+     */
+    tickAsync(island: Island, ticks: number, realPlayers: Player[] | undefined, tickFlag: TickFlag | undefined, onProgress: (progess: number) => Promise<void>): Promise<void>;
+    createRenderer(entity: Entity): 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.
+     * @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.
+     */
+    reset(saveType?: SaveType | false, shouldDisconnect?: boolean): Promise<void>;
+    fastForwardIsland(island: Island, ticks: number, multiplayerLoadingDescription?: MultiplayerLoadingDescription): Promise<void>;
+}