bard-legends-framework 1.5.3 → 1.7.0

package/dist/index.d.ts

@@ -1,15 +1,27 @@
 import * as actions_lib from 'actions-lib';
-import { IDAttachable, Attachable, AttachmentID, IdleSingleEvent, IdleSequence, Sequence, SingleNotifier, Notifier, SingleEvent, Reducer, Variable, Action, ClassID } from 'actions-lib';
-import { Vector, Radian, Rectangle, Vec2, RGBColor, Grid, GridNeighborType, Line } from 'helpers-lib';
+import { IDAttachable, Attachable, AttachmentID, IdleSingleEvent, IdleSequence, Variable, Reducer, Sequence, SingleNotifier, Notifier, SingleEvent, Action, ClassID, NotifierCallbackFunction, IAttachment } from 'actions-lib';
+import { Vector, DynamicID, Vec2, RGBColor, Radian, Rectangle, Grid, GridNeighborType, Line } from 'helpers-lib';
+import p2$1 from 'p2';
 import * as Pixi from 'pixi.js';
 
-declare class ControllerLink {
-    trigger<T>(functionName: string, ...args: any[]): T;
-}
-interface ControllerDecoratorMeta {
-    controllerLink: ControllerLink;
-}
-declare function ControllerDecorator(meta: ControllerDecoratorMeta): (ControllerClass: any) => any;
+/**
+ * Binds a controller to its gateway (the class produced by `Gateway<T>()`). The controller must
+ * structurally match the gateway's controller type, so wiring the wrong controller to a gateway is
+ * a compile error.
+ *
+ * The controller is instantiated now — its constructor dependencies are resolved through the DI
+ * container — and its methods are bound straight onto the gateway prototype, so a later
+ * `gateway.method(...)` is a direct call into the controller with no proxy and no per-call lookup.
+ *
+ * ```ts
+ * @ControllerDecorator(SampleGateway)
+ * export class SampleController {
+ *   constructor(private store: SampleStore) {}
+ *   ...
+ * }
+ * ```
+ */
+declare function ControllerDecorator<TController>(gateway: new () => TController): (ControllerClass: new (...args: any[]) => TController) => void;
 
 type EntityClassType<T extends Entity = Entity> = (new (...args: any[]) => T) & {
     id: number;
@@ -40,6 +52,30 @@ declare abstract class SingletonEntity extends Entity {
     constructor();
 }
 
+/**
+ * Base class factory for a module's public Gateway. Use it as:
+ *
+ * ```ts
+ * @ServiceDecorator()
+ * export class SampleGateway extends Gateway<SampleController>() {}
+ * ```
+ *
+ * The gateway body stays empty:
+ *  - its instance type is its Controller, so calls are type-checked against the controller and
+ *    "go to definition" / F12 jumps straight to the controller method;
+ *  - its methods are installed once, at registration time, by `@ControllerDecorator(ThisGateway)`,
+ *    as bound references to the controller's methods (see `bindControllerToGateway`).
+ *
+ * The controller is referenced here only as a *type* (`Gateway<SampleController>()`), so importing
+ * a gateway never pulls in its controller. That keeps two modules that use each other's gateways
+ * free of import/injection cycles: the gateway is a dependency-free runtime sink.
+ *
+ * Performance: there is no Proxy and no per-call dispatch table. After registration a call is a
+ * prototype-method lookup (monomorphic, inline-cacheable) plus one bound-function call into the
+ * controller — effectively a direct method call.
+ */
+declare function Gateway<TController>(): new () => TController;
+
 declare class BardLegendsHardReset {
     static readonly onHardReset: actions_lib.Notifier<void>;
     static hardReset(): void;
@@ -60,7 +96,6 @@ declare abstract class Scene<InputType, OutputType> extends IDAttachable {
     readonly onClose: actions_lib.PersistentSingleNotifier<OutputType>;
     constructor();
     close(...args: void extends OutputType ? (OutputType extends void ? [] : [OutputType]) : [OutputType]): IdleSingleEvent<OutputType>;
-    private animateAndClose;
     protected abstract init(input: InputType): IdleSingleEvent;
     protected abstract update(time: number, delta: number): void;
     protected abstract prepareToClose(): IdleSingleEvent;
@@ -108,6 +143,227 @@ declare abstract class View extends IDAttachable {
     update(time: number, delta: number): void;
 }
 
+type AudioAppearTransitionType = 'ease' | 'instant';
+declare class Audio {
+    private constructor();
+    setVolumes(volumes: {
+        master: number;
+        music: number;
+        sound: number;
+    }): void;
+    appear(on: boolean, type?: AudioAppearTransitionType): IdleSingleEvent;
+}
+
+interface FocusingNewTargetInfo {
+    time: number;
+    duration: number;
+    position: Vector;
+    roundPosition: boolean;
+    roundPositionThreshold: number;
+    focusingAnimation: FocusingAnimation;
+}
+declare class CameraEntity extends SingletonEntity {
+    readonly position: Variable<Vector>;
+    readonly offset: Variable<Vector>;
+    readonly targetPosition: Variable<Vector | undefined>;
+    readonly focusingNewTargetInfo: Variable<FocusingNewTargetInfo | undefined>;
+}
+
+declare class CameraService {
+    createCamera(): CameraEntity;
+    getCameraPosition(): Vector;
+    setPosition(position: Vector): void;
+    setTransition(options: FocusingOptions): void;
+    update(time: number, delta: number): void;
+}
+
+declare enum CameraLayer {
+    BackgroundScreen = "backgroundScreen",
+    Background = "background",
+    Main = "main",
+    Foreground = "foreground",
+    ForegroundScreen = "foregroundScreen"
+}
+declare enum FocusingAnimation {
+    Instant = 1,
+    EaseInOut = 2,
+    EaseOut = 3
+}
+interface FocusingOptions {
+    duration?: number;
+    animation?: FocusingAnimation;
+    roundPosition?: boolean;
+    roundPositionThreshold?: number;
+}
+type CameraAppearTransitionType = 'alpha' | 'pureBlack' | 'instant';
+
+declare class CameraController {
+    constructor(_cameraService: CameraService);
+    createCamera(): number;
+    update(time: number, delta: number): void;
+    setPosition(position: Vector): void;
+    setTransition(options: FocusingOptions): void;
+    getCameraPosition(): Vector;
+}
+
+declare const CameraGateway_base: new () => CameraController;
+declare class CameraGateway extends CameraGateway_base {
+}
+
+declare class Camera {
+    readonly layers: Record<CameraLayer, number>;
+    get position(): Vector;
+    constructor();
+    setPosition(position: Vector): void;
+    setTransition(options: FocusingOptions): void;
+    appear(on: boolean, type?: CameraAppearTransitionType): IdleSingleEvent;
+    screenPositonToStagePosition(screenPosition: Vector): Vector;
+}
+
+declare const DEFAULT_SHADER_RESOLUTION = 2;
+interface AssetDefinition<T = string> {
+    readonly id: T;
+    readonly url: string;
+}
+declare enum BlendMode {
+    Normal = 0,
+    Add = 1,
+    Screen = 3,
+    Luminosity = 16,
+    ColorDodge = 7
+}
+interface SpriteIDRegistry {
+}
+type SpriteID = DynamicID<SpriteIDRegistry, 'SpriteID'>;
+interface SpriteDefinition {
+    readonly id: SpriteID;
+    readonly scale: number;
+    readonly anchor: Vec2;
+    readonly size: Vec2;
+    readonly boundingShapes?: PolygonDefinition | undefined;
+    readonly destroyAssetOnDestroy?: boolean | undefined;
+}
+interface GlowingShapeDefinition {
+    readonly color: RGBColor;
+    readonly shapeAlpha: number;
+    readonly glowAlpha: number;
+    readonly glowOptions: GlowOptions;
+    readonly shapes: PolygonDefinition;
+}
+type PolygonDefinition = readonly (readonly Vec2[])[];
+interface GlowOptions {
+    readonly color: RGBColor;
+    readonly blurRadius: number | Vector;
+    readonly expand: number;
+    readonly blendMode: BlendMode;
+}
+type GlowEffectOptions = Partial<GlowOptions> & {
+    glowAlpha?: number;
+};
+interface SoundIDRegistry {
+}
+type SoundID = DynamicID<SoundIDRegistry, 'SoundID'>;
+interface SoundDefinition {
+    readonly id: SoundID;
+    readonly duration: number;
+}
+interface MusicIDRegistry {
+}
+type MusicID = DynamicID<MusicIDRegistry, 'MusicID'>;
+interface MusicDefinition {
+    readonly id: MusicID;
+    readonly soundID: SoundID;
+    readonly loop: {
+        readonly from: number;
+        readonly to: number;
+    } | undefined;
+}
+
+interface GameConfiguration {
+    readonly screenResolution: {
+        readonly width: number;
+        readonly height: number;
+    } | undefined;
+    readonly maxScreenResolution: {
+        readonly width: number;
+        readonly height: number;
+    } | undefined;
+    readonly devMode: boolean;
+    readonly backgroundColor: RGBColor;
+    readonly antialias: boolean;
+    readonly resolution: number;
+}
+interface GameSetupOptions {
+    readonly spriteAssetDefinitions: readonly AssetDefinition<SpriteID>[];
+    readonly spriteDefinitions: Readonly<Record<SpriteID, SpriteDefinition>>;
+    readonly fontAssetDefinitions: readonly AssetDefinition[];
+    readonly soundAssetDefinitions: readonly AssetDefinition<SoundID>[];
+    readonly soundDefinitions: Readonly<Record<SoundID, SoundDefinition>>;
+    readonly musicDefinitions: Readonly<Record<MusicID, MusicDefinition>>;
+}
+declare class Game {
+    static get instance(): Game;
+    static readonly pause: Reducer<boolean, boolean>;
+    static readonly freeze: Reducer<boolean, boolean>;
+    static get camera(): Camera;
+    static get audio(): Audio;
+    static appear(on: boolean, options?: {
+        camera?: CameraAppearTransitionType;
+        audio?: AudioAppearTransitionType;
+    }): IdleSingleEvent;
+    static get time(): number;
+    readonly renderer: Pixi.Renderer;
+    readonly _screenSize: Variable<Vector>;
+    readonly screenSize: actions_lib.PersistentNotifier<Vector>;
+    readonly _screenSizeCenter: Variable<Vector>;
+    readonly screenSizeCenter: actions_lib.PersistentNotifier<Vector>;
+    readonly devMode: boolean;
+    constructor(partialConfiguration?: Partial<GameConfiguration>);
+    setup(setupOptions: GameSetupOptions): Promise<void>;
+    setResolution(resolution: number): void;
+}
+
+declare abstract class AudioContainer extends IDAttachable {
+    protected _source: AudioBufferSourceNode;
+    protected _gain: GainNode;
+    protected _startingTime: number;
+    protected readonly _time: Variable<number>;
+    readonly time: actions_lib.PersistentNotifier<number>;
+    constructor(output: AudioNode);
+    get volume(): number;
+    set volume(value: number);
+    setVolume(value: number): this;
+    /**
+     * @param time in seconds
+     * @returns IdleSingleEvent that resolves in the given time
+     */
+    notifyOnTime(targetTime: number): IdleSingleEvent;
+    destroy(): void;
+    protected _play(options: {
+        readonly soundID: SoundID;
+        readonly start: number;
+        readonly end: number;
+        readonly loop: boolean;
+        readonly onComplete?: () => void;
+    }): void;
+}
+
+interface MusicOptions {
+    readonly offset: number;
+    readonly muffle?: number;
+}
+declare class Music extends AudioContainer {
+    static createByName(musicName: MusicID, options?: MusicOptions): Music;
+    constructor(musicDefinition: MusicDefinition, options?: MusicOptions);
+    muffle(strength: number, transitionDuration?: number): IdleSingleEvent;
+    destroy(): void;
+}
+
+declare class Sound extends AudioContainer {
+    static createByName(soundName: SoundID): Sound;
+    constructor(soundDefinition: SoundDefinition);
+}
+
 declare enum ContainerEventType {
     Click = "click",
     MouseOver = "mouseover",
@@ -224,51 +480,13 @@ declare class Filters {
     removeColorFilter(): void;
 }
 
-declare const DEFAULT_SHADER_RESOLUTION = 2;
-interface AssetDefinition<T extends string = string> {
-    readonly id: string;
-    readonly url: T;
-}
-declare enum BlendMode {
-    Normal = 0,
-    Add = 1,
-    Screen = 3,
-    Luminosity = 16,
-    ColorDodge = 7
-}
-interface SpriteDefinition {
-    readonly id: string;
-    readonly scale: number;
-    readonly anchor: Vec2;
-    readonly size: Vec2;
-    readonly boundingShapes?: PolygonDefinition | undefined;
-    readonly destroyAssetOnDestroy?: boolean | undefined;
-}
-interface GlowingShapeDefinition {
-    readonly color: RGBColor;
-    readonly shapeAlpha: number;
-    readonly glowAlpha: number;
-    readonly glowOptions: GlowOptions;
-    readonly shapes: PolygonDefinition;
-}
-type PolygonDefinition = readonly (readonly Vec2[])[];
-interface GlowOptions {
-    readonly color: RGBColor;
-    readonly blurRadius: number | Vector;
-    readonly expand: number;
-    readonly blendMode: BlendMode;
-}
-type GlowEffectOptions = Partial<GlowOptions> & {
-    glowAlpha?: number;
-};
-
 interface SpriteOptions {
     readonly textureSize?: Vector;
     readonly texturePosition?: Vector;
     readonly ignoreAnchor?: boolean;
 }
 declare class Sprite extends Container {
-    static createByName(spriteName: string): Sprite;
+    static createByName(spriteName: SpriteID): Sprite;
     static createSnapshotSprite(container: Container): Sprite;
     readonly pixiSprite: Pixi.Sprite;
     constructor(spriteDefinition: SpriteDefinition, options?: SpriteOptions);
@@ -444,7 +662,7 @@ declare class MenuUI extends Container {
     readonly onCreate: actions_lib.PersistentSingleNotifier<void>;
     readonly onOpen: actions_lib.PersistentSingleNotifier<void>;
     readonly onClose: actions_lib.PersistentSingleNotifier<void>;
-    constructor(windowSprite: string, partialOptions: Partial<MenuOptions>);
+    constructor(windowSprite: SpriteID, partialOptions: Partial<MenuOptions>);
     getBoundingMask(): Sprite;
     close(): IdleSingleEvent;
 }
@@ -453,7 +671,7 @@ interface MenuEntityOptions {
     readonly closeOnBackgroundClick: boolean;
 }
 declare class MenuEntity extends SingletonEntity {
-    static subscribeIsOpen(): IdleSequence<boolean>;
+    static subscribeIsOpen(): Sequence<boolean>;
     constructor(partialOptions: Partial<MenuEntityOptions>);
     onCreate(): IdleSingleEvent;
     onOpen(): IdleSingleEvent;
@@ -469,7 +687,7 @@ declare class MenuView extends View {
     readonly onCreate: SingleNotifier<Container>;
     readonly onOpen: SingleNotifier;
     readonly onClose: SingleNotifier;
-    constructor(entity: MenuEntity, windowSprite: string, partialOptions: Partial<MenuViewOptions>);
+    constructor(entity: MenuEntity, windowSprite: SpriteID, partialOptions: Partial<MenuViewOptions>);
 }
 
 interface ScrollAreaUIOptions {
@@ -496,6 +714,8 @@ declare class AnimationInterpolationFunctions {
     static lineer(time: number): number;
     static easeIn(time: number): number;
     static easeOut(time: number): number;
+    static easeInCubic(time: number): number;
+    static easeOutCubic(time: number): number;
     static easeInOut(time: number): number;
     static easeInOutCubic(t: number): number;
     static blink(t: number): number;
@@ -516,6 +736,14 @@ declare class AnimationEaseInOut implements AnimatorAnimation {
     start(): void;
     multiplierFunction(t: number): number;
 }
+declare class AnimationEaseInCubic implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+declare class AnimationEaseOutCubic implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
 declare class AnimationEaseInOutCubic implements AnimatorAnimation {
     start(): void;
     multiplierFunction(t: number): number;
@@ -533,6 +761,8 @@ declare class Animations {
     static easeIn: AnimationEaseIn;
     static easeOut: AnimationEaseOut;
     static easeInOut: AnimationEaseInOut;
+    static easeInCubic: AnimationEaseInCubic;
+    static easeOutCubic: AnimationEaseOutCubic;
     static easeInOutCubic: AnimationEaseInOutCubic;
     static blink: AnimationBlink;
 }
@@ -711,87 +941,6 @@ declare class ScrollMaskUI extends Container {
     constructor(container: Container, size: Vector, padding: number, direction?: ScrollDirection);
 }
 
-declare enum CameraLayer {
-    BackgroundScreen = "backgroundScreen",
-    Background = "background",
-    Main = "main",
-    Foreground = "foreground",
-    ForegroundScreen = "foregroundScreen"
-}
-declare enum FocusingAnimation {
-    Instant = 1,
-    EaseInOut = 2,
-    EaseOut = 3
-}
-interface FocusingOptions {
-    duration?: number;
-    animation?: FocusingAnimation;
-    roundPosition?: boolean;
-    roundPositionThreshold?: number;
-}
-type CameraAppearTransitionType = 'alpha' | 'pureBlack' | 'instant';
-
-declare class CameraGateway {
-    createCamera(): string;
-    update(time: number, delta: number): void;
-    setPosition(position: Vector): void;
-    setTransition(options: FocusingOptions): void;
-    getCameraPosition(): Vector;
-}
-
-declare class Camera {
-    readonly layers: Record<CameraLayer, number>;
-    get position(): Vector;
-    constructor();
-    setPosition(position: Vector): void;
-    setTransition(options: FocusingOptions): void;
-    appear(on: boolean, type?: CameraAppearTransitionType): IdleSingleEvent;
-}
-
-interface GameConfiguration {
-    readonly screenResolution: {
-        readonly width: number;
-        readonly height: number;
-    } | undefined;
-    readonly maxScreenResolution: {
-        readonly width: number;
-        readonly height: number;
-    } | undefined;
-    readonly devMode: boolean;
-    readonly backgroundColor: RGBColor;
-    readonly antialias: boolean;
-    readonly resolution: number;
-}
-interface GameSetupOptions {
-    readonly assetDefinitions: readonly AssetDefinition<string>[];
-    readonly spriteDefinitions: Readonly<Record<string, SpriteDefinition>>;
-}
-declare class Game {
-    static get instance(): Game;
-    static readonly pause: Reducer<boolean, boolean>;
-    static get camera(): Camera;
-    static get time(): number;
-    readonly stage: Container;
-    readonly renderer: Pixi.Renderer;
-    readonly _screenSize: Variable<Vector>;
-    readonly screenSize: actions_lib.PersistentNotifier<Vector>;
-    readonly _screenSizeCenter: Variable<Vector>;
-    readonly screenSizeCenter: actions_lib.PersistentNotifier<Vector>;
-    readonly devMode: boolean;
-    constructor(partialConfiguration?: Partial<GameConfiguration>);
-    setup(setupOptions: GameSetupOptions): Promise<void>;
-    setResolution(resolution: number): void;
-    screenPositonToStagePosition(screenPosition: Vector): Vector;
-    setScreenPositionToStagePositionFunction(converterFunction: (screenPosition: Vector) => Vector): void;
-    resetScreenPositionToStagePositionFunction(): void;
-    destroyAsset(assetID: string): void;
-}
-
-declare class PositionConversionHelper {
-    static includeScaleInScreenPosition(screenPosition: Vector, gameInstanceScale: number, screenSizeCenter: Vector): Vector;
-    static normalizePolygonByAnchor(polygon: PolygonDefinition, frameSize: Vector, frameAnchor: Vector): PolygonDefinition;
-}
-
 interface KeyboardKeyInfo {
     readonly key: string;
     readonly code: string;
@@ -819,7 +968,6 @@ declare class MouseService {
      * accounting for canvas offset (e.g. letterboxing when max resolution is smaller than the window)
      * and CSS scaling of the canvas.
      */
-    private clientPositionToScreenPosition;
 }
 
 declare class MouseTargetFocusService {
@@ -995,7 +1143,147 @@ interface MapSizeDTO {
     readonly center: Vector;
 }
 
-declare class PhysicsGateway {
+declare class PhysicsWorldEntity extends Entity {
+    readonly mapSize: Vector;
+    readonly mapSizeCenter: Vector;
+    readonly modifyUpdateCycle: boolean;
+    readonly p2World: p2$1.World;
+    readonly materials: Readonly<Map<string, p2$1.Material>>;
+    readonly materialDefinitions: Map<string, MaterialDefinition>;
+    readonly physicsBodyGroupToP2Group: Map<string, number>;
+    readonly physicsBodyGroupToP2Mask: Map<string, number>;
+    readonly availabilityGridCache: Map<number, Map<PhysicsBodyGroup, Grid<boolean>>>;
+    readonly vectorFieldCache: Map<string, VectorFieldPathFinder>;
+    readonly bodiesInContactWith: Map<number, {
+        p2Body: p2$1.Body;
+        entity: PhysicsEntity;
+    }>;
+    readonly collisionReports: Map<number, CollisionReport[]>;
+    readonly paused: Variable<boolean>;
+    readonly lastP2Time: Variable<number>;
+    readonly onPhysicsStep: Action<{
+        time: number;
+        delta: number;
+    }>;
+    constructor(mapSize: Vector, modifyUpdateCycle: boolean, p2World: p2$1.World, materials: Map<string, p2$1.Material>, materialContactDefinitions: Map<string, MaterialDefinition>, physicsBodyGroupToP2Group: Map<PhysicsBodyGroup, number>, physicsBodyGroupToP2Mask: Map<PhysicsBodyGroup, number>);
+}
+
+declare class PhysicsBodyGroupService {
+    createBodyGroupsAndMasks(physicsBodyGroups: readonly PhysicsBodyGroup[], interactingBodyGroups: InteractingBodyGroups): {
+        readonly physicsBodyGroupToP2Group: Map<PhysicsBodyGroup, number>;
+        readonly physicsBodyGroupToP2Mask: Map<PhysicsBodyGroup, number>;
+    };
+    getGroupConstant(physicsWorldID: number, group: PhysicsBodyGroup): number;
+    getMaskConstant(physicsWorldID: number, group: PhysicsBodyGroup): number;
+    canCollide(physicsWorld: PhysicsWorldEntity, groupType1: PhysicsBodyGroup, groupType2: PhysicsBodyGroup): boolean;
+}
+
+declare class AvailabilityGridCacheService {
+    constructor(_physicsBodyGroupService: PhysicsBodyGroupService);
+    getCollidableGrids(physicsWorld: PhysicsWorldEntity, physicsBodyGroup: PhysicsBodyGroup): {
+        grid: Grid<boolean>;
+        cellSize: number;
+    }[];
+    get(physicsWorld: PhysicsWorldEntity, cellSize: number, group: PhysicsBodyGroup): Grid<boolean> | undefined;
+    set(physicsWorld: PhysicsWorldEntity, cellSize: number, group: PhysicsBodyGroup, grid: Grid<boolean>): void;
+    clear(physicsWorld: PhysicsWorldEntity): void;
+}
+
+declare class AvailabilityGridService {
+    constructor(_physicsBodyGroupService: PhysicsBodyGroupService, _availabilityGridCacheService: AvailabilityGridCacheService);
+    onBodyAdded(physicsWorld: PhysicsWorldEntity, body: p2.Body, physicsBodyGroup: PhysicsBodyGroup): void;
+    findClosestAvailableSpace(physicsWorld: PhysicsWorldEntity, body: p2.Body, physicsBodyGroup: PhysicsBodyGroup, gridCellSize?: number): Vector | undefined;
+    getAvilabilityGrid(physicsWorld: PhysicsWorldEntity, cellSize: number, physicsBodyGroup: PhysicsBodyGroup): Grid<boolean>;
+}
+
+declare class PathFinderService {
+    constructor(_physicsAvailabilityGrid: AvailabilityGridService);
+    findPathAStar(physicsWorldID: number, startingPosition: Vector, target: Vector | number, collidableWithGroup: PhysicsBodyGroup, options?: {
+        neighborType?: GridNeighborType;
+        gridCellSize?: number;
+    }): PathFinderResult;
+    findPathDirection(physicsWorldID: number, startingPosition: Vector, target: Vector | number, collidableWithGroup: PhysicsBodyGroup, gridCellSize?: number): Radian | undefined;
+}
+
+declare class TestVisualsService {
+    constructor(_availabilityGridService: AvailabilityGridService, _pathFinderService: PathFinderService);
+    printPathfindingTestGrid(physicsWorldID: number, testLayerID: number, target: Vector | number, physicsBodyGroup: PhysicsBodyGroup, area: Rectangle, gridCellSize: number): void;
+    createExplosionDebugVisual(physicsWorld: PhysicsWorldEntity, testLayerID: number, rayCasts: RayCast[], explosionCenter: Vector, radius: number, duration?: number): void;
+    createElipticExplosionDebugVisual(physicsWorld: PhysicsWorldEntity, testLayerID: number, rayCasts: RayCast[], explosionCenter: Vector, rotation: Radian, size: Vector, duration?: number): void;
+    createPhysicsEntityShapeVisual(p2Body: p2$1.Body, testLayerID: number, options?: {
+        overridePosition?: Vector | undefined;
+        overrideRotation?: Radian | undefined;
+        color?: RGBColor | undefined;
+    }): void;
+}
+
+declare class HitTestService {
+    constructor(_testVisualsService: TestVisualsService);
+    hitTest(p2Body: p2$1.Body, options?: Partial<HitTestOptions>): boolean;
+}
+
+declare class CollisionsService {
+    registerPhysicsWorld(physicsWorld: PhysicsWorldEntity): void;
+    step(physicsWorld: PhysicsWorldEntity, time: number, delta: number): void;
+}
+
+declare class BorderService {
+    createBorders(physicsWorldID: AttachmentID, mapSize: Vector, borderBodyGroup: PhysicsBodyGroup): void;
+}
+
+declare class MaterialsService {
+    createMaterials(p2World: p2$1.World, borderProperties: BorderProperties, materialDefinitions: readonly MaterialDefinition[], materialContactDefinitions: readonly MaterialContactDefinition[]): {
+        materials: Map<string, p2$1.Material>;
+        materialDefinitions: Map<string, MaterialDefinition>;
+    };
+    getMaterial(physicsWorldID: number, name: string): p2$1.Material;
+    getMaterialDefinition(physicsWorldID: number, name: string): MaterialDefinition;
+}
+
+declare class PhysicsWorldService {
+    constructor(_materialsService: MaterialsService, _borderService: BorderService, _availabilityGridService: AvailabilityGridService, _collisionsService: CollisionsService, _physicsBodyGroupService: PhysicsBodyGroupService);
+    createPhysicsWorld(request: CreatePhysicsWorldRequestDTO): number;
+    addBody(physicsWorldID: number, body: p2$1.Body, addInEmptySpace: boolean, physicsBodyGroup: PhysicsBodyGroup, includeOnPathfinding: boolean): boolean;
+    removeBody(physicsWorldID: number, body: p2$1.Body): void;
+    setPaused(pause: boolean, physicsWorldID: number): void;
+}
+
+declare class RayCastingService {
+    castClosest(physicsWorld: PhysicsWorldEntity, line: Line, physicsBodyGroup: PhysicsBodyGroup): RayCastHit | undefined;
+    castAllFirstContacts(physicsWorld: PhysicsWorldEntity, line: Line, physicsBodyGroup: PhysicsBodyGroup): RayCastHit[];
+}
+
+declare class ImpactService {
+    applyImpulse(body: p2.Body, hitPosition: Vector, hitDirection: Vector, severity: number): void;
+}
+
+interface ExplosionHitWithP2Body extends ExplosionHit {
+    p2Body: p2.Body;
+}
+declare class RayCastHitConverterService {
+    toExplosionHits(rayCasts: RayCast[], allRaysStartingFromSamePosition?: boolean): ExplosionHitWithP2Body[];
+}
+
+declare class ElipticExplosionService {
+    constructor(_rayCastingService: RayCastingService, _testVisualsService: TestVisualsService, _rayCastHitConverterService: RayCastHitConverterService, _impactService: ImpactService);
+    createElipticExplosion(physicsWorldID: number, explosionCenter: Vector, rotation: Radian, size: Vector, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
+}
+
+declare class ExplosionService {
+    constructor(_rayCastingService: RayCastingService, _testVisualsService: TestVisualsService, _rayCastHitConverterService: RayCastHitConverterService, _impactService: ImpactService);
+    createExplosion(physicsWorldID: number, explosionCenter: Vector, radius: number, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
+}
+
+declare class PhysicsQueryService {
+    getMapSize(physicsWorldID: number): MapSizeDTO;
+    subscribeToPhysicsStep(physicsWorldID: number, callback: NotifierCallbackFunction<{
+        time: number;
+        delta: number;
+    }>): IAttachment;
+}
+
+declare class PhysicsController {
+    constructor(_physicsWorldService: PhysicsWorldService, _pathFinderService: PathFinderService, _testVisualsService: TestVisualsService, _explosionService: ExplosionService, _elipticExplosionService: ElipticExplosionService, _hitTestService: HitTestService, _physicsQueryService: PhysicsQueryService, _impactService: ImpactService);
     createPhysicsWorld(request: CreatePhysicsWorldRequestDTO): number;
     getMapSize(physicsWorldID: number): MapSizeDTO;
     setPaused(pause: boolean, physicsWorldID: number): void;
@@ -1008,4 +1296,8 @@ declare class PhysicsGateway {
     printPathfindingTestGrid(physicsWorldID: number, testLayerID: number, target: Vector | number, physicsBodyGroup: PhysicsBodyGroup, area: Rectangle, gridCellSize?: number): void;
 }
 
-export { AnimationFlicker, AnimationInterpolationFunctions, type AnimationOptions, Animations, AnimationsCompletionHandlingType, Animator, type AnimatorAnimation, type AssetDefinition, BORDER_MATERIAL_NAME, BardLegendsHardReset, BlendMode, type BorderProperties, Camera, CameraGateway, type CircleShapeData, ClosestAvailableSpaceHelper, type CollisionDetails, type CollisionReport, Container, ContainerEventType, ControllerDecorator, type ControllerDecoratorMeta, ControllerLink, type CreateDashedLineOptions, type CreatePhysicsWorldRequestDTO, Cursor, DEFAULT_SHADER_RESOLUTION, DeltaTime, DisplayObjectArray, type DisplayObjectArrayOptions, type DropShadowOptions, Entity, EntityDecorator, type ExplosionHit, FadeInContent, type FadeInContentOptions, FadeInStateAnimation, FocusingAnimation, Game, type GlowEffectOptions, type GlowOptions, type GlowingShapeDefinition, Graphics, type HitTestOptions, ImmovablePhysicsEntity, type InteractingBodyGroups, type KeyboardKeyInfo, KeyboardService, type MapSizeDTO, type MaterialContactDefinition, type MaterialDefinition, MenuEntity, type MenuOptions, MenuUI, MenuView, MouseService, MouseTargetFocusService, MovableEntity, MovablePhysicsEntity, type PartialTextOptions, PathFinder, type PathFinderResult, type PhysicsBodyDTO, PhysicsEntity, type PhysicsEntityDefinition, type PhysicsExplosionOptions, PhysicsGateway, PhysicsShapeType, Placeholder, type PolygonDefinition, type PolygonShapeData, PositionConversionHelper, ROTATIONAL_SPEED_LIMIT, type RayCast, type RayCastHit, ReAnimateHandlingType, type RectangleShapeData, RichText, type RichTextOptions, type RichTextRectangleCut, type RichTextStyles, SPEED_LIMIT, Scene, SceneDecorator, ScrollAreaUI, ScrollDirection, type ScrollInContentOptions, ScrollMaskUI, Service, ServiceDecorator, type SetParentOptions, type ShapeDefinition, SingletonEntity, SlideInContent, SlideInContentByIndex, SlideStateAnimation, SlideStateAnimationState, Sprite, type SpriteDefinition, StateAnimation, type StateAnimationOptions, Text, type TextAlignment, type TextOptions, UpdatableContainer, UpdateCycle, VectorFieldPathFinder, VectorSet, View, ViewDecorator, type ViewDecoratorMeta };
+declare const PhysicsGateway_base: new () => PhysicsController;
+declare class PhysicsGateway extends PhysicsGateway_base {
+}
+
+export { AnimationFlicker, AnimationInterpolationFunctions, type AnimationOptions, Animations, AnimationsCompletionHandlingType, Animator, type AnimatorAnimation, type AssetDefinition, type AudioAppearTransitionType, BORDER_MATERIAL_NAME, BardLegendsHardReset, BlendMode, type BorderProperties, Camera, CameraGateway, type CircleShapeData, ClosestAvailableSpaceHelper, type CollisionDetails, type CollisionReport, Container, ContainerEventType, ControllerDecorator, type CreateDashedLineOptions, type CreatePhysicsWorldRequestDTO, Cursor, DEFAULT_SHADER_RESOLUTION, DeltaTime, DisplayObjectArray, type DisplayObjectArrayOptions, type DropShadowOptions, Entity, EntityDecorator, type ExplosionHit, FadeInContent, type FadeInContentOptions, FadeInStateAnimation, FocusingAnimation, Game, Gateway, type GlowEffectOptions, type GlowOptions, type GlowingShapeDefinition, Graphics, type HitTestOptions, ImmovablePhysicsEntity, type InteractingBodyGroups, type KeyboardKeyInfo, KeyboardService, type MapSizeDTO, type MaterialContactDefinition, type MaterialDefinition, MenuEntity, type MenuOptions, MenuUI, MenuView, MouseService, MouseTargetFocusService, MovableEntity, MovablePhysicsEntity, Music, type MusicDefinition, type MusicID, type MusicIDRegistry, type PartialTextOptions, PathFinder, type PathFinderResult, type PhysicsBodyDTO, PhysicsEntity, type PhysicsEntityDefinition, type PhysicsExplosionOptions, PhysicsGateway, PhysicsShapeType, Placeholder, type PolygonDefinition, type PolygonShapeData, ROTATIONAL_SPEED_LIMIT, type RayCast, type RayCastHit, ReAnimateHandlingType, type RectangleShapeData, RichText, type RichTextOptions, type RichTextRectangleCut, type RichTextStyles, SPEED_LIMIT, Scene, SceneDecorator, ScrollAreaUI, ScrollDirection, type ScrollInContentOptions, ScrollMaskUI, Service, ServiceDecorator, type SetParentOptions, type ShapeDefinition, SingletonEntity, SlideInContent, SlideInContentByIndex, SlideStateAnimation, SlideStateAnimationState, Sound, type SoundDefinition, type SoundID, type SoundIDRegistry, Sprite, type SpriteDefinition, type SpriteID, type SpriteIDRegistry, StateAnimation, type StateAnimationOptions, Text, type TextAlignment, type TextOptions, UpdatableContainer, UpdateCycle, VectorFieldPathFinder, VectorSet, View, ViewDecorator, type ViewDecoratorMeta };