react-simple-game-engine 0.1.60 → 0.1.63

package/lib/classes/animations/animation.d.ts

@@ -0,0 +1,14 @@
+import { Sprite } from "../sprites/sprite";
+export declare abstract class AnimationSprite<S extends Sprite<any>> {
+    protected currentFrame: number;
+    protected _isRunning: boolean;
+    protected timeCounter: number;
+    delatime: number;
+    sprite: S;
+    set isRunning(_isRunning: boolean);
+    abstract initial(params: any): void;
+    draw(): void;
+    protected abstract checkFrameMax(): boolean;
+    protected abstract onDraw(): void;
+}
+//# sourceMappingURL=animation.d.ts.map

package/lib/classes/animations/avatar.animation.d.ts

@@ -0,0 +1,16 @@
+import { AvatarSprite } from "../sprites/avatar.sprite";
+import { AnimationSprite } from "./animation";
+declare type Offset = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare class AvatarAnimationSprite extends AnimationSprite<AvatarSprite> {
+    private offset;
+    initial({ x, y, width, height }: Partial<Offset>): void;
+    protected checkFrameMax(): boolean;
+    onDraw(): void;
+}
+export {};
+//# sourceMappingURL=avatar.animation.d.ts.map

package/lib/classes/animations/color.animation.d.ts

@@ -0,0 +1,9 @@
+import { ColorSprite } from "../sprites/color.sprite";
+import { AnimationSprite } from "./animation";
+export declare class ColorAnimationSprite extends AnimationSprite<ColorSprite> {
+    private colors;
+    initial(colors: ColorSprite["source"][]): void;
+    protected checkFrameMax(): boolean;
+    protected onDraw(): void;
+}
+//# sourceMappingURL=color.animation.d.ts.map

package/lib/classes/camera.d.ts

@@ -0,0 +1,14 @@
+export declare class Camera {
+    private _width;
+    private _height;
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    constructor(_width: number, _height: number);
+    get width(): number;
+    get height(): number;
+    set width(width: number);
+    set height(height: number);
+}
+//# sourceMappingURL=camera.d.ts.map

package/lib/classes/entities/circle.entity.d.ts

@@ -0,0 +1,15 @@
+import { Body } from "matter-js";
+import { CreateBodyDefine, EntityInitial } from "../../export-types";
+import { Entity } from "./entity";
+export declare class CircleEntity<P extends Record<string, any> = Record<string, any>> extends Entity<P> {
+    radius: number;
+    onSpriteWidthHeightBinding(): {
+        width: number;
+        height: number;
+    };
+    protected onInitial(): EntityInitial<this>;
+    protected onCreateBody({ x, y, ...transform }: NonNullable<CreateBodyDefine<{
+        radius: number;
+    }>["transform"]>, options?: CreateBodyDefine["bodyOptions"]): Body;
+}
+//# sourceMappingURL=circle.entity.d.ts.map

package/lib/classes/entities/entity-sult.d.ts

@@ -0,0 +1,34 @@
+import { Initialler } from "../../export-interfaces";
+import { Camera } from "../camera";
+import { LogicComponent } from "../logic-component";
+import { Scene } from "../scene";
+import { WorldManagement } from "../world-management";
+export declare abstract class EntitySult<P = any> implements Initialler<P> {
+    camera: Camera;
+    readonly id: string;
+    private _layerIndex;
+    private _name;
+    private _scene;
+    private _worldManagement;
+    private _children;
+    private _parent?;
+    abstract update(): void;
+    abstract draw(): void;
+    get children(): EntitySult<any>[];
+    get layerIndex(): number;
+    get name(): string;
+    set layerIndex(_layerIndex: number);
+    set name(_name: string);
+    get parent(): EntitySult<any> | undefined;
+    get scene(): Scene<any>;
+    get worldManagement(): WorldManagement;
+    addChild(target: EntitySult | LogicComponent<EntitySult>): void;
+    removeChild(entity: EntitySult): void;
+    unChild(entity: EntitySult): void;
+    getProperty<T>(name: string): T;
+    preInitial(worldManagement: WorldManagement): void;
+    active(worldManagement: WorldManagement): void;
+    onActive(): void;
+    initial(params: P): void;
+}
+//# sourceMappingURL=entity-sult.d.ts.map

