整理ecs框架

source/src/ECS/Components/Camera.ts

@@ -1,234 +1,236 @@
-class Camera extends Component {
-    private _zoom;
-    private _origin: Vector2 = Vector2.zero;
+module es {
+    export class Camera extends Component {
+        private _zoom;
+        private _origin: Vector2 = Vector2.zero;
 
-    private _minimumZoom = 0.3;
-    private _maximumZoom = 3;
+        private _minimumZoom = 0.3;
+        private _maximumZoom = 3;
 
-    private _position: Vector2 = Vector2.zero;
-    /** 
-     * 如果相机模式为cameraWindow 则会进行缓动移动 
-     * 该值为移动速度 
-     */
-    public followLerp = 0.1;
-    public deadzone: Rectangle = new Rectangle();
-    /** 锁定偏移量 默认中心 */
-    public focusOffset: Vector2 = new Vector2();
-    /** 是否地图锁定 如果锁定则需要设置mapSize属性 */
-    public mapLockEnabled: boolean = false;
-    /** 设置地图大小 默认从0 0左上角开始 只需要输入地图宽高 */
-    public mapSize: Vector2 = new Vector2();
-    /** 跟随的实体 设置后镜头将锁定目标为中心 */
-    public targetEntity: Entity;
-    private _worldSpaceDeadZone: Rectangle = new Rectangle();
-    private _desiredPositionDelta: Vector2 = new Vector2();
-    private _targetCollider: Collider;
-    /** 相机模式 */
-    public cameraStyle: CameraStyle = CameraStyle.lockOn;
+        private _position: Vector2 = Vector2.zero;
+        /**
+         * 如果相机模式为cameraWindow 则会进行缓动移动
+         * 该值为移动速度
+         */
+        public followLerp = 0.1;
+        public deadzone: Rectangle = new Rectangle();
+        /** 锁定偏移量 默认中心 */
+        public focusOffset: Vector2 = new Vector2();
+        /** 是否地图锁定 如果锁定则需要设置mapSize属性 */
+        public mapLockEnabled: boolean = false;
+        /** 设置地图大小 默认从0 0左上角开始 只需要输入地图宽高 */
+        public mapSize: Vector2 = new Vector2();
+        /** 跟随的实体 设置后镜头将锁定目标为中心 */
+        public targetEntity: Entity;
+        private _worldSpaceDeadZone: Rectangle = new Rectangle();
+        private _desiredPositionDelta: Vector2 = new Vector2();
+        private _targetCollider: Collider;
+        /** 相机模式 */
+        public cameraStyle: CameraStyle = CameraStyle.lockOn;
 
-    public get zoom(){
-        if (this._zoom == 0)
-            return 1;
+        public get zoom(){
+            if (this._zoom == 0)
+                return 1;
 
-        if (this._zoom < 1)
-            return MathHelper.map(this._zoom, this._minimumZoom, 1, -1, 0);
+            if (this._zoom < 1)
+                return MathHelper.map(this._zoom, this._minimumZoom, 1, -1, 0);
 
-        return MathHelper.map(this._zoom, 1, this._maximumZoom, 0, 1);
-    }
-
-    public set zoom(value: number){
-        this.setZoom(value);
-    }
-
-    public get minimumZoom(){
-        return this._minimumZoom;
-    }
-
-    public set minimumZoom(value: number){
-        this.setMinimumZoom(value);
-    }
-
-    public get maximumZoom(){
-        return this._maximumZoom;
-    }
-
-    public set maximumZoom(value: number){
-        this.setMaximumZoom(value);
-    }
-
-    public get origin(){
-        return this._origin;
-    }
-
-    public set origin(value: Vector2){
-        if (this._origin != value){
-            this._origin = value;
-        }
-    }
-
-    public get position(){
-        return this._position;
-    }
-
-    public set position(value: Vector2){
-        this._position = value;
-    }
-
-    public get x(){
-        return this._position.x;
-    }
-    public set x(value: number){
-        this._position.x = value;
-    }
-    public get y(){
-        return this._position.y;
-    }
-    public set y(value: number){
-        this._position.y = value;
-    }
-
-    constructor() {
-        super();
-
-        this.width = SceneManager.stage.stageWidth;
-        this.height = SceneManager.stage.stageHeight;
-        this.setZoom(0);
-    }
-
-    public onSceneSizeChanged(newWidth: number, newHeight: number){
-        let oldOrigin = this._origin;
-        this.origin = new Vector2(newWidth / 2, newHeight / 2);
-
-        this.entity.position = Vector2.add(this.entity.position, Vector2.subtract(this._origin, oldOrigin));
-    }
-
-    public setMinimumZoom(minZoom: number): Camera{
-        if (this._zoom < minZoom)
-            this._zoom = this.minimumZoom;
-
-        this._minimumZoom = minZoom;
-        return this;
-    }
-
-    public setMaximumZoom(maxZoom: number): Camera {
-        if (this._zoom > maxZoom)
-            this._zoom = maxZoom;
-
-        this._maximumZoom = maxZoom;
-        return this;
-    }
-
-    public setZoom(zoom: number): Camera{
-        let newZoom = MathHelper.clamp(zoom, -1, 1);
-        if (newZoom == 0){
-            this._zoom = 1;
-        } else if(newZoom < 0){
-            this._zoom = MathHelper.map(newZoom, -1, 0, this._minimumZoom, 1);
-        } else {
-            this._zoom = MathHelper.map(newZoom, 0, 1, 1, this._maximumZoom);
+            return MathHelper.map(this._zoom, 1, this._maximumZoom, 0, 1);
         }
 
-        SceneManager.scene.scaleX = this._zoom;
-        SceneManager.scene.scaleY = this._zoom;
-        return this;
-    }
-
-    public setRotation(rotation: number): Camera {
-        SceneManager.scene.rotation = rotation;
-        return this;
-    }
-
-    public setPosition(position: Vector2){
-        this.entity.position = position;
-
-        return this;
-    }
-
-    public follow(targetEntity: Entity, cameraStyle: CameraStyle = CameraStyle.cameraWindow){
-        this.targetEntity = targetEntity;
-        this.cameraStyle = cameraStyle;
-        let cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-
-        switch (this.cameraStyle){
-            case CameraStyle.cameraWindow:
-                let w = cameraBounds.width / 6;
-                let h = cameraBounds.height / 3;
-                this.deadzone = new Rectangle((cameraBounds.width - w) / 2, (cameraBounds.height - h) / 2, w, h);
-                break;
-            case CameraStyle.lockOn:
-                this.deadzone = new Rectangle(cameraBounds.width / 2, cameraBounds.height / 2, 10, 10);
-                break;
+        public set zoom(value: number){
+            this.setZoom(value);
         }
-    }
 
-    public update(){
-        let cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        let halfScreen = Vector2.multiply(new Vector2(cameraBounds.width, cameraBounds.height), new Vector2(0.5));
-        this._worldSpaceDeadZone.x = this.position.x - halfScreen.x * SceneManager.scene.scaleX  + this.deadzone.x + this.focusOffset.x;
-        this._worldSpaceDeadZone.y = this.position.y - halfScreen.y * SceneManager.scene.scaleY + this.deadzone.y + this.focusOffset.y;
-        this._worldSpaceDeadZone.width = this.deadzone.width;
-        this._worldSpaceDeadZone.height = this.deadzone.height;
+        public get minimumZoom(){
+            return this._minimumZoom;
+        }
 
-        if (this.targetEntity)
-            this.updateFollow();
+        public set minimumZoom(value: number){
+            this.setMinimumZoom(value);
+        }
 
-        this.position = Vector2.lerp(this.position, Vector2.add(this.position, this._desiredPositionDelta), this.followLerp);
-        this.entity.roundPosition();
+        public get maximumZoom(){
+            return this._maximumZoom;
+        }
 
-        if (this.mapLockEnabled){
-            this.position = this.clampToMapSize(this.position);
+        public set maximumZoom(value: number){
+            this.setMaximumZoom(value);
+        }
+
+        public get origin(){
+            return this._origin;
+        }
+
+        public set origin(value: Vector2){
+            if (this._origin != value){
+                this._origin = value;
+            }
+        }
+
+        public get position(){
+            return this._position;
+        }
+
+        public set position(value: Vector2){
+            this._position = value;
+        }
+
+        public get x(){
+            return this._position.x;
+        }
+        public set x(value: number){
+            this._position.x = value;
+        }
+        public get y(){
+            return this._position.y;
+        }
+        public set y(value: number){
+            this._position.y = value;
+        }
+
+        constructor() {
+            super();
+
+            this.width = SceneManager.stage.stageWidth;
+            this.height = SceneManager.stage.stageHeight;
+            this.setZoom(0);
+        }
+
+        public onSceneSizeChanged(newWidth: number, newHeight: number){
+            let oldOrigin = this._origin;
+            this.origin = new Vector2(newWidth / 2, newHeight / 2);
+
+            this.entity.position = Vector2.add(this.entity.position, Vector2.subtract(this._origin, oldOrigin));
+        }
+
+        public setMinimumZoom(minZoom: number): Camera{
+            if (this._zoom < minZoom)
+                this._zoom = this.minimumZoom;
+
+            this._minimumZoom = minZoom;
+            return this;
+        }
+
+        public setMaximumZoom(maxZoom: number): Camera {
+            if (this._zoom > maxZoom)
+                this._zoom = maxZoom;
+
+            this._maximumZoom = maxZoom;
+            return this;
+        }
+
+        public setZoom(zoom: number): Camera{
+            let newZoom = MathHelper.clamp(zoom, -1, 1);
+            if (newZoom == 0){
+                this._zoom = 1;
+            } else if(newZoom < 0){
+                this._zoom = MathHelper.map(newZoom, -1, 0, this._minimumZoom, 1);
+            } else {
+                this._zoom = MathHelper.map(newZoom, 0, 1, 1, this._maximumZoom);
+            }
+
+            SceneManager.scene.scaleX = this._zoom;
+            SceneManager.scene.scaleY = this._zoom;
+            return this;
+        }
+
+        public setRotation(rotation: number): Camera {
+            SceneManager.scene.rotation = rotation;
+            return this;
+        }
+
+        public setPosition(position: Vector2){
+            this.entity.position = position;
+
+            return this;
+        }
+
+        public follow(targetEntity: Entity, cameraStyle: CameraStyle = CameraStyle.cameraWindow){
+            this.targetEntity = targetEntity;
+            this.cameraStyle = cameraStyle;
+            let cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
+
+            switch (this.cameraStyle){
+                case CameraStyle.cameraWindow:
+                    let w = cameraBounds.width / 6;
+                    let h = cameraBounds.height / 3;
+                    this.deadzone = new Rectangle((cameraBounds.width - w) / 2, (cameraBounds.height - h) / 2, w, h);
+                    break;
+                case CameraStyle.lockOn:
+                    this.deadzone = new Rectangle(cameraBounds.width / 2, cameraBounds.height / 2, 10, 10);
+                    break;
+            }
+        }
+
+        public update(){
+            let cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
+            let halfScreen = Vector2.multiply(new Vector2(cameraBounds.width, cameraBounds.height), new Vector2(0.5));
+            this._worldSpaceDeadZone.x = this.position.x - halfScreen.x * SceneManager.scene.scaleX  + this.deadzone.x + this.focusOffset.x;
+            this._worldSpaceDeadZone.y = this.position.y - halfScreen.y * SceneManager.scene.scaleY + this.deadzone.y + this.focusOffset.y;
+            this._worldSpaceDeadZone.width = this.deadzone.width;
+            this._worldSpaceDeadZone.height = this.deadzone.height;
+
+            if (this.targetEntity)
+                this.updateFollow();
+
+            this.position = Vector2.lerp(this.position, Vector2.add(this.position, this._desiredPositionDelta), this.followLerp);
             this.entity.roundPosition();
+
+            if (this.mapLockEnabled){
+                this.position = this.clampToMapSize(this.position);
+                this.entity.roundPosition();
+            }
+        }
+
+        private clampToMapSize(position: Vector2){
+            let cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
+            let halfScreen = Vector2.multiply(new Vector2(cameraBounds.width, cameraBounds.height), new Vector2(0.5));
+            let cameraMax = new Vector2(this.mapSize.x - halfScreen.x, this.mapSize.y - halfScreen.y);
+
+            return Vector2.clamp(position, halfScreen, cameraMax);
+        }
+
+        private updateFollow(){
+            this._desiredPositionDelta.x = this._desiredPositionDelta.y = 0;
+
+            if (this.cameraStyle == CameraStyle.lockOn){
+                let targetX = this.targetEntity.position.x;
+                let targetY = this.targetEntity.position.y;
+
+                if (this._worldSpaceDeadZone.x > targetX)
+                    this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
+                else if(this._worldSpaceDeadZone.x < targetX)
+                    this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
+
+                if (this._worldSpaceDeadZone.y < targetY)
+                    this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
+                else if(this._worldSpaceDeadZone.y > targetY)
+                    this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
+            } else {
+                if (!this._targetCollider){
+                    this._targetCollider = this.targetEntity.getComponent<Collider>(Collider);
+                    if (!this._targetCollider)
+                        return;
+                }
+
+                let targetBounds = this.targetEntity.getComponent<Collider>(Collider).bounds;
+                if (!this._worldSpaceDeadZone.containsRect(targetBounds)){
+                    if (this._worldSpaceDeadZone.left > targetBounds.left)
+                        this._desiredPositionDelta.x = targetBounds.left - this._worldSpaceDeadZone.left;
+                    else if(this._worldSpaceDeadZone.right < targetBounds.right)
+                        this._desiredPositionDelta.x = targetBounds.right - this._worldSpaceDeadZone.right;
+
+                    if (this._worldSpaceDeadZone.bottom < targetBounds.bottom)
+                        this._desiredPositionDelta.y = targetBounds.bottom - this._worldSpaceDeadZone.bottom;
+                    else if(this._worldSpaceDeadZone.top > targetBounds.top)
+                        this._desiredPositionDelta.y = targetBounds.top - this._worldSpaceDeadZone.top;
+                }
+            }
         }
     }
 
-    private clampToMapSize(position: Vector2){
-        let cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        let halfScreen = Vector2.multiply(new Vector2(cameraBounds.width, cameraBounds.height), new Vector2(0.5));
-        let cameraMax = new Vector2(this.mapSize.x - halfScreen.x, this.mapSize.y - halfScreen.y);
-
-        return Vector2.clamp(position, halfScreen, cameraMax);
-    }
-
-    private updateFollow(){
-        this._desiredPositionDelta.x = this._desiredPositionDelta.y = 0;
-
-        if (this.cameraStyle == CameraStyle.lockOn){
-            let targetX = this.targetEntity.position.x;
-            let targetY = this.targetEntity.position.y;
-
-            if (this._worldSpaceDeadZone.x > targetX)
-                this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
-            else if(this._worldSpaceDeadZone.x < targetX)
-                this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
-
-            if (this._worldSpaceDeadZone.y < targetY)
-                this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
-            else if(this._worldSpaceDeadZone.y > targetY)
-                this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
-        } else {
-            if (!this._targetCollider){
-                this._targetCollider = this.targetEntity.getComponent<Collider>(Collider);
-                if (!this._targetCollider)
-                    return;
-            }
-
-            let targetBounds = this.targetEntity.getComponent<Collider>(Collider).bounds;
-            if (!this._worldSpaceDeadZone.containsRect(targetBounds)){
-                if (this._worldSpaceDeadZone.left > targetBounds.left)
-                    this._desiredPositionDelta.x = targetBounds.left - this._worldSpaceDeadZone.left;
-                else if(this._worldSpaceDeadZone.right < targetBounds.right)
-                    this._desiredPositionDelta.x = targetBounds.right - this._worldSpaceDeadZone.right;
-
-                if (this._worldSpaceDeadZone.bottom < targetBounds.bottom)
-                    this._desiredPositionDelta.y = targetBounds.bottom - this._worldSpaceDeadZone.bottom;
-                else if(this._worldSpaceDeadZone.top > targetBounds.top)
-                    this._desiredPositionDelta.y = targetBounds.top - this._worldSpaceDeadZone.top;
-            }
-        }
+    export enum CameraStyle {
+        lockOn,
+        cameraWindow,
     }
 }
-
-enum CameraStyle {
-    lockOn,
-    cameraWindow,
-}

source/src/ECS/Components/Physics/Colliders/Collider.ts

@@ -1,6 +1,14 @@
 abstract class Collider extends Component {
     /** 对撞机的基本形状 */
     public shape: Shape;
+    protected _localOffset: Vector2 = Vector2.zero;
+    public get localOffset(){
+        return this._localOffset;
+    }
+    public set localOffset(){
+
+    }
+    public _localOffsetLength: number;
     /** 在处理冲突时，physicsLayer可以用作过滤器。Flags类有帮助位掩码的方法。 */
     public physicsLayer = 1 << 0;
     /** 如果这个碰撞器是一个触发器，它将不会引起碰撞，但它仍然会触发事件 */
@@ -15,38 +23,32 @@ abstract class Collider extends Component {
     /** 默认为所有层。 */
     public collidesWithLayers = Physics.allLayers;
 
-    public _localOffsetLength: number;
     /** 标记来跟踪我们的实体是否被添加到场景中 */
     protected _isParentEntityAddedToScene;
     protected _colliderRequiresAutoSizing;
-    protected _localOffset: Vector2 = new Vector2(0, 0);
     /** 标记来记录我们是否注册了物理系统 */
     protected _isColliderRegistered;
 
     public get bounds(): Rectangle {
         let shapeBounds = this.shape.bounds;
-        let colliderBuonds = new Rectangle(this.x + this.localOffset.x, this.y + this.localOffset.y, shapeBounds.width, shapeBounds.height);
+        let colliderBuonds = new Rectangle(this.entity.x, this.entity.y, shapeBounds.width, shapeBounds.height);
         return colliderBuonds;
     }
 
-    public get localOffset() {
-        return this._localOffset;
-    }
-
     /**
-     * 将localOffset添加到实体。获取碰撞器的最终位置。这允许您向一个实体添加多个碰撞器并分别定位它们。
+     * 将localOffset添加到实体。获取碰撞器的最终位置。
+     * 这允许您向一个实体添加多个碰撞器并分别定位它们。
+     * @param offset 
      */
-    public set localOffset(value: Vector2) {
-        this.setLocalOffset(value);
-    }
-
-    public setLocalOffset(offset: Vector2) {
-        if (this._localOffset != offset) {
+    public setLocalOffset(offset: Vector2): Collider{
+        if (this._localOffset != offset){
             this.unregisterColliderWithPhysicsSystem();
             this._localOffset = offset;
             this._localOffsetLength = this._localOffset.length();
             this.registerColliderWithPhysicsSystem();
         }
+
+        return this;
     }
 
     /**
@@ -85,15 +87,15 @@ abstract class Collider extends Component {
      */
     public collidesWith(collider: Collider, motion: Vector2) {
         // 改变形状的位置，使它在移动后的位置，这样我们可以检查重叠
-        let oldPosition = this.shape.position;
-        this.shape.position = Vector2.add(this.shape.position, motion);
+        let oldPosition = this.entity.position;
+        this.entity.position = Vector2.add(this.entity.position, motion);
 
         let result = this.shape.collidesWithShape(collider.shape);
         if (result)
             result.collider = collider;
 
         // 将图形位置返回到检查前的位置
-        this.shape.position = oldPosition;
+        this.entity.position = oldPosition;
 
         return result;
     }
@@ -111,19 +113,17 @@ abstract class Collider extends Component {
                 // 这里我们需要大小*反尺度，因为当我们自动调整碰撞器的大小时，它需要没有缩放的渲染
                 let width = bounds.width / this.entity.scale.x;
                 let height = bounds.height / this.entity.scale.y;
-
                 // 圆碰撞器需要特别注意原点
                 if (this instanceof CircleCollider){
                     let circleCollider = this as CircleCollider;
                     circleCollider.radius = Math.max(width, height) * 0.5;
-
-                    this.localOffset = bounds.location;
                 } else {
                     this.width = width;
                     this.height = height;
-
-                    this.localOffset = bounds.location;
                 }
+                
+                // 获取渲染的中心，将其转移到本地坐标，并使用它作为碰撞器的localOffset
+                this.localOffset = Vector2.subtract(bounds.center, this.entity.position);
             } else {
                 console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.");
             }
@@ -154,8 +154,8 @@ abstract class Collider extends Component {
     public update(){
         let renderable = this.entity.getComponent<RenderableComponent>(RenderableComponent);
         if (renderable){
-            this.$setX(renderable.x + this.localOffset.x);
-            this.$setY(renderable.y + this.localOffset.y);
+            this.$setX(renderable.x);
+            this.$setY(renderable.y);
         }
     }
 }

source/src/ECS/Components/Physics/Colliders/PolygonCollider.ts

@@ -16,8 +16,6 @@ class PolygonCollider extends Collider {
         if (isPolygonClosed)
             points.splice(points.length - 1, 1);
 
-        let center = Polygon.findPolygonCenter(points);
-        this.setLocalOffset(center);
         Polygon.recenterPolygonVerts(points);
         this.shape = new Polygon(points);
     }

source/src/ECS/Components/SpriteRenderer.ts

@@ -1,17 +1,17 @@
-class SpriteRenderer extends RenderableComponent{
+class SpriteRenderer extends RenderableComponent {
     private _sprite: Sprite;
     protected bitmap: egret.Bitmap;
 
     /** 应该由这个精灵显示的精灵 */
-    public get sprite(): Sprite{
+    public get sprite(): Sprite {
         return this._sprite;
     }
     /** 应该由这个精灵显示的精灵 */
-    public set sprite(value: Sprite){
+    public set sprite(value: Sprite) {
         this.setSprite(value);
     }
 
-    public setSprite(sprite: Sprite): SpriteRenderer{
+    public setSprite(sprite: Sprite): SpriteRenderer {
         this.removeChildren();
         this._sprite = sprite;
         if (this._sprite) {
@@ -24,7 +24,7 @@ class SpriteRenderer extends RenderableComponent{
         return this;
     }
 
-    public setColor(color: number): SpriteRenderer{
+    public setColor(color: number): SpriteRenderer {
         let colorMatrix = [
             1, 0, 0, 0, 0,
             0, 1, 0, 0, 0,
@@ -40,23 +40,27 @@ class SpriteRenderer extends RenderableComponent{
         return this;
     }
 
-    public isVisibleFromCamera(camera: Camera): boolean{
+    public isVisibleFromCamera(camera: Camera): boolean {
         this.isVisible = new Rectangle(0, 0, this.stage.stageWidth, this.stage.stageHeight).intersects(this.bounds);
         this.visible = this.isVisible;
         return this.isVisible;
     }
 
     /** 渲染处理 在每个模块中处理各自的渲染逻辑 */
-    public render(camera: Camera){
-        this.x = -camera.position.x + camera.origin.x;
-        this.y = -camera.position.y + camera.origin.y;
+    public render(camera: Camera) {
+        if (this.x != -camera.position.x + camera.origin.x ||
+            this.y != -camera.position.y + camera.origin.y) {
+            this.x = -camera.position.x + camera.origin.x;
+            this.y = -camera.position.y + camera.origin.y;
+            this.entity.onEntityTransformChanged(TransformComponent.position);
+        }
     }
 
-    public onRemovedFromEntity(){
+    public onRemovedFromEntity() {
         if (this.parent)
             this.parent.removeChild(this);
     }
 
-    public reset(){
+    public reset() {
     }
 }