rul2d/dist/index.d.ts

Rul2d is a powerful and flexible TypeScript library for creating games using HTML5 Canvas.

interface IAngle {
    radians: number;
}

interface IAngleable {
    setAngle(angle: Angle): void;
    addAngle(angle: Angle): void;
}

declare abstract class CustomObject {
    private static createdObjectsCount;
    private _id;
    constructor();
    loadJSONFromFile(src: string): Promise<void>;
    protected _loadJSONFromFile(result: Record<string, any>): Promise<void>;
    get id(): number;
    log(): void;
    simplify(): {};
    toString(): string;
    toJSONString(): string;
    valueOf(): number;
}

declare class Angle extends CustomObject implements IAngleable {
    static Pi: number;
    static Pi2: number;
    static Rad_1: number;
    private _radians;
    static degToRad(deg: number): number;
    static radToDeg(rad: number): number;
    static from(rad: number): Angle;
    static fromRadians(rad: number): Angle;
    static fromDegrees(deg: number): Angle;
    constructor();
    set radians(rad: number);
    get radians(): number;
    set degrees(deg: number);
    get degrees(): number;
    simplify(): IAngle;
    setAngle(angle: Angle): void;
    addAngle(angle: Angle): void;
    valueOf(): number;
    toString(): string;
}

interface ISimplePoint {
    x: number;
    y: number;
}

interface IPointable {
    set point(value: ISimplePoint);
    get point(): PointType;
    set x(value: number);
    get x(): number;
    set y(value: number);
    get y(): number;
    setPosition(x?: number, y?: number): void;
    addPosition(x: number, y: number): void;
    move(point: ISimplePoint, delta: number): void;
}

interface IRoot {
    get inheritOpacity(): number;
    get zIndex(): number;
}

interface ISimpleSize {
    width: number;
    height: number;
}

interface ISizeable {
    set center(value: ISimplePoint);
    get center(): PointType;
    set size(value: ISimpleSize);
    get size(): ISizeable;
    setSize(width?: number, height?: number): void;
}

interface IRectangle extends ISizeable, IPointable {
    get bottom(): number;
    get right(): number;
}

interface ISimpleRect extends ISimplePoint, ISimpleSize {
}

interface IMinMax {
    min: number;
    max: number;
}

interface ISimpleCamera extends ISimplePoint {
    zoom: number;
    zoomLimit: IMinMax;
}

declare class Bounds extends CustomObject implements IMinMax {
    min: number;
    max: number;
    constructor(min: number, max: number);
    set(min: number, max: number): void;
    get(value: number): number;
    simplify(): IMinMax;
}

interface ISimpleDrawableObject {
    color: {
        r: number;
        g: number;
        b: number;
        a: number;
    };
    lineWidth: number;
    opacity: number;
    zIndex: number;
}

interface ISimpleShape extends ISimplePoint {
    size: ISimpleSize;
    angle: IAngle;
}

declare class CachedValue<T, V = undefined> extends CustomObject {
    private _cachedValue;
    private _isNeedUpdate;
    private _updateCallback;
    constructor(defaultValue: T);
    needUpdate(value?: boolean | null): void;
    setUpdateCallback(callback?: (value?: V) => T): void;
    get(value?: V): T;
    update(value?: V): T;
    simplify(): {
        value: T;
        isNeedUpdate: boolean;
    };
}

declare class Size extends CustomObject implements ISizeable {
    width: number;
    height: number;
    constructor(width?: number, height?: number);
    setSize(width?: number, height?: number): void;
    set center({ x, y }: ISimplePoint);
    get center(): PointType;
    set size({ width, height }: ISimpleSize);
    get size(): ISizeable;
    simplify(): ISimpleSize;
}

declare class Shape extends Point implements IRectangle, IAngleable {
    static rotatePoints(corners: Point[], angle: Angle, center: Point): Point[];
    static cosBounds: Bounds;
    protected _isCachedValueExist: boolean;
    protected _size: Size;
    protected _cachedPath: CachedValue<Path2D>;
    protected _cachedBoundingBox: CachedValue<ISimpleRect>;
    protected _cachedCorners: CachedValue<Point[]>;
    protected _angle: Angle;
    protected _flipDirection: Point;
    constructor(x?: number, y?: number, width?: number, height?: number);
    get bottom(): number;
    get right(): number;
    flip(x: boolean, y: boolean): void;
    flipHorisontally(value: boolean): void;
    flipVertically(value: boolean): void;
    protected _updateCorners(): Point[];
    getCorners(): Point[];
    protected _updateBox(): ISimpleRect;
    getBox(): ISimpleRect;
    protected _updatePath(): Path2D;
    getPath(): Path2D;
    set size(value: ISimpleSize);
    get size(): Size;
    set center({ x, y }: ISimplePoint);
    get center(): Point;
    needUpdate(value?: boolean | null): void;
    isObjectInViewport(camera: Camera): boolean;
    setPosition(x?: number, y?: number): void;
    setSize(width?: number, height?: number): void;
    setAngle(angle: Angle): void;
    addAngle(angle: Angle): void;
    set angle(value: Angle);
    get angle(): Angle;
    get factRect(): ISimpleRect;
    simplify(): ISimpleDrawableObject & ISimpleShape;
    protected _stroke(ctx: Context): void;
    protected _fill(ctx: Context): void;
    clip(ctx: Context, callback: (path: Path2D) => void): void;
    isShapesIntersects(shape: Shape): boolean;
    isPointInBoundingBox(point: Point): boolean;
    isBoxesIntersects(other: ISimpleRect): boolean;
    isPointInShape(point: Point): boolean;
    drawTransformed(ctx: Context, cb: (x: number, y: number, width: number, height: number) => void): void;
}

declare class Rectangle extends Shape implements IRectangle {
    constructor(x?: number, y?: number, width?: number, height?: number);
    get bottom(): number;
    get right(): number;
    set rect({ x, y, width, height }: ISimpleRect);
    get rect(): Rectangle;
    set rotatedRectangle(rect: ISimpleRect & IAngle);
    get rotatedRectangle(): Rectangle;
    protected _updateCorners(): Point[];
    static from(position: ISimplePoint, size: ISimpleSize): Rectangle;
    static fromSimpleRectangle(rect: ISimpleRect): Rectangle;
    static fromPoints(first: Point, second: Point): Rectangle;
}

declare class StorageEvent<T> extends Event {
    key?: keyof T;
    value?: T[keyof T];
}

interface IEventOptions {
    isOnce?: boolean;
}