package/lib/classes/entities/entity.d.ts

@@ -0,0 +1,55 @@
+import Matter from "matter-js";
+import { Sprite } from "../sprites/sprite";
+import { CreateBodyDefine, EntityInitial, EntityPrepare, MasterBody } from "../../export-types";
+import { EntitySult } from "./entity-sult";
+import { LogicComponent } from "../logic-component";
+import { Sound } from "../sound";
+declare type TimerJobListener = () => void;
+declare type TerminateOptions = {
+    duration?: number;
+    effect: EntitySult | LogicComponent<EntitySult>;
+};
+export declare abstract class Entity<P extends Record<string, any> = Record<string, any>> extends EntitySult<EntityInitial<Entity>> {
+    private _body;
+    private _sprite;
+    private _props;
+    private timerJobListeners;
+    private isTerminate;
+    enabledGravity: boolean;
+    sound?: Sound;
+    set sprite(sprite: Sprite<any>);
+    get sprite(): Sprite<any>;
+    get position(): Matter.Vector;
+    get body(): MasterBody;
+    get props(): P;
+    /**
+     * @param {TerminateOptions} options
+     * #duration: time to disappear from the world in seconds, default: 0.2 seconds
+     * #effect: effect to showing on duration time
+     * @void
+     */
+    terminate(options?: TerminateOptions): void;
+    /**
+     * @param {number} interval in seconds
+     * @param {TimerJobListener} job function that run per #interval
+     * @void
+     */
+    onTimer(interval: number, job: TimerJobListener, defaultRun?: boolean): () => void;
+    createBody(transform: CreateBodyDefine["transform"], options?: CreateBodyDefine["bodyOptions"]): MasterBody;
+    protected abstract onCreateBody(transform: CreateBodyDefine["transform"], options?: CreateBodyDefine["bodyOptions"]): Matter.Body;
+    initial({ transform, sprite: spriteComponent, bodyOptions, props, ...params }: EntityInitial<this>): void;
+    protected abstract onInitial(): EntityInitial<this>;
+    protected onPrepare(): EntityPrepare<this>;
+    update(): void;
+    onUpdate(): void;
+    draw(): void;
+    abstract onSpriteWidthHeightBinding(): {
+        width: number;
+        height: number;
+    };
+    onCollision(target: Entity): void;
+    onCollisionEnd(target: Entity): void;
+    onCollisionActive(target: Entity): void;
+}
+export {};
+//# sourceMappingURL=entity.d.ts.map

package/lib/classes/entities/rect.entity.d.ts

@@ -0,0 +1,17 @@
+import { Body } from "matter-js";
+import { CreateBodyDefine, EntityInitial } from "../../export-types";
+import { Entity } from "./entity";
+export declare class RectEntity<P extends Record<string, any> = any> extends Entity<P> {
+    width: number;
+    height: number;
+    onSpriteWidthHeightBinding(): {
+        width: number;
+        height: number;
+    };
+    protected onInitial(): EntityInitial<this>;
+    protected onCreateBody({ x, y, ...transform }: NonNullable<CreateBodyDefine<{
+        width?: number;
+        height?: number;
+    }>["transform"]>, options?: CreateBodyDefine["bodyOptions"]): Body;
+}
+//# sourceMappingURL=rect.entity.d.ts.map

package/lib/classes/logic-component.d.ts

