@safe-engine/cocos 1.0.1

package/dist/dragonbones/index.d.ts

@@ -0,0 +1,20 @@
+import { EntityManager, EventManager, EventReceive, System } from 'entityx-ts';
+import { DragonBonesData, DragonBonesProps } from '../../@types/safex';
+import { ComponentX } from '../gworld/core/decorator';
+export declare class DragonBones extends ComponentX<DragonBonesProps> {
+    data: DragonBonesData;
+    atlas: string;
+    skin: string;
+    animation: string;
+    loop: boolean;
+    timeScale: number;
+    setAnimation(name: string, loop?: boolean): void;
+    setSkeletonData(data: string): void;
+}
+export declare class DragonBonesSystem implements System {
+    configure(event_manager: EventManager): void;
+    receive(type: string, event: EventReceive): void;
+    update(entities: EntityManager, events: EventManager, dt: number): void;
+}
+export declare function setupDragonBones(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/dragonbones/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dragonbones/index.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,MAAM,EACP,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAGtE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAKrD,qBAAa,WAAY,SAAQ,UAAU,CAAC,gBAAgB,CAAC;IAC3D,IAAI,EAAE,eAAe,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IAEjB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,UAAQ;IAOvC,eAAe,CAAC,IAAI,EAAE,MAAM;CAK7B;AAED,qBAAa,iBAAkB,YAAW,MAAM;IAC9C,SAAS,CAAC,aAAa,EAAE,YAAY;IAMrC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY;IAgDzC,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM;CAMjE;AAED,wBAAgB,gBAAgB,SAK/B"}

package/dist/dragonbones/index.js

@@ -0,0 +1,112 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DragonBonesSystem = exports.DragonBones = void 0;
+exports.setupDragonBones = setupDragonBones;
+var dragonbones_js_1 = require("@cocos/dragonbones-js");
+var entityx_ts_1 = require("entityx-ts");
+var gworld_1 = require("../gworld");
+var NodeComp_1 = require("../gworld/components/NodeComp");
+var decorator_1 = require("../gworld/core/decorator");
+var CocosFactory_1 = require("./cocos/CocosFactory");
+// import { dragonBones } from './dragonBones'
+var DragonBones = /** @class */ (function (_super) {
+    __extends(DragonBones, _super);
+    function DragonBones() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DragonBones.prototype.setAnimation = function (name, loop) {
+        if (loop === void 0) { loop = false; }
+        var skel = this.node.instance;
+        if (skel.setAnimation) {
+            skel.setAnimation(0, name, loop);
+        }
+    };
+    DragonBones.prototype.setSkeletonData = function (data) {
+        var skel = this.node.instance;
+        var atlas = data.replace('.json', '.atlas');
+        skel.initWithArgs(data, atlas, this.node.scale);
+    };
+    return DragonBones;
+}(decorator_1.ComponentX));
+exports.DragonBones = DragonBones;
+var DragonBonesSystem = /** @class */ (function () {
+    function DragonBonesSystem() {
+    }
+    DragonBonesSystem.prototype.configure = function (event_manager) {
+        event_manager.subscribe((0, entityx_ts_1.ComponentAddedEvent)(DragonBones), this);
+        event_manager.subscribe((0, entityx_ts_1.ComponentRemovedEvent)(DragonBones), this);
+        // const factory = CocosFactory.factory;
+    };
+    DragonBonesSystem.prototype.receive = function (type, event) {
+        switch (type) {
+            case (0, entityx_ts_1.ComponentAddedEvent)(DragonBones): {
+                console.log('DragonBones', event);
+                var ett = event.entity;
+                var dbComp = event.entity.getComponent(DragonBones);
+                var data = dbComp.data, animation = dbComp.animation, loop = dbComp.loop, timeScale = dbComp.timeScale;
+                // const texturePath = atlas.replace('.json', '.png')
+                var atlas = data.atlas, skeleton = data.skeleton, texture = data.texture;
+                // cc.textureCache.addImage(texture)
+                var factory = CocosFactory_1.CocosFactory.factory;
+                var dataSkel = cc.loader.getRes(skeleton);
+                var dataAtlas = cc.loader.getRes(atlas);
+                var textureCache = cc.textureCache.getTextureForKey(texture);
+                // texture.initWithFile(texturePath);
+                factory.parseDragonBonesData(dataSkel);
+                factory.parseTextureAtlasData(dataAtlas, textureCache);
+                // factory.loadDragonBonesData(skel);
+                // console.log(skeleton, dataSkel);
+                var armature = factory.buildArmature(dataSkel.armature[0].name);
+                // console.log('armature', armature)
+                var node = armature.getDisplay();
+                console.log('node', node);
+                dragonbones_js_1.WorldClock.clock.add(armature);
+                // armature.animation.gotoAndPlay('walk', 0.2);
+                var state = armature.animation.gotoAndPlay(animation, 0, 0, 0);
+                console.log('state', state);
+                // if (skin) {
+                //   node.setSkin(skin)
+                // }
+                if (animation) {
+                    // node.setAnimation(0, animation, loop)
+                }
+                dbComp.node = ett.assign(new NodeComp_1.NodeComp(node, ett));
+                break;
+            }
+            case (0, entityx_ts_1.ComponentRemovedEvent)(DragonBones): {
+                var component = event.component;
+                break;
+            }
+            default:
+                break;
+        }
+    };
+    DragonBonesSystem.prototype.update = function (entities, events, dt) {
+        // throw new Error('Method not implemented.');
+        // console.log('update', dt)
+        dragonbones_js_1.WorldClock.clock.advanceTime(dt);
+        // CocosFactory.advanceTime(dt);
+    };
+    return DragonBonesSystem;
+}());
+exports.DragonBonesSystem = DragonBonesSystem;
+function setupDragonBones() {
+    gworld_1.GameWorld.Instance.systems.add(DragonBonesSystem);
+    gworld_1.GameWorld.Instance.listUpdate.push(DragonBonesSystem);
+    gworld_1.GameWorld.Instance.systems.configureOnce(DragonBonesSystem);
+}

package/dist/gworld/components/AnimationComponent.d.ts

@@ -0,0 +1,65 @@
+import { EnhancedComponent } from './EnhancedComponent';
+export declare namespace AnimationClip {
+    interface IEvent {
+        frame: number;
+        func: string;
+        params: string[];
+        isCalled: boolean;
+    }
+}
+export declare enum WrapMode {
+    Default = 0,
+    Normal = 1,
+    Loop = 2,
+    PingPong = 22,
+    Reverse = 36,
+    LoopReverse = 38,
+    PingPongReverse = 54
+}
+interface AnimProp {
+    frame: number;
+    value: number;
+}
+interface SpriteFrameProp {
+    frame: number;
+    value: string;
+}
+interface CurveData {
+    comps: {
+        spriteFrame: SpriteFrameProp[];
+        nextFrame: number;
+    };
+    props: {
+        [key: string]: AnimProp[];
+    };
+}
+export declare class AnimationClip {
+    static WrapMode: typeof WrapMode;
+    sample: number;
+    speed: number;
+    wrapMode: WrapMode;
+    events: AnimationClip.IEvent[];
+    duration: number;
+    name: string;
+    curveData: CurveData;
+}
+export declare class AnimationComp extends EnhancedComponent {
+    defaultClip: AnimationClip;
+    clips: AnimationClip[];
+    playOnLoad: boolean;
+    private isPaused;
+    private elapsed;
+    private currentClip;
+    constructor(defaultClip: AnimationClip, clips: AnimationClip[], playOnLoad: boolean);
+    start(): void;
+    update(dt: Float): void;
+    getAnimationState(name: string): {
+        isPlaying: boolean;
+    };
+    play(name?: string): void;
+    pause(): void;
+    resume(): void;
+    stop(name?: string): void;
+}
+export {};
+//# sourceMappingURL=AnimationComponent.d.ts.map

package/dist/gworld/components/AnimationComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationComponent.d.ts","sourceRoot":"","sources":["../../../src/gworld/components/AnimationComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAGvD,MAAM,CAAC,OAAO,WAAW,aAAa,CAAC;IACrC,UAAiB,MAAM;QACrB,KAAK,EAAE,MAAM,CAAA;QACb,IAAI,EAAE,MAAM,CAAA;QACZ,MAAM,EAAE,MAAM,EAAE,CAAA;QAChB,QAAQ,EAAE,OAAO,CAAA;KAClB;CACF;AAED,oBAAY,QAAQ;IAClB,OAAO,IAAI;IACX,MAAM,IAAI;IACV,IAAI,IAAI;IACR,QAAQ,KAAK;IACb,OAAO,KAAK;IACZ,WAAW,KAAK;IAChB,eAAe,KAAK;CACrB;AAED,UAAU,QAAQ;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,UAAU,eAAe;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,UAAU,SAAS;IACjB,KAAK,EAAE;QAAE,WAAW,EAAE,eAAe,EAAE,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;IAC5D,KAAK,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAA;KAAE,CAAA;CACrC;AAED,qBAAa,aAAa;IACxB,OAAc,QAAQ,kBAAW;IAC1B,MAAM,SAAK;IACX,KAAK,SAAI;IACT,QAAQ,WAAkB;IAC1B,MAAM,EAAE,aAAa,CAAC,MAAM,EAAE,CAAK;IACnC,QAAQ,SAAI;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,SAAS,CAAA;CACrB;AAID,qBAAa,aAAc,SAAQ,iBAAiB;IAClD,WAAW,EAAE,aAAa,CAAA;IAC1B,KAAK,EAAE,aAAa,EAAE,CAAA;IACtB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,CAAC,QAAQ,CAAO;IACvB,OAAO,CAAC,OAAO,CAAI;IACnB,OAAO,CAAC,WAAW,CAAe;gBAEtB,WAAW,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,UAAU,EAAE,OAAO;IAOnF,KAAK;IASL,MAAM,CAAC,EAAE,EAAE,KAAK;IAqChB,iBAAiB,CAAC,IAAI,EAAE,MAAM;;;IAMvB,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM;IAoBlB,KAAK;IAKL,MAAM;IAKN,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM;CAI1B"}

package/dist/gworld/components/AnimationComponent.js

@@ -0,0 +1,141 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnimationComp = exports.AnimationClip = exports.WrapMode = void 0;
+var EnhancedComponent_1 = require("./EnhancedComponent");
+var RenderComponent_1 = require("./RenderComponent");
+var WrapMode;
+(function (WrapMode) {
+    WrapMode[WrapMode["Default"] = 0] = "Default";
+    WrapMode[WrapMode["Normal"] = 1] = "Normal";
+    WrapMode[WrapMode["Loop"] = 2] = "Loop";
+    WrapMode[WrapMode["PingPong"] = 22] = "PingPong";
+    WrapMode[WrapMode["Reverse"] = 36] = "Reverse";
+    WrapMode[WrapMode["LoopReverse"] = 38] = "LoopReverse";
+    WrapMode[WrapMode["PingPongReverse"] = 54] = "PingPongReverse";
+})(WrapMode || (exports.WrapMode = WrapMode = {}));
+var AnimationClip = /** @class */ (function () {
+    function AnimationClip() {
+        this.sample = 60;
+        this.speed = 1;
+        this.wrapMode = WrapMode.Normal;
+        this.events = [];
+        this.duration = 0;
+    }
+    AnimationClip.WrapMode = WrapMode;
+    return AnimationClip;
+}());
+exports.AnimationClip = AnimationClip;
+// cc.AnimationClip = AnimationClip;
+var AnimationComp = /** @class */ (function (_super) {
+    __extends(AnimationComp, _super);
+    function AnimationComp(defaultClip, clips, playOnLoad) {
+        var _this = _super.call(this) || this;
+        _this.isPaused = true;
+        _this.elapsed = 0;
+        _this.defaultClip = defaultClip;
+        _this.clips = clips;
+        _this.playOnLoad = playOnLoad;
+        return _this;
+    }
+    AnimationComp.prototype.start = function () {
+        var _this = this;
+        if (this.playOnLoad) {
+            setTimeout(function () {
+                _this.play();
+            }, 0);
+        }
+        // cc.log(this.clips);
+    };
+    AnimationComp.prototype.update = function (dt) {
+        var _this = this;
+        if (this.isPaused || !this.node.active) {
+            return;
+        }
+        var _a = this.currentClip, curveData = _a.curveData, wrapMode = _a.wrapMode, events = _a.events, duration = _a.duration, speed = _a.speed;
+        this.elapsed += dt * speed;
+        var _b = curveData.comps, spriteFrame = _b.spriteFrame, nextFrame = _b.nextFrame;
+        var nextFrameTime = spriteFrame[nextFrame].frame;
+        events.forEach(function (evt) {
+            var func = evt.func, frame = evt.frame, params = evt.params, isCalled = evt.isCalled;
+            if (!isCalled && _this.elapsed >= frame) {
+                evt.isCalled = true;
+                // this.node.emit(func, ...params)
+            }
+        });
+        if (this.elapsed >= nextFrameTime) {
+            var imageComp = this.node.getComponent(RenderComponent_1.SpriteRender);
+            if (imageComp) {
+                imageComp.spriteFrame = spriteFrame[nextFrame].value;
+            }
+            // cc.log(spriteFrame[nextFrame].value, nextFrameTime);
+            curveData.comps.nextFrame += 1;
+            curveData.comps.nextFrame = cc.clampf(curveData.comps.nextFrame, 0, spriteFrame.length - 1);
+            if (this.elapsed >= duration) {
+                if (wrapMode === WrapMode.Loop) {
+                    curveData.comps.nextFrame = 0;
+                    this.elapsed = 0;
+                    events.forEach(function (evt) {
+                        evt.isCalled = false;
+                    });
+                }
+                else {
+                    this.isPaused = true;
+                }
+            }
+        }
+    };
+    AnimationComp.prototype.getAnimationState = function (name) {
+        return {
+            isPlaying: !this.isPaused,
+        };
+    };
+    AnimationComp.prototype.play = function (name) {
+        this.elapsed = 0;
+        // cc.log('play', name, this.defaultClip.name);
+        if (!name) {
+            if (!this.defaultClip) {
+                return;
+            }
+            name = this.defaultClip.name;
+        }
+        else if (this.currentClip && name === this.currentClip.name) {
+            return;
+        }
+        this.currentClip = this.clips.find(function (clip) { return clip.name === name; });
+        this.currentClip.curveData.comps.nextFrame = 0;
+        // cc.log('name', name, this.currentClip);
+        this.currentClip.events.forEach(function (evt) {
+            evt.isCalled = false;
+        });
+        this.isPaused = false;
+    };
+    AnimationComp.prototype.pause = function () {
+        this.node.instance.pause();
+        this.isPaused = true;
+    };
+    AnimationComp.prototype.resume = function () {
+        this.node.instance.resume();
+        this.isPaused = false;
+    };
+    AnimationComp.prototype.stop = function (name) {
+        this.node.instance.unscheduleAllCallbacks();
+        this.isPaused = true;
+    };
+    return AnimationComp;
+}(EnhancedComponent_1.EnhancedComponent));
+exports.AnimationComp = AnimationComp;

package/dist/gworld/components/CollideComponent.d.ts

@@ -0,0 +1,64 @@
+import { Vec2 } from '../../polyfills';
+import { NoRenderComponentX } from '../core/decorator';
+interface ColliderProps {
+    offset?: Vec2;
+    tag?: number;
+    enabled?: boolean;
+    onCollisionEnter?: (other: Collider) => void;
+    onCollisionExit?: (other: Collider) => void;
+    onCollisionStay?: (other: Collider) => void;
+}
+export declare class Collider<T = ColliderProps> extends NoRenderComponentX<T> {
+    _worldPoints: cc.Vec2[] | cc.Point[];
+    _worldPosition: cc.Vec2 | cc.Point;
+    _worldRadius: any;
+    _AABB: cc.Rect;
+    _preAabb: cc.Rect;
+    getAABB(): cc.Rect;
+    get world(): {
+        points: cc.Point[] | cc.Vec2[];
+        preAabb: cc.Rect;
+    };
+}
+interface BoxColliderProps extends ColliderProps {
+    width: number;
+    height: number;
+}
+export declare class BoxCollider extends Collider<BoxColliderProps> {
+    get size(): cc.Size;
+    set size(s: cc.Size);
+    update(dt: any, draw: cc.DrawNode): void;
+}
+interface CircleColliderProps extends ColliderProps {
+    radius: number;
+}
+export declare class CircleCollider extends Collider<CircleColliderProps> {
+    update(dt: any, draw: cc.DrawNode): void;
+}
+interface PolygonColliderProps extends ColliderProps {
+    points: Array<Vec2>;
+}
+export declare class PolygonCollider extends Collider<PolygonColliderProps> {
+    get points(): Vec2[];
+    set points(points: Vec2[]);
+    update(dt: any, draw: cc.DrawNode): void;
+}
+export declare enum CollisionType {
+    NONE = 0,
+    ENTER = 1,
+    STAY = 2,
+    EXIT = 3
+}
+export declare class Contract {
+    _collider1: Collider;
+    _collider2: Collider;
+    _touching: boolean;
+    _isPolygonPolygon: boolean;
+    _isCircleCircle: boolean;
+    _isPolygonCircle: boolean;
+    constructor(collider1: Collider, collider2: Collider);
+    updateState(): CollisionType;
+    test(): any;
+}
+export {};
+//# sourceMappingURL=CollideComponent.d.ts.map

package/dist/gworld/components/CollideComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollideComponent.d.ts","sourceRoot":"","sources":["../../../src/gworld/components/CollideComponent.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAYtD,UAAU,aAAa;IACrB,MAAM,CAAC,EAAE,IAAI,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAA;IAC5C,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAA;IAC3C,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAA;CAC5C;AACD,qBAAa,QAAQ,CAAC,CAAC,GAAG,aAAa,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IACpE,YAAY,EAAE,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,CAAK;IACzC,cAAc,EAAE,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,KAAK,CAAA;IAClC,YAAY,MAAA;IACZ,KAAK,EAAE,EAAE,CAAC,IAAI,CAAsB;IACpC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAsB;IAGvC,OAAO;IAGP,IAAI,KAAK;;;MAKR;CACF;AAED,UAAU,gBAAiB,SAAQ,aAAa;IAC9C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AACD,qBAAa,WAAY,SAAQ,QAAQ,CAAC,gBAAgB,CAAC;IACzD,IAAI,IAAI,IAII,EAAE,CAAC,IAAI,CAFlB;IAED,IAAI,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,EAGlB;IAED,MAAM,CAAC,EAAE,KAAA,EAAE,IAAI,EAAE,EAAE,CAAC,QAAQ;CA4B7B;AAED,UAAU,mBAAoB,SAAQ,aAAa;IACjD,MAAM,EAAE,MAAM,CAAA;CACf;AACD,qBAAa,cAAe,SAAQ,QAAQ,CAAC,mBAAmB,CAAC;IAC/D,MAAM,CAAC,EAAE,KAAA,EAAE,IAAI,EAAE,EAAE,CAAC,QAAQ;CAqB7B;AAED,UAAU,oBAAqB,SAAQ,aAAa;IAClD,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;CACpB;AAED,qBAAa,eAAgB,SAAQ,QAAQ,CAAC,oBAAoB,CAAC;IACjE,IAAI,MAAM,IAAI,IAAI,EAAE,CAInB;IAED,IAAI,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,EAExB;IAED,MAAM,CAAC,EAAE,KAAA,EAAE,IAAI,EAAE,EAAE,CAAC,QAAQ;CAqB7B;AAED,oBAAY,aAAa;IACvB,IAAI,IAAA;IACJ,KAAK,IAAA;IACL,IAAI,IAAA;IACJ,IAAI,IAAA;CACL;AASD,qBAAa,QAAQ;IACnB,UAAU,EAAE,QAAQ,CAAA;IACpB,UAAU,EAAE,QAAQ,CAAA;IACpB,SAAS,EAAE,OAAO,CAAA;IAClB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,eAAe,EAAE,OAAO,CAAA;IACxB,gBAAgB,EAAE,OAAO,CAAA;gBAEb,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ;IAsBpD,WAAW;IAeX,IAAI;CAyBL"}

package/dist/gworld/components/CollideComponent.js

@@ -0,0 +1,266 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contract = exports.CollisionType = exports.PolygonCollider = exports.CircleCollider = exports.BoxCollider = exports.Collider = void 0;
+var max_1 = __importDefault(require("lodash/max"));
+var min_1 = __importDefault(require("lodash/min"));
+var polyfills_1 = require("../../polyfills");
+var decorator_1 = require("../core/decorator");
+function getNodeToWorldTransformAR(node) {
+    var t = node.instance.getNodeToWorldTransform();
+    var anchorPointSize = node.instance.getAnchorPointInPoints();
+    var transform = cc.affineTransformTranslate(t, anchorPointSize.x, anchorPointSize.y);
+    return transform;
+}
+function cloneRect(origin) {
+    return cc.rect(origin.x, origin.y, origin.width, origin.height);
+}
+var Collider = /** @class */ (function (_super) {
+    __extends(Collider, _super);
+    function Collider() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this._worldPoints = [];
+        _this._AABB = cc.rect(0, 0, 0, 0);
+        _this._preAabb = cc.rect(0, 0, 0, 0);
+        return _this;
+    }
+    // update(dt: number, draw?: cc.DrawNode) {}
+    Collider.prototype.getAABB = function () {
+        return this._AABB;
+    };
+    Object.defineProperty(Collider.prototype, "world", {
+        get: function () {
+            return {
+                points: this._worldPoints,
+                preAabb: this._preAabb,
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Collider;
+}(decorator_1.NoRenderComponentX));
+exports.Collider = Collider;
+var BoxCollider = /** @class */ (function (_super) {
+    __extends(BoxCollider, _super);
+    function BoxCollider() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(BoxCollider.prototype, "size", {
+        get: function () {
+            return cc.size(this.props.width, this.props.height);
+        },
+        set: function (s) {
+            this.props.width = s.width;
+            this.props.height = s.height;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BoxCollider.prototype.update = function (dt, draw) {
+        if (!this.node) {
+            return;
+        }
+        var collider = this.getComponent(Collider);
+        var _a = collider.props.offset || (0, polyfills_1.Vec2)(0, 0), x = _a.x, y = _a.y;
+        var hw = this.props.width * 0.5;
+        var hh = this.props.height * 0.5;
+        var transform = getNodeToWorldTransformAR(this.node);
+        var rect = cc.rect(x - hw, y - hh, this.props.width, this.props.height);
+        var rectTrs = cc.rectApplyAffineTransform(rect, transform);
+        // cc.log(rectTrs);
+        collider._worldPoints[0] = (0, polyfills_1.Vec2)(rectTrs.x, rectTrs.y);
+        collider._worldPoints[1] = (0, polyfills_1.Vec2)(rectTrs.x, rectTrs.y + rectTrs.height);
+        collider._worldPoints[2] = (0, polyfills_1.Vec2)(rectTrs.x + rectTrs.width, rectTrs.y + rectTrs.height);
+        collider._worldPoints[3] = (0, polyfills_1.Vec2)(rectTrs.x + rectTrs.width, rectTrs.y);
+        var listX = collider._worldPoints.map(function (_a) {
+            var x = _a.x;
+            return x;
+        });
+        var listY = collider._worldPoints.map(function (_a) {
+            var y = _a.y;
+            return y;
+        });
+        collider._preAabb = cloneRect(collider._AABB);
+        collider._AABB.x = (0, min_1.default)(listX);
+        collider._AABB.y = (0, min_1.default)(listY);
+        collider._AABB.width = (0, max_1.default)(listX) - collider._AABB.x;
+        collider._AABB.height = (0, max_1.default)(listY) - collider._AABB.y;
+        if (draw) {
+            draw.drawPoly(collider._worldPoints, null, 3, cc.Color.DEBUG_BORDER_COLOR);
+        }
+    };
+    return BoxCollider;
+}(Collider));
+exports.BoxCollider = BoxCollider;
+var CircleCollider = /** @class */ (function (_super) {
+    __extends(CircleCollider, _super);
+    function CircleCollider() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CircleCollider.prototype.update = function (dt, draw) {
+        if (!this.node) {
+            return;
+        }
+        var transform = getNodeToWorldTransformAR(this.node);
+        var collider = this.getComponent(Collider);
+        collider._worldRadius = this.props.radius * this.node.scaleX;
+        collider._worldPosition = cc.pointApplyAffineTransform(collider.props.offset, transform);
+        if (draw) {
+            draw.drawDot(collider._worldPosition, collider._worldRadius, cc.Color.DEBUG_FILL_COLOR);
+            draw.drawCircle(collider._worldPosition, collider._worldRadius, 0, 64, true, 3, cc.Color.DEBUG_BORDER_COLOR);
+        }
+        collider._preAabb = cloneRect(collider._AABB);
+        collider._AABB.x = collider._worldPosition.x - collider._worldRadius;
+        collider._AABB.y = collider._worldPosition.y - collider._worldRadius;
+        collider._AABB.width = collider._worldRadius * 2;
+        collider._AABB.height = collider._AABB.width;
+        // draw.drawRect(cc.p(this._AABB.x, this._AABB.y),
+        //   cc.p(this._worldPosition.x + this._worldRadius, this._worldPosition.y + this._worldRadius),
+        //   cc.Color.WHITE, 3, cc.Color.DEBUG_BORDER_COLOR);
+    };
+    return CircleCollider;
+}(Collider));
+exports.CircleCollider = CircleCollider;
+var PolygonCollider = /** @class */ (function (_super) {
+    __extends(PolygonCollider, _super);
+    function PolygonCollider() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(PolygonCollider.prototype, "points", {
+        get: function () {
+            var _a = this.props.offset, x = _a.x, y = _a.y;
+            var pointsList = this.props.points.map(function (p) { return (0, polyfills_1.Vec2)(p.x + x, p.y + y); });
+            return pointsList;
+        },
+        set: function (points) {
+            this.props.points = points;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PolygonCollider.prototype.update = function (dt, draw) {
+        if (!this.node) {
+            return;
+        }
+        var transform = getNodeToWorldTransformAR(this.node);
+        var collider = this.getComponent(Collider);
+        collider._worldPoints = this.points.map(function (p) { return cc.pointApplyAffineTransform(p, transform); });
+        // cc.log(polyPoints);
+        if (draw) {
+            draw.drawPoly(collider._worldPoints, cc.Color.DEBUG_FILL_COLOR, 3, cc.Color.DEBUG_BORDER_COLOR);
+        }
+        var listX = collider._worldPoints.map(function (_a) {
+            var x = _a.x;
+            return x;
+        });
+        var listY = collider._worldPoints.map(function (_a) {
+            var y = _a.y;
+            return y;
+        });
+        collider._preAabb = cloneRect(collider._AABB);
+        collider._AABB.x = (0, min_1.default)(listX);
+        collider._AABB.y = (0, min_1.default)(listY);
+        collider._AABB.width = (0, max_1.default)(listX) - collider._AABB.x;
+        collider._AABB.height = (0, max_1.default)(listY) - collider._AABB.y;
+        // draw.drawRect(cc.p(this._AABB.x, this._AABB.y), cc.p(max(listX), max(listY)),
+        // cc.Color.WHITE, 3, cc.Color.DEBUG_BORDER_COLOR);
+    };
+    return PolygonCollider;
+}(Collider));
+exports.PolygonCollider = PolygonCollider;
+var CollisionType;
+(function (CollisionType) {
+    CollisionType[CollisionType["NONE"] = 0] = "NONE";
+    CollisionType[CollisionType["ENTER"] = 1] = "ENTER";
+    CollisionType[CollisionType["STAY"] = 2] = "STAY";
+    CollisionType[CollisionType["EXIT"] = 3] = "EXIT";
+})(CollisionType || (exports.CollisionType = CollisionType = {}));
+function isPolygonCollider(col) {
+    return col.getComponent(PolygonCollider) || col.getComponent(BoxCollider);
+}
+function isCircleCollider(col) {
+    return col.getComponent(CircleCollider);
+}
+var Contract = /** @class */ (function () {
+    function Contract(collider1, collider2) {
+        this._collider1 = collider1;
+        this._collider2 = collider2;
+        var isCollider1Polygon = isPolygonCollider(collider1);
+        var isCollider2Polygon = isPolygonCollider(collider2);
+        var isCollider1Circle = isCircleCollider(collider1);
+        var isCollider2Circle = isCircleCollider(collider2);
+        if (isCollider1Polygon && isCollider2Polygon) {
+            this._isPolygonPolygon = true;
+        }
+        else if (isCollider1Circle && isCollider2Circle) {
+            this._isCircleCircle = true;
+        }
+        else if (isCollider1Polygon && isCollider2Circle) {
+            this._isPolygonCircle = true;
+        }
+        else if (isCollider1Circle && isCollider2Polygon) {
+            this._isPolygonCircle = true;
+            this._collider1 = collider2;
+            this._collider2 = collider1;
+        }
+        // cc.log(this._isPolygonPolygon);
+    }
+    Contract.prototype.updateState = function () {
+        var result = this.test();
+        var type = CollisionType.NONE;
+        if (result && !this._touching) {
+            this._touching = true;
+            type = CollisionType.ENTER;
+        }
+        else if (result && this._touching) {
+            type = CollisionType.STAY;
+        }
+        else if (!result && this._touching) {
+            this._touching = false;
+            type = CollisionType.EXIT;
+        }
+        return type;
+    };
+    Contract.prototype.test = function () {
+        // if (!shouldCollider(this._collider1, this._collider2)) {
+        //   return false;
+        // }
+        // cc.log(this._collider1.getAABB(), this._collider2.getAABB());
+        if (!cc.rectIntersectsRect(this._collider1.getAABB(), this._collider2.getAABB())) {
+            return false;
+        }
+        if (this._isPolygonPolygon) {
+            return cc.Intersection.polygonPolygon(this._collider1._worldPoints, this._collider2._worldPoints);
+        }
+        if (this._isCircleCircle) {
+            var p1 = this._collider1;
+            var p2 = this._collider2;
+            return cc.Intersection.circleCircle(p1._worldPosition, p1._worldRadius, p2._worldPosition, p2._worldRadius);
+        }
+        if (this._isPolygonCircle) {
+            var p2 = this._collider2;
+            return cc.Intersection.polygonCircle(this._collider1._worldPoints, p2._worldPosition, p2._worldRadius);
+        }
+        return false;
+    };
+    return Contract;
+}());
+exports.Contract = Contract;