declare class EventEmitter<Type = any, Key extends string = string> extends CustomObject {
    protected _events: Dict<Set<EventCallback<Type>>>;
    constructor();
    on(key: Key, callback: EventCallback<Type>, { isOnce }?: IEventOptions): void;
    once(key: Key, callback: EventCallback<Type>): void;
    off(key: Key, callback: EventCallback<Type>): boolean;
    emit(key: Key, value?: Type): void;
}

declare class LocalStorageManager<T extends Record<string, any>> extends EventEmitter<StorageEvent<T>, LocalStorageEmitKeys> {
    private _name;
    private _value;
    private _isLoaded;
    constructor(name: string);
    private _load;
    set<K extends keyof T>(key: K, value: T[K]): void;
    setAll<K extends keyof T>(obj: Partial<T>): void;
    get<K extends keyof T>(key: K, defaultValue?: T[K]): T[K] | undefined;
    getAll(): Partial<T>;
}

declare class Camera extends CustomObject implements IPointable, IAngleable {
    static addStandardWheelListener(camera: Camera): boolean;
    static loadCameraFromStorage(storage: LocalStorageManager<ISimpleCamera>, camera: Camera): void;
    static addStandardCameraSaver(storageName: string, camera: Camera): void;
    protected _ctx: Context | null;
    protected _zoom: number;
    protected _zoomLimit: Bounds;
    protected _position: Point;
    protected _targetPosition: Point;
    protected _angle: Angle;
    protected _smoothingEnabled: boolean;
    protected _smoothingQuality: SmoothingQuality;
    protected _lerpFactor: number;
    protected _cachedViewport: CachedValue<Rectangle>;
    constructor(ctx?: Context);
    setSmoothFactor(factor: number): void;
    setSmoothing(enabled: boolean, quality: SmoothingQuality): void;
    updateSmoothing(): void;
    setAngle(angle: Angle): void;
    addAngle(angle: Angle): void;
    get canvas(): Canvas | null;
    setZoomLimit(min: number, max: number): void;
    protected _updateViewport(): Rectangle;
    get viewport(): Rectangle;
    set x(value: number);
    get x(): number;
    set y(value: number);
    get y(): number;
    set zoom(value: number);
    get zoom(): number;
    set point(value: PointType);
    get point(): PointType;
    updatePosition(): boolean;
    get position(): Point;
    get target(): Point;
    setPositionInstant(x?: number, y?: number): void;
    setPosition(x?: number, y?: number): void;
    addPosition(x: number, y: number): void;
    move(point: ISimplePoint, delta: number): void;
    doIfContextExist(cb: (ctx: Context) => void): void;
    setContext(ctx: Context): void;
    begin(): void;
    translate(): void;
    scale(): void;
    rotate(): void;
    end(): void;
    update(callback: (ctx: Context) => void): void;
    simplify(): ISimpleCamera;
}

/**
 * Enum that defines the way an object will be rendered
 */
declare enum DrawMode {
    /**
     * Only the filled part is rendered
     */
    Fill = 0,
    /**
     Only the outline is rendered.
     */
    Stroke = 1,
    /**
     * The outline and the filled part are rendered
     */
    All = 2
}

interface IManager {
    updateZIndex(): void;
}

declare class Color extends CustomObject {
    static componentBounds: Bounds;
    private _r;
    private _g;
    private _b;
    private _a;
    constructor();
    setRGBA(r: number, g: number, b: number, a?: number): this;
    toString(): string;
    simplify(): {
        r: number;
        g: number;
        b: number;
        a: number;
    };
    static interpolate(first: Color, second: Color, factor: number): Color;
    static from(r: number, g: number, b: number, a?: number): Color;
    static fromSimple({ r, g, b, a }: {
        r: number;
        g: number;
        b: number;
        a: number;
    }): Color;
    static random(a?: number): Color;
    static get Transparent(): Color;
    static get Black(): Color;
    static get White(): Color;
    static get Red(): Color;
    static get Blue(): Color;
    static get Green(): Color;
}

interface INetClient<T = any> {
    open(ip: string): void;
    on(key: string, callback: EventCallback<T>, options?: IEventOptions): void;
    once(key: string, callback: EventCallback<T>, options?: IEventOptions): void;
    off(key: string, callback: EventCallback<T>, options?: IEventOptions): boolean;
    send(type: string, value: CustomObject): void;
    close(code?: number, reason?: string): void;
}

interface IGameWorldOptions {
    root?: HTMLElement;
    camera?: Camera;
    size?: ISimpleSize | null;
    useCulling?: boolean;
    netClient?: INetClient;
}

interface ITempCanvasOptions {
    size: ISimpleSize;
    callback: (ctx: Context) => void;
    quality?: number;
    mimeImageType?: string;
}

declare class CanvasManager extends CustomObject {
    static tempCanvasManager: CanvasManager | null;
    static createImageURLFromTempCanvas({ size, quality, mimeImageType: imageType, callback }: ITempCanvasOptions): string;
    static createTempCanvasManager(root: HTMLElement, size: ISimpleSize): CanvasManager;
    private _canvas;
    private _ctx;
    private _isContextNeedUpdate;
    constructor();
    get canvas(): Canvas | null;
    get ctx(): Context | null;
    get isCanvasExist(): boolean;
    setCanvas(canvas: Canvas): void;
    getContext(): Context | null;
    resize({ width, height }: ISimpleSize): void;
    resizeToClientRect(): void;
    create({ root, size }?: {
        root?: HTMLElement;
        size?: ISimpleSize | null;
    }): Canvas;
    clear({ x, y }?: ISimplePoint): void;
    addStandardResizeHandler(): void;
    simplify(): {
        isContextNeedUpdate: boolean;
    };
}

declare abstract class UIObject extends GameEntity {
    abstract setSize(width?: number, height?: number): void;
}

interface IShapeConfig {
    setShape(shape: Shape): void;
    set shape(shape: Shape);
    get shape(): Shape;
}