@@ -0,0 +1,16 @@
+import { Initialler } from "../export-interfaces";
+import { Configable, Configation } from "../export-types";
+import { WorldManagement } from "./world-management";
+export declare class LogicComponent<C extends Initialler = Initialler> {
+    private readonly configale;
+    private readonly _isPrefab?;
+    private _worldManagement;
+    layerIndex: number;
+    constructor(configale: Configable<C>, _isPrefab?: boolean | undefined);
+    get isPrefab(): boolean | undefined;
+    set worldManagement(_worldManagement: WorldManagement);
+    output({ worldManagement, ...targetParams }?: {
+        worldManagement?: WorldManagement;
+    } & Configation<C>): C;
+}
+//# sourceMappingURL=logic-component.d.ts.map

package/lib/classes/p5.d.ts

@@ -0,0 +1,11 @@
+import p5 from "p5";
+declare type ItemWithPercent<I> = [I, number];
+declare type LastItem<I> = [I];
+export declare type Collection<I> = [...ItemWithPercent<I>[], LastItem<I>];
+export declare class P5 extends p5 {
+    running: boolean;
+    constructor(sketch: (p5: P5) => void);
+    choose<I = any>(collection: Collection<I>): I;
+}
+export {};
+//# sourceMappingURL=p5.d.ts.map

package/lib/classes/particle-system.d.ts

@@ -0,0 +1,30 @@
+import p5 from "p5";
+import { Particle, ParticleInitialParams } from "./particle";
+import { EntitySult } from "./entities/entity-sult";
+declare type ParticleClass = {
+    new (...args: ConstructorParameters<typeof Particle>): Particle;
+};
+declare type ParticleOptions = Omit<ParticleInitialParams, "vec" | "angle" | "camera"> & {
+    x?: number;
+    y?: number;
+};
+declare type ParticleSystemInitialParams = {
+    particleClass?: ParticleClass;
+    particleOptions?: ParticleOptions;
+    quantityPerFrame?: number;
+    vecWeight?: number;
+    forces?: p5.Vector[];
+};
+export declare class ParticleSystem extends EntitySult<ParticleSystemInitialParams> {
+    private particles;
+    private forces;
+    private particleOptions;
+    private particleClass;
+    quantityPerFrame: number;
+    vecWeight: number;
+    initial({ forces, particleOptions, ...params }: ParticleSystemInitialParams): void;
+    update(): void;
+    draw(): void;
+}
+export {};
+//# sourceMappingURL=particle-system.d.ts.map

package/lib/classes/particle.d.ts

@@ -0,0 +1,35 @@
+import p5 from "p5";
+import { Initialler } from "../export-interfaces";
+import { Avatar, Color } from "../export-types";
+import { Camera } from "./camera";
+export declare type ParticleInitialParams = {
+    vec?: p5.Vector;
+    angle?: number;
+    sprite?: Avatar;
+    color?: Color;
+    size?: number;
+    lifetime?: number;
+    camera: Camera;
+    forceSpriteSize?: boolean;
+};
+export declare class Particle extends p5.Vector implements Initialler<ParticleInitialParams> {
+    private vec;
+    private acc;
+    private angle;
+    camera: Camera;
+    sprite?: Avatar;
+    color: Color;
+    size: number;
+    lifetimeRemain: number;
+    private forceSpriteSize;
+    private _lifetime;
+    set lifetime(lifetime: number);
+    get lifetime(): number;
+    initial({ vec, ...params }: ParticleInitialParams): void;
+    applyForce(force: p5.Vector): void;
+    isDead(): boolean;
+    update(): void;
+    draw(): void;
+    onDraw(_: Color): void;
+}
+//# sourceMappingURL=particle.d.ts.map

package/lib/classes/prefab.d.ts

@@ -0,0 +1,7 @@
+import { Configable } from "../export-types";
+import { EntitySult } from "./entities/entity-sult";
+import { LogicComponent } from "./logic-component";
+export declare class Prefab<C extends EntitySult = EntitySult> extends LogicComponent<C> {
+    constructor(configale: Configable<C>);
+}
+//# sourceMappingURL=prefab.d.ts.map

