Remove clutter

frontend/.dockerignore

@@ -1,5 +0,0 @@
-Dockerfile
-node_modules
-dist
-package-lock.json
-.*

frontend/src/scripts/commands/move-to.ts

@@ -0,0 +1,12 @@
+import { vec2 } from 'gl-matrix';
+import { Command } from './command';
+
+export class MoveToCommand extends Command {
+  public constructor(public readonly position?: vec2) {
+    super();
+  }
+
+  public get type(): string {
+    return 'MoveToCommand';
+  }
+}

frontend/src/scripts/commands/render.ts

@@ -0,0 +1,12 @@
+import { Renderer } from 'sdf-2d';
+import { Command } from './command';
+
+export class RenderCommand extends Command {
+  public constructor(public readonly renderer?: Renderer) {
+    super();
+  }
+
+  public get type(): string {
+    return 'RenderCommand';
+  }
+}

frontend/src/scripts/commands/step.ts

@@ -0,0 +1,11 @@
+import { Command } from './command';
+
+export class StepCommand extends Command {
+  public constructor(public readonly deltaTimeInMiliseconds?: DOMHighResTimeStamp) {
+    super();
+  }
+
+  public get type(): string {
+    return 'StepCommand';
+  }
+}

frontend/src/scripts/commands/teleport-to.ts

@@ -0,0 +1,12 @@
+import { vec2 } from 'gl-matrix';
+import { Command } from './command';
+
+export class TeleportToCommand extends Command {
+  public constructor(public readonly position?: vec2) {
+    super();
+  }
+
+  public get type(): string {
+    return 'TeleportToCommand';
+  }
+}

frontend/src/scripts/game.ts

@@ -1,7 +1,10 @@
 import { vec2 } from 'gl-matrix';
 import { CircleLight, compile, Flashlight, InvertedTunnel, Renderer } from 'sdf-2d';
 import { CommandBroadcaster } from './commands/command-broadcaster';
-import { RenderCommand } from './graphics/commands/render';
+import { MoveToCommand } from './commands/move-to';
+import { RenderCommand } from './commands/render';
+import { StepCommand } from './commands/step';
+import { TeleportToCommand } from './commands/teleport-to';
 import { DeltaTimeCalculator } from './helper/delta-time-calculator';
 import { prettyPrint } from './helper/pretty-print';
 import { rgb } from './helper/rgb';
@@ -14,12 +17,9 @@ import { Camera } from './objects/types/camera';
 import { Character } from './objects/types/character';
 import { createDungeon } from './objects/world/create-dungeon';
 import { BoundingBoxBase } from './physics/bounds/bounding-box-base';
-import { MoveToCommand } from './physics/commands/move-to';
-import { StepCommand } from './physics/commands/step';
-import { TeleportToCommand } from './physics/commands/teleport-to';
 import { Physics } from './physics/physics';
 import { settings } from './settings';