declare class ShapeableObject extends DrawableObject implements IShapeConfig, IRectangle, IAngleable {
    protected _shape: Shape;
    constructor(x?: number, y?: number, width?: number, height?: number);
    get bottom(): number;
    get right(): number;
    set point(value: ISimplePoint);
    get point(): PointType;
    set x(value: number);
    get x(): number;
    set y(value: number);
    get y(): number;
    updatePositionByOffset(point: ISimplePoint): void;
    addPosition(x: number, y: number): void;
    move(point: ISimplePoint, delta: number): void;
    setPosition(x?: number, y?: number): void;
    set center(value: PointType);
    get center(): PointType;
    set size(value: ISimpleSize);
    get size(): Size;
    setSize(width?: number, height?: number): void;
    isPointInShape(point: Point): boolean;
    setShape(shape: Shape): void;
    setAngle(angle: Angle): void;
    addAngle(angle: Angle): void;
    set shape(shape: Shape);
    get shape(): Shape;
    get factRect(): ISimpleRect;
    setOffset(x: number, y: number): void;
    set offset({ x, y }: ISimplePoint);
    get offset(): ISimplePoint;
    protected _fill(ctx: Context): void;
    protected _stroke(ctx: Context): void;
    protected _draw(ctx: Context): void;
    update(delta: number): void;
    isObjectInViewport(camera: Camera): boolean;
}

declare class PointerableObject extends ShapeableObject implements IShapeConfig, IRectangle {
    protected _nonDownCallbackFactory(cb: PointCallback): PointCallback;
    protected _hoverCallback: PointCallback;
    protected _pressedCallback: PointCallback;
    protected _downCallback: PointCallback;
    protected _upCallback: PointCallback;
    protected _nonInteractiveCallback: PointCallback;
    protected _isPressed: boolean;
    isPressedInFrame: boolean;
    constructor(x?: number, y?: number, width?: number, height?: number);
    get isPressed(): boolean;
    get hoverCallback(): PointCallback;
    get pressedCallback(): PointCallback;
    get nonInteractiveCallback(): PointCallback;
    doWhenDown(cb: PointCallback): void;
    doWhenUp(cb: PointCallback): void;
    doWhenPressed(cb: PointCallback): void;
    doWhenHover(cb: PointCallback): void;
    doWhenNotInteracted(cb: PointCallback): void;
}

declare class PointerInputManager extends CustomObject implements IManager {
    private static _pointerableSortCallback;
    private _pointersLocation;
    private _cursorPosition;
    private _pointerables;
    private _camera;
    private _isPressed;
    constructor();
    private _setCursorPoint;
    private _getPointerIndex;
    private _createPoint;
    private _editPoint;
    private _downEventCallback;
    private _moveEventCallback;
    private _upEventCallback;
    private _allControlsEventCallback;
    setCamera(camera: Camera): void;
    getCursorPosition(): Point;
    private _updatePointWithCamera;
    addPointerable(obj: PointerableObject): void;
    removePointerable(obj: PointerableObject): void;
    addControls(canvas: Canvas): void;
    updateZIndex(): void;
    get isPressed(): boolean;
    update(): void;
}

declare abstract class GameObject extends DrawableObject implements IManager {
    protected _objects: DrawableObject[];
    constructor();
    protected _addObjectToArray<T extends DrawableObject>(object: T, arr: T[]): boolean;
    protected _removeObjectFromArray<T extends DrawableObject>(object: T, arr: T[]): boolean;
    setPointerManager(manager: PointerInputManager): void;
    forUI(callback: (obj: UIObject, index: number) => void): void;
    forAll(callback: (obj: DrawableObject, index: number) => void): void;
    addObjects(...objects: DrawableObject[]): void;
    addObject(object: DrawableObject): boolean;
    removeObject(object: DrawableObject): boolean;
    forEach(callback?: (obj: DrawableObject, index: number) => void): void;
    protected _preload(world: GameWorld): Promise<void>;
    preload(world: GameWorld): Promise<void>;
    protected _create(world: GameWorld): DrawableObject[];
    init(world: GameWorld): void;
    protected _draw(ctx: Context): void;
    updateObjects(delta: number): void;
    updatePositionByOffset(point: ISimplePoint): void;
    protected _update(delta: number): void;
    update(delta: number): void;
    updateZIndex(): void;
    isObjectInViewport(camera: Camera): boolean;
    get factRect(): ISimpleRect;
}

declare abstract class GameEntity extends GameObject implements IPointable {
    protected _position: Point;
    protected _factRect: CachedValue<ISimpleRect>;
    constructor(x?: number, y?: number);
    addObject(object: DrawablePointerable): boolean;
    removeObject(object: DrawablePointerable): boolean;
    get factRect(): ISimpleRect;
    set x(value: number);
    get x(): number;
    set y(value: number);
    get y(): number;
    set point(point: ISimplePoint);
    get point(): PointType;
    setPosition(x?: number, y?: number): void;
    addPosition(x: number, y: number): void;
    move(point: ISimplePoint, delta: number): void;
    updateObjectsPosition(): void;
    protected _updateFactRect(): ISimpleRect;
    isObjectInViewport(camera: Camera): boolean;
    updatePositionByOffset(point: ISimplePoint): void;
    update(delta: number): void;
}

declare abstract class GameScene extends GameObject {
    protected _uiObjects: UIObject[];
    constructor();
    protected get _allObjects(): GameEntity[];
    get canBeSubObject(): boolean;
    private _addUI;
    addObject(object: GameEntity): boolean;
    private _removeUI;
    removeObject(object: DrawableObject): boolean;
    forUI(callback: (obj: UIObject, index: number) => void): void;
    protected _init(world: GameWorld): void;
    init(world: GameWorld): void;
    protected _preload(world: GameWorld): Promise<void>;
    updateObjects(delta: number): void;
    updateZIndex(): void;
    drawUI(ctx: Context): void;
}