package/lib/classes/saver.d.ts

@@ -0,0 +1,11 @@
+declare type Typed = never | undefined | BooleanConstructor | StringConstructor | NumberConstructor;
+declare type ValueType<V extends any = undefined, T extends Typed = Typed> = V extends undefined ? T extends BooleanConstructor ? boolean : T extends StringConstructor ? string : T extends NumberConstructor ? number : V : V;
+declare class _Saver {
+    private store;
+    constructor();
+    set<V extends any = any>(key: string, value: V): void;
+    get<V extends any = undefined, T extends Typed = Typed>(key: string, type?: T): ValueType<V, T>;
+}
+export declare const Saver: _Saver;
+export {};
+//# sourceMappingURL=saver.d.ts.map

package/lib/classes/scene-management.d.ts

@@ -0,0 +1,22 @@
+import { Scene } from "./scene";
+export declare type SceneClass = {
+    new (): Scene;
+    tag?: string;
+};
+declare type ChangeSceneListener = (scene: Scene) => void;
+export declare class SceneManagement {
+    private Scenes;
+    private _currentScene;
+    private changeSceneListener;
+    static getTag(Scene: SceneClass): string | undefined;
+    constructor(Scenes: SceneClass[]);
+    get currentScene(): Scene<any>;
+    onChangeScene(func: ChangeSceneListener): void;
+    canNext(): boolean;
+    next(): void;
+    replay(): void;
+    gotoScene(tag: string): void;
+    private startScene;
+}
+export {};
+//# sourceMappingURL=scene-management.d.ts.map

package/lib/classes/scene.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="p5" />
+import { ComponentType } from "react";
+import { Camera } from "./camera";
+import { LogicComponent } from "./logic-component";
+import { SceneManagement } from "./scene-management";
+import { EntitySult } from "./entities/entity-sult";
+import { Prefab } from "./prefab";
+import { Sound } from "./sound";
+import { Avatar, GetSoundOptions, SoundDecor, SoundManagement, SpriteDecor } from "../export-types";
+import { SoundType } from "../export-enums";
+declare type SoundOptionsChangeListener<O extends SoundType> = (options: SoundManagement[O]) => void;
+declare type LoadAssetsListener = (loadedAssets: boolean) => void;
+declare type EntityPropsChangeListener<V = any> = (value: V) => void;
+export declare abstract class Scene<UIP = any> {
+    static soundsDecor: SoundDecor[];
+    static spritesDecor: SpriteDecor[];
+    private ui;
+    private worldManagement;
+    private _loadedAssets;
+    private loadAssetsListener;
+    private readonly entityPropsChangeListeners;
+    private readonly soundBackgroundOptionsChangeListeners;
+    private readonly soundOnceOptionsChangeListeners;
+    private readonly prefabs;
+    readonly sounds: Sound[];
+    readonly sprites: Avatar[];
+    assetsDelay: number;
+    tag: string;
+    manager: SceneManagement;
+    readonly sessionId: string;
+    abstract getComponents(camera: Camera): LogicComponent<EntitySult>[];
+    constructor();
+    get UI(): ComponentType<UIP>;
+    get UIProps(): UIP;
+    get soundBackgroundOptions(): SoundManagement[SoundType.BACKGROUND];
+    get soundOnceOptions(): SoundManagement[SoundType.ONCE];
+    set soundBackgroundOptions(options: Partial<SoundManagement[SoundType.BACKGROUND]>);
+    set soundOnceOptions(options: Partial<SoundManagement[SoundType.ONCE]>);
+    onSoundOnceOptionsChange(func: SoundOptionsChangeListener<SoundType.ONCE>): () => void;
+    onSoundBackgroundOptionsChange(func: SoundOptionsChangeListener<SoundType.BACKGROUND>): () => void;
+    private bootSoundOptions;
+    protected getSoundOptions(): GetSoundOptions;
+    protected onBorn(): void;
+    protected getUIProps(): UIP;
+    get loadedAssets(): boolean;
+    private set loadedAssets(value);
+    emitEntityPropsChange<V = any>(name: string, value: V): void;
+    onEntityPropsChange<V = any>(name: string, func: EntityPropsChangeListener<V>): () => void;
+    onLoadAssetNotify(func: LoadAssetsListener): void;
+    destructor(): void;
+    switchToScene(tag: string): void;
+    private loadSprites;
+    private loadSounds;
+    createSprites(...srcables: (string | {
+        src: string;
+    })[]): Promise<import("p5").Image[]>;
+    createSounds(...srcables: (string | {
+        src: string;
+        volumn?: number;
+        type?: SoundType;
+    })[]): Promise<Sound[]>;
+    mapSprites(...srcs: string[]): Promise<void>;
+    mapSounds(...srcs: string[]): Promise<void>;
+    loadAssets(delay?: number): Promise<void>;
+    onLoadAssets(): Promise<void>;
+    getPrefab<C extends EntitySult>(Class: {
+        new (...args: any[]): Prefab<C>;
+    }): Prefab<C>;
+    bootstrap(camera: Camera): void;
+    protected onDraw(): void;
+    protected onUpdate(): void;
+    action(): void;
+}
+export {};
+//# sourceMappingURL=scene.d.ts.map

