Refactor physics

backend/src/objects/circle-physical.ts

@@ -0,0 +1,143 @@
+import { vec2 } from 'gl-matrix';
+import { Circle, clamp, GameObject, settings } from 'shared';
+import { Physical } from '../physics/physical';
+
+import { BoundingBox } from '../physics/bounding-boxes/bounding-box';
+import { BoundingBoxBase } from '../physics/bounding-boxes/bounding-box-base';
+
+export class CirclePhysical implements Circle, Physical {
+  readonly isInverted = false;
+  readonly canCollide = true;
+  readonly canMove = true;
+
+  private _isAirborne = true;
+
+  private velocity = vec2.create();
+
+  public get isAirborne(): boolean {
+    return this._isAirborne;
+  }
+
+  private _boundingBox: BoundingBox;
+
+  constructor(private _center: vec2, private _radius: number, private owner: GameObject) {
+    this._boundingBox = new BoundingBox(null);
+    this.recalculateBoundingBox();
+  }
+
+  public get boundingBox(): BoundingBoxBase {
+    return this._boundingBox;
+  }
+
+  public get center(): vec2 {
+    return this._center;
+  }
+
+  public set center(value: vec2) {
+    this._center = value;
+    this.recalculateBoundingBox();
+  }
+
+  public get gameObject(): GameObject {
+    return this.owner;
+  }
+
+  public get radius(): number {
+    return this._radius;
+  }
+
+  public set radius(value: number) {
+    this._radius = value;
+    this.recalculateBoundingBox();
+  }
+
+  public distance(target: vec2): number {
+    return vec2.distance(target, this.center) - this.radius;
+  }
+
+  public distanceBetween(target: CirclePhysical): number {
+    return vec2.distance(target.center, this.center) - this.radius - target.radius;
+  }
+
+  public areIntersecting(other: CirclePhysical): boolean {
+    return other.distance(this.center) < this.radius;
+  }
+
+  public isInside(other: CirclePhysical): boolean {
+    return other.distance(this.center) < -this.radius;
+  }
+
+  public getPerimeterPoints(count: number): Array<vec2> {
+    const result: Array<vec2> = [];
+    for (let i = 0; i < count; i++) {
+      result.push(
+        vec2.fromValues(
+          Math.cos((2 * Math.PI * i) / count) * this.radius + this.center.x,
+          Math.sin((2 * Math.PI * i) / count) * this.radius + this.center.y
+        )
+      );
+    }
+    return result;
+  }
+
+  private recalculateBoundingBox() {
+    this._boundingBox.xMin = this.center.x - this._radius;
+    this._boundingBox.xMax = this.center.x + this._radius;
+    this._boundingBox.yMin = this.center.y - this._radius;
+    this._boundingBox.yMax = this.center.y + this._radius;
+  }
+
+  public applyForce(force: vec2, timeInMilliseconds: number) {
+    vec2.add(
+      this.velocity,
+      this.velocity,
+      vec2.scale(vec2.create(), force, timeInMilliseconds)
+    );
+
+    vec2.set(
+      this.velocity,
+      clamp(this.velocity.x, -settings.maxVelocityX, settings.maxVelocityX),
+      clamp(this.velocity.y, -settings.maxVelocityY, settings.maxVelocityY)
+    );
+  }
+
+  public resetVelocity() {
+    this.velocity = vec2.create();
+  }
+
+  /*public step(timeInMilliseconds: number): boolean {
+    vec2.scale(
+      this.velocity,
+      this.velocity,
+      Math.pow(settings.velocityAttenuation, timeInMilliseconds)
+    );
+    const distance = vec2.scale(vec2.create(), this.velocity, timeInMilliseconds);
+    const distanceLength = vec2.length(distance);
+    const stepCount = Math.ceil(distanceLength / settings.physicsMaxStep);
+    vec2.scale(distance, distance, 1 / stepCount);
+
+    let wasHit = false;
+
+    for (let i = 0; i < stepCount; i++) {
+      const { normal, tangent, hitSurface } = this.physics.tryMovingDynamicCircle(
+        this,
+        distance
+      );
+      if (hitSurface) {
+        vec2.scale(this.velocity, tangent, vec2.dot(tangent, this.velocity));
+        wasHit = true;
+      }
+
+      this._isAirborne = !(
+        hitSurface && vec2.dot(normal, settings.gravitationalForce) < 0
+      );
+    }
+
+    return wasHit;
+  }*/
+
+  public toJSON(): any {
+    const { center, radius } = this;
+    return { center, radius };
+  }
+}