新增DelayedIteratingSystem/IntervalSystem/IntervalIteratingSystem

source/src/ECS/Components/ComponentPool.ts

@@ -1,24 +0,0 @@
-module es {
-    export class ComponentPool<T extends PooledComponent> {
-        private _cache: T[];
-        private _type: any;
-
-        constructor(typeClass: any) {
-            this._type = typeClass;
-            this._cache = [];
-        }
-
-        public obtain(): T {
-            try {
-                return this._cache.length > 0 ? this._cache.shift() : new this._type();
-            } catch (err) {
-                throw new Error(this._type + err);
-            }
-        }
-
-        public free(component: T) {
-            component.reset();
-            this._cache.push(component);
-        }
-    }
-}

source/src/ECS/Components/PooledComponent.ts

@@ -1,6 +0,0 @@
-module es {
-    /** 回收实例的组件类型。 */
-    export abstract class PooledComponent extends Component {
-        public abstract reset();
-    }
-}

source/src/ECS/Entity.ts

@@ -380,6 +380,16 @@ module es {
             this.components.update();
         }
 
+        /**
+         * 创建组件的新实例。返回实例组件
+         * @param componentType 
+         */
+        public createComponent<T extends Component>(componentType: new () => T): T {
+            let component = new componentType();
+            this.addComponent(component);
+            return component;
+        }
+
         /**
          * 将组件添加到组件列表中。返回组件。
          * @param component

source/src/ECS/Systems/DelayedIteratingSystem.ts

@@ -0,0 +1,131 @@
+///<reference path="./EntitySystem.ts"/>
+module es {
+    /**
+     * 追踪每个实体的冷却时间，当实体的计时器耗尽时进行处理
+     * 
+     * 一个示例系统将是ExpirationSystem，该系统将在特定生存期后删除实体。 
+     * 你不必运行会为每个实体递减timeLeft值的系统
+     * 而只需使用此系统在寿命最短的实体时在将来执行
+     * 然后重置系统在未来的某一个最短命实体的时间运行
+     * 
+     * 另一个例子是一个动画系统
+     * 你知道什么时候你必须对某个实体进行动画制作，比如300毫秒内。
+     * 所以你可以设置系统以300毫秒为单位运行来执行动画
+     * 
+     * 这将在某些情况下节省CPU周期
+     */
+    export abstract class DelayedIteratingSystem extends EntitySystem {
+        /**
+         * 一个实体应被处理的时间
+         */
+        private delay: number = 0;
+        /**
+         * 如果系统正在运行，并倒计时延迟
+         */
+        private running: boolean = false;
+        /**
+         * 倒计时
+         */
+        private acc: number = 0;
+
+        constructor(matcher: Matcher) {
+            super(matcher);
+        }
+
+        protected process(entities: Entity[]) {
+            let processed = entities.length;
+            if (processed == 0) {
+                this.stop();
+                return;
+            }
+
+            this.delay = Number.MAX_VALUE;
+            for (let i = 0; processed > i; i++) {
+                let e = entities[i];
+                this.processDelta(e, this.acc);
+                let remaining = this.getRemainingDelay(e);
+                if (remaining <= 0) {
+                    this.processExpired(e);
+                } else {
+                    this.offerDelay(remaining);
+                }
+            }
+
+            this.acc = 0;
+        }
+
+        protected checkProcessing() {
+            if (this.running) {
+                this.acc += Time.deltaTime;
+                return this.acc >= this.delay;
+            }
+            return false;
+        }
+
+        /**
+         * 只有当提供的延迟比系统当前计划执行的时间短时，才会重新启动系统。
+         * 如果系统已经停止（不运行），那么提供的延迟将被用来重新启动系统，无论其值如何
+         * 如果系统已经在倒计时，并且提供的延迟大于剩余时间，系统将忽略它。
+         * 如果提供的延迟时间短于剩余时间，系统将重新启动，以提供的延迟时间运行。
+         * @param offeredDelay 
+         */
+        public offerDelay(offeredDelay: number) {
+            if (!this.running) {
+                this.running = true;
+                this.delay = offeredDelay;
+            } else {
+                this.delay = Math.min(this.delay, offeredDelay);
+            }
+        }
+
+        /**
+         * 处理本系统感兴趣的实体
+         * 从实体定义的延迟中抽象出accumulativeDelta
+         * @param entity 
+         * @param accumulatedDelta 本系统最后一次执行后的delta时间
+         */
+        protected abstract processDelta(entity: Entity, accumulatedDelta: number);
+
+        protected abstract processExpired(entity: Entity);
+
+        /**
+         * 返回该实体处理前的延迟时间
+         * @param entity 
+         */
+        protected abstract getRemainingDelay(entity: Entity): number;
+
+        /**
+         * 获取系统被命令处理实体后的初始延迟
+         */
+        public getInitialTimeDelay() {
+            return this.delay;
+        }
+
+        /**
+         * 获取系统计划运行前的时间
+         * 如果系统没有运行，则返回零
+         */
+        public getRemainingTimeUntilProcessing(): number {
+            if (this.running) {
+                return this.delay - this.acc;
+            }
+
+            return 0;
+        }
+
+        /**
+         * 检查系统是否正在倒计时处理
+         */
+        public isRunning(): boolean {
+            return this.running;
+        }
+
+        /**
+         * 停止系统运行，中止当前倒计时
+         */
+        public stop() {
+            this.running = false;
+            this.acc = 0;
+        }
+    }
+}