package/lib/classes/sound-watcher.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from "react";
+import { SoundType } from "../export-enums";
+import { SoundManagement } from "../export-types";
+import { Scene } from "./scene";
+declare type SoundOnceWatcherProps = {
+    scene: Scene;
+    children: (value: SoundManagement[SoundType.ONCE]) => ReactNode;
+};
+export declare function SoundOnceWatcher({ scene, children }: SoundOnceWatcherProps): JSX.Element;
+declare type SoundBackgroundWatcherProps = {
+    scene: Scene;
+    children: (value: SoundManagement[SoundType.BACKGROUND]) => ReactNode;
+};
+export declare function SoundBackgroundWatcher({ scene, children, }: SoundBackgroundWatcherProps): JSX.Element;
+export {};
+//# sourceMappingURL=sound-watcher.d.ts.map

package/lib/classes/sound.d.ts

@@ -0,0 +1,14 @@
+import { SoundType } from "../export-enums";
+import { SoundManagement } from "../export-types";
+export declare class Sound {
+    private readonly type;
+    static Management: SoundManagement;
+    readonly native: HTMLAudioElement;
+    constructor(type?: SoundType);
+    get volumn(): number;
+    set volumn(vol: number);
+    playNow(): Promise<void>;
+    stop(): Promise<void>;
+    play(): Promise<void>;
+}
+//# sourceMappingURL=sound.d.ts.map

package/lib/classes/sprites/avatar.sprite.d.ts

@@ -0,0 +1,20 @@
+import { Avatar } from "../../export-types";
+import { GetInitialParams, Sprite } from "./sprite";
+declare type SpriteOffet = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    index: number;
+};
+declare type AvatarGetInitialParams<S extends AvatarSprite> = GetInitialParams<S> & {
+    offset?: Partial<SpriteOffet>;
+};
+export declare class AvatarSprite extends Sprite<Avatar | undefined | null> {
+    private _offset;
+    get offset(): SpriteOffet;
+    onDraw(): void;
+    initial(params?: AvatarGetInitialParams<this>): void;
+}
+export {};
+//# sourceMappingURL=avatar.sprite.d.ts.map

package/lib/classes/sprites/color.sprite.d.ts

@@ -0,0 +1,7 @@
+import { Color } from "../../export-types";
+import { Sprite } from "./sprite";
+export declare class ColorSprite extends Sprite<Color> {
+    constructor();
+    onDraw(): void;
+}
+//# sourceMappingURL=color.sprite.d.ts.map

package/lib/classes/sprites/sprite.d.ts

