Added damage display on ship sprites

src/scripts/game/Battle.ts

@@ -65,8 +65,8 @@ module SpaceTac.Game {
         // Defines the initial ship positions of all engaged fleets
         placeShips(): void {
             this.first_turn = true;
-            this.placeFleetShips(this.fleets[0], 100, 100, 0);
-            this.placeFleetShips(this.fleets[1], 300, 100, Math.PI);
+            this.placeFleetShips(this.fleets[0], 100, 300, 0);
+            this.placeFleetShips(this.fleets[1], 950, 300, Math.PI);
         }
 
         // End the current ship turn, passing control to the next one in play order
@@ -134,7 +134,7 @@ module SpaceTac.Game {
         //  facing_angle is the forward angle in radians
         private placeFleetShips(fleet: Fleet, x: number, y: number, facing_angle: number): void {
             var side_angle = facing_angle + Math.PI * 0.5;
-            var spacing = 50;
+            var spacing = 150;
             var total_length = spacing * (fleet.ships.length - 1);
             var dx = Math.cos(side_angle);
             var dy = Math.sin(side_angle);

src/scripts/game/Ship.ts

@@ -198,6 +198,16 @@ module SpaceTac.Game {
             }
         }
 
+        // Apply damages to hull and/or shield
+        addDamage(hull: number, shield: number, log: boolean = true): void {
+            this.setAttribute(this.hull, -hull, true, log);
+            this.setAttribute(this.shield, -shield, true, log);
+
+            if (log && this.getBattle()) {
+                this.getBattle().log.add(new DamageEvent(this, hull, shield));
+            }
+        }
+
         // Add an empty equipment slot of the given type
         addSlot(type: SlotType): Slot {
             var result = new Slot(this, type);

src/scripts/game/effects/DamageEffect.ts

@@ -16,23 +16,27 @@ module SpaceTac.Game {
 
         applyOnShip(ship: Ship): boolean {
             var damage = this.value;
+            var hull: number;
+            var shield: number;
 
             // Apply on shields
-            var absorbed = ship.shield.current;
             if (damage >= ship.shield.current) {
-                ship.setAttribute(ship.shield, 0);
+                shield = ship.shield.current;
             } else {
-                ship.setAttribute(ship.shield, -damage, true);
+                shield = damage;
             }
-            damage -= absorbed;
+            damage -= shield;
 
             // Apply on hull
             if (damage >= ship.hull.current) {
-                ship.setAttribute(ship.hull, 0);
+                hull = ship.hull.current;
             } else {
-                ship.setAttribute(ship.hull, -damage, true);
+                hull = damage;
             }
 
+            // Effective damages on ship
+            ship.addDamage(hull, shield);
+
             return true;
         }
     }

src/scripts/game/equipments/ConventionalEngine.ts

@@ -9,7 +9,7 @@ module SpaceTac.Game.Equipments {
             super(SlotType.Engine, "Conventional Engine");
 
             this.min_level = new IntegerRange(1, 1);
-            this.distance = new Range(50, 50);
+            this.distance = new Range(300, 300);
             this.ap_usage = new Range(3);
 
             this.addPermanentAttributeMaxEffect(AttributeCode.Initiative, 1);

src/scripts/game/equipments/GatlingGun.ts

@@ -8,7 +8,7 @@ module SpaceTac.Game.Equipments {
         constructor() {
             super("Gatling Gun", 50, 100);
 
-            this.setRange(300, 300, false);
+            this.setRange(1000, 1000, false);
 
             this.ap_usage = new Range(3, 4);
             this.min_level = new IntegerRange(1, 3);

src/scripts/game/events/DamageEvent.ts

@@ -0,0 +1,19 @@
+module SpaceTac.Game {
+    "use strict";
+
+    // Event logged when a ship takes damage
+    export class DamageEvent extends BaseLogEvent {
+        // Damage to hull
+        hull: number;
+
+        // Damage to shield
+        shield: number;
+
+        constructor(ship: Ship, hull: number, shield: number) {
+            super("damage", ship);
+
+            this.hull = hull;
+            this.shield = shield;
+        }
+    }
+}

src/scripts/game/specs/Battle.spec.ts

@@ -43,23 +43,23 @@ module SpaceTac.Game {
             battle.placeShips();
 
             expect(ship1.arena_x).toBeCloseTo(100, 0.0001);
-            expect(ship1.arena_y).toBeCloseTo(50, 0.0001);
+            expect(ship1.arena_y).toBeCloseTo(150, 0.0001);
             expect(ship1.arena_angle).toBeCloseTo(0, 0.0001);
 
             expect(ship2.arena_x).toBeCloseTo(100, 0.0001);
-            expect(ship2.arena_y).toBeCloseTo(100, 0.0001);
+            expect(ship2.arena_y).toBeCloseTo(300, 0.0001);
             expect(ship2.arena_angle).toBeCloseTo(0, 0.0001);
 
             expect(ship3.arena_x).toBeCloseTo(100, 0.0001);
-            expect(ship3.arena_y).toBeCloseTo(150, 0.0001);
+            expect(ship3.arena_y).toBeCloseTo(450, 0.0001);
             expect(ship3.arena_angle).toBeCloseTo(0, 0.0001);
 
-            expect(ship4.arena_x).toBeCloseTo(300, 0.0001);
-            expect(ship4.arena_y).toBeCloseTo(125, 0.0001);
+            expect(ship4.arena_x).toBeCloseTo(950, 0.0001);
+            expect(ship4.arena_y).toBeCloseTo(375, 0.0001);
             expect(ship4.arena_angle).toBeCloseTo(Math.PI, 0.0001);
 
-            expect(ship5.arena_x).toBeCloseTo(300, 0.0001);
-            expect(ship5.arena_y).toBeCloseTo(75, 0.0001);
+            expect(ship5.arena_x).toBeCloseTo(950, 0.0001);
+            expect(ship5.arena_y).toBeCloseTo(225, 0.0001);
             expect(ship5.arena_angle).toBeCloseTo(Math.PI, 0.0001);
         });
 

src/scripts/game/specs/Ship.spec.ts

@@ -93,5 +93,31 @@ module SpaceTac.Game {
             expect(ship.hull.current).toEqual(120);
             expect(ship.shield.current).toEqual(150);
         });
+
+        it("applies and logs hull and shield damage", function () {
+            var fleet = new Fleet();
+            var battle = new Battle(fleet);
+            var ship = new Ship(fleet);
+
+            ship.hull.setMaximal(50);
+            ship.shield.setMaximal(100);
+            ship.restoreHealth();
+            battle.log.clear();
+
+            ship.addDamage(10, 20);
+            expect(ship.hull.current).toEqual(40);
+            expect(ship.shield.current).toEqual(80);
+            expect(battle.log.events.length).toBe(3);
+            expect(battle.log.events[0]).toEqual(new AttributeChangeEvent(ship, ship.hull));
+            expect(battle.log.events[1]).toEqual(new AttributeChangeEvent(ship, ship.shield));
+            expect(battle.log.events[2]).toEqual(new DamageEvent(ship, 10, 20));
+
+            battle.log.clear();
+
+            ship.addDamage(15, 25, false);
+            expect(ship.hull.current).toEqual(25);
+            expect(ship.shield.current).toEqual(55);
+            expect(battle.log.events.length).toBe(0);
+        });
     });
 }

src/scripts/view/battle/Arena.ts

@@ -29,7 +29,6 @@ module SpaceTac.View {
             this.hovered = null;
 
             super(battleview.game);
-            this.scale.set(2, 2);
 
             var background = new Phaser.Button(battleview.game, 0, 0, "battle-arena-background");
             var expected_width = 1280 - 252;

src/scripts/view/battle/ArenaShip.ts

@@ -84,5 +84,32 @@ module SpaceTac.View {
                 this.sprite.rotation = facing_angle;
             }
         }
+
+        // Briefly display the damage done to the ship
+        displayDamage(hull: number, shield: number) {
+            if (hull > 0) {
+                var hull_text = new Phaser.Text(this.game, -20, -20, Math.round(hull).toString(),
+                    {font: "bold 16px Arial", align: "center", fill: "#ffbbbb"});
+                hull_text.anchor.set(0.5, 0.5);
+                this.addChild(hull_text);
+                this.animateDamageText(hull_text);
+            }
+            if (shield > 0) {
+                var shield_text = new Phaser.Text(this.game, 20, -20, Math.round(shield).toString(),
+                    {font: "bold 16px Arial", align: "center", fill: "#bbbbff"});
+                shield_text.anchor.set(0.5, 0.5);
+                this.addChild(shield_text);
+                this.animateDamageText(shield_text);
+            }
+        }
+
+        private animateDamageText(text: Phaser.Text) {
+            var tween = this.game.tweens.create(text);
+            tween.to({y: -50, alpha: 0}, 800, Phaser.Easing.Circular.In, false, 200);
+            tween.onComplete.addOnce(() => {
+                text.destroy();
+            });
+            tween.start();
+        }
     }
 }