declare enum KeyCodes {
    Any = "Any",
    All = "All",
    A = "KeyA",
    B = "KeyB",
    C = "KeyC",
    D = "KeyD",
    E = "KeyE",
    F = "KeyF",
    G = "KeyG",
    H = "KeyH",
    I = "KeyI",
    J = "KeyJ",
    K = "KeyK",
    L = "KeyL",
    M = "KeyM",
    N = "KeyN",
    O = "KeyO",
    P = "KeyP",
    Q = "KeyQ",
    R = "KeyR",
    S = "KeyS",
    T = "KeyT",
    U = "KeyU",
    V = "KeyV",
    W = "KeyW",
    X = "KeyX",
    Y = "KeyY",
    Z = "KeyZ",
    D0 = "Digit0",
    D1 = "Digit1",
    D2 = "Digit2",
    D3 = "Digit3",
    D4 = "Digit4",
    D5 = "Digit5",
    D6 = "Digit6",
    D7 = "Digit7",
    D8 = "Digit8",
    D9 = "Digit9",
    Num0 = "Numpad0",
    Num1 = "Numpad1",
    Num2 = "Numpad2",
    Num3 = "Numpad3",
    Num4 = "Numpad4",
    Num5 = "Numpad5",
    Num6 = "Numpad6",
    Num7 = "Numpad7",
    Num8 = "Numpad8",
    Num9 = "Numpad9",
    F1 = "F1",
    F2 = "F2",
    F3 = "F3",
    F4 = "F4",
    F5 = "F5",
    F6 = "F6",
    F7 = "F7",
    F8 = "F8",
    F9 = "F9",
    F10 = "F10",
    F11 = "F11",
    F12 = "F12",
    ArrowUp = "ArrowUp",
    ArrowDown = "ArrowDown",
    ArrowLeft = "ArrowLeft",
    ArrowRight = "ArrowRight",
    Enter = "Enter",
    Space = "Space",
    Esc = "Escape",
    Tab = "Tab",
    BackSpace = "Backspace",
    Delete = "Delete",
    ShiftLeft = "ShiftLeft",
    ShiftRight = "ShiftRight",
    CtrlLeft = "ControlLeft",
    CtrlRight = "ControlRight",
    AltLeft = "AltLeft",
    AltRight = "AltRight",
    MetaLeft = "MetaLeft",
    MetaRight = "MetaRight",
    CapsLock = "CapsLock",
    NumLock = "NumLock",
    Comma = "Comma",
    Period = "Period",
    Slash = "Slash",
    BackSlash = "Backslash",
    Semicolon = "Semicolon",
    Quote = "Quote",
    BracketLeft = "BracketLeft",
    BracketRight = "BracketRight",
    Minus = "Minus",
    Equal = "Equal"
}

interface IKeyOptions {
    altKey?: boolean;
    shiftKey?: boolean;
    ctrlKey?: boolean;
    metaKey?: boolean;
    ignoreModifiers?: boolean;
}

declare class HotKey extends CustomObject {
    key: KeyCodes;
    options: IKeyOptions;
    constructor(key: KeyCodes, options?: IKeyOptions);
    simplify(): {
        key: KeyCodes;
        options: IKeyOptions;
    };
}

declare class KeyboardManager extends EventEmitter<KeyboardEvent> {
    static stringify(key: string, options?: IKeyOptions): string;
    static from(event: KeyboardEvent): string;
    constructor();
    hasStringifiedKey(key: string, options: IKeyOptions): [string, boolean];
    addKey({ key, options }: HotKey, callback: KeyboardEventCallback): void;
    addKeys(keys: KeyCodes[], callback: KeyboardEventCallback, options?: IKeyOptions): void;
    removeKey({ key, options }: HotKey, callback: KeyboardEventCallback): boolean;
    onceKey(key: HotKey, callback: EventCallback<KeyboardEvent>): void;
    protected _handleIgnoreModifiersKey(e: KeyboardEvent): void;
    protected _handleAnyKey(e: KeyboardEvent): void;
    protected _handleAllKey(e: KeyboardEvent): void;
    anyKey(callback: KeyboardEventCallback, options?: IKeyOptions): void;
    allKey(callback: KeyboardEventCallback): void;
    addControls(key: 'keydown' | 'keyup'): void;
}

interface IKeyAxisOptions {
    negative: HotKey;
    positive: HotKey;
    callback: (value: number) => void;
}

interface IKeyVectorOptions {
    negativeX: HotKey;
    positiveX: HotKey;
    negativeY: HotKey;
    positiveY: HotKey;
    callback: PointCallback;
}

declare class KeyStateManager extends CustomObject {
    downKeyboardManager: KeyboardManager | null;
    upKeyboardManager: KeyboardManager | null;
    private _hotKey;
    private _upCallback;
    private _downCallback;
    constructor();
    trackKeyState({ options, key }: HotKey, callback: (isPressed: boolean) => void): void;
    trackAxis({ negative, positive, callback }: IKeyAxisOptions): void;
    trackVector({ negativeX, negativeY, positiveX, positiveY, callback }: IKeyVectorOptions): void;
    setKey(key: KeyCodes, options?: IKeyOptions): void;
    setKeyboardManagers(down: KeyboardManager, up: KeyboardManager): void;
    bindKeyHandlers(downCallback: KeyboardEventCallback, upCallback: KeyboardEventCallback): void;
    unbindKeyHandlers(downCallback?: KeyboardEventCallback, upCallback?: KeyboardEventCallback): void;
    private _registerCallbacks;
}

interface ICustomWorldFunctionality {
    doWhenAddNewScene(obj: GameScene): void;
    doWhenDeleteScene(obj: GameScene): void;
    doWhenAddInWorld(world: GameWorld): void;
    doWhenRemoveFromWorld(world: GameWorld): void;
    doWhenChangeScene(oldScene: GameScene | null, newScene: GameScene | null): void;
    update(delta: number, world: GameWorld): void;
}

declare class GameWorld extends CustomObject implements IManager, IRoot {
    static createGameLoop(callback: (delta: number, lastDelta: number, prevTime: number) => void): number;
    private _canvasManager;
    private _canvas;
    private _ctx;
    private _camera;
    private _gameScenes;
    private _currentScene;
    private _customFunctionality;
    eventEmitter: EventEmitter<Event>;
    downKeyboardManager: KeyboardManager;
    upKeyboardManager: KeyboardManager;
    keyStateManager: KeyStateManager;
    pointerManager: PointerInputManager;
    uiPointerManager: PointerInputManager;
    netClient?: INetClient;
    isUseCulling: boolean;
    constructor({ netClient, root, camera, size, useCulling }?: IGameWorldOptions);
    get zIndex(): number;
    get inheritOpacity(): number;
    get canvasManager(): CanvasManager;
    get camera(): Camera;
    set camera(camera: Camera);
    updateZIndex(): void;
    addCustomFunctionality(func: ICustomWorldFunctionality): void;
    removeCustomFunctionality(func: ICustomWorldFunctionality): boolean;
    forFunctionalities(callback: (func: ICustomWorldFunctionality) => void): void;
    addScene(key: string, scene: GameScene): void;
    removeScene(key: string): void;
    forEach(callback: (scene: GameScene) => void): void;
    setScene(key: string): void;
    getScene(): GameScene | null;
    protected _addControls(): void;
    private _updateCurrentScene;
    private _culling;
    private _update;
    private _preload;
    start(ip?: string): Promise<void>;
    simplify(): {
        isUseCulling: boolean;
        camera: ISimpleCamera;
    };
}

