@safe-engine/cocos 2.6.3 → 2.6.5

package/dist/gworld/systems/CollideSystem.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollideSystem = void 0;
+var entityx_ts_1 = require("entityx-ts");
+var utils_1 = require("../../helper/utils");
+var CollideComponent_1 = require("../components/CollideComponent");
+var NodeComp_1 = require("../components/NodeComp");
+var CollideSystem = /** @class */ (function () {
+    function CollideSystem() {
+        var _this = this;
+        this.listColliders = [];
+        this._contracts = [];
+        this.removeColliders = [];
+        this.enabledDebugDraw = false;
+        this.enabled = true;
+        this.colliderMatrix = [[true]];
+        this.onAddCollider = function (_a) {
+            var entity = _a.entity, component = _a.component;
+            var collider = entity.assign(new CollideComponent_1.Collider(component));
+            collider.node = entity.getComponent(NodeComp_1.NodeComp);
+            collider.props = component.props;
+            // collider.props.enable = true
+            component.node = entity.getComponent(NodeComp_1.NodeComp);
+            _this.addCollider(collider);
+        };
+        this.onRemoveCollider = function (_a) {
+            var entity = _a.entity, component = _a.component;
+            _this.removeColliders.push(component.getComponent(CollideComponent_1.Collider));
+        };
+    }
+    CollideSystem.prototype.configure = function (event_manager) {
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, CollideComponent_1.BoxCollider, this.onAddCollider.bind(this));
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, CollideComponent_1.CircleCollider, this.onAddCollider.bind(this));
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, CollideComponent_1.PolygonCollider, this.onAddCollider.bind(this));
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentRemoved, CollideComponent_1.BoxCollider, this.onRemoveCollider.bind(this));
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentRemoved, CollideComponent_1.CircleCollider, this.onRemoveCollider.bind(this));
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentRemoved, CollideComponent_1.PolygonCollider, this.onRemoveCollider.bind(this));
+    };
+    CollideSystem.prototype.update = function (entities, events, dt) {
+        var _this = this;
+        if (!this.enabled) {
+            return;
+        }
+        this.listColliders.forEach(function (collider) {
+            if (!cc.sys.isObjectValid(collider.node.instance)) {
+                _this.removeColliders.push(collider);
+            }
+        });
+        // this.removeColliders.forEach(comp => {
+        //   this.listColliders = this.listColliders.filter(col => !col.isEqual(comp)
+        //     && cc.sys.isObjectValid(col.node.instance));
+        //   this._contracts = this._contracts.filter(contract => {
+        //     const col1 = contract._collider1;
+        //     const col2 = contract._collider2;
+        //     if (col1.isEqual(comp) || !cc.sys.isObjectValid(col1.node.instance)) {
+        //       if (contract._touching) {
+        //         col2.node.emit('onCollisionExit', col1, col2);
+        //       }
+        //       return false;
+        //     }
+        //     if (col2.isEqual(comp) || !cc.sys.isObjectValid(col2.node.instance)) {
+        //       if (contract._touching) {
+        //         col1.node.emit('onCollisionExit', col2, col1);
+        //       }
+        //       return false;
+        //     }
+        //     return true;
+        //   }
+        //   );
+        // });
+        this.removeColliders = [];
+        var draw;
+        var _a = this, enabledDebugDraw = _a.enabledDebugDraw, debugGraphics = _a.debugGraphics;
+        if (enabledDebugDraw) {
+            draw = debugGraphics;
+            draw.clear();
+            //   this.listColliders.forEach(collider => {
+            //     if (collider.node && collider.node.active) {
+            //       collider.update(dt, draw);
+            //     }
+            //   });
+            // } else {
+            //   this.listColliders.forEach(collider => {
+            //     if (collider.node && collider.node.active) {
+            //       collider.update(dt);
+            //     }
+            //   });
+        }
+        for (var _i = 0, _b = entities.entities_with_components(CollideComponent_1.BoxCollider); _i < _b.length; _i++) {
+            var entt = _b[_i];
+            var comp = entt.getComponent(CollideComponent_1.BoxCollider);
+            comp.update(dt, draw);
+        }
+        for (var _c = 0, _d = entities.entities_with_components(CollideComponent_1.CircleCollider); _c < _d.length; _c++) {
+            var entt = _d[_c];
+            var comp = entt.getComponent(CollideComponent_1.CircleCollider);
+            comp.update(dt, draw);
+        }
+        for (var _e = 0, _f = entities.entities_with_components(CollideComponent_1.PolygonCollider); _e < _f.length; _e++) {
+            var entt = _f[_e];
+            var comp = entt.getComponent(CollideComponent_1.PolygonCollider);
+            comp.update(dt, draw);
+        }
+        this._contracts.forEach(function (contract) {
+            var col1 = contract._collider1;
+            var col2 = contract._collider2;
+            if (!cc.sys.isObjectValid(col1.node.instance) ||
+                !cc.sys.isObjectValid(col2.node.instance) ||
+                !col1.node ||
+                !col2.node ||
+                !col1.node.active ||
+                !col2.node.active) {
+                return;
+            }
+            var type = contract.updateState();
+            switch (type) {
+                case CollideComponent_1.CollisionType.ENTER: {
+                    if (col1.props.onCollisionEnter) {
+                        col1.props.onCollisionEnter(col2);
+                    }
+                    if (col2.props.onCollisionEnter) {
+                        col2.props.onCollisionEnter(col1);
+                    }
+                    break;
+                }
+                case CollideComponent_1.CollisionType.STAY:
+                    if (col1.props.onCollisionStay) {
+                        col1.props.onCollisionStay(col2);
+                    }
+                    if (col2.props.onCollisionStay) {
+                        col2.props.onCollisionStay(col1);
+                    }
+                    break;
+                case CollideComponent_1.CollisionType.EXIT:
+                    if (col1.props.onCollisionExit) {
+                        col1.props.onCollisionExit(col2);
+                    }
+                    if (col2.props.onCollisionExit) {
+                        col2.props.onCollisionExit(col1);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        });
+    };
+    CollideSystem.prototype.addCollider = function (collider) {
+        var _this = this;
+        this.listColliders.forEach(function (col) {
+            if ((0, utils_1.shouldCollider)(col, collider)) {
+                _this._contracts.push(new CollideComponent_1.Contract(col, collider));
+            }
+        });
+        this.listColliders.push(collider);
+    };
+    CollideSystem.prototype.removeCollider = function (collider) {
+        this.removeColliders.push(collider);
+    };
+    CollideSystem.prototype.addDebugNode = function (root) {
+        this.debugGraphics = new cc.DrawNode();
+        this.debugGraphics.zIndex = 1000;
+        root.addChild(this.debugGraphics);
+    };
+    CollideSystem.prototype.toggleDebugDraw = function (enable) {
+        if (enable === void 0) { enable = true; }
+        this.enabledDebugDraw = enable;
+        this.addDebugNode(cc.director.getRunningScene());
+    };
+    return CollideSystem;
+}());
+exports.CollideSystem = CollideSystem;

