1 files changed, 163 insertions, 30 deletions

diff --git a/game.ts b/game.ts
index 52fe2a5..820d525 100644
--- a/game.ts
+++ b/game.ts
@@ -6,6 +6,7 @@
 import Vector3 = THREE.Vector3;
 import Material = THREE.Material;
 import Geometry = THREE.Geometry;
+import smoothstep = THREE.Math.smoothstep;
 
 //wtf fix..
 Physijs.scripts.worker = "physi_js/physijs_worker.js";
@@ -45,7 +46,6 @@ class PointerLock {
             if (this.game.state == GameState.INITIALIZED || this.game.state == GameState.PAUSED) {
                 this.game.start();
             }
-            console.log("gained");
         } else {
             //lost
             this.hasLock = false;
@@ -57,7 +57,6 @@ class PointerLock {
             if (this.game.state == GameState.STARTED) {
                 this.game.pause();
             }
-            console.log("lost");
         }
     };
 
@@ -206,14 +205,60 @@ class Mouse {
     }
 }
 
+class Poly extends Physijs.PlaneMesh {
+
+    constructor(private pos:Vector3) {
+        super(Poly.generateGeometry(),
+            Physijs.createMaterial(new THREE.MeshBasicMaterial({
+                    color: 0x10a010
+                }),
+                1,
+                1
+            ),
+            0.1);
+        this.addEventListener("ready", () => this.init());
+    }
+
+    init():void {
+        //launch the poly into space
+        this.position.copy(this.pos);
+        this.setLinearVelocity(Poly.generateDirection().normalize());
+    }
+
+    static generateDirection():Vector3 {
+        let verts = [];
+        for (let i = 0; i < 3; i++) {
+            verts.push(Math.random());
+        }
+        return new Vector3().fromArray(verts);
+    }
+
+    static generateGeometry():THREE.Geometry {
+        //generate two random verts, construct a triangle
+        let geom = new THREE.Geometry();
+        geom.vertices.push(new Vector3());
+        geom.vertices.push(Poly.generateDirection());
+        geom.vertices.push(Poly.generateDirection());
+        geom.faces.push(new THREE.Face3(0, 1, 2));
+        return geom;
+    }
+
+}
+
 /**
  *
  */
 class Morph extends Physijs.SphereMesh {
+    radius:number;
     static levels:number[] = [4, 6, 12, 20];
 
     constructor(public level:number, material?:THREE.Material, mass?:number) {
         super(Morph.generateGeometry(level), material, mass);
+        this.radius = this.geometry.boundingSphere.radius;
+        this.addEventListener("ready", () => this.init());
+    }
+
+    init():void {
     }
 
     static generateGeometry(level:number):THREE.Geometry {
@@ -225,9 +270,9 @@ class Morph extends Physijs.SphereMesh {
             case 6:
                 return new THREE.BoxGeometry(1, 1, 1, 1, 1, 1);
             case 12:
-                return new THREE.DodecahedronGeometry(1, 0);
-            case 20:
                 return new THREE.IcosahedronGeometry(1, 0);
+            case 20:
+                return new THREE.DodecahedronGeometry(1, 0);
             default:
                 return new THREE.TetrahedronGeometry();
         }
@@ -235,6 +280,8 @@ class Morph extends Physijs.SphereMesh {
 
     private updateGeometry():void {
         this.geometry = Morph.generateGeometry(this.level);
+        this.geometry.computeBoundingSphere();
+        this.radius = this.geometry.boundingSphere.radius;
     }
 
     shrink():void {
@@ -251,6 +298,11 @@ class Morph extends Physijs.SphereMesh {
         }
     }
 
+    collides(other:Morph):boolean {
+        return this.position.clone().sub(other.position).length() < this.radius + other.radius;
+    }
+
+
 }
 
 /**
@@ -271,7 +323,11 @@ class Projectile extends Morph {
         this.position.copy(pos.clone().add(dir.clone().setLength(2)));
     }
 
-    shoot():void {
+    init():void {
+        this.launch();
+    };
+
+    launch():void {
         this.setLinearVelocity(this.dir);
     }
 
@@ -280,16 +336,29 @@ class Projectile extends Morph {
     }
 }
 
+class LiveMorph extends Morph {
+    life:number = 100;
+
+    damage(by:number):void {
+        if (this.isAlive())
+            this.life -= by;
+    }
+
+    isAlive():boolean {
+        return this.life > 0;
+    }
+}
+
 /**
  *
  */
-class Enemy extends Morph {
-    speed:number = 10;
+class Enemy extends LiveMorph {
+    speed:number = 20;
 
     constructor() {
         super(0, Physijs.createMaterial(
             new THREE.MeshBasicMaterial({
-                color: 0xb02000
+                color: 0xa01b00
             }),
             .8,
             .6
@@ -301,23 +370,34 @@ class Enemy extends Morph {
         this.setLinearVelocity(toPlayer.setLength(this.speed));
     }
 
+    die():Poly[] {
+        let polys = [];
+        let amount = Math.floor(Math.random() * 10);
+        for (let i = 0; i < amount; i++) {
+            let poly = new Poly(this.position);
+            polys.push(poly);
+        }
+
+        return polys;
+    }
+
 }
 
-class Player extends Morph {
-    minus:number;
-    plus:number;
-    life:number;
+class Player extends LiveMorph {
+    minus:number = 0;
+    plus:number = 0;
+    speed:number = 25;
+
     forward:Vector3 = new Vector3(0, 0, -1);
     upward:Vector3 = new Vector3(0, 1, 0);
-    camera:Vector3 = new Vector3(0, 10, 10);
+    camera:Vector3 = new Vector3(0, 7, 10);
     heading:number = 0;
     pitch:number = 0;
-    speed:number = 25;
 
     projectiles:Projectile[] = [];
+    listener:THREE.AudioListener;
 
     constructor() {
-
         super(1, Physijs.createMaterial(
             new THREE.MeshBasicMaterial({
                 color: 0x00a0b0
@@ -326,6 +406,13 @@ class Player extends Morph {
             0.1
             ),
             0.5);
+        this.listener = new THREE.AudioListener();
+        this.add(this.listener);
+    }
+
+    init():void {
+        this.castShadow = true;
+        this.setDamping(0.05, 0.05);
     }
 
     jump():void {
@@ -347,16 +434,21 @@ class Player extends Morph {
     }
 
     getRight():Vector3 {
-        return this.getDirection().cross(this.upward).normalize();
+        return this.getForward().cross(this.upward).normalize();
     }
 
     getDirection():Vector3 {
+        return this.getForward().applyAxisAngle(this.getRight(), this.pitch);
+    }
+
+    getForward():Vector3 {
         return this.forward.clone().applyAxisAngle(this.upward, this.heading);
     }
 
     getCamera():Vector3 {
         return this.camera.clone().applyAxisAngle(this.upward, this.heading).applyAxisAngle(this.getRight(), this.pitch);
     }
+
 }
 
 class World extends Physijs.Scene {
@@ -367,16 +459,14 @@ class World extends Physijs.Scene {
         super();
         this.setGravity(new THREE.Vector3(0, -40, 0));
 
+        player.position.set(0, player.radius, 0);
         this.add(player);
-        player.position.set(0, 2, 0);
-        player.castShadow = true;
-        player.setDamping(0.05, 0.05);
 
         for (let i = 0; i < 10; i++) {
             let enemy = new Enemy();
             let x = Math.floor(Math.random() * 20 + 3);
             let z = Math.floor(Math.random() * 20 + 3);
-            enemy.position.set(x, 2, z);
+            enemy.position.set(x, enemy.radius, z);
             this.add(enemy);
             this.mobs.push(enemy);
         }
@@ -409,30 +499,55 @@ class World extends Physijs.Scene {
     }
 
     tick(delta:number):void {
+
         //push projectiles queued from player into the world.
         while (this.player.projectiles.length > 0) {
             let projectile = this.player.projectiles.pop();
             this.projectiles.push(projectile);
             this.add(projectile);
-            projectile.shoot();
         }
 
         //enemy movement
         this.mobs.forEach((mob) => {
             mob.approach(this.player);
+            if (mob.collides(this.player)) {
+                //collide?
+                this.player.damage((mob.level + 1) * 3);
+            }
         });
-        //tick projectiles and remove them if time out
-        //todo fix projectile removal, now ammojs spams obj s undefined
-        /*
-        this.projectiles.filter((projectile) => {
+
+        //tick projectiles and remove them if time out/on hit
+        this.projectiles = this.projectiles.filter((projectile) => {
             projectile.tick(delta);
             let keep = projectile.time < 10 * 1000;
+            let collided:boolean = false;
             if (!keep) {
                 this.remove(projectile);
+            } else {
+                for (let mob of this.mobs) {
+                    if (mob.collides(projectile)) {
+                        collided = true;
+                        if (mob.level == projectile.level) {
+                            mob.damage((projectile.level + 1) * 10);
+                        }
+                        break;
+                    }
+                }
             }
-            return keep;
+            return keep && !collided;
+        });
+
+        this.mobs = this.mobs.filter((mob) => {
+            let alive = mob.isAlive();
+            if (!alive) {
+                let polys = mob.die();
+                polys.forEach((poly) => {
+                    this.add(poly);
+                });
+                this.remove(mob);
+            }
+            return alive;
         });
-        */
 
         //physijs
         this.simulate(delta, 1);
@@ -525,7 +640,7 @@ class Game {
         this.camera.lookAt(this.player.position);
 
         //player movement
-        let forward = this.player.getDirection();
+        let forward = this.player.getForward();
         forward.setLength(this.player.speed);
         let right = forward.clone().cross(this.player.upward);
         right.setLength(this.player.speed);
@@ -559,7 +674,17 @@ class Game {
             this.player.jump();
         }
 
+        //debug shoot
+        if (this.keyboard.down("C")){
+            this.player.click(THREE.MOUSE.LEFT);
+        }
+
         this.world.tick(delta);
+
+        //die!
+        if (!this.player.isAlive()) {
+            this.stop();
+        }
     }
 
     run(timestamp?):void {
@@ -611,14 +736,22 @@ class Game {
         this.keepRunning = false;
     }
 
-    stop() {
+    stop(result:boolean = false) {
         this.pause();
         this.state = GameState.STOPPED;
 
         this.mouse.unregister();
         this.keyboard.unregister();
         window.removeEventListener("resize", this.onWindowResize, false);
-        //todo
+
+        let blocker = document.getElementById("block");
+        blocker.style.display = '-webkit-box';
+        blocker.style.display = '-moz-box';
+        blocker.style.display = 'box';
+        let instructions = document.getElementById("instructions");
+        instructions.style.fontSize = "40px";
+        instructions.innerHTML = result ? "You won!" : "You lost!";
+        instructions.style.display = "";
     }
 }