-import { BlobShape } from './shapes/types/blob-shape';
+import { BlobShape } from './shapes/blob-shape';
 
 export class Game implements IGame {
   public readonly objects = new Objects();
@@ -45,10 +45,22 @@ export class Game implements IGame {
     this.rendererPromise = compile(
       canvas,
       [
-        InvertedTunnel.descriptor,
-        Flashlight.descriptor,
-        BlobShape.descriptor,
-        CircleLight.descriptor,
+        {
+          ...InvertedTunnel.descriptor,
+          shaderCombinationSteps: [0, 2, 4, 8, 16],
+        },
+        {
+          ...Flashlight.descriptor,
+          shaderCombinationSteps: [0, 1],
+        },
+        {
+          ...BlobShape.descriptor,
+          shaderCombinationSteps: [0, 1],
+        },
+        {
+          ...CircleLight.descriptor,
+          shaderCombinationSteps: [0, 1, 2, 4, 8, 16],
+        },
       ],
       {
         shadowTraceCount: 12,
@@ -90,7 +102,9 @@ export class Game implements IGame {
 
   private initializeScene() {
     createDungeon(this.objects, this.physics);
-    //createDungeon(this.objects, this.physics);
+    createDungeon(this.objects, this.physics);
+    createDungeon(this.objects, this.physics);
+    createDungeon(this.objects, this.physics);
 
     this.character = new Character(this.physics, this);
     this.objects.addObject(this.character);

frontend/src/scripts/objects/types/camera.ts

@@ -1,9 +1,9 @@
 import { vec2 } from 'gl-matrix';
-import { RenderCommand } from '../../graphics/commands/render';
+import { MoveToCommand } from '../../commands/move-to';
+import { RenderCommand } from '../../commands/render';
 import { CursorMoveCommand } from '../../input/commands/cursor-move-command';
 import { ZoomCommand } from '../../input/commands/zoom';
 import { BoundingBox } from '../../physics/bounds/bounding-box';
-import { MoveToCommand } from '../../physics/commands/move-to';
 import { GameObject } from '../game-object';
 
 export class Camera extends GameObject {

frontend/src/scripts/objects/types/lamp.ts

@@ -1,9 +1,9 @@
 import { vec2, vec3 } from 'gl-matrix';
 import { CircleLight } from 'sdf-2d';
-import { RenderCommand } from '../../graphics/commands/render';
+import { MoveToCommand } from '../../commands/move-to';
+import { RenderCommand } from '../../commands/render';
 import { BoundingBoxBase } from '../../physics/bounds/bounding-box-base';
 import { ImmutableBoundingBox } from '../../physics/bounds/immutable-bounding-box';
-import { MoveToCommand } from '../../physics/commands/move-to';
 import { PhysicalObject } from '../../physics/physical-object';
 import { Physics } from '../../physics/physics';
 import { settings } from '../../settings';

frontend/src/scripts/objects/types/tunnel.ts

@@ -1,13 +1,13 @@
 import { vec2 } from 'gl-matrix';
-import { RenderCommand } from '../../graphics/commands/render';
+import { InvertedTunnel } from 'sdf-2d';
+import { RenderCommand } from '../../commands/render';
 import { BoundingBoxBase } from '../../physics/bounds/bounding-box-base';
 import { ImmutableBoundingBox } from '../../physics/bounds/immutable-bounding-box';
 import { Physics } from '../../physics/physics';
 import { StaticPhysicalObject } from '../../physics/static-physical-object';
-import { TunnelShape } from '../../shapes/types/tunnel-shape';
 
 export class Tunnel extends StaticPhysicalObject {
-  private shape: TunnelShape;
+  private shape: InvertedTunnel;
 
   constructor(
     physics: Physics,
@@ -17,7 +17,7 @@ export class Tunnel extends StaticPhysicalObject {
     toRadius: number
   ) {
     super(physics, true);
-    this.shape = new TunnelShape(from, to, fromRadius, toRadius);
+    this.shape = new InvertedTunnel(from, to, fromRadius, toRadius);
     this.addToPhysics();
 
     this.addCommandExecutor(RenderCommand, this.draw.bind(this));

frontend/src/scripts/settings.ts

@@ -1,3 +1,5 @@
 export const settings = {
   lightCutoffDistance: 600,
+  hitDetectionCirclePointCount: 8,
+  hitDetectionMaxOverlap: 0.01,
 };

frontend/src/scripts/shapes/blob-shape.ts

@@ -0,0 +1,106 @@
+import { mat2d, vec2 } from 'gl-matrix';
+import { Drawable, DrawableDescriptor } from 'sdf-2d';
+import { BoundingCircle } from '../physics/bounds/bounding-circle';
+
+export class BlobShape extends Drawable {
+  public static descriptor: DrawableDescriptor = {
+    sdf: {
+      shader: `
+      uniform vec2 headCenters[BLOB_COUNT];
+      uniform vec2 leftFootCenters[BLOB_COUNT];
+      uniform vec2 rightFootCenters[BLOB_COUNT];
+      uniform float headRadii[BLOB_COUNT];
+      uniform float footRadii[BLOB_COUNT];
+      //uniform float ks[BLOB_COUNT];
+
+      float smoothMin(float a, float b)
+      {
+        const float k = 80.0;
+        float res = exp2( -k*a ) + exp2( -k*b );
+        return -log2( res )/k;
+      }
+
+      float circleDistance(vec2 circleCenter, float radius, vec2 target) {
+        return distance(target, circleCenter) - radius;
+      }
+
+      float blobMinDistance(vec2 target, out float colorIndex) {
+        float minDistance = 1000.0;
+        colorIndex = 3.0;
+
+        for (int i = 0; i < BLOB_COUNT; i++) {
+          float headDistance = circleDistance(headCenters[i], headRadii[i], target);
+          float leftFootDistance = circleDistance(leftFootCenters[i], footRadii[i], target);
+          float rightFootDistance = circleDistance(rightFootCenters[i], footRadii[i], target);
+
+          float res = min(
+            smoothMin(headDistance, leftFootDistance),
+            smoothMin(headDistance, rightFootDistance)
+          );
+
+          minDistance = min(minDistance, res);
+        }
+
+        return minDistance;
+      }
+    `,
+      distanceFunctionName: 'blobMinDistance',
+    },
+    propertyUniformMapping: {
+      footRadius: 'footRadii',
+      headRadius: 'headRadii',
+      rightFootCenter: 'rightFootCenters',
+      leftFootCenter: 'leftFootCenters',
+      headCenter: 'headCenters',
+    },
+    uniformCountMacroName: 'BLOB_COUNT',
+    shaderCombinationSteps: [0, 1, 10],
+    empty: new BlobShape(),
+  };
+  protected head: BoundingCircle;
+  protected leftFoot: BoundingCircle;
+  protected rightFoot: BoundingCircle;
+
+  public constructor() {
+    super();
+
+    const circle = new BoundingCircle(null, vec2.create(), 200);
+    this.setCircles([circle, circle, circle]);
+  }
+
+  public setCircles([head, leftFoot, rightFoot]: [
+    BoundingCircle,
+    BoundingCircle,
+    BoundingCircle
+  ]) {
+    this.head = head;
+    this.leftFoot = leftFoot;
+    this.rightFoot = rightFoot;
+  }
+
+  public minDistance(target: vec2): number {
+    return Math.min(
+      this.head.distance(target),
+      this.leftFoot.distance(target),
+      this.rightFoot.distance(target)
+    );
+  }
+
+  protected getObjectToSerialize(transform2d: mat2d, transform1d: number): any {
+    return {
+      headCenter: vec2.transformMat2d(vec2.create(), this.head.center, transform2d),
+      leftFootCenter: vec2.transformMat2d(
+        vec2.create(),
+        this.leftFoot.center,
+        transform2d
+      ),
+      rightFootCenter: vec2.transformMat2d(
+        vec2.create(),
+        this.rightFoot.center,
+        transform2d
+      ),
+      headRadius: this.head.radius * transform1d,
+      footRadius: this.leftFoot.radius * transform1d,
+    };
+  }
+}

frontend/src/scripts/shapes/types/circle-shape.ts

@@ -1,17 +0,0 @@
-import { vec2 } from 'gl-matrix';
-import { Circle } from 'sdf-2d';
-import { GameObject } from '../../objects/game-object';
-
-export class CircleShape extends Circle {
-  public constructor(
-    center = vec2.create(),
-    radius = 0,
-    public readonly gameObject: GameObject = null
-  ) {
-    super(center, radius);
-  }
-
-  public clone(): CircleShape {
-    return new CircleShape(vec2.clone(this.center), this.radius, this.gameObject);
-  }
-}

frontend/src/scripts/shapes/types/tunnel-shape.ts

@@ -1,17 +0,0 @@
-import { vec2 } from 'gl-matrix';
-import { InvertedTunnel } from 'sdf-2d';
-
-export class TunnelShape extends InvertedTunnel {
-  constructor(from: vec2, to: vec2, fromRadius: number, toRadius: number) {
-    super(from, to, fromRadius, toRadius);
-  }
-
-  public clone(): TunnelShape {
-    return new TunnelShape(
-      vec2.clone(this.from),
-      vec2.clone(this.to),
-      this.fromRadius,
-      this.toRadius
-    );
-  }
-}