declare abstract class DrawableObject extends CustomObject implements IRoot {
    static positiveNumberBounds: Bounds;
    static normalizedBounds: Bounds;
    protected _lineWidth: number;
    protected _opacity: number;
    protected _zIndex: number;
    protected _currentRootId: number;
    protected _offset: ISimplePoint;
    protected _color: Color;
    protected _isInitialized: boolean;
    protected _drawMode: DrawMode;
    outlineColor: Color;
    isVisible: boolean;
    isInViewport: boolean;
    managers: Set<IManager>;
    root: CurrentRoot;
    eventEmitter: EventEmitter;
    constructor();
    setDrawMode(mode: DrawMode): void;
    abstract get factRect(): ISimpleRect;
    get canBeSubObject(): boolean;
    get zIndex(): number;
    set zIndex(z: number);
    get inheritOpacity(): number;
    setVisibility(value: boolean): void;
    toggleVisibility(): boolean;
    setColor(color: Color): void;
    setOffset(x: number, y: number): void;
    abstract updatePositionByOffset(point: ISimplePoint): void;
    set offset({ x, y }: ISimplePoint);
    get offset(): ISimplePoint;
    set color(color: Color);
    get color(): Color;
    set opacity(value: number);
    get opacity(): number;
    set lineWidth(value: number);
    get lineWidth(): number;
    simplify(): ISimpleDrawableObject;
    updateColor(ctx: Context): void;
    updateContextParameters(ctx: Context): void;
    protected _init(world: GameWorld): void;
    init(world: GameWorld): void;
    isNeedDraw(): boolean;
    update(delta: number): void;
    protected _fill(ctx: Context): void;
    protected _stroke(ctx: Context): void;
    protected _drawDefault(ctx: Context): void;
    protected _draw(ctx: Context): void;
    abstract isObjectInViewport(camera: Camera): boolean;
    executeCallbackByDrawMode(fillCallback: Callback, strokeCallback: Callback): void;
    draw(ctx: Context): void;
}

declare class Point extends DrawableObject implements IPointable {
    static get NaN(): Point;
    static fromSimplePoint({ x, y }: ISimplePoint): Point;
    static drawRadius: number;
    protected _x: number;
    protected _y: number;
    constructor(x?: number, y?: number);
    get factRect(): ISimpleRect;
    set x(value: number);
    get x(): number;
    set y(value: number);
    get y(): number;
    set point({ x, y }: ISimplePoint);
    get point(): PointType;
    updatePositionByOffset({ x, y }: ISimplePoint): void;
    setPosition(x?: number, y?: number): void;
    addPosition(x: number, y: number): void;
    move({ x, y }: ISimplePoint, delta: number): void;
    simplify(): {
        x: number;
        y: number;
        color: {
            r: number;
            g: number;
            b: number;
            a: number;
        };
        lineWidth: number;
        opacity: number;
        zIndex: number;
    };
    drawPoint(ctx: Context): void;
    drawOutline(ctx: Context): void;
    private _drawArc;
    protected _fill(ctx: Context): void;
    protected _stroke(ctx: Context): void;
    isObjectInViewport(camera: Camera): boolean;
}

declare class SimpleRect extends CustomObject implements ISimpleRect {
    x: number;
    y: number;
    width: number;
    height: number;
    constructor(x?: number, y?: number, width?: number, height?: number);
    simplify(): {
        x: number;
        y: number;
        width: number;
        height: number;
    };
}

type Callback = () => void;
type SearchCallback<T> = (obj: T) => number | string;
type EventCallback<T = any> = (value?: T) => void;
type PointCallback = (point: Point) => void;
type Constructor<T = {}> = new (...args: any[]) => T;
type KeyboardEventCallback = EventCallback<KeyboardEvent>;
type FormattedTextCallback = (ctx: Context, text: string, rect: SimpleRect, renderType: RenderType) => void;
type CurrentRoot = null | IRoot;
type FollowedCameraObject = DrawablePointerable | Shape | ShapeableObject | null;
type SmoothingQuality = 'low' | 'medium' | 'high';
type LocalStorageEmitKeys = 'init' | 'load' | 'set';
type CacheDictTypes = 'image' | 'text' | 'json';
type TextHorisontalAlign = 'left' | 'center' | 'right';
type TextVerticalAlign = 'top' | 'middle' | 'bottom';
type RenderType = 'stroke' | 'fill';
type Context = CanvasRenderingContext2D;
type Canvas = HTMLCanvasElement;
type Dict<T> = Map<string, T>;
type ColorStop = [number, Color];
type PointType = IPointable & ISimplePoint;
type RectType = IRectangle & ISimpleRect;
type DrawablePointerable = DrawableObject & PointType;
type PositionableObject = ISimplePoint & {
    doWhenUpdatePosition: Function;
};
type TypeAndValue<T, V> = {
    type: T;
    value: V;
};

declare class AssetsManager {
    static instance: AssetsManager;
    private _cachedImages;
    private _cachedTexts;
    private _cachedJSON;
    private _cachedAudios;
    private _cachedBinaries;
    constructor();
    clear(type: CacheDictTypes, src: string): boolean;
    clearDict(type: CacheDictTypes): void;
    clearAll(): void;
    private _loadFile;
    loadTextFile(src: string): Promise<string>;
    loadBinarytFile(src: string): Promise<ArrayBuffer>;
    loadJSONFile(src: string): Promise<Record<string, any>>;
    loadImageFile(src: string): Promise<HTMLImageElement>;
    loadAudioFile(src: string, audioContext: AudioContext): Promise<AudioBuffer>;
}

declare class PointerPoint extends Point {
    pointerId: number;
    constructor(x?: number, y?: number, id?: number);
}

declare abstract class Timer extends CustomObject {
    paused: boolean;
    constructor();
    abstract reset(): void;
    abstract start(): void;
    abstract stop(): void;
    simplify(): {
        paused: boolean;
    };
}

declare class ElapsedClock extends Timer {
    protected _startTime: number;
    protected _accumulated_time: number;
    constructor();
    reset(): void;
    start(): void;
    stop(): void;
    getElapsedTime(): number;
    simplify(): {
        start: number;
        accumulated: number;
        elapsed: number;
        paused: boolean;
    };
}

declare class PeriodicTimer extends Timer {
    protected _currentTime: number;
    protected _callback: Callback;
    targetTime: number;
    constructor(time?: number, callback?: Callback);
    start(): void;
    reset(): void;
    stop(): void;
    setCallback(cb: Callback): void;
    get currentTime(): number;
    update(delta: number): void;
    simplify(): {
        targetTime: number;
        currentTime: number;
        paused: boolean;
    };
}

