ractor actions

src/components/thing.ts

@@ -11,16 +11,9 @@ export default class Thing {
     this.moveable = moveable;
   }
 
-  takeDamage(damage = 1) {
-    if (this.health - damage >= 0) {
-      this._health -= damage;
-      log.debug(
-        `${this.id} took ${damage} damage, health is now ${this.health}`
-      );
-    } else {
-      this._health = 0;
-      log.debug(this.id + ' out of health, ready for destruction');
-    }
+  set health(health: number) {
+    this._health = health;
+    log.debug(`${this.id} health: ${this._health}`);
   }
 
   get health() {

src/entities/actor.ts

@@ -1,11 +1,9 @@
-import { Directions } from '../systems';
 import { log } from '../utilities';
 import Interactable from './interactable';
 
 export default class Actor extends Interactable {
   protected focus?: Interactable;
-  protected speed = 100;
-  protected direction = 'down';
+  protected damage = 1;
 
   constructor(id: string) {
     super(id);
@@ -27,6 +25,10 @@ export default class Actor extends Interactable {
     return this.focus;
   }
 
+  getDamage() {
+    return this.damage;
+  }
+
   update() {
     if (this.sprite) {
       if (this.thing.health < 1) {
@@ -51,68 +53,4 @@ export default class Actor extends Interactable {
   clearFocus() {
     this.focus = undefined;
   }
-
-  attack() {
-    if (this.focus) {
-      this.focus.thing.takeDamage(1);
-      this.sprite?.play(`action-${this.direction}`);
-    } else {
-      log.debug('Nothing to attack');
-    }
-  }
-
-  move(direction: Directions) {
-    if (this.sprite) {
-      const normalizedVelocity = this.calcVelocity(direction);
-      this.sprite.setVelocity(
-        normalizedVelocity.x * this.speed,
-        normalizedVelocity.y * this.speed
-      );
-      this.sprite.play(`walk-${direction}`, true);
-      this.direction = direction;
-      this.focus = undefined;
-    }
-  }
-
-  calcVelocity(direction: string) {
-    const velocity = new Phaser.Math.Vector2(0, 0);
-    switch (direction) {
-      case 'up':
-        velocity.y -= 1;
-        break;
-      case 'down':
-        velocity.y += 1;
-        break;
-      case 'left':
-        velocity.x -= 1;
-        break;
-      case 'right':
-        velocity.x += 1;
-        break;
-    }
-    return velocity.normalize();
-  }
-
-  stop() {
-    if (this.sprite) {
-      this.sprite.setVelocity(0, 0);
-      this.sprite.play(`idle-${this.direction}`, true);
-    }
-  }
-
-  setSpeed(speed: number) {
-    this.speed = speed;
-  }
-
-  getSpeed() {
-    return this.speed;
-  }
-
-  setDirection(direction: string) {
-    this.direction = direction;
-  }
-
-  getDirection() {
-    return this.direction;
-  }
 }

src/entities/interactable.ts

@@ -1,13 +1,25 @@
 import Thing from '../components/thing';
+import { Directions } from '../systems';
 import { log } from '../utilities';
 
 export default class Interactable {
   public thing: Thing;
   public sprite?: Phaser.Physics.Arcade.Sprite;
+  protected speed = 100;
+  protected direction = Directions.down;
+
   constructor(id: string) {
     this.thing = new Thing(id);
   }
 
+  setSpeed(speed: number) {
+    this.speed = speed;
+  }
+
+  getSpeed(): number {
+    return this.speed;
+  }
+
   setSprite(sprite: Phaser.Physics.Arcade.Sprite) {
     this.sprite = sprite;
   }
@@ -16,6 +28,26 @@ export default class Interactable {
     this.sprite?.destroy();
   }
 
+  get health() {
+    return this.thing.health;
+  }
+
+  set health(health: number) {
+    this.thing.health = health;
+  }
+
+  get id() {
+    return this.thing.id;
+  }
+
+  setDirection(direction: string) {
+    this.direction = direction;
+  }
+
+  getDirection() {
+    return this.direction;
+  }
+
   update() {
     if (this.sprite) {
       if (this.thing.health < 1) {

src/scenes/gameScene.ts

@@ -24,6 +24,8 @@ export class GameScene extends Phaser.Scene {
 
     this.initObjects();
     log.debug('game scene created');
+    this.scene.launch('UI');
+    log.debug('ui scene launched');
   }
 
   private initObjects() {

src/scenes/uiScene.ts

@@ -0,0 +1,29 @@
+const sceneConfig: Phaser.Types.Scenes.SettingsConfig = {
+  active: false,
+  visible: false,
+  key: 'UI'
+};
+
+export class UIScene extends Phaser.Scene {
+  constructor() {
+    super(sceneConfig);
+  }
+
+  create() {
+    let playerHealth = this.add.text(-10, -10, 'Player: 3');
+    let benchHealth = this.add.text(-10, -10, 'Bench: 3');
+
+    let ourGame = this.scene.get('Game');
+
+    //  Listen for events from it
+    ourGame.events.on(
+      'addScore',
+      function () {
+        this.score += 10;
+
+        info.setText('Score: ' + this.score);
+      },
+      this
+    );
+  }
+}

src/systems/action.ts

@@ -36,20 +36,78 @@ export class Action {
   static performAction(action: Actions, actor: Actor) {
     switch (action) {
       case Actions.attack:
-        actor.attack();
+        this.attack(actor);
         break;
       case Actions.moveUp:
-        actor.move(Directions.up);
+        this.move(actor, Directions.up);
         break;
       case Actions.moveDown:
-        actor.move(Directions.down);
+        this.move(actor, Directions.down);
         break;
       case Actions.moveLeft:
-        actor.move(Directions.left);
+        this.move(actor, Directions.left);
         break;
       case Actions.moveRight:
-        actor.move(Directions.right);
+        this.move(actor, Directions.right);
         break;
     }
   }
+
+  static takeDamage(interactable: Interactable, damage = 1) {
+    interactable.health -= damage;
+    log.info(
+      `${interactable.id} took ${damage} damage, health is now ${interactable.health}`
+    );
+  }
+
+  static attack(attacker: Actor) {
+    const focusInteractable = attacker.getFocus();
+    if (focusInteractable) {
+      this.takeDamage(focusInteractable, attacker.getDamage());
+      attacker.sprite?.play(`action-${attacker.getDirection()}`);
+    } else {
+      log.debug(`${attacker.id} has no focus to attack`);
+    }
+  }
+
+  static move(interactable: Interactable, direction: Directions) {
+    if (interactable.sprite) {
+      const normalizedVelocity = this.calcVelocity(direction);
+      interactable.sprite.setVelocity(
+        normalizedVelocity.x * interactable.getSpeed(),
+        normalizedVelocity.y * interactable.getSpeed()
+      );
+      interactable.setDirection(direction);
+      interactable.sprite.play(`walk-${direction}`, true);
+      if (interactable instanceof Actor) {
+        interactable.clearFocus();
+      }
+    }
+  }
+
+  static calcVelocity(direction: string) {
+    const velocity = new Phaser.Math.Vector2(0, 0);
+    switch (direction) {
+      case 'up':
+        velocity.y -= 1;
+        break;
+      case 'down':
+        velocity.y += 1;
+        break;
+      case 'left':
+        velocity.x -= 1;
+        break;
+      case 'right':
+        velocity.x += 1;
+        break;
+    }
+    return velocity.normalize();
+  }
+
+  stop(interactable: Interactable) {
+    if (interactable.sprite) {
+      interactable.sprite.setVelocity(0, 0);
+      interactable.sprite.play(`idle-${this.direction}`, true);
+    }
+  }
 }