react-simple-game-engine 0.1.62 → 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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-simple-game-engine",
-  "version": "0.1.62",
+  "version": "0.1.63",
   "description": "",
   "main": "lib/index.js",
   "types": "lib",
@@ -22,6 +22,7 @@
   },
   "files": [
     "/lib/index.js",
+    "/lib/*/**/***.d.ts",
     "/lib/*/**.d.ts",
     "/lib/*.d.ts"
   ],