/**
 * Enum that defines which messages will be displayed in the console
 *
 * Each level includes messages from the previous levels
 *
 * Пример:
 * ```js
 * Logging.debugLevel = LoggingLevel.None
 * Logging.info("Info") // doesn't displayed
 * Logging.error("Error") // doesn't displayed
 * Logging.Warn("Warning") // doesn't displayed
 *
 * Logging.debugLevel = LoggingLevel.Info
 * Logging.info("Info") // displayed
 * Logging.error("Error") // doesn't displayed
 * Logging.Warn("Warning") // doesn't displayed
 *
 * Logging.debugLevel = LoggingLevel.Error
 * Logging.info("Info") // displayed
 * Logging.error("Error") // displayed
 * Logging.Warn("Warning") // doesn't displayed
 *
 * Logging.debugLevel = LoggingLevel.Warn
 * Logging.info("Info") // displayed
 * Logging.error("Error") // displayed
 * Logging.Warn("Warning") // displayed
 * ```
 */
declare enum LoggingLevel {
    /**
     * No messages from Logging will be displayed in the console
     */
    None = 0,
    /**
     * Only informational messages will be displayed
     */
    Info = 1,
    /**
     * Errors will also be displayed
     */
    Error = 2,
    /**
     * Warnings will also be displayed
     */
    Warn = 3,
    /**
     * Debug messages will also be displayed
     */
    Debug = 4,
    /**
     * Engine errors will also be displayed
     */
    EngineError = 5,
    /**
     * Engine warnings will also be displayed
     */
    EngineWarn = 6,
    /**
     * Engine messages will also be displayed
     */
    EngineLog = 7,
    /**
     * Very frequent engine messages will also be displayed
     */
    EngineSpam = 8,
    /**
     * All types of messages are displayed in the console
     */
    Full = 9
}

declare class Logging {
    static debugLevel: LoggingLevel;
    static isShowTrace: boolean;
    static message(cb: (...values: any[]) => void, needLevel: LoggingLevel, ...values: any[]): void;
    static error(...values: any[]): void;
    static warn(...values: any[]): void;
    static debug(...values: any[]): void;
    static info(...values: any[]): void;
    static engineError(...values: any[]): void;
    static engineWarn(...values: any[]): void;
    static engineLog(...values: any[]): void;
    static engineSpam(...values: any[]): void;
}

declare class MathUtils {
    static lerp(value: number, target: number, factor: number): number;
    static floor(x: number, afterDot?: number): number;
    static ceil(x: number, afterDot?: number): number;
    static round(x: number, afterDot?: number): number;
    static updateWithAfterDotNumber(x: number, afterDot: number, callback: (power: number) => number): number;
    static percents(value: number, { min, max }?: IMinMax): number;
    static getArrayValueByCondition<T>(array: T[], conditionCallback: (value: number, last: number) => boolean, valueCallback?: (value: T) => number): T | null;
    static min<T>(values: T[], valueCallback?: (value: T) => number): T | null;
    static max<T>(values: T[], valueCallback?: (value: T) => number): T | null;
}

declare class Random {
    static number(max: number, afterDot?: number): number;
    static range(min: number, max: number, afterDot?: number): number;
    static chance(value: number, max: number): boolean;
    static array(count: number, { min, max }?: IMinMax, afterDot?: number): number[];
}

declare class SAT {
    static projectPolygon(axis: ISimplePoint, polygon: Shape): IMinMax;
    static projectionsOverlap(first: IMinMax, second: IMinMax): boolean;
    static checkIntersections(first: Shape, second: Shape): boolean;
}

declare class Search {
    static binary<T>(arr: T[], target: T, callback?: SearchCallback<T>): number;
    static findInsertPosition<T>(arr: T[], value: T, callback?: SearchCallback<T>): number;
    static linear<T>(arr: T[], target: number, callback?: SearchCallback<T>): number;
}

declare class Sorting {
    static addToArray<T>(arr: T[], value: T, callback?: SearchCallback<T>): number;
    static merge<T>(arr: T[], callback?: SearchCallback<T>): T[];
    static quick<T>(arr: T[], callback?: (value: T) => number): T[];
}

declare class VectorUtils {
    static getAngle({ x, y }: ISimplePoint, { x: x1, y: y1 }: ISimplePoint): Angle;
    static getPerpendicular({ x, y }: ISimplePoint): ISimplePoint;
    static getDoubleDistance({ x, y }: ISimplePoint, { x: x1, y: y1 }: ISimplePoint): number;
    static getDistance(first: ISimplePoint, second: ISimplePoint): number;
    static isInDistance(first: ISimplePoint, second: ISimplePoint, maxDistance: number): boolean;
    static magnitude(vector: ISimplePoint): number;
    static cross(first: ISimplePoint, second: ISimplePoint): number;
    static dot(first: ISimplePoint, second: ISimplePoint): number;
    static normalize(point: ISimplePoint): ISimplePoint;
    static createPointByCallback(first: ISimplePoint, second: ISimplePoint, callback: (first: number, second: number) => number): ISimplePoint;
    static plus(first: ISimplePoint, second: ISimplePoint): ISimplePoint;
    static minus(first: ISimplePoint, second: ISimplePoint): ISimplePoint;
    static multiply(first: ISimplePoint, second: ISimplePoint): ISimplePoint;
    static div(first: ISimplePoint, second: ISimplePoint): ISimplePoint;
    static negative({ x, y }: ISimplePoint): ISimplePoint;
    static multiplyOnNumber({ x, y }: ISimplePoint, num: number): ISimplePoint;
}

declare class RangeWrapper extends Bounds {
    constructor(min: number, max: number);
    get(value: number): number;
}

declare class SpriteKeyFrame extends CustomObject implements ISimplePoint {
    x: number;
    y: number;
    duration: number;
    currentTime: number;
    constructor(x: number, y: number, duration: number);
    static createFrames(start: ISimplePoint, end: ISimplePoint, columns: number, duration: number): SpriteKeyFrame[];
    static createGenerator(duration: number): (x: number, y: number) => SpriteKeyFrame;
    simplify(): {
        x: number;
        y: number;
        duration: number;
    };
}

declare class SpriteAnimation extends CustomObject {
    protected _keyframes: SpriteKeyFrame[];
    protected _totalDuration: number;
    constructor();
    get totalDuration(): number;
    deleteKeyFrames(): void;
    add(...frames: SpriteKeyFrame[]): void;
    remove(...frames: SpriteKeyFrame[]): void;
    updateFramesCurrentTime(): void;
    getFrameByTime(time: number): SpriteKeyFrame | null;
    simplify(): {
        keyframes: {
            x: number;
            y: number;
            duration: number;
        }[];
        totalDuration: number;
    };
}

