Added unit testing for BattleView

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

@@ -1,4 +1,5 @@
 /// <reference path="../../definitions/jasmine.d.ts"/>
+/// <reference path="../events/BaseLogEvent.ts"/>
 
 module SpaceTac.Game {
     "use strict";

src/scripts/view/battle/BattleView.ts

@@ -142,8 +142,12 @@ module SpaceTac.View {
         setShipHovered(ship: Game.Ship): void {
             this.ship_hovered = ship;
             this.card_hovered.setShip(ship);
-            if (this.targetting && ship) {
-                this.targetting.setTargetShip(ship);
+            if (this.targetting) {
+                if (ship) {
+                    this.targetting.setTargetShip(ship);
+                } else {
+                    this.targetting.unsetTarget();
+                }
             }
         }
 

src/scripts/view/battle/Targetting.ts

@@ -4,6 +4,9 @@ module SpaceTac.View {
     // Targetting system
     //  Allows to pick a target for an action
     export class Targetting {
+        // Current target
+        target: Game.Target;
+
         // Signal to receive hovering events
         targetHovered: Phaser.Signal;
 
@@ -19,9 +22,6 @@ module SpaceTac.View {
         // Source of the targetting
         private source: PIXI.Sprite;
 
-        // Current target
-        private target: Game.Target;
-
         // Create a default targetting mode
         constructor(battleview: BattleView) {
             this.battleview = battleview;

src/scripts/view/specs/BattleView.spec.ts

@@ -0,0 +1,103 @@
+/// <reference path="../../definitions/jasmine.d.ts"/>
+/// <reference path="TestGame.ts"/>
+/// <reference path="../battle/BattleView.ts"/>
+
+module SpaceTac.View.Specs {
+    "use strict";
+
+    export function inbattleview_it(desc: string, func: (battleview: BattleView) => void) {
+        var battleview = new BattleView();
+        var battle = Game.Battle.newQuickRandom();
+        var player = battle.fleets[0].player;
+        ingame_it(desc, (game: Phaser.Game, state: Phaser.State) => {
+            func(battleview);
+        }, battleview, player, battle);
+    }
+
+    describe("BattleView", () => {
+        inbattleview_it("forwards events in targetting mode", (battleview: BattleView) => {
+            expect(battleview.targetting).toBeNull();
+
+            battleview.cursorInSpace(5, 5);
+
+            expect(battleview.targetting).toBeNull();
+
+            // Enter targetting mode
+            var result = battleview.enterTargettingMode();
+
+            expect(battleview.targetting).toBeTruthy();
+            expect(result).toBe(battleview.targetting);
+
+            // Collect targetting events
+            var hovered = [];
+            var clicked = [];
+            result.targetHovered.add((target: Game.Target) => {
+                hovered.push(target);
+            });
+            result.targetSelected.add((target: Game.Target) => {
+                clicked.push(target);
+            });
+
+            // Forward selection in space
+            battleview.cursorInSpace(8, 4);
+
+            expect(battleview.ship_hovered).toBeNull();
+            expect(battleview.targetting.target).toEqual(Game.Target.newFromLocation(8, 4));
+
+            // Process a click on space
+            battleview.cursorClicked();
+
+            // Forward ship hovering
+            battleview.cursorOnShip(battleview.battle.play_order[0]);
+
+            expect(battleview.ship_hovered).toEqual(battleview.battle.playing_ship);
+            expect(battleview.targetting.target).toEqual(Game.Target.newFromShip(battleview.battle.playing_ship));
+
+            // Don't leave a ship we're not hovering
+            battleview.cursorOffShip(battleview.battle.play_order[1]);
+
+            expect(battleview.ship_hovered).toEqual(battleview.battle.playing_ship);
+            expect(battleview.targetting.target).toEqual(Game.Target.newFromShip(battleview.battle.playing_ship));
+
+            // Don't move in space while on ship
+            battleview.cursorInSpace(1, 3);
+
+            expect(battleview.ship_hovered).toEqual(battleview.battle.playing_ship);
+            expect(battleview.targetting.target).toEqual(Game.Target.newFromShip(battleview.battle.playing_ship));
+
+            // Process a click on ship
+            battleview.cursorClicked();
+
+            // Leave the ship
+            battleview.cursorOffShip(battleview.battle.play_order[0]);
+
+            expect(battleview.ship_hovered).toBeNull();
+            expect(battleview.targetting.target).toBeNull();
+
+            // Quit targetting
+            battleview.exitTargettingMode();
+
+            expect(battleview.targetting).toBeNull();
+
+            // Events process normally
+            battleview.cursorInSpace(8, 4);
+            expect(battleview.ship_hovered).toBeNull();
+            battleview.cursorOnShip(battleview.battle.play_order[0]);
+            expect(battleview.ship_hovered).toEqual(battleview.battle.playing_ship);
+
+            // Quit twice don't do anything
+            battleview.exitTargettingMode();
+
+            // Check collected targetting events
+            expect(hovered).toEqual([
+                Game.Target.newFromLocation(8, 4),
+                Game.Target.newFromShip(battleview.battle.playing_ship),
+                null
+            ]);
+            expect(clicked).toEqual([
+                Game.Target.newFromLocation(8, 4),
+                Game.Target.newFromShip(battleview.battle.playing_ship),
+            ]);
+        });
+    });
+}

src/scripts/view/specs/TestGame.ts

@@ -3,29 +3,28 @@
 module SpaceTac.View.Specs {
     "use strict";
 
-    // Internal test state for Phaser
-    class TestState extends Phaser.State {
-        private testfunc: (game: Phaser.Game) => void;
-        private donefunc: () => void;
-
-        init(testfunc: (game: Phaser.Game) => void, donefunc: () => void) {
-            this.testfunc = testfunc;
-            this.donefunc = donefunc;
-        }
-
-        create() {
-            this.testfunc(this.game);
-            this.game.destroy();
-            this.donefunc();
-        }
-    }
-
     // Test game wrapper (use instead of jasmine 'it')
-    export function ingame_it(desc: string, func: (game: Phaser.Game) => void) {
+    export function ingame_it(desc: string, func: (game: Phaser.Game, state: Phaser.State) => void,
+                              state: Phaser.State = null, ...stateargs: any[]) {
         it(desc, (done: () => void) => {
             var game = new Phaser.Game(500, 500, Phaser.HEADLESS);
-            game.state.add("main", TestState);
-            game.state.start("main", true, true, func, done);
+
+            if (!state) {
+                state = new Phaser.State();
+            }
+
+            var orig_create = state.create;
+            state.create = function() {
+                orig_create.apply(state);
+                func(game, state);
+                done();
+            };
+
+            game.state.add("test", state);
+            stateargs.unshift(true);
+            stateargs.unshift(true);
+            stateargs.unshift("test");
+            game.state.start.apply(game.state, stateargs);
         });
     }
 }