Added target effects and basic weapon structure (WIP)

src/scripts/game/Equipment.ts

@@ -30,9 +30,13 @@ module SpaceTac.Game {
         // Permanent effects
         permanent_effects: BaseEffect[];
 
+        // Effects on target
+        target_effects: BaseEffect[];
+
         // Basic constructor
         constructor() {
             this.permanent_effects = [];
+            this.target_effects = [];
         }
     }
 }

src/scripts/game/LootTemplate.ts

@@ -22,9 +22,12 @@ module SpaceTac.Game {
         // Duration, in number of turns
         duration: IntegerRange;
 
-        // Effects
+        // Permanent effects (when attached to an equipment slot)
         permanent_effects: EffectTemplate[];
 
+        // Effects on target
+        target_effects: EffectTemplate[];
+
         // Action Points usage
         ap_usage: Range;
 
@@ -41,6 +44,7 @@ module SpaceTac.Game {
             this.ap_usage = new Range(0, 0);
             this.min_level = new IntegerRange(0, 0);
             this.permanent_effects = [];
+            this.target_effects = [];
         }
 
         // Generate a random equipment with this template
@@ -68,6 +72,9 @@ module SpaceTac.Game {
             this.permanent_effects.forEach((eff_template: EffectTemplate) => {
                 result.permanent_effects.push(eff_template.generateFixed(power));
             });
+            this.target_effects.forEach((eff_template: EffectTemplate) => {
+                result.target_effects.push(eff_template.generateFixed(power));
+            });
 
             return result;
         }
@@ -123,6 +130,13 @@ module SpaceTac.Game {
             this.permanent_effects.push(template);
         }
 
+        // Convenience function to add a "damage on target" effect
+        addDamageOnTargetEffect(min: number, max: number = null): void {
+            var template = new EffectTemplate(new DamageEffect(0));
+            template.addModifier("value", new Range(min, max));
+            this.target_effects.push(template);
+        }
+
         // Method to reimplement to assign an action to a generated equipment
         protected getActionForEquipment(equipment: Equipment): BaseAction {
             return null;

src/scripts/game/actions/FireWeaponAction.ts

@@ -0,0 +1,36 @@
+/// <reference path="BaseAction.ts"/>
+
+module SpaceTac.Game {
+    "use strict";
+
+    // Action to fire a weapon on another ship, or in space
+    export class FireWeaponAction extends BaseAction {
+        constructor() {
+            super("fire", true);
+        }
+
+        canBeUsed(battle: Battle, ship: Ship): boolean {
+            return ship.ap_current.current > 0;
+        }
+
+        checkLocationTarget(battle: Battle, ship: Ship, target: Target): Target {
+            // TODO In space targetting
+            return null;
+        }
+
+        checkShipTarget(battle: Battle, ship: Ship, target: Target): Target {
+            if (ship.getPlayer() === target.ship.getPlayer()) {
+                // No friendly fire
+                return null;
+            } else {
+                // TODO Limit by weapon range
+                return target;
+            }
+        }
+
+        protected customApply(battle: Battle, ship: Ship, target: Target): boolean {
+            // TODO
+            return false;
+        }
+    }
+}

src/scripts/game/effects/DamageEffect.ts

@@ -0,0 +1,17 @@
+/// <reference path="BaseEffect.ts"/>
+
+module SpaceTac.Game {
+    "use strict";
+
+    // Apply damage to a ship
+    export class DamageEffect extends BaseEffect {
+        // Base damage points
+        value: number;
+
+        constructor(value: number) {
+            super("damage");
+
+            this.value = value;
+        }
+    }
+}

src/scripts/game/equipments/AbstractWeapon.ts

@@ -0,0 +1,19 @@
+/// <reference path="../LootTemplate.ts"/>
+
+module SpaceTac.Game.Equipments {
+    "use strict";
+
+    // Base convenience class for weapons
+    export class AbstractWeapon extends LootTemplate {
+        constructor(name: string, min_damage: number, max_damage: number=null) {
+            super(SlotType.Weapon, name);
+
+            this.addDamageOnTargetEffect(min_damage, max_damage);
+        }
+
+        protected getActionForEquipment(equipment: Equipment): BaseAction {
+            var result = new FireWeaponAction();
+            return result;
+        }
+    }
+}

src/scripts/game/equipments/GatlingGun.ts

@@ -1,12 +1,12 @@
-/// <reference path="../LootTemplate.ts"/>
+/// <reference path="AbstractWeapon.ts"/>
 
 module SpaceTac.Game.Equipments {
     "use strict";
 
     // Equipment: Gatling Gun
-    export class GatlingGun extends LootTemplate {
+    export class GatlingGun extends AbstractWeapon {
         constructor() {
-            super(SlotType.Weapon, "Gatling Gun");
+            super("Gatling Gun", 10, 20);
 
             this.distance = new Range(20, 30);
             this.ap_usage = new Range(3, 4);

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

@@ -0,0 +1,22 @@
+/// <reference path="../../definitions/jasmine.d.ts"/>
+
+module SpaceTac.Game.Specs {
+    "use strict";
+
+    describe("AbstractWeapon", function () {
+        it("has fire action, and damage effects on target", function () {
+            var weapon = new Equipments.AbstractWeapon("Super Fire Weapon", 50, 60);
+
+            var equipment = weapon.generateFixed(0.1);
+            expect(equipment.target_effects.length).toBe(1);
+
+            var effect = <DamageEffect>equipment.target_effects[0];
+            expect(effect.code).toEqual("damage");
+            expect(effect.value).toEqual(51);
+
+            var action = equipment.action;
+            expect(action.code).toEqual("fire");
+            expect(action.needs_target).toBe(true);
+        });
+    });
+}

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

@@ -80,5 +80,16 @@ module SpaceTac.Game.Specs {
             expect(result.min).toBeCloseTo(0.25, 0.000001);
             expect(result.max).toBeCloseTo(0.5, 0.000001);
         });
+
+        it("adds damage on target effects", () => {
+            var template = new LootTemplate(SlotType.Weapon, "Bulletator");
+            template.addDamageOnTargetEffect(80, 120);
+
+            var result = template.generateFixed(0.5);
+            expect(result.target_effects.length).toBe(1);
+            var effect = <DamageEffect>result.target_effects[0];
+            expect(effect.code).toEqual("damage");
+            expect(effect.value).toEqual(100);
+        });
     });
 }

src/scripts/view/battle/Arena.ts

@@ -29,6 +29,7 @@ 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/common/Tools.ts

@@ -30,7 +30,6 @@ module SpaceTac.View {
             } else if (value - dest < -Math.PI) {
                 dest -= 2 * Math.PI;
             }
-            console.log(value, dest);
             var changes: Object = {};
             changes[property] = dest;
             tween.to(changes);