package/dist/gworld/systems/GUISystem.d.ts

@@ -0,0 +1,15 @@
+import { EntityManager, EventManager, System } from 'entityx-ts';
+export declare class GUISystem implements System {
+    defaultFont: string;
+    configure(event_manager: EventManager): void;
+    private onAddButtonComp;
+    private onAddProgressTimerComp;
+    private onAddLabelComp;
+    private onAddLabelOutlineComp;
+    private onAddLabelShadowComp;
+    private onAddRichTextComp;
+    private onAddScrollViewComp;
+    private onAddBlockInputEventsComp;
+    update(entities: EntityManager, events: EventManager, dt: number): any;
+}
+//# sourceMappingURL=GUISystem.d.ts.map

package/dist/gworld/systems/GUISystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GUISystem.d.ts","sourceRoot":"","sources":["../../../src/gworld/systems/GUISystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAoC,MAAM,EAAE,MAAM,YAAY,CAAA;AAiBlG,qBAAa,SAAU,YAAW,MAAM;IACtC,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,aAAa,EAAE,YAAY;IAWrC,OAAO,CAAC,eAAe,CAuBtB;IAED,OAAO,CAAC,sBAAsB,CAa7B;IAED,OAAO,CAAC,cAAc,CAMrB;IAED,OAAO,CAAC,qBAAqB,CAM5B;IAED,OAAO,CAAC,oBAAoB,CAM3B;IAED,OAAO,CAAC,iBAAiB,CAQxB;IAED,OAAO,CAAC,mBAAmB,CAU1B;IAED,OAAO,CAAC,yBAAyB,CAOhC;IAED,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM;CAIjE"}

