@wayward/types 2.12.3-beta.dev.20221230.1 → 2.13.0-beta

package/LICENSE

@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2019 Wayward
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+The MIT License (MIT)
+
+Copyright (c) 2019 Wayward
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/README.md

@@ -1,11 +1,11 @@
-# Wayward Types
-
-TypeScript declarations used for modding Wayward.
-
-## Usage
-
-Visit the [Wiki](https://github.com/WaywardGame/types/wiki/mod-create-&-update) of this repository for more information on `+mod create` to create mods and `+mod update` to update preexisting mods.
-
-## Documentation
-
+# Wayward Types
+
+TypeScript declarations used for modding Wayward.
+
+## Usage
+
+Visit the [Wiki](https://github.com/WaywardGame/types/wiki/mod-create-&-update) of this repository for more information on `+mod create` to create mods and `+mod update` to update preexisting mods.
+
+## Documentation
+
 Visit [waywardgame.github.io](https://waywardgame.github.io/) for documentation and an organized view of these types.

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/audio/Audio.d.ts

@@ -8,11 +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 IAudio from "audio/IAudio";
 import { Music, SfxType } from "audio/IAudio";
 import EventEmitter from "event/EventEmitter";
-import type Island from "game/island/Island";
 import type EnumCursor from "utilities/enum/EnumCursor";
+import type { IVector4 } from "utilities/math/Vector4";
 export declare enum Fading {
     None = 0,
     In = 1,
@@ -21,20 +20,24 @@ export declare enum Fading {
 export interface IAudioEvents {
     init(): any;
     /**
-     * Called when a sound effect is queued
+     * Called when a ui sound effect is played
      * @param type The sound effect type
-     * @param x The x location in the world for the effect
-     * @param y The y location in the world for the effect
-     * @param z The z location in the world for the effect
      * @returns False to cancel the sound effect, a sound effect to play instead of the given one, or undefined to use the default logic
      */
-    queueSoundEffect?(type: SfxType, x: number, y: number, z: number): SfxType | boolean | undefined;
+    playUiSoundEffect?(type: SfxType): SfxType | boolean | undefined;
+    /**
+     * Called when a game sound effect is queued
+     * @param type The sound effect type
+     * @param position The position of the sound effect
+     * @returns False to cancel the sound effect, a sound effect to play instead of the given one, or undefined to use the default logic
+     */
+    queueGameSoundEffect?(type: SfxType, position: IVector4): SfxType | boolean | undefined;
 }
-export default class WAudio extends EventEmitter.Host<IAudioEvents> implements IAudio {
+export default class WAudio extends EventEmitter.Host<IAudioEvents> {
     private readonly _musicInfo;
     private readonly _sfxInfo;
     private readonly _soundQueue;
-    private readonly _recentlyPlayedSounds;
+    private readonly _recentlyPlayedGameSounds;
     private readonly _fileFormat;
     private _onInitializedPromise;
     private _audioContext;
@@ -67,11 +70,18 @@ export default class WAudio extends EventEmitter.Host<IAudioEvents> implements I
     updateMusicSpeed(speed: number): Promise<void>;
     updateVolume(): void;
     updatePosition(): Promise<void>;
-    queueEffect(type: SfxType, island: Island | undefined, x: number, y: number, z: number, delay?: number, speed?: number, noPosition?: boolean, force?: boolean): void;
-    processEffects(): void;
+    /**
+     * Plays a ui sound effect (a sound effect with no position)
+     */
+    playUiSoundEffect(sfxType: SfxType, speed?: number): Promise<void>;
+    /**
+     * Plays a sound effect (game / location based)
+     */
+    queueGameSoundEffect(type: SfxType, position: IVector4, delay?: number, speed?: number): void;
+    processGameSounds(): void;
     private _stopMusic;
     private _playMusic;
-    private _playEffect;
+    private _playSound;
     private _isComparableSound;
     private _getAudioBuffer;
     private initializeAudio;

package/definitions/game/audio/IAudio.d.ts

@@ -8,21 +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 Island from "game/island/Island";
-import type EnumCursor from "utilities/enum/EnumCursor";
-export interface IAudio {
-    resetMusicHandler(): void;
-    getMusicHandler(): EnumCursor<Music>;
-    setMusicHandler(handler: EnumCursor<Music>): void;
-    playMusic(): void;
-    stopMusic(): void;
-    processEffects(): void;
-    queueEffect(soundEffect: SfxType, island: Island | undefined, x: number, y: number, z: number, delay?: number, speed?: number, noPosition?: boolean): void;
-    updateMusicSpeed(speed: number): void;
-    updatePosition(): void;
-    updateVolume(): void;
-}
-export default IAudio;
 export declare enum SfxType {
     Boat = 0,
     Bow = 1,
@@ -32,37 +17,38 @@ export declare enum SfxType {
     CreatureHit = 5,
     CreatureNoise = 6,
     Damaged = 7,
-    Death = 8,
-    Eating = 9,
-    Exceptional = 10,
-    Extinguish = 11,
-    Fail = 12,
-    GraniteHit = 13,
-    Hit = 14,
-    Hurt = 15,
-    Minecart = 16,
-    Miss = 17,
-    PickUp = 18,
-    SandstoneHit = 19,
-    Swim = 20,
-    Throw = 21,
-    Trample = 22,
-    TreeHit = 23,
-    UiActivate = 24,
-    UiChoose = 25,
-    UiClose = 26,
-    UiDisable = 27,
-    UiEnable = 28,
-    UiInput = 29,
-    UiInputdelete = 30,
-    UiInvalid = 31,
-    UiOpen = 32,
-    UiOpensmall = 33,
-    UiProtect = 34,
-    UiSelect = 35,
-    UiUnprotect = 36,
-    Walk = 37,
-    Water = 38
+    DangerousMove = 8,
+    Death = 9,
+    Eating = 10,
+    Exceptional = 11,
+    Extinguish = 12,
+    Fail = 13,
+    GraniteHit = 14,
+    Hit = 15,
+    Hurt = 16,
+    Minecart = 17,
+    Miss = 18,
+    PickUp = 19,
+    SandstoneHit = 20,
+    Swim = 21,
+    Throw = 22,
+    Trample = 23,
+    TreeHit = 24,
+    UiActivate = 25,
+    UiChoose = 26,
+    UiClose = 27,
+    UiDisable = 28,
+    UiEnable = 29,
+    UiInput = 30,
+    UiInputdelete = 31,
+    UiInvalid = 32,
+    UiOpen = 33,
+    UiOpensmall = 34,
+    UiProtect = 35,
+    UiSelect = 36,
+    UiUnprotect = 37,
+    Walk = 38,
+    Water = 39
 }
 export type SfxUi = Extract<keyof typeof SfxType, `Ui${string}`> extends `Ui${infer RESULT}` ? Lowercase<RESULT> : never;
 export declare enum Music {

package/definitions/game/audio/Music.d.ts

@@ -9,5 +9,4 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { Music } from "audio/IAudio";
-import type { IMusicDescription } from "audio/IMusic";
-export declare const musicDescriptions: OptionalDescriptions<Music, IMusicDescription>;
+export declare const musicDescriptions: Map<Music, import("../mod/ModRegistry").IModdable>;

package/definitions/game/audio/SoundEffects.d.ts

@@ -10,4 +10,4 @@
  */
 import { SfxType } from "audio/IAudio";
 import type { ISoundEffectDescription } from "audio/IMusic";
-export declare const soundEffectDescriptions: OptionalDescriptions<SfxType, ISoundEffectDescription>;
+export declare const soundEffectDescriptions: Map<SfxType, ISoundEffectDescription>;

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";
@@ -29,6 +30,7 @@ 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 { MilestoneManager } from "game/milestones/MilestoneManager";
 import type TileEvent from "game/tile/TileEvent";
 import type TileEventManager from "game/tile/TileEventManager";
 import type LanguageManager from "language/LanguageManager";
@@ -50,75 +52,83 @@ 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,
+    Milestones = 20,
+    Mods = 21,
+    Multiplayer = 22,
+    NPCManager = 23,
+    NPCs = 24,
+    PlayerManager = 25,
+    Players = 26,
+    Prompt = 27,
+    SaveManager = 28,
+    ScreenManager = 29,
+    Steamworks = 30,
+    TileEventManager = 31,
+    TileEvents = 32,
+    Ui = 33,
+    UiActionBar = 34,
+    UiMovementHandler = 35,
+    WorldRenderer = 36
 }
 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.Milestones](): MilestoneManager;
+    [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 register(eventBus: EventBus): (constructor: AbstractNullaryClass<any>) => any;
+    function unregister(eventBus: EventBus): boolean;
+    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,
@@ -19,6 +18,7 @@ export declare enum Priority {
 }
 export declare const SYMBOL_SUBSCRIPTIONS: unique symbol;
 export declare const SYMBOL_SUPERCLASSES: unique symbol;
+export declare const SYMBOL_SUBSCRIPTION_STATE_IDS: unique symbol;
 type Abstract<T> = Function & {
     prototype: T;
 };
@@ -29,9 +29,11 @@ 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>>;
+    [SYMBOL_SUBSCRIPTION_STATE_IDS]: Map<keyof E, number>;
 }
 export interface ISelfSubscribedEmitter<E> {
     [SYMBOL_SUBSCRIPTIONS]: Array<[ISelfSubscribedEmitter<any>, keyof E, string | number | symbol, number?]>;
@@ -39,15 +41,22 @@ export interface ISelfSubscribedEmitter<E> {
 type ArgsOf<F> = ArgumentsOf<Extract<F, AnyFunction>>;
 type ReturnOf<F> = ReturnType<Extract<F, AnyFunction>>;
 type Handler<H, F> = (host: H, ...args: ArgsOf<F>) => ReturnOf<F>;
+type WeakHandler<H, F> = WeakRef<Handler<H, F>>;
 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;
+    /**
+     * Emit an event only to the subscribers of this emitter instance.
+     */
+    emitSelf<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;
@@ -60,24 +69,23 @@ export interface IEventEmitter<H = any, E = any> {
 export 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> {
+declare class EventEmitter<H, E> {
     private readonly host;
+    static RECORD_MODE: boolean;
     private readonly hostClass;
     private readonly subscriptions;
-    private eventEmitterMeta?;
-    get event(): IEventEmitter<this, IEventEmitterEvents<H, E>>;
+    private readonly subscriptionsRecord;
+    private readonly cachedEmitSelfHandlers;
     constructor(host: H);
     raw(): IEventEmitter<H, E>;
+    emitSelf<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): 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]>>;
+    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>]>>;
@@ -85,8 +93,8 @@ declare class EventEmitter<H, E> implements IEventEmitter<H, E> {
     until(promise: Promise<any>): IUntilSubscriber<H, E>;
     hasHandlersForEvent(...events: Array<keyof E>): boolean;
     private copyFrom;
-    private handlersForEvent;
-    private handlers;
+    private readonly cachedClassHandlers;
+    protected handlersForEvent<K extends keyof E>(event: K, ignoreClassSubscriptions?: true): Array<keyof H | WeakHandler<any, any>>;
 }
 declare module EventEmitter {
     class Host<E> implements IEventEmitterHost<E> {

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

@@ -10,9 +10,12 @@
  */
 import type { EventBusHost } from "event/EventBuses";
 import { EventBus } from "event/EventBuses";
+import type EventEmitter from "event/EventEmitter";
 import type { Events, IEventEmitterHost, IEventEmitterHostClass } from "event/EventEmitter";
 type HostOrHostClass = IEventEmitterHost<any> | IEventEmitterHostClass<any>;
-type HostFromHostOrHostClass<H> = H extends IEventEmitterHostClass<any> ? InstanceOf<H> : H;
+type HostFromHostOrHostClass<H> = H extends {
+    event: EventEmitter<null, any>;
+} ? H : H extends IEventEmitterHostClass<any> ? InstanceOf<H> : H;
 export type Emitter = HostOrHostClass;
 export type EmitterOrBus = EventBus | Emitter;
 export type Event<E extends EmitterOrBus> = keyof Events<E extends EventBus ? EventBusHost<E> : E>;