@@ -0,0 +1,26 @@
+import { Avatar, Color } from "../../export-types";
+import { AnimationSprite } from "../animations/animation";
+import { Entity } from "../entities/entity";
+import { LogicComponent } from "../logic-component";
+export declare type SourceType = Avatar | Color | undefined | null;
+export declare type GetInitialParams<S extends Sprite<any> = any> = {
+    source?: S["source"];
+    animation?: LogicComponent<AnimationSprite<S>>;
+};
+export declare abstract class Sprite<SpriteType extends SourceType> {
+    source: SpriteType;
+    private _entity;
+    private _width;
+    private _height;
+    private _animation;
+    set animation(ani: AnimationSprite<this>);
+    get animation(): AnimationSprite<this>;
+    set entity(entity: Entity);
+    get entity(): Entity;
+    get width(): number;
+    get height(): number;
+    draw(): void;
+    abstract onDraw(): void;
+    initial(params?: GetInitialParams<this>): void;
+}
+//# sourceMappingURL=sprite.d.ts.map

package/lib/classes/watcher.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from "react";
+import { Scene } from "./scene";
+declare type WatcherProps<IV> = {
+    scene: Scene;
+    names: string | string[];
+    initialValues: IV;
+    children: (value: IV) => ReactNode;
+};
+export declare function Watcher<IV extends Record<string, any> = Record<string, any>>({ scene, names: _names, children, initialValues, }: WatcherProps<IV>): JSX.Element;
+export {};
+//# sourceMappingURL=watcher.d.ts.map

package/lib/classes/world-management.d.ts

@@ -0,0 +1,28 @@
+import { Engine } from "matter-js";
+import { Camera } from "./camera";
+import { Scene } from "./scene";
+import { EntitySult } from "./entities/entity-sult";
+export declare class WorldManagement {
+    private _camera;
+    private _scene;
+    private readonly entitiesHash;
+    private readonly entitiesPool;
+    private readonly entitiesName;
+    private _engine;
+    constructor(_camera: Camera, _scene: Scene);
+    get engine(): Engine;
+    get camera(): Camera;
+    get scene(): Scene<any>;
+    private iterateEntities;
+    private joinPool;
+    private outPool;
+    destructor(): void;
+    changeEntityLayerIndex(entity: EntitySult, newIndex: number): void;
+    changeEntityName(entity: EntitySult, newName: string): void;
+    getEntity<T extends EntitySult = EntitySult>(name: string): T;
+    addEntity(entity: EntitySult): void;
+    removeEntity(entity: EntitySult): void;
+    update(): void;
+    draw(): void;
+}
+//# sourceMappingURL=world-management.d.ts.map

package/lib/decorators/scene-tag.decor.d.ts

@@ -0,0 +1,6 @@
+import { Scene } from "../classes/scene";
+export declare function SceneTag(tag: string): (target: {
+    tag?: string;
+    new (): Scene;
+}) => void;
+//# sourceMappingURL=scene-tag.decor.d.ts.map

package/lib/decorators/scene-ui.decor.d.ts

@@ -0,0 +1,7 @@
+import { ComponentType } from "react";
+import { Scene } from "../classes/scene";
+export declare function SceneUI(ui: ComponentType<any>): (target: {
+    ui?: ComponentType<any>;
+    new (): Scene;
+}) => void;
+//# sourceMappingURL=scene-ui.decor.d.ts.map

package/lib/decorators/sound-from.decor.d.ts

@@ -0,0 +1,6 @@
+import { SoundType } from "../export-enums";
+export declare function SoundFrom(srcable?: string | {
+    src?: string;
+    volumn?: number;
+}, type?: SoundType): (target: any, propertyKey: string) => void;
+//# sourceMappingURL=sound-from.decor.d.ts.map

package/lib/decorators/sprite-from.decor.d.ts