package/dist/gworld/systems/GUISystem.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GUISystem = void 0;
+var entityx_ts_1 = require("entityx-ts");
+var __1 = require("../..");
+var polyfills_1 = require("../../polyfills");
+var GUIComponent_1 = require("../components/GUIComponent");
+var NodeComp_1 = require("../components/NodeComp");
+var GUISystem = /** @class */ (function () {
+    function GUISystem() {
+        var _this = this;
+        this.onAddButtonComp = function (_a) {
+            var entity = _a.entity, button = _a.component;
+            var nodeComp = entity.getComponent(NodeComp_1.NodeComp);
+            // const { normalImage, selectedImage, disableImage, texType, zoomScale } = button
+            button.node = nodeComp;
+            var touchComp = entity.assign(new __1.TouchEventRegister());
+            touchComp.props.onTouchStart = function (touch) {
+                var p = touch.getLocation();
+                // console.log('onTouchBegan', p, nodeComp)
+                var rect = nodeComp.getBoundingBox();
+                var nodeSpaceLocation = nodeComp.parent.convertToNodeSpace(p);
+                if (rect.contains(nodeSpaceLocation) && button.enabled && nodeComp.active) {
+                    var scale = cc.scaleTo(0.3, 1.2);
+                    nodeComp.runAction(scale);
+                    button.props.onPress(button);
+                    // return true
+                }
+            };
+            touchComp.props.onTouchEnd = function () {
+                var scale = cc.scaleTo(0.3, 1);
+                nodeComp.runAction(scale);
+                // return true
+            };
+            touchComp.props.onTouchCancel = touchComp.props.onTouchEnd;
+        };
+        this.onAddProgressTimerComp = function (_a) {
+            var entity = _a.entity, bar = _a.component;
+            var _b = bar.props, spriteFrame = _b.spriteFrame, _c = _b.fillType, fillType = _c === void 0 ? GUIComponent_1.FillType.HORIZONTAL : _c, _d = _b.fillRange, fillRange = _d === void 0 ? 1 : _d, _e = _b.fillCenter, fillCenter = _e === void 0 ? (0, polyfills_1.Vec2)(1, 0) : _e;
+            var sprite = new cc.Sprite(spriteFrame);
+            var pTimer = new cc.ProgressTimer(sprite);
+            var ptt = fillType === GUIComponent_1.FillType.RADIAL ? cc.ProgressTimer.TYPE_RADIAL : cc.ProgressTimer.TYPE_BAR;
+            pTimer.setType(ptt);
+            if (fillType !== GUIComponent_1.FillType.RADIAL) {
+                var rate = fillType === GUIComponent_1.FillType.HORIZONTAL ? cc.p(1, 0) : cc.p(0, 1);
+                pTimer.setBarChangeRate(rate);
+            }
+            pTimer.setPercentage(fillRange * 100);
+            pTimer.setMidpoint(fillCenter);
+            bar.node = entity.assign(new NodeComp_1.NodeComp(pTimer, entity));
+        };
+        this.onAddLabelComp = function (_a) {
+            var entity = _a.entity, label = _a.component;
+            var _b = label.props, _c = _b.string, string = _c === void 0 ? '' : _c, _d = _b.font, font = _d === void 0 ? _this.defaultFont : _d, _e = _b.size, size = _e === void 0 ? 64 : _e;
+            var fontName = cc.path.basename(font, '.ttf');
+            var node = new ccui.Text(string, fontName, size);
+            node.setTextVerticalAlignment(cc.VERTICAL_TEXT_ALIGNMENT_BOTTOM);
+            label.node = entity.assign(new NodeComp_1.NodeComp(node, entity));
+        };
+        this.onAddLabelOutlineComp = function (_a) {
+            var entity = _a.entity, outline = _a.component;
+            var _b = outline.props, color = _b.color, width = _b.width;
+            var node = entity.getComponent(NodeComp_1.NodeComp);
+            if (node.instance instanceof ccui.Text) {
+                node.instance.enableOutline(color, width);
+            }
+        };
+        this.onAddLabelShadowComp = function (_a) {
+            var entity = _a.entity, shadow = _a.component;
+            var _b = shadow.props, color = _b.color, blur = _b.blur, offset = _b.offset;
+            var node = entity.getComponent(NodeComp_1.NodeComp);
+            if (node.instance instanceof ccui.Text) {
+                node.instance.enableShadow(color, offset, blur);
+            }
+        };
+        this.onAddRichTextComp = function (_a) {
+            var entity = _a.entity, rich = _a.component;
+            var _b = rich.props.string, string = _b === void 0 ? '' : _b;
+            var node = new ccui.RichText();
+            node.width = 500;
+            node.height = 300;
+            node.ignoreContentAdaptWithSize(false);
+            rich.node = entity.assign(new NodeComp_1.NodeComp(node, entity));
+            rich.string = string;
+        };
+        this.onAddScrollViewComp = function (_a) {
+            var entity = _a.entity, scrollView = _a.component;
+            var _b = scrollView.props, viewSize = _b.viewSize, contentSize = _b.contentSize, _c = _b.direction, direction = _c === void 0 ? cc.SCROLLVIEW_DIRECTION_VERTICAL : _c;
+            var node = new cc.ScrollView(viewSize);
+            node.setContentSize(contentSize);
+            node.setViewSize(viewSize);
+            node.setDirection(direction);
+            // node.setContentOffset(cc.p(0, viewSize.height - contentSize.height))
+            // node.setTouchEnabled(false)
+            node.setBounceable(false);
+            scrollView.node = entity.assign(new NodeComp_1.NodeComp(node, entity));
+        };
+        this.onAddBlockInputEventsComp = function (_a) {
+            var entity = _a.entity, blockInput = _a.component;
+            var node = entity.getComponent(NodeComp_1.NodeComp);
+            if (node.instance instanceof ccui.ImageView) {
+                node.instance.setTouchEnabled(true);
+                node.instance.setScale9Enabled(true);
+            }
+            blockInput.node = node;
+        };
+    }
+    GUISystem.prototype.configure = function (event_manager) {
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, GUIComponent_1.ButtonComp, this.onAddButtonComp);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, GUIComponent_1.ProgressTimerComp, this.onAddProgressTimerComp);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, GUIComponent_1.LabelComp, this.onAddLabelComp);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, GUIComponent_1.LabelOutlineComp, this.onAddLabelOutlineComp);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, GUIComponent_1.LabelShadowComp, this.onAddLabelShadowComp);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, GUIComponent_1.RichTextComp, this.onAddRichTextComp);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, GUIComponent_1.ScrollViewComp, this.onAddScrollViewComp);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, GUIComponent_1.BlockInputEventsComp, this.onAddBlockInputEventsComp);
+    };
+    GUISystem.prototype.update = function () {
+        // throw new Error('Method not implemented.');
+    };
+    return GUISystem;
+}());
+exports.GUISystem = GUISystem;