src/scripts/view/battle/LogProcessor.ts

@@ -34,24 +34,17 @@ module SpaceTac.View {
 
             switch (event.code) {
                 case "ship_change":
-                    // Playing ship changed
-                    this.view.arena.setShipPlaying(event.target.ship);
-                    this.view.card_playing.setShip(event.target.ship);
-                    this.view.action_bar.setShip(event.target.ship);
+                    this.processShipChangeEvent(<Game.ShipChangeEvent>event);
+                    break;
+                case "damage":
+                    this.processDamageEvent(<Game.DamageEvent>event);
                     break;
                 case "move":
-                    var move_event = <Game.MoveEvent>event;
-                    var sprite = this.view.arena.findShipSprite(move_event.ship);
-                    if (sprite) {
-                        sprite.moveTo(move_event.target.x, move_event.target.y, move_event.facing_angle, true);
-                    }
+                    this.processMoveEvent(<Game.MoveEvent>event);
                     break;
                 case "attr":
-                    var attr_event = <Game.AttributeChangeEvent>event;
-                    var item = this.view.ship_list.findItem(attr_event.ship);
-                    if (item) {
-                        item.attributeChanged(attr_event.attribute);
-                    }
+                    this.processAttributeChangedEvent(<Game.AttributeChangeEvent>event);
+                    break;
             }
         }
 
@@ -62,5 +55,36 @@ module SpaceTac.View {
                 this.subscription = null;
             }
         }
+
+        // Playing ship changed
+        private processShipChangeEvent(event: Game.ShipChangeEvent) {
+            this.view.arena.setShipPlaying(event.target.ship);
+            this.view.card_playing.setShip(event.target.ship);
+            this.view.action_bar.setShip(event.target.ship);
+        }
+
+        // Damage to ship
+        private processDamageEvent(event: Game.DamageEvent) {
+            var sprite = this.view.arena.findShipSprite(event.ship);
+            if (sprite) {
+                sprite.displayDamage(event.hull, event.shield);
+            }
+        }
+
+        // Ship moved
+        private processMoveEvent(event: Game.MoveEvent) {
+            var sprite = this.view.arena.findShipSprite(event.ship);
+            if (sprite) {
+                sprite.moveTo(event.target.x, event.target.y, event.facing_angle, true);
+            }
+        }
+
+        // Ship attribute changed
+        private processAttributeChangedEvent(event: Game.AttributeChangeEvent) {
+            var item = this.view.ship_list.findItem(event.ship);
+            if (item) {
+                item.attributeChanged(event.attribute);
+            }
+        }
     }
 }