新增box复合体 修复vector2运算问题

source/src/Debug/DebugDefaults.ts

@@ -0,0 +1,4 @@
+class DebugDefaults {
+    public static verletParticle = 0xDC345E;
+    public static verletConstraintEdge = 0x433E36;
+}

source/src/ECS/Components/RenderableComponent.ts

@@ -8,11 +8,11 @@ abstract class RenderableComponent extends Component {
     private _localOffset: Vector2;
 
     public get width(){
-        return this.bounds.width;
+        return this.getWidth();
     }
 
     public get height(){
-        return this.bounds.height;
+        return this.getHeight();
     }
 
     public get isVisible(){
@@ -29,8 +29,20 @@ abstract class RenderableComponent extends Component {
     }
 
     public get bounds(): Rectangle{
+        return this.getBounds();
+    }
+
+    protected getWidth(){
+        return this.bounds.width;
+    }
+
+    protected getHeight(){
+        return this.bounds.height;
+    }
+
+    protected getBounds(){
         if (this._areBoundsDirty){
-            this._bounds.calculateBounds(this.entity.transform.position, this._localOffset, Vector2.Zero,
+            this._bounds.calculateBounds(this.entity.transform.position, this._localOffset, new Vector2(0, 0),
                 this.entity.transform.scale, this.entity.transform.rotation, this.width, this.height);
             this._areBoundsDirty = false;
         }

source/src/ECS/Transform.ts

@@ -49,7 +49,7 @@ class Transform {
 
     constructor(entity: Entity){
         this.entity = entity;
-        this._scale = this._localScale = Vector2.One;
+        this._scale = this._localScale = new Vector2(0, 0);
         this._children = [];
     }
 

source/src/ECS/Utils/ComponentList.ts

@@ -122,6 +122,11 @@ class ComponentList {
 
     public update(){
         this.updateLists();
+        for (let i = 0; i < this._components.length; i ++){
+            let component = this._components[i];
+            if (component.enabled && (component.updateInterval == 1 || Time.frameCount % component.updateInterval == 0))
+                component.update();
+        }
     }
 
     public onEntityTransformChanged(comp){

source/src/ECS/Utils/Time.ts

@@ -1,7 +1,8 @@
 class Time {
     public static unscaledDeltaTime;
-    public static deltaTime: number;
+    public static deltaTime: number = 0;
     public static timeScale = 1;
+    public static frameCount = 0;;
     
     private static _lastTime = 0;
 
@@ -9,6 +10,7 @@ class Time {
         let dt = (currentTime - this._lastTime) / 1000;
         this.deltaTime = dt * this.timeScale;
         this.unscaledDeltaTime = dt;
+        this.frameCount ++;
 
         this._lastTime = currentTime;
     }

source/src/Math/Vector2.ts

@@ -3,17 +3,6 @@ class Vector2 {
     public x: number = 0;
     public y: number = 0;
 
-    private static readonly zeroVector = new Vector2(0, 0);
-    private static readonly unitVector = new Vector2(1, 1);
-
-    public static get One(){
-        return this.unitVector;
-    }
-
-    public static get Zero(){
-        return this.zeroVector;
-    }
-
     /**
      * 从两个值构造一个带有X和Y的二维向量。
      * @param x 二维空间中的x坐标
@@ -25,26 +14,30 @@ class Vector2 {
     }
 
     public static add(value1: Vector2, value2: Vector2){
-        value1.x += value2.x;
-        value1.y += value2.y;
-        return value1;
+        let result: Vector2 = new Vector2(0, 0);
+        result.x = value1.x + value2.x;
+        result.y = value1.y + value2.y;
+        return result;
     }
 
     public static divide(value1: Vector2, value2: Vector2){
-        value1.x /= value2.x;
-        value1.y /= value2.y;
+        let result: Vector2 = new Vector2(0, 0);
+        result.x = value1.x / value2.x;
+        result.y = value1.y / value2.y;
         return value1;
     }
 
     public static multiply(value1: Vector2, value2: Vector2){
-        value1.x *= value2.x;
-        value1.y *= value2.y;
-        return value1;
+        let result: Vector2 = new Vector2(0, 0);
+        result.x = value1.x * value2.x;
+        result.y = value1.y * value2.y;
+        return result;
     }
 
     public static subtract(value1: Vector2, value2: Vector2){
-        value1.x -= value2.x;
-        value1.y -= value2.y;
+        let result: Vector2 = new Vector2(0, 0);
+        result.x = value1.x - value2.x;
+        result.y = value1.y - value2.y;
         return value1;
     }
 
@@ -55,6 +48,10 @@ class Vector2 {
         this.y *= val;
     }
 
+    public length(){
+        return Math.sqrt((this.x * this.x) + (this.y * this.y));
+    }
+
     /**
      * 返回两个向量的点积
      * @param value1 
@@ -77,4 +74,9 @@ class Vector2 {
     public static transform(position: Vector2, matrix: Matrix2D){
         return new Vector2((position.x * matrix.m11) + (position.y * matrix.m21), (position.x * matrix.m12) + (position.y * matrix.m22));
     }
+
+    public static distance(value1: Vector2, value2: Vector2){
+        let v1 = value1.x - value2.x, v2 = value1.y - value2.y;
+        return Math.sqrt((v1 * v1) + (v2 * v2));
+    }
 }

source/src/Physics/Collision.ts

@@ -33,7 +33,7 @@ class Collisions {
     }
 
     public static lineToLineIntersection(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): Vector2 {
-        let intersection = Vector2.Zero;
+        let intersection = new Vector2(0, 0);
 
         let b = Vector2.subtract(a2, a1);
         let d = Vector2.subtract(b2, b1);

source/src/Physics/Physics.ts

@@ -0,0 +1,7 @@
+class Physics {
+    private static _spatialHash: SpatialHash;
+
+    public static overlapCircleAll(center: Vector2, randius: number, results: any[], layerMask = -1){
+        return this._spatialHash.overlapCircle(center, randius, results, layerMask);
+    }
+}

source/src/Physics/Verlet/Composites/Box.ts

@@ -0,0 +1,19 @@
+///<reference path="./Composite.ts"/>
+class Box extends Composite{
+    constructor(center: Vector2, width: number, height: number, borderStiffness = 0.2, diagonalStiffness = 0.5){
+        super();
+
+        let tl = this.addParticle(new Particle(Vector2.add(center, new Vector2(-width / 2, -height / 2))));
+        let tr = this.addParticle(new Particle(Vector2.add(center, new Vector2(width / 2, -height / 2))));
+        let br = this.addParticle(new Particle(Vector2.add(center, new Vector2(width / 2, height / 2))));
+        let bl = this.addParticle(new Particle(Vector2.add(center, new Vector2(-width / 2, height / 2))));
+
+        this.addConstraint(new DistanceConstraint(tl, tr, borderStiffness));
+        this.addConstraint(new DistanceConstraint(tr, br, borderStiffness));
+        this.addConstraint(new DistanceConstraint(br, bl, borderStiffness));
+        this.addConstraint(new DistanceConstraint(bl, tl, borderStiffness));
+
+        this.addConstraint(new DistanceConstraint(tl, br, diagonalStiffness)).setCollidesWithColliders(false);
+        this.addConstraint(new DistanceConstraint(bl, tr, diagonalStiffness)).setCollidesWithColliders(false);
+    }
+}

source/src/Physics/Verlet/Composites/Composite.ts

@@ -0,0 +1,67 @@
+class Composite {
+    private _constraints: Constraint[] = [];
+
+    public friction = new Vector2(0.98, 1);
+    public drawParticles: boolean = true;
+    public drawConstraints: boolean = true;
+    public particles: Particle[] = [];
+    /**
+     * 处理解决所有约束条件
+     */
+    public solveConstraints(){
+        for (let i = this._constraints.length - 1; i >= 0; i --){
+            this._constraints[i].solve();
+        }
+    }
+
+    public addParticle(particle: Particle){
+        this.particles.push(particle);
+        return particle;
+    }
+
+    public addConstraint<T extends Constraint>(constraint: T): T{
+        this._constraints.push(constraint);
+        constraint.composite = this;
+        return constraint;
+    }
+
+    public removeConstraint(constraint: Constraint){
+        this._constraints.remove(constraint);
+    }
+
+    public updateParticles(deltaTimeSquared: number, gravity: Vector2){
+        for (let j = 0; j < this.particles.length; j ++){
+            let p = this.particles[j];
+            if (p.isPinned){
+                p.position = p.pinnedPosition;
+                continue;
+            }
+
+            p.applyForce(Vector2.multiply(new Vector2(p.mass, p.mass), gravity));
+
+            let vel = Vector2.multiply(Vector2.subtract(p.position, p.lastPosition), this.friction);
+            let nextPos = Vector2.add(Vector2.add(p.position, vel), Vector2.multiply(p.acceleration, new Vector2(0.5 * deltaTimeSquared, 0.5 * deltaTimeSquared)));
+
+            p.lastPosition = p.position;
+            p.position = nextPos;
+            p.acceleration.x = p.acceleration.y = 0;
+        }
+    }
+
+    public debugRender(graphics: egret.Graphics){
+        if (this.drawConstraints){
+            for (let i = 0; i < this._constraints.length; i ++){
+                this._constraints[i].debugRender(graphics);
+            }
+        }
+
+        if (this.drawParticles){
+            for (let i = 0; i < this.particles.length; i ++){
+                let size = this.particles[i].radius ? this.particles[i].radius : 4;
+                graphics.lineStyle(4, DebugDefaults.verletParticle);
+                graphics.drawRect(this.particles[i].position.x, this.particles[i].position.y, size, size);
+                graphics.endFill();
+            }
+        }
+    }
+}

source/src/Physics/Verlet/Constraint/Constraint.ts

@@ -0,0 +1,8 @@
+abstract class Constraint {
+    public composite: Composite;
+    public collidesWithColliders = true;
+
+    public abstract solve();
+
+    public debugRender(graphics: egret.Graphics) {}
+}

source/src/Physics/Verlet/Constraint/DistanceConstraint.ts

@@ -0,0 +1,54 @@
+class DistanceConstraint extends Constraint {
+    public stiffness: number = 0;
+    public restingDistance: number = 0;
+    public tearSensitivity = Number.POSITIVE_INFINITY;
+
+    private _particleOne: Particle;
+    private _particleTwo: Particle;
+
+    constructor(first: Particle, second: Particle, stiffness: number, distance = -1){
+        super();
+
+        this._particleOne = first;
+        this._particleTwo = second;
+        this.stiffness = stiffness;
+
+        if (distance > -1){
+            this.restingDistance = distance;
+        }else{
+            this.restingDistance = Vector2.distance(first.position, second.position);
+        }
+    }
+
+    public setCollidesWithColliders(collidesWithColliders: boolean){
+        this.collidesWithColliders = collidesWithColliders;
+        return this;
+    }
+
+    public solve() {
+        let diff = Vector2.subtract(this._particleOne.position, this._particleTwo.position);
+        let d = diff.length();
+
+        let difference = (this.restingDistance - d) / d;
+
+        if (d / this.restingDistance > this.tearSensitivity){
+            this.composite.removeConstraint(this);
+            return;
+        }
+
+        let im1 = 1 / this._particleOne.mass;
+        let im2 = 1 / this._particleTwo.mass;
+        let scalarP1 = (im1 / (im1 + im2)) * this.stiffness;
+        let scalarP2 = this.stiffness - scalarP1;
+
+        this._particleOne.position = Vector2.add(this._particleOne.position, Vector2.multiply(diff, new Vector2(scalarP1 * difference, scalarP1 * difference)));
+        this._particleTwo.position = Vector2.subtract(this._particleTwo.position, Vector2.multiply(diff, new Vector2(scalarP2 * difference, scalarP2 * difference)))
+    }
+
+    public debugRender(graphics: egret.Graphics){
+        graphics.lineStyle(1, DebugDefaults.verletConstraintEdge);
+        graphics.lineTo(this._particleOne.position.x, this._particleOne.position.y);
+        graphics.lineTo(this._particleTwo.position.x, this._particleTwo.position.y);
+        graphics.endFill();
+    }
+}

source/src/Physics/Verlet/Particle.ts

@@ -1,17 +1,19 @@
-class Particle {
-    public position: Vector2;
-    public lastPosition: Vector2;
-    public isPinned: boolean;
-    public pinnedPosition;
-    public acceleration: Vector2;
-    public mass: number = 1;
-
-    constructor(position: Vector2){
-        this.position = position;
-        this.lastPosition = position;
-    }
-
-    public applyForce(force: Vector2){
-        this.acceleration = Vector2.add(this.acceleration, new Vector2(force.x / this.mass, force.y / this.mass));
-    }
+class Particle {
+    public position: Vector2 = new Vector2(0, 0);
+    public lastPosition: Vector2 = new Vector2(0, 0);
+    public isPinned: boolean;
+    public pinnedPosition;
+    public acceleration: Vector2 = new Vector2(0, 0);
+    public mass: number = 1;
+    public radius: number = 0;
+    public collidesWithColliders = true;
+
+    constructor(position: Vector2){
+        this.position = position;
+        this.lastPosition = position;
+    }
+
+    public applyForce(force: Vector2){
+        this.acceleration = Vector2.add(this.acceleration, new Vector2(force.x / this.mass, force.y / this.mass));
+    }
 }

source/src/Physics/Verlet/SpatialHash.ts

@@ -0,0 +1,7 @@
+class SpatialHash {
+    public overlapCircle(circleCenter: Vector2, radius: number, results: any[], layerMask){
+        let resultCounter = 0;
+
+        return resultCounter;
+    }
+}

source/src/Physics/Verlet/VerletWorld.ts

@@ -0,0 +1,113 @@
+/**
+ * 基于verlet 物理引擎进行改造的物理引擎 ts重写
+ * https://github.com/subprotocol/verlet-js
+ */
+class VerletWorld {
+    public gravity: Vector2 = new Vector2(0, 980);
+    public maximumStepIterations = 5;
+    public constraintIterations = 3;
+    public simulationBounds: Rectangle;
+
+    private _leftOverTime: number = 0;
+    private _iterationSteps: number = 0;
+    private _fixedDeltaTime = 1 / 60;
+    private _composites: Composite[] = [];
+    private _fixedDeltaTimeSq: number;
+
+    private static _colliders = new Array(4);
+
+    constructor(simulationBounds?: Rectangle){
+        this.simulationBounds = simulationBounds;
+        this._fixedDeltaTimeSq = Math.pow(this._fixedDeltaTime, 2);
+    }
+
+    public update(){
+        this.updateTiming();
+
+        for (let iteration = 1; iteration <= this._iterationSteps; iteration ++){
+            for (let i = this._composites.length - 1; i >= 0; i --){
+                let composite = this._composites[i];
+
+                for (let s = 0; s < this.constraintIterations; s++){
+                    composite.solveConstraints();
+                }
+
+                composite.updateParticles(this._fixedDeltaTimeSq, this.gravity);
+
+                for (let j = 0; j < composite.particles.length; j ++){
+                    let p = composite.particles[j];
+
+                    if (this.simulationBounds){
+                        this.constrainParticleToBounds(p);
+                    }
+
+                    // if (p.collidesWithColliders)
+                    //     this.handleCollisions(p, -1);
+                }
+            }
+        }
+    }
+
+    private handleCollisions(p: Particle, collidesWithLayers: number){
+        let collidedCount = Physics.overlapCircleAll(p.position, p.radius, VerletWorld._colliders, collidesWithLayers);
+        // handle
+    }
+
+    private constrainParticleToBounds(p: Particle){
+        let tempPos = p.position;
+        let bounds = this.simulationBounds;
+
+        if (p.radius == 0){
+            if (tempPos.y > bounds.height){
+                tempPos.y = bounds.height;
+            } else if(tempPos.y < bounds.y){
+                tempPos.y = bounds.y;
+            }
+
+            if (tempPos.x < bounds.x){
+                tempPos.x = bounds.x;
+            }else if(tempPos.x > bounds.width){
+                tempPos.x = bounds.width;
+            }
+        }else{
+            if (tempPos.y < bounds.y + p.radius){
+                tempPos.y = 2 * (bounds.y + p.radius) - tempPos.y;
+            }
+            if (tempPos.y > bounds.height - p.radius){
+                tempPos.y = 2 * (bounds.height - p.radius) - tempPos.y;
+            }
+            if (tempPos.x > bounds.width - p.radius){
+                tempPos.x = 2 * (bounds.width - p.radius) - tempPos.x;
+            }
+            if (tempPos.x < bounds.x + p.radius)
+                tempPos.x = 2 * (bounds.x + p.radius) - tempPos.x;
+        }
+
+        p.position = tempPos;
+    }
+
+    public debugRender(displayObject: egret.DisplayObject){
+        if (!displayObject)
+            return;
+
+        displayObject.stage.removeChildren();
+        for (let i = 0; i < this._composites.length; i ++){
+            let shape = new egret.Shape();
+            this._composites[i].debugRender(shape.graphics);
+            displayObject.stage.addChild(shape);
+        }
+    }
+
+    public addComposite<T extends Composite>(composite: T): T{
+        this._composites.push(composite);
+        return composite;
+    }
+
+    private updateTiming(){
+        this._leftOverTime += Time.deltaTime;
+        this._iterationSteps = Math.trunc(this._leftOverTime / this._fixedDeltaTime);
+        this._leftOverTime -= this._iterationSteps * this._fixedDeltaTime;
+
+        this._iterationSteps = Math.min(this._iterationSteps, this.maximumStepIterations);
+    }
+}

source/src/Utils/Verlet/Composites/Composite.ts

@@ -1,25 +0,0 @@
-class Composite {
-    private _constraints: Constraint[] = [];
-
-    public particles: Particle[] = [];
-    /**
-     * 处理解决所有约束条件
-     */
-    public solveConstraints(){
-        for (let i = this._constraints.length - 1; i >= 0; i --){
-            this._constraints[i].solve();
-        }
-    }
-
-    public updateParticles(deltaTimeSquared: number, gravity: Vector2){
-        for (let j = 0; j < this.particles.length; j ++){
-            let p = this.particles[j];
-            if (p.isPinned){
-                p.position = p.pinnedPosition;
-                continue;
-            }
-
-            p.applyForce(Vector2.multiply(new Vector2(p.mass, p.mass), gravity));
-        }
-    }
-}

source/src/Utils/Verlet/Constraint/Constraint.ts

@@ -1,5 +0,0 @@
-abstract class Constraint {
-    public composite: Composite;
-
-    public abstract solve();
-}

source/src/Utils/Verlet/VerletWorld.ts

@@ -1,45 +0,0 @@
-/**
- * 基于verlet 物理引擎进行改造的物理引擎 ts重写
- * https://github.com/subprotocol/verlet-js
- */
-class VerletWorld {
-    public gravity: Vector2 = new Vector2(0, 980);
-    public maximumStepIterations = 5;
-    public constraintIterations = 3;
-    public simulationBounds: Rectangle;
-
-    private _leftOverTime: number;
-    private _iterationSteps: number;
-    private _fixedDeltaTime = 1 / 60;
-    private _composites: Composite[] = [];
-    private _fixedDeltaTimeSq: number;
-
-    constructor(simulationBounds?: Rectangle){
-        this.simulationBounds = simulationBounds;
-        this._fixedDeltaTimeSq = Math.pow(this._fixedDeltaTime, 2);
-    }
-
-    public update(){
-        this.updateTiming();
-
-        for (let iteration = 1; iteration <= this._iterationSteps; iteration ++){
-            for (let i = this._composites.length - 1; i >= 0; i --){
-                let composite = this._composites[i];
-
-                for (let s = 0; s < this.constraintIterations; s++){
-                    composite.solveConstraints();
-                }
-
-                composite.updateParticles(this._fixedDeltaTimeSq, this.gravity);
-            }
-        }
-    }
-
-    private updateTiming(){
-        this._leftOverTime += Time.deltaTime;
-        this._iterationSteps = Math.trunc(this._leftOverTime / this._fixedDeltaTime);
-        this._leftOverTime -= this._iterationSteps * this._fixedDeltaTime;
-
-        this._iterationSteps = Math.min(this._iterationSteps, this.maximumStepIterations);
-    }
-}