package/dist/gworld/systems/NoRenderSystem.d.ts

@@ -0,0 +1,16 @@
+import { EntityManager, EventManager, System } from 'entityx-ts';
+export declare class NoRenderSystem implements System {
+    configure(event_manager: EventManager): void;
+    onAddTouchEventRegister: ({ entity, component }: {
+        entity: any;
+        component: any;
+    }) => void;
+    onAddExtraDataComp: ({ component }: {
+        component: any;
+    }) => void;
+    onRemovedTouchEventRegister: ({ component }: {
+        component: any;
+    }) => void;
+    update(entities: EntityManager, events: EventManager, dt: number): any;
+}
+//# sourceMappingURL=NoRenderSystem.d.ts.map

package/dist/gworld/systems/NoRenderSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoRenderSystem.d.ts","sourceRoot":"","sources":["../../../src/gworld/systems/NoRenderSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAc,MAAM,EAAE,MAAM,YAAY,CAAA;AAM5E,qBAAa,cAAe,YAAW,MAAM;IAC3C,SAAS,CAAC,aAAa,EAAE,YAAY;IAMrC,uBAAuB;;;eAiDtB;IAED,kBAAkB;;eAIjB;IAED,2BAA2B;;eAM1B;IAED,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM;CAIjE"}

package/dist/gworld/systems/NoRenderSystem.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoRenderSystem = void 0;
+var entityx_ts_1 = require("entityx-ts");
+var NodeComp_1 = require("../components/NodeComp");
+var NoRenderComponent_1 = require("../components/NoRenderComponent");
+var NoRenderSystem = /** @class */ (function () {
+    function NoRenderSystem() {
+        this.onAddTouchEventRegister = function (_a) {
+            var entity = _a.entity, component = _a.component;
+            var ett = entity;
+            var touchComp = component;
+            var nodeComp = ett.getComponent(NodeComp_1.NodeComp);
+            touchComp.node = nodeComp;
+            touchComp.listener = cc.eventManager.addListener({
+                event: cc.EventListener.TOUCH_ONE_BY_ONE,
+                swallowTouches: true,
+                onTouchBegan: function (touch) {
+                    var onTouchStart = touchComp.props.onTouchStart;
+                    // console.log('onTouchBegan', onTouchStart)
+                    if (!nodeComp.parent) {
+                        if (onTouchStart) {
+                            onTouchStart(touch, nodeComp);
+                        }
+                        return true;
+                    }
+                    var p = touch.getLocation();
+                    var rect = nodeComp.getBoundingBox();
+                    var nodeSpaceLocation = nodeComp.parent.convertToNodeSpace(p);
+                    if (rect.contains(nodeSpaceLocation)) {
+                        if (onTouchStart) {
+                            onTouchStart(touch, nodeComp);
+                        }
+                        return true;
+                    }
+                },
+                onTouchMoved: function (touch) {
+                    var onTouchMove = touchComp.props.onTouchMove;
+                    if (!onTouchMove)
+                        return false;
+                    onTouchMove(touch, nodeComp);
+                    return true;
+                },
+                onTouchEnded: function (touch) {
+                    var onTouchEnd = touchComp.props.onTouchEnd;
+                    if (!onTouchEnd)
+                        return false;
+                    onTouchEnd(touch, nodeComp);
+                    return true;
+                },
+                onTouchCancelled: function (touch) {
+                    var onTouchCancel = touchComp.props.onTouchCancel;
+                    if (!onTouchCancel)
+                        return false;
+                    onTouchCancel(touch, nodeComp);
+                    return true;
+                },
+            }, nodeComp.instance);
+        };
+        this.onAddExtraDataComp = function (_a) {
+            var component = _a.component;
+            var extra = component;
+            var _b = extra.props, key = _b.key, value = _b.value;
+            extra.data[key] = value;
+        };
+        this.onRemovedTouchEventRegister = function (_a) {
+            var component = _a.component;
+            var touchComp = component;
+            if (touchComp.listener) {
+                cc.eventManager.removeListener(touchComp.listener);
+                touchComp.listener = null;
+            }
+        };
+    }
+    NoRenderSystem.prototype.configure = function (event_manager) {
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, NoRenderComponent_1.ExtraDataComp, this.onAddExtraDataComp);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, NoRenderComponent_1.TouchEventRegister, this.onAddTouchEventRegister);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentRemoved, NoRenderComponent_1.TouchEventRegister, this.onRemovedTouchEventRegister);
+    };
+    NoRenderSystem.prototype.update = function () {
+        // throw new Error('Method not implemented.');
+    };
+    return NoRenderSystem;
+}());
+exports.NoRenderSystem = NoRenderSystem;