@@ -0,0 +1,4 @@
+export declare function SpriteFrom(srcable?: string | {
+    src?: string;
+}): (target: any, propertyKey: string) => void;
+//# sourceMappingURL=sprite-from.decor.d.ts.map

package/lib/export-enums.d.ts

@@ -0,0 +1,5 @@
+export declare enum SoundType {
+    ONCE = 0,
+    BACKGROUND = 1
+}
+//# sourceMappingURL=export-enums.d.ts.map

package/lib/export-interfaces.d.ts

@@ -0,0 +1,4 @@
+export interface Initialler<P = any> {
+    initial: (params: P) => void;
+}
+//# sourceMappingURL=export-interfaces.d.ts.map

package/lib/export-types.d.ts

@@ -0,0 +1,53 @@
+import { Entity } from "./classes/entities/entity";
+import { Sprite } from "./classes/sprites/sprite";
+import type { Body, IChamferableBodyDefinition } from "matter-js";
+import { Initialler } from "./export-interfaces";
+import { Sound } from "./classes/sound";
+import { SoundType } from "./export-enums";
+export type { Collection } from "./classes/p5";
+export declare type Avatar = ReturnType<import("./classes/p5").P5["loadImage"]>;
+export declare type Color = [number, number, number, number?];
+export declare type EntityPrepare<E extends Entity> = EntityInitial<E>;
+export declare type MasterBody = Body & {
+    entity: Entity;
+};
+export declare type CreateBodyDefine<E extends Record<string, any> = Record<string, any>> = {
+    transform?: {
+        x?: number;
+        y?: number;
+    } & E;
+    bodyOptions?: IChamferableBodyDefinition;
+};
+declare type TransformArgs<E extends Entity> = Parameters<E["onCreateBody"]>[0];
+declare type BodyOptionsArgs<E extends Entity> = Parameters<E["onCreateBody"]>[1];
+export declare type EntityInitial<E extends Entity> = {
+    transform?: TransformArgs<E>;
+    bodyOptions?: BodyOptionsArgs<E>;
+    sprite?: import("./classes/logic-component").LogicComponent<Sprite<any>>;
+    sound?: Sound;
+    enabledGravity?: boolean;
+    name?: string;
+    props?: Partial<E["props"]>;
+};
+export declare type Configation<C extends Initialler> = Parameters<C["initial"]>[0];
+export declare type Configable<C extends Initialler = Initialler> = {
+    new (): C;
+} | [{
+    new (): C;
+}, Configation<C>];
+export declare type SoundManagement = Record<SoundType, {
+    canPlay: boolean;
+    loop: boolean;
+}>;
+export declare type SoundDecor = {
+    propertyKey: string;
+    src?: string;
+    type: SoundType;
+    volumn?: number;
+};
+export declare type SpriteDecor = {
+    propertyKey: string;
+    src?: string;
+};
+export declare type GetSoundOptions = DeepPartial<SoundManagement>;
+//# sourceMappingURL=export-types.d.ts.map

package/lib/index.d.ts

@@ -0,0 +1,25 @@
+export { Saver } from "./classes/saver";
+export { Sound } from "./classes/sound";
+export { P5 } from "./classes/p5";
+export { ParticleSystem } from "./classes/particle-system";
+export { Particle } from "./classes/particle";
+export { AnimationSprite } from "./classes/animations/animation";
+export { AvatarAnimationSprite } from "./classes/animations/avatar.animation";
+export { ColorAnimationSprite } from "./classes/animations/color.animation";
+export { Entity } from "./classes/entities/entity";
+export { CircleEntity } from "./classes/entities/circle.entity";
+export { RectEntity } from "./classes/entities/rect.entity";
+export { Prefab } from "./classes/prefab";
+export { LogicComponent } from "./classes/logic-component";
+export { Scene } from "./classes/scene";
+export { Camera } from "./classes/camera";
+export { Sprite } from "./classes/sprites/sprite";
+export { AvatarSprite } from "./classes/sprites/avatar.sprite";
+export { ColorSprite } from "./classes/sprites/color.sprite";
+export { SpriteFrom } from "./decorators/sprite-from.decor";
+export { SoundFrom } from "./decorators/sound-from.decor";
+export { SceneTag } from "./decorators/scene-tag.decor";
+export { SceneUI } from "./decorators/scene-ui.decor";
+export { ScenesProcess } from "./ui-components/ScenesProcess";
+export { default as Matter } from "matter-js";
+//# sourceMappingURL=index.d.ts.map