interface IFont {
    family: string;
    size: number;
    kerning: CanvasFontKerning;
    variant: CanvasFontVariantCaps;
    stretch: CanvasFontStretch;
    color: Color;
    outlineColor: Color;
    letterSpacing: number;
    tabSize: number;
    horisontalAlign: TextHorisontalAlign;
    verticalAlign: TextVerticalAlign;
}

interface JsonDrawableText {
    text?: TypeAndValue<'src' | 'text', string>;
    font?: Partial<IFont>;
}

interface ITextRendering {
    updateText(ctx: Context, point: ISimplePoint, preUpdatedText: string[]): string[];
    strokeDrawText(ctx: Context, args: [string, number, number]): void;
    fillDrawText(ctx: Context, args: [string, number, number]): void;
}

declare class DynamicText extends ShapeableObject {
    private static _transformColorFromSimpleColor;
    static getTextHeight(ctx: Context, text: string): number;
    protected _text: string;
    protected _fittedText: CachedValue<string[], Context>;
    protected _font: IFont;
    protected _maxSymbols: number;
    protected _ctx?: Context;
    protected _customRenderingText: ITextRendering;
    replaceableSymbols: Dict<string>;
    constructor(x?: number, y?: number, width?: number, height?: number);
    protected _loadJSONFromFile({ text, font }: JsonDrawableText): Promise<void>;
    setAlign(horisontal: TextHorisontalAlign, vertical: TextVerticalAlign): void;
    protected _updateTabSize(): void;
    protected _drawText(ctx: Context, point?: ISimplePoint): void;
    setCustomTextRendering(rendering: ITextRendering): void;
    protected _updateFittedText(ctx?: Context): string[];
    protected _needUpdateText(value?: boolean | null): void;
    setSize(width?: number, height?: number): void;
    set font(value: Partial<IFont>);
    set text(text: string);
    get text(): string;
    protected _updateFont(ctx: Context): void;
    protected _getTextOffsetByAlign(totalHeight: number): Size;
    protected _fill(ctx: Context): void;
}

declare class StaticText extends DynamicText {
    protected _cachedTextImageUrl: CachedValue<string>;
    protected _image: HTMLImageElement;
    constructor(x?: number, y?: number, width?: number, height?: number);
    protected _updateTextImageUrl(): string;
    protected _needUpdateText(value?: boolean | null): void;
    set font(value: Partial<IFont>);
    protected _draw(ctx: Context): void;
}

declare class DefaultTextRendering implements ITextRendering {
    strokeDrawText(ctx: Context, args: [string, number, number]): void;
    fillDrawText(ctx: Context, args: [string, number, number]): void;
    updateText(ctx: Context, point: ISimplePoint, preUpdatedText: string[]): string[];
}

declare class FormattedTextRendering implements ITextRendering {
    private static _parsedSymbols;
    private _drawText;
    protected static _drawFormattedText(ctx: Context, line: string, x: number, y: number, renderType: RenderType): void;
    protected static _parseText(text: string): TypeAndValue<string, string>[];
    strokeDrawText(ctx: Context, [line, x, y]: [string, number, number]): void;
    fillDrawText(ctx: Context, [line, x, y]: [string, number, number]): void;
    updateText(ctx: Context, point: ISimplePoint, preUpdatedText: string[]): string[];
}

declare class Circle extends Shape {
    private _radius;
    constructor(x?: number, y?: number, radius?: number);
    protected _updateCorners(): Point[];
    protected _updateBox(): ISimpleRect;
    protected _updatePath(): Path2D;
    isPointInShape(point: Point): boolean;
    setRadius(radius?: number): void;
    set radius(radius: number);
    get radius(): number;
    setSize(width?: number, height?: number): void;
    simplify(): ISimpleDrawableObject & ISimpleShape & {
        radius: number;
    };
}

type JsonRelativeShape = ISimplePoint[];

declare class DrawablePath extends Shape {
    protected _relativePoints: Point[];
    constructor(x?: number, y?: number);
    get relativePoints(): Point[];
    clearPoints(): void;
    addPoints(...points: Point[]): void;
    removePoints(...points: Point[]): void;
    protected _loadJSONFromFile(result: JsonRelativeShape): Promise<void>;
    protected _updateCorners(): Point[];
    protected _draw(ctx: Context): void;
}

declare class RelativeShape extends DrawablePath {
    constructor(x?: number, y?: number, width?: number, height?: number);
    get absolutePoints(): Point[];
    fitPoints(): void;
    protected _updateCorners(): Point[];
}

interface ICornerRadii {
    leftTop: number;
    leftBottom: number;
    rightTop: number;
    rightBottom: number;
}

declare class RoundedRectangle extends Shape {
    static createArc(center: Point, radius: number, startAngle: Angle, endAngle: Angle, segments?: number): Point[];
    protected _rawRadii: ICornerRadii;
    protected _radii: CachedValue<ICornerRadii>;
    protected _arcSegmentsCount: number;
    protected _boxRectangle: Rectangle;
    constructor(x?: number, y?: number, width?: number, height?: number);
    set arcSegmentsCount(value: number);
    get arcSegmentsCount(): number;
    setRadii(leftTop: number, leftBottom: number, rightTop: number, rightBottom: number): void;
    setSize(width?: number, height?: number): void;
    get maxRadius(): number;
    protected _normalizeRadii(): ICornerRadii;
    protected _updateBox(): ISimpleRect;
    protected _updateCorners(): Point[];
}

declare class Triangle extends Shape {
    constructor(x?: number, y?: number, width?: number, height?: number);
    protected _updateCorners(): Point[];
}

declare class LinearGradient extends ShapeableObject {
    protected _colorStops: ColorStop[];
    protected _image: HTMLImageElement;
    protected _cachedImageUrl: CachedValue<void>;
    protected _gradientAngle: Angle;
    protected _step: number;
    isStatic: boolean;
    constructor(x?: number, y?: number, width?: number, height?: number);
    set step(value: number);
    get step(): number;
    protected _drawGradient(ctx: Context, x?: number, y?: number): void;
    protected _updateCachedImageUrl(): void;
    setPosition(x?: number, y?: number): void;
    setSize(width?: number, height?: number): void;
    setGradientAngle(angle: Angle): void;
    addGradientAngle(angle: Angle): void;
    addColorStop(offset: number, color: Color): void;
    removeColorStop(offset: number): boolean;
    protected _fill(ctx: Context): void;
}

interface JsonCanvasImage extends Record<string, any> {
    src: string;
}