package/dist/gworld/systems/RenderSystem.d.ts

@@ -0,0 +1,22 @@
+import { EntityManager, EventManager, System } from 'entityx-ts';
+export declare enum SpriteTypes {
+    SIMPLE = 0,
+    SLICED = 1,
+    TILED = 2,
+    FILLED = 3,
+    MESH = 4,
+    ANIMATION = 5
+}
+export declare class RenderSystem implements System {
+    configure(event_manager: EventManager): void;
+    private onAddNodeRender;
+    private onAddSpriteRender;
+    private onAddMaskRender;
+    private onAddSpineSkeleton;
+    private onAddGraphicsRender;
+    private onAddParticleComp;
+    private onAddTiledMap;
+    private onRemovedNodeComp;
+    update(entities: EntityManager, events: EventManager, dt: number): void;
+}
+//# sourceMappingURL=RenderSystem.d.ts.map

package/dist/gworld/systems/RenderSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderSystem.d.ts","sourceRoot":"","sources":["../../../src/gworld/systems/RenderSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAoC,MAAM,EAAE,MAAM,YAAY,CAAA;AAMlG,oBAAY,WAAW;IACrB,MAAM,IAAA;IACN,MAAM,IAAA;IACN,KAAK,IAAA;IACL,MAAM,IAAA;IACN,IAAI,IAAA;IACJ,SAAS,IAAA;CACV;AAED,qBAAa,YAAa,YAAW,MAAM;IACzC,SAAS,CAAC,aAAa,EAAE,YAAY;IAWrC,OAAO,CAAC,eAAe,CAKtB;IAED,OAAO,CAAC,iBAAiB,CAOxB;IAED,OAAO,CAAC,eAAe,CAKtB;IACD,OAAO,CAAC,kBAAkB,CAazB;IAED,OAAO,CAAC,mBAAmB,CAQ1B;IAED,OAAO,CAAC,iBAAiB,CAKxB;IAED,OAAO,CAAC,aAAa,CAKpB;IAED,OAAO,CAAC,iBAAiB,CAKxB;IAED,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM;CAGjE"}

package/dist/gworld/systems/RenderSystem.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderSystem = exports.SpriteTypes = void 0;
+var entityx_ts_1 = require("entityx-ts");
+var CCSkeletonAnimation_1 = require("../../spine/CCSkeletonAnimation");
+var NodeComp_1 = require("../components/NodeComp");
+var RenderComponent_1 = require("../components/RenderComponent");
+var SpriteTypes;
+(function (SpriteTypes) {
+    SpriteTypes[SpriteTypes["SIMPLE"] = 0] = "SIMPLE";
+    SpriteTypes[SpriteTypes["SLICED"] = 1] = "SLICED";
+    SpriteTypes[SpriteTypes["TILED"] = 2] = "TILED";
+    SpriteTypes[SpriteTypes["FILLED"] = 3] = "FILLED";
+    SpriteTypes[SpriteTypes["MESH"] = 4] = "MESH";
+    SpriteTypes[SpriteTypes["ANIMATION"] = 5] = "ANIMATION";
+})(SpriteTypes || (exports.SpriteTypes = SpriteTypes = {}));
+var RenderSystem = /** @class */ (function () {
+    function RenderSystem() {
+        this.onAddNodeRender = function (_a) {
+            var entity = _a.entity;
+            var nodeRenderComp = entity.getComponent(RenderComponent_1.NodeRender);
+            var node = new cc.Node();
+            var ett = entity;
+            nodeRenderComp.node = ett.assign(new NodeComp_1.NodeComp(node, ett));
+        };
+        this.onAddSpriteRender = function (_a) {
+            var entity = _a.entity, spriteComp = _a.component;
+            var spriteFrame = spriteComp.props.spriteFrame;
+            var frame = cc.spriteFrameCache.getSpriteFrame(spriteFrame);
+            // console.log('frame', spriteFrame, frame)
+            var node = new cc.Sprite(frame);
+            var ett = entity;
+            spriteComp.node = ett.assign(new NodeComp_1.NodeComp(node, ett));
+        };
+        this.onAddMaskRender = function (_a) {
+            var entity = _a.entity, maskComp = _a.component;
+            var inverted = maskComp.props.inverted;
+            var node = new cc.ClippingNode();
+            node.setInverted(inverted);
+            maskComp.node = entity.assign(new NodeComp_1.NodeComp(node, entity));
+        };
+        this.onAddSpineSkeleton = function (_a) {
+            var entity = _a.entity;
+            var spineComp = entity.getComponent(RenderComponent_1.SpineSkeleton);
+            var _b = spineComp.props, data = _b.data, skin = _b.skin, animation = _b.animation, loop = _b.loop, _c = _b.timeScale, timeScale = _c === void 0 ? 1 : _c;
+            var atlas = data.atlas, skeleton = data.skeleton;
+            // cc.log(skel, atlas);
+            var node = CCSkeletonAnimation_1.SkeletonAnimation.createWithJsonFile(skeleton, atlas, timeScale);
+            if (skin) {
+                node.setSkin(skin);
+            }
+            if (animation) {
+                node.setAnimation(0, animation, loop);
+            }
+            spineComp.node = entity.assign(new NodeComp_1.NodeComp(node, entity));
+        };
+        this.onAddGraphicsRender = function (_a) {
+            var entity = _a.entity;
+            var graphicsComp = entity.getComponent(RenderComponent_1.GraphicsRender);
+            var _b = graphicsComp.props, lineWidth = _b.lineWidth, strokeColor = _b.strokeColor, fillColor = _b.fillColor;
+            var node = new cc.DrawNode();
+            node.setColor(strokeColor);
+            node.setDrawColor(fillColor);
+            node.setLineWidth(lineWidth);
+            graphicsComp.node = entity.assign(new NodeComp_1.NodeComp(node, entity));
+        };
+        this.onAddParticleComp = function (_a) {
+            var entity = _a.entity;
+            var particleComp = entity.getComponent(RenderComponent_1.ParticleComp);
+            var plistFile = particleComp.props.plistFile;
+            var node = new cc.ParticleSystem(plistFile);
+            particleComp.node = entity.assign(new NodeComp_1.NodeComp(node, entity));
+        };
+        this.onAddTiledMap = function (_a) {
+            var entity = _a.entity;
+            var tiledMapComp = entity.getComponent(RenderComponent_1.TiledMap);
+            var mapFile = tiledMapComp.props.mapFile;
+            var node = new cc.TMXTiledMap(mapFile);
+            tiledMapComp.node = entity.assign(new NodeComp_1.NodeComp(node, entity));
+        };
+        this.onRemovedNodeComp = function (_a) {
+            var component = _a.component;
+            var node = component;
+            if (node.instance) {
+                node.instance.removeFromParent(true);
+            }
+        };
+    }
+    RenderSystem.prototype.configure = function (event_manager) {
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, RenderComponent_1.NodeRender, this.onAddNodeRender);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, RenderComponent_1.SpriteRender, this.onAddSpriteRender);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, RenderComponent_1.MaskRender, this.onAddMaskRender);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, RenderComponent_1.SpineSkeleton, this.onAddSpineSkeleton);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, RenderComponent_1.GraphicsRender, this.onAddGraphicsRender);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, RenderComponent_1.ParticleComp, this.onAddParticleComp);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentAdded, RenderComponent_1.TiledMap, this.onAddTiledMap);
+        event_manager.subscribe(entityx_ts_1.EventTypes.ComponentRemoved, NodeComp_1.NodeComp, this.onRemovedNodeComp);
+    };
+    RenderSystem.prototype.update = function (entities, events, dt) {
+        // throw new Error('Method not implemented.');
+    };
+    return RenderSystem;
+}());
+exports.RenderSystem = RenderSystem;