package/lib/ui-components/SceneRunner.d.ts

@@ -0,0 +1,14 @@
+import { ComponentType, ReactNode } from "react";
+import { Scene } from "../classes/scene";
+export declare type SceneRunnerPublicProps = {
+    width: number;
+    height: number;
+    assetsLoader?: ReactNode | ComponentType;
+    assetsDelay?: number;
+};
+declare type SceneRunnerProps = SceneRunnerPublicProps & {
+    current: Scene;
+};
+export declare function SceneRunner({ assetsDelay, current, width, height, assetsLoader: AssetsLoader, }: SceneRunnerProps): JSX.Element;
+export {};
+//# sourceMappingURL=SceneRunner.d.ts.map

package/lib/ui-components/ScenesProcess.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { SceneClass } from "../classes/scene-management";
+import { SceneRunnerPublicProps } from "./SceneRunner";
+declare type WorldViewProps = SceneRunnerPublicProps & {
+    list: SceneClass[];
+};
+export declare function ScenesProcess({ list, ...props }: WorldViewProps): JSX.Element;
+export {};
+//# sourceMappingURL=ScenesProcess.d.ts.map

package/lib/ui-components/Sketch.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Camera } from "../classes/camera";
+declare type SketchProps = {
+    onSetup: (camera: Camera) => void;
+    onDraw: () => void;
+    onPreload?: () => void;
+    width: number;
+    height: number;
+};
+export declare function Sketch({ onSetup, onDraw, onPreload, width, height, }: SketchProps): JSX.Element;
+export {};
+//# sourceMappingURL=Sketch.d.ts.map

package/lib/{utilities.js → utilities.d.ts}

@@ -1,2 +1,3 @@
 export * from "./classes/watcher";
 export * from "./classes/sound-watcher";
+//# sourceMappingURL=utilities.d.ts.map

package/lib/utils.d.ts

@@ -0,0 +1,8 @@
+import { Sound } from "./classes/sound";
+import { SoundType } from "./export-enums";
+import { Avatar } from "./export-types";
+export declare function createAssetImage(src: string): Promise<Avatar>;
+export declare function createAssetSound(src: string, type?: SoundType): Promise<Sound>;
+export declare function tick(delay?: number): Promise<unknown>;
+export declare function copyProperties(source: Record<string, any>, target: Record<string, any>): void;
+//# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-simple-game-engine",
-  "version": "0.1.60",
+  "version": "0.1.63",
   "description": "",
   "main": "lib/index.js",
   "types": "lib",
@@ -22,10 +22,9 @@
   },
   "files": [
     "/lib/index.js",
-    "/lib/utilities.js",
-    "/lib/export-types.js",
-    "/lib/export-interfaces.js",
-    "/lib/export-enums.js"
+    "/lib/*/**/***.d.ts",
+    "/lib/*/**.d.ts",
+    "/lib/*.d.ts"
   ],
   "keywords": [
     "game engine",

package/lib/export-enums.js

@@ -1,5 +0,0 @@
-export var SoundType;
-(function (SoundType) {
-    SoundType[SoundType["ONCE"] = 0] = "ONCE";
-    SoundType[SoundType["BACKGROUND"] = 1] = "BACKGROUND";
-})(SoundType || (SoundType = {}));

package/lib/export-interfaces.js

@@ -1 +0,0 @@
-export {};

package/lib/export-types.js

@@ -1 +0,0 @@
-export {};