interface JsonSpriteSheet extends JsonCanvasImage {
    size: ISimpleSize & {
        type: 'grid' | 'dimensions';
    };
}

interface JsonAnimatedSprite extends JsonSpriteSheet {
    animations: Record<string, (ISimplePoint & {
        duration: number;
    })[]>;
}

declare class CanvasImage extends ShapeableObject {
    protected _cuttedImageBox: Rectangle | null;
    protected _image: HTMLImageElement;
    protected _isLoaded: boolean;
    constructor(x?: number, y?: number, width?: number, height?: number);
    protected _loadJSONFromFile(result: JsonCanvasImage): Promise<void>;
    doWhenLoaded(cb: Callback): void;
    setShape(shape: Shape): void;
    setAngle(angle: Angle): void;
    cutImage({ x, y, width, height }: SimpleRect): void;
    setImage(image: HTMLImageElement): void;
    setSizeByImage(): void;
    loadImage(src: string): Promise<void>;
    isLoaded(): boolean;
    protected _fill(ctx: Context): void;
}

declare class SpriteSheet extends CanvasImage {
    protected _currentFrame: SimpleRect;
    protected _rows: number;
    protected _columns: number;
    constructor(x?: number, y?: number, width?: number, height?: number);
    loadImage(src: string): Promise<void>;
    protected _loadJSONFromFile(result: JsonSpriteSheet): Promise<void>;
    setGrid(columns?: number, rows?: number): void;
    setGridBySize(width: number, height: number): void;
    getGridSize(): Point;
    setCurrentFrameByIndex(index: number): void;
    setCurrentFrame({ x, y }: ISimplePoint): void;
    getCurrentFrame(): SimpleRect;
}

declare class AnimatedSprite extends SpriteSheet {
    protected _currentAnimation?: SpriteAnimation;
    protected _currentAnimationFrame: SpriteKeyFrame;
    protected _currentAnimationKey: string;
    protected _animations: Dict<SpriteAnimation>;
    protected _timer: PeriodicTimer;
    isPlaying: boolean;
    constructor(x?: number, y?: number, width?: number, height?: number);
    protected _loadJSONFromFile(result: JsonAnimatedSprite): Promise<void>;
    play(key: string): void;
    pause(): void;
    setAnimation(key: string, animation: SpriteAnimation): void;
    selectAnimation(key: string): void;
    updateTimer(): void;
    removeAnimation(key: string): void;
    hasCurrentAnimation(): boolean;
    protected _updateTime(delta: number): void;
    protected _updateAnimation(): void;
    update(delta: number): void;
    protected _draw(ctx: Context): void;
}

declare class FollowedCamera extends Camera {
    private _followedObject;
    constructor(ctx?: Context);
    setFollowedObject(obj: FollowedCameraObject): void;
    updatePosition(): boolean;
    update(callback: (ctx: Context) => void): void;
}

declare class BaseAudio extends DrawableObject {
    static volumeBounds: Bounds;
    protected _context: AudioContext;
    protected _audioSource: AudioBufferSourceNode;
    protected _gain: GainNode;
    protected _audioNodes: AudioNode[];
    protected _src: string;
    protected _isInitialStarted: boolean;
    protected _paused: boolean;
    protected _loop: boolean;
    constructor();
    set loop(value: boolean);
    get loop(): boolean;
    set volume(value: number);
    get volume(): number;
    get audioContext(): AudioContext;
    get allNodes(): AudioNode[];
    protected _disconnectAllNodes(): void;
    protected _connectAllNodes(): void;
    protected _updateAllNodes(cb?: Callback): void;
    addAudioNode(node: AudioNode): void;
    removeAudioNode(node: AudioNode): void;
    insertAudioNode(index: number, node: AudioNode): void;
    setAudioBuffer(buffer: AudioBuffer): void;
    loadFromFile(src: string): Promise<void>;
    protected _recreateSource(): void;
    start(secs?: number): void;
    stop(): void;
    get factRect(): ISimpleRect;
    updatePositionByOffset(point: ISimplePoint): void;
    protected _draw(ctx: Context): void;
    isObjectInViewport(camera: Camera): boolean;
    simplify(): {
        volume: number;
        loop: boolean;
        src: string;
        color: {
            r: number;
            g: number;
            b: number;
            a: number;
        };
        lineWidth: number;
        opacity: number;
        zIndex: number;
    };
}

declare class PositionedAudio extends BaseAudio implements IPointable {
    circle: Circle;
    protected _listenedObject?: IPointable;
    protected _maxVolume: number;
    constructor(x?: number, y?: number, radius?: number);
    set point(value: ISimplePoint);
    get point(): PointType;
    set x(value: number);
    get x(): number;
    set y(value: number);
    get y(): number;
    setPosition(x?: number, y?: number): void;
    set radius(radius: number);
    get radius(): number;
    setListenedObject(obj: IPointable): void;
    addPosition(x: number, y: number): void;
    move(point: ISimplePoint, delta: number): void;
    protected _draw(ctx: Context): void;
    protected set factVolume(value: number);
    get factVolume(): number;
    set volume(value: number);
    get volume(): number;
    get factRect(): ISimpleRect;
    update(delta: number): void;
    updatePositionByOffset(point: ISimplePoint): void;
    simplify(): {
        radius: number;
        volume: number;
        loop: boolean;
        src: string;
        color: {
            r: number;
            g: number;
            b: number;
            a: number;
        };
        lineWidth: number;
        opacity: number;
        zIndex: number;
    };
}

declare class StereoPositionedAudio extends PositionedAudio {
    static panBounds: Bounds;
    protected _panner: StereoPannerNode;
    constructor(x?: number, y?: number, radius?: number);
    get allNodes(): AudioNode[];
    set pan(pan: number);
    get pan(): number;
    update(delta: number): void;
}

interface IControlsManager extends IManager {
    addControls(key: string): void;
}

interface ISimpleColor {
    r: number;
    g: number;
    b: number;
    a: number;
}

export { Angle, AnimatedSprite, AssetsManager, BaseAudio, Bounds, CachedValue, Camera, CanvasImage, CanvasManager, Circle, Color, CustomObject, DefaultTextRendering, DrawMode, DrawableObject, DrawablePath, DynamicText, ElapsedClock, EventEmitter, FollowedCamera, FormattedTextRendering, GameEntity, GameObject, GameScene, GameWorld, HotKey, KeyCodes, KeyStateManager, KeyboardManager, LinearGradient, LocalStorageManager, Logging, LoggingLevel, MathUtils, PeriodicTimer, Point, PointerInpu