package/dist/helper/NodePool.d.ts

@@ -0,0 +1,9 @@
+import { NodeComp } from "../gworld/components/NodeComp";
+export declare class NodePool {
+    items: NodeComp[];
+    put(node: NodeComp): void;
+    get(): NodeComp;
+    size(): number;
+    clear(): void;
+}
+//# sourceMappingURL=NodePool.d.ts.map

package/dist/helper/NodePool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodePool.d.ts","sourceRoot":"","sources":["../../src/helper/NodePool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAA;AAExD,qBAAa,QAAQ;IACnB,KAAK,EAAE,QAAQ,EAAE,CAAK;IAEtB,GAAG,CAAC,IAAI,EAAE,QAAQ;IAQlB,GAAG,IAAI,QAAQ;IAMf,IAAI;IAIJ,KAAK;CAIN"}

package/dist/helper/NodePool.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodePool = void 0;
+var NodePool = /** @class */ (function () {
+    function NodePool() {
+        this.items = [];
+    }
+    NodePool.prototype.put = function (node) {
+        if (node) {
+            node.active = false;
+            node.removeFromParent();
+            this.items.push(node);
+        }
+    };
+    NodePool.prototype.get = function () {
+        var node = this.items.pop();
+        node.active = true;
+        return node;
+    };
+    NodePool.prototype.size = function () {
+        return this.items.length;
+    };
+    NodePool.prototype.clear = function () {
+        this.items.forEach(function (node) { return node.destroy(); });
+        this.items.length = 0;
+    };
+    return NodePool;
+}());
+exports.NodePool = NodePool;

package/dist/helper/html-text-parser.d.ts

@@ -0,0 +1,30 @@
+/****************************************************************************
+ Copyright (c) 2013-2016 Chukong Technologies Inc.
+ Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+ https://www.cocos.com/
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated engine source code (the "Software"), a limited,
+ worldwide, royalty-free, non-assignable, revocable and non-exclusive license
+ to use Cocos Creator solely to develop games on your target platforms. You shall
+ not use Cocos Creator software for developing other software or tools that's
+ used for developing games. You are not granted to publish, distribute,
+ sublicense, and/or sell copies of Cocos Creator.
+
+ The software or tools in this License Agreement are licensed, not sold.
+ Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+/**
+ * A utils class for parsing HTML texts. The parsed results will be an object array.
+ */
+export declare const HtmlTextParser: () => void;
+//# sourceMappingURL=html-text-parser.d.ts.map

package/dist/helper/html-text-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-text-parser.d.ts","sourceRoot":"","sources":["../../src/helper/html-text-parser.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;8EAwB8E;AAK9E;;GAEG;AACH,eAAO,MAAM,cAAc,YAS1B,CAAA"}