source/src/ECS/Systems/EntitySystem.ts

@@ -11,6 +11,9 @@ module es {
 
         private _scene: Scene;
 
+        /**
+         * 这个系统所属的场景
+         */
         public get scene() {
             return this._scene;
         }
@@ -45,42 +48,53 @@ module es {
             this.onAdded(entity);
         }
 
-        public onAdded(entity: Entity) {
-        }
+        public onAdded(entity: Entity) { }
 
         public remove(entity: Entity) {
             new linq.List(this._entities).remove(entity);
             this.onRemoved(entity);
         }
 
-        public onRemoved(entity: Entity) {
-
-        }
+        public onRemoved(entity: Entity) { }
 
         public update() {
-            this.begin();
-            this.process(this._entities);
+            if (this.checkProcessing()) {
+                this.begin();
+                this.process(this._entities);
+            }
         }
 
         public lateUpdate() {
-            this.lateProcess(this._entities);
-            this.end();
+            if (this.checkProcessing()) {
+                this.lateProcess(this._entities);
+                this.end();
+            }
         }
 
-        protected begin() {
+        /**
+         * 在系统处理开始前调用
+         * 在下一个系统开始处理或新的处理回合开始之前（以先到者为准），使用此方法创建的任何实体都不会激活
+         */
+        protected begin() { }
 
-        }
+        protected process(entities: Entity[]) { }
 
-        protected process(entities: Entity[]) {
+        protected lateProcess(entities: Entity[]) { }
 
-        }
-
-        protected lateProcess(entities: Entity[]) {
-
-        }
-
-        protected end() {
+        /**
+         * 系统处理完毕后调用
+         */
+        protected end() { }
 
+        /**
+         * 系统是否需要处理
+         * 
+         * 在启用系统时有用，但仅偶尔需要处理
+         * 这只影响处理，不影响事件或订阅列表
+         * @returns 如果系统应该处理，则为true，如果不处理则为false。
+         */
+        protected checkProcessing() {
+            return true;
         }
     }
 }

source/src/ECS/Systems/IntervalIteratingSystem.ts

@@ -0,0 +1,25 @@
+///<reference path="./IntervalSystem.ts"/>
+module es {
+    /**
+     * 每x个ticks处理一个实体的子集
+     * 
+     * 典型的用法是每隔一定的时间间隔重新生成弹药或生命值
+     * 而无需在每个游戏循环中都进行
+     * 而是每100毫秒一次或每秒
+     */
+    export abstract class IntervalIteratingSystem extends IntervalSystem {
+        constructor(matcher: Matcher, interval: number) {
+            super(matcher, interval);
+        }
+
+        /**
+         * 处理本系统感兴趣的实体
+         * @param entity
+         */
+        public abstract processEntity(entity: Entity);
+
+        protected process(entities: Entity[]) {
+            entities.forEach(entity => this.processEntity(entity));
+        }
+    }
+}

source/src/ECS/Systems/IntervalSystem.ts

@@ -0,0 +1,40 @@
+module es {
+    /**
+     * 实体系统以一定的时间间隔进行处理
+     */
+    export abstract class IntervalSystem extends EntitySystem {
+        /**
+         * 累积增量以跟踪间隔 
+         */
+        protected acc: number = 0;
+        /**
+         * 更新之间需要等待多长时间
+         */
+        private readonly interval: number = 0;
+        private intervalDelta: number = 0;
+
+        constructor(matcher: Matcher, interval: number) {
+            super(matcher);
+            this.interval = interval;
+        }
+
+        protected checkProcessing() {
+            this.acc += Time.deltaTime;
+            if (this.acc >= this.interval) {
+                this.acc -= this.interval;
+                this.intervalDelta = (this.acc - this.intervalDelta);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         * 获取本系统上次处理后的实际delta值
+         */
+        protected getIntervalDelta() {
+            return this.interval + this.intervalDelta;
+        }
+    }
+}