2017-02-09 00:00:35 +00:00
|
|
|
module TS.SpaceTac.Specs {
|
2015-01-07 00:00:00 +00:00
|
|
|
describe("Ship", function () {
|
2015-01-29 00:00:00 +00:00
|
|
|
it("moves and computes facing angle", function () {
|
2014-12-31 00:00:00 +00:00
|
|
|
var ship = new Ship(null, "Test");
|
2015-01-29 00:00:00 +00:00
|
|
|
ship.setArenaFacingAngle(0);
|
2014-12-31 00:00:00 +00:00
|
|
|
ship.setArenaPosition(50, 50);
|
|
|
|
|
2015-01-29 00:00:00 +00:00
|
|
|
expect(ship.arena_x).toEqual(50);
|
|
|
|
expect(ship.arena_y).toEqual(50);
|
|
|
|
expect(ship.arena_angle).toEqual(0);
|
2014-12-31 00:00:00 +00:00
|
|
|
|
|
|
|
ship.moveTo(51, 50);
|
|
|
|
expect(ship.arena_x).toEqual(51);
|
|
|
|
expect(ship.arena_y).toEqual(50);
|
2015-01-29 00:00:00 +00:00
|
|
|
expect(ship.arena_angle).toEqual(0);
|
2015-01-26 00:00:00 +00:00
|
|
|
|
|
|
|
ship.moveTo(50, 50);
|
2015-01-29 00:00:00 +00:00
|
|
|
expect(ship.arena_angle).toBeCloseTo(3.14159265, 0.00001);
|
2015-01-26 00:00:00 +00:00
|
|
|
|
|
|
|
ship.moveTo(51, 51);
|
|
|
|
expect(ship.arena_angle).toBeCloseTo(0.785398, 0.00001);
|
|
|
|
|
|
|
|
ship.moveTo(51, 52);
|
|
|
|
expect(ship.arena_angle).toBeCloseTo(1.5707963, 0.00001);
|
|
|
|
|
|
|
|
ship.moveTo(52, 52);
|
2015-01-29 00:00:00 +00:00
|
|
|
expect(ship.arena_x).toEqual(52);
|
|
|
|
expect(ship.arena_y).toEqual(52);
|
2015-01-26 00:00:00 +00:00
|
|
|
expect(ship.arena_angle).toEqual(0);
|
|
|
|
|
|
|
|
ship.moveTo(52, 50);
|
|
|
|
expect(ship.arena_angle).toBeCloseTo(-1.5707963, 0.00001);
|
|
|
|
|
|
|
|
ship.moveTo(50, 50);
|
|
|
|
expect(ship.arena_angle).toBeCloseTo(3.14159265, 0.00001);
|
|
|
|
});
|
|
|
|
|
2017-05-16 23:12:05 +00:00
|
|
|
it("applies equipment cooldown", function () {
|
|
|
|
let ship = new Ship();
|
|
|
|
let equipment = new Equipment(SlotType.Weapon);
|
|
|
|
equipment.cooldown.configure(1, 1);
|
|
|
|
ship.addSlot(SlotType.Weapon).attach(equipment);
|
|
|
|
|
|
|
|
expect(equipment.cooldown.canUse()).toBe(true, 1);
|
|
|
|
equipment.cooldown.use();
|
|
|
|
expect(equipment.cooldown.canUse()).toBe(false, 2);
|
|
|
|
|
|
|
|
ship.startBattle();
|
|
|
|
expect(equipment.cooldown.canUse()).toBe(true, 3);
|
|
|
|
|
|
|
|
ship.startTurn();
|
|
|
|
equipment.cooldown.use();
|
|
|
|
expect(equipment.cooldown.canUse()).toBe(false, 4);
|
|
|
|
ship.endTurn();
|
|
|
|
expect(equipment.cooldown.canUse()).toBe(false, 5);
|
|
|
|
|
|
|
|
ship.startTurn();
|
|
|
|
expect(equipment.cooldown.canUse()).toBe(false, 6);
|
|
|
|
ship.endTurn();
|
|
|
|
expect(equipment.cooldown.canUse()).toBe(true, 7);
|
|
|
|
});
|
|
|
|
|
2015-01-16 00:00:00 +00:00
|
|
|
it("lists available actions from attached equipment", function () {
|
|
|
|
var ship = new Ship(null, "Test");
|
|
|
|
var actions: BaseAction[];
|
|
|
|
var slot: Slot;
|
|
|
|
var equipment: Equipment;
|
|
|
|
|
|
|
|
actions = ship.getAvailableActions();
|
|
|
|
expect(actions.length).toBe(1);
|
|
|
|
expect(actions[0].code).toEqual("endturn");
|
|
|
|
|
|
|
|
slot = ship.addSlot(SlotType.Engine);
|
|
|
|
equipment = new Equipment();
|
2017-04-18 19:51:23 +00:00
|
|
|
equipment.slot_type = slot.type;
|
2015-01-28 00:00:00 +00:00
|
|
|
equipment.action = new MoveAction(equipment);
|
2015-01-16 00:00:00 +00:00
|
|
|
slot.attach(equipment);
|
|
|
|
|
2017-03-09 18:43:24 +00:00
|
|
|
slot = ship.addSlot(SlotType.Weapon);
|
|
|
|
equipment = new Equipment();
|
2017-04-18 19:51:23 +00:00
|
|
|
equipment.slot_type = slot.type;
|
2017-03-09 18:43:24 +00:00
|
|
|
slot.attach(equipment);
|
|
|
|
|
2015-01-16 00:00:00 +00:00
|
|
|
actions = ship.getAvailableActions();
|
|
|
|
expect(actions.length).toBe(2);
|
|
|
|
expect(actions[0].code).toEqual("move");
|
|
|
|
expect(actions[1].code).toEqual("endturn");
|
|
|
|
});
|
2015-01-22 00:00:00 +00:00
|
|
|
|
|
|
|
it("applies permanent effects of equipments on attributes", function () {
|
|
|
|
var ship = new Ship(null, "Test");
|
|
|
|
var slot: Slot;
|
|
|
|
var equipment: Equipment;
|
|
|
|
|
|
|
|
slot = ship.addSlot(SlotType.Power);
|
|
|
|
equipment = new Equipment();
|
2017-04-18 19:51:23 +00:00
|
|
|
equipment.slot_type = slot.type;
|
|
|
|
equipment.effects.push(new AttributeEffect("power_capacity", 4));
|
2015-01-22 00:00:00 +00:00
|
|
|
slot.attach(equipment);
|
|
|
|
|
|
|
|
slot = ship.addSlot(SlotType.Power);
|
|
|
|
equipment = new Equipment();
|
2017-04-18 19:51:23 +00:00
|
|
|
equipment.slot_type = slot.type;
|
|
|
|
equipment.effects.push(new AttributeEffect("power_capacity", 5));
|
2015-01-22 00:00:00 +00:00
|
|
|
slot.attach(equipment);
|
|
|
|
|
|
|
|
ship.updateAttributes();
|
2017-02-07 19:15:21 +00:00
|
|
|
expect(ship.attributes.power_capacity.get()).toBe(9);
|
2015-01-22 00:00:00 +00:00
|
|
|
});
|
2015-01-28 00:00:00 +00:00
|
|
|
|
|
|
|
it("repairs hull and recharges shield", function () {
|
|
|
|
var ship = new Ship(null, "Test");
|
|
|
|
|
2017-02-07 19:15:21 +00:00
|
|
|
ship.setAttribute("hull_capacity", 120);
|
|
|
|
ship.setAttribute("shield_capacity", 150);
|
2015-01-28 00:00:00 +00:00
|
|
|
|
2017-02-07 19:15:21 +00:00
|
|
|
expect(ship.values.hull.get()).toEqual(0);
|
|
|
|
expect(ship.values.shield.get()).toEqual(0);
|
2015-01-28 00:00:00 +00:00
|
|
|
|
|
|
|
ship.restoreHealth();
|
|
|
|
|
2017-02-07 19:15:21 +00:00
|
|
|
expect(ship.values.hull.get()).toEqual(120);
|
|
|
|
expect(ship.values.shield.get()).toEqual(150);
|
2015-01-28 00:00:00 +00:00
|
|
|
});
|
2015-02-03 00:00:00 +00:00
|
|
|
|
|
|
|
it("applies and logs hull and shield damage", function () {
|
|
|
|
var fleet = new Fleet();
|
|
|
|
var battle = new Battle(fleet);
|
|
|
|
var ship = new Ship(fleet);
|
|
|
|
|
2017-04-24 17:59:16 +00:00
|
|
|
TestTools.setShipHP(ship, 150, 400);
|
2015-02-03 00:00:00 +00:00
|
|
|
ship.restoreHealth();
|
|
|
|
battle.log.clear();
|
|
|
|
|
|
|
|
ship.addDamage(10, 20);
|
2017-04-24 17:59:16 +00:00
|
|
|
expect(ship.values.hull.get()).toEqual(140);
|
|
|
|
expect(ship.values.shield.get()).toEqual(380);
|
2015-02-03 00:00:00 +00:00
|
|
|
expect(battle.log.events.length).toBe(3);
|
2017-02-12 22:18:36 +00:00
|
|
|
expect(battle.log.events[0]).toEqual(new ValueChangeEvent(ship, ship.values.shield, -20));
|
|
|
|
expect(battle.log.events[1]).toEqual(new ValueChangeEvent(ship, ship.values.hull, -10));
|
2015-02-03 00:00:00 +00:00
|
|
|
expect(battle.log.events[2]).toEqual(new DamageEvent(ship, 10, 20));
|
|
|
|
|
|
|
|
battle.log.clear();
|
|
|
|
|
|
|
|
ship.addDamage(15, 25, false);
|
2017-04-24 17:59:16 +00:00
|
|
|
expect(ship.values.hull.get()).toEqual(125);
|
|
|
|
expect(ship.values.shield.get()).toEqual(355);
|
2015-02-03 00:00:00 +00:00
|
|
|
expect(battle.log.events.length).toBe(0);
|
2017-04-24 17:59:16 +00:00
|
|
|
|
|
|
|
ship.addDamage(125, 355, false);
|
|
|
|
expect(ship.values.hull.get()).toEqual(0);
|
|
|
|
expect(ship.values.shield.get()).toEqual(0);
|
|
|
|
expect(ship.alive).toBe(false);
|
2015-02-03 00:00:00 +00:00
|
|
|
});
|
2015-02-06 00:00:00 +00:00
|
|
|
|
2017-01-23 23:07:54 +00:00
|
|
|
it("sets and logs sticky effects", function () {
|
2015-02-27 00:00:00 +00:00
|
|
|
var ship = new Ship();
|
|
|
|
var battle = new Battle(ship.fleet);
|
|
|
|
|
2017-01-24 00:14:04 +00:00
|
|
|
ship.addStickyEffect(new StickyEffect(new BaseEffect("test"), 2, false, true));
|
2015-02-27 00:00:00 +00:00
|
|
|
|
2017-01-24 00:14:04 +00:00
|
|
|
expect(ship.sticky_effects).toEqual([new StickyEffect(new BaseEffect("test"), 2, false, true)]);
|
2015-02-27 00:00:00 +00:00
|
|
|
expect(battle.log.events).toEqual([
|
2017-01-24 00:14:04 +00:00
|
|
|
new EffectAddedEvent(ship, new StickyEffect(new BaseEffect("test"), 2, false, true))
|
2015-02-27 00:00:00 +00:00
|
|
|
]);
|
|
|
|
|
2017-01-20 00:02:18 +00:00
|
|
|
ship.startTurn();
|
2015-02-27 00:00:00 +00:00
|
|
|
battle.log.clear();
|
|
|
|
ship.endTurn();
|
|
|
|
|
2017-01-24 00:14:04 +00:00
|
|
|
expect(ship.sticky_effects).toEqual([new StickyEffect(new BaseEffect("test"), 1, false, true)]);
|
2015-02-27 00:00:00 +00:00
|
|
|
expect(battle.log.events).toEqual([
|
2017-01-24 00:14:04 +00:00
|
|
|
new EffectDurationChangedEvent(ship, new StickyEffect(new BaseEffect("test"), 1, false, true), 2)
|
2015-02-27 00:00:00 +00:00
|
|
|
]);
|
|
|
|
|
2017-01-20 00:02:18 +00:00
|
|
|
ship.startTurn();
|
2015-02-27 00:00:00 +00:00
|
|
|
battle.log.clear();
|
|
|
|
ship.endTurn();
|
|
|
|
|
2017-01-23 23:07:54 +00:00
|
|
|
expect(ship.sticky_effects).toEqual([]);
|
2015-02-27 00:00:00 +00:00
|
|
|
expect(battle.log.events).toEqual([
|
2017-01-24 00:14:04 +00:00
|
|
|
new EffectDurationChangedEvent(ship, new StickyEffect(new BaseEffect("test"), 0, false, true), 1),
|
|
|
|
new EffectRemovedEvent(ship, new StickyEffect(new BaseEffect("test"), 0, false, true))
|
2015-02-27 00:00:00 +00:00
|
|
|
]);
|
|
|
|
|
2017-01-20 00:02:18 +00:00
|
|
|
ship.startTurn();
|
2015-02-27 00:00:00 +00:00
|
|
|
battle.log.clear();
|
|
|
|
ship.endTurn();
|
|
|
|
|
2017-01-23 23:07:54 +00:00
|
|
|
expect(ship.sticky_effects).toEqual([]);
|
2015-02-27 00:00:00 +00:00
|
|
|
expect(battle.log.events).toEqual([]);
|
|
|
|
});
|
|
|
|
|
2015-02-06 00:00:00 +00:00
|
|
|
it("sets and logs death state", function () {
|
2015-02-06 00:00:00 +00:00
|
|
|
var fleet = new Fleet();
|
|
|
|
var battle = new Battle(fleet);
|
|
|
|
var ship = new Ship(fleet);
|
|
|
|
|
|
|
|
expect(ship.alive).toBe(true);
|
|
|
|
|
2017-02-07 19:15:21 +00:00
|
|
|
ship.values.hull.set(10);
|
2015-02-06 00:00:00 +00:00
|
|
|
battle.log.clear();
|
|
|
|
ship.addDamage(5, 0);
|
|
|
|
|
|
|
|
expect(ship.alive).toBe(true);
|
|
|
|
expect(battle.log.events.length).toBe(2);
|
2017-02-07 19:15:21 +00:00
|
|
|
expect(battle.log.events[0].code).toEqual("value");
|
2015-02-06 00:00:00 +00:00
|
|
|
expect(battle.log.events[1].code).toEqual("damage");
|
|
|
|
|
|
|
|
battle.log.clear();
|
|
|
|
ship.addDamage(5, 0);
|
|
|
|
|
|
|
|
expect(ship.alive).toBe(false);
|
|
|
|
expect(battle.log.events.length).toBe(3);
|
2017-02-07 19:15:21 +00:00
|
|
|
expect(battle.log.events[0].code).toEqual("value");
|
2015-02-06 00:00:00 +00:00
|
|
|
expect(battle.log.events[1].code).toEqual("damage");
|
|
|
|
expect(battle.log.events[2].code).toEqual("death");
|
|
|
|
});
|
|
|
|
|
|
|
|
it("checks if a ship is able to play", function () {
|
|
|
|
var ship = new Ship();
|
|
|
|
|
|
|
|
expect(ship.isAbleToPlay()).toBe(false);
|
|
|
|
expect(ship.isAbleToPlay(false)).toBe(true);
|
|
|
|
|
2017-02-07 19:15:21 +00:00
|
|
|
ship.values.power.set(5);
|
2015-02-06 00:00:00 +00:00
|
|
|
|
|
|
|
expect(ship.isAbleToPlay()).toBe(true);
|
|
|
|
expect(ship.isAbleToPlay(false)).toBe(true);
|
|
|
|
|
2017-02-07 19:15:21 +00:00
|
|
|
ship.values.hull.set(10);
|
2015-02-06 00:00:00 +00:00
|
|
|
ship.addDamage(8, 0);
|
|
|
|
|
|
|
|
expect(ship.isAbleToPlay()).toBe(true);
|
|
|
|
expect(ship.isAbleToPlay(false)).toBe(true);
|
|
|
|
|
|
|
|
ship.addDamage(8, 0);
|
|
|
|
|
|
|
|
expect(ship.isAbleToPlay()).toBe(false);
|
|
|
|
expect(ship.isAbleToPlay(false)).toBe(false);
|
|
|
|
});
|
2015-02-13 00:00:00 +00:00
|
|
|
|
|
|
|
it("counts attached equipment", function () {
|
|
|
|
var ship = new Ship();
|
|
|
|
|
|
|
|
expect(ship.getEquipmentCount()).toBe(0);
|
|
|
|
|
2017-03-05 14:12:08 +00:00
|
|
|
ship.addSlot(SlotType.Hull).attach(new Equipment(SlotType.Hull));
|
2015-02-13 00:00:00 +00:00
|
|
|
ship.addSlot(SlotType.Shield);
|
|
|
|
ship.addSlot(SlotType.Weapon).attach(new Equipment(SlotType.Weapon));
|
|
|
|
|
|
|
|
expect(ship.getEquipmentCount()).toBe(2);
|
|
|
|
});
|
|
|
|
|
|
|
|
it("can pick a random attached equipment", function () {
|
|
|
|
var ship = new Ship();
|
|
|
|
|
|
|
|
expect(ship.getRandomEquipment()).toBe(null);
|
|
|
|
|
2017-03-05 14:12:08 +00:00
|
|
|
ship.addSlot(SlotType.Hull).attach(new Equipment(SlotType.Hull));
|
2015-02-13 00:00:00 +00:00
|
|
|
ship.addSlot(SlotType.Shield);
|
|
|
|
ship.addSlot(SlotType.Weapon).attach(new Equipment(SlotType.Weapon));
|
|
|
|
|
2017-02-26 17:44:15 +00:00
|
|
|
var random = new SkewedRandomGenerator([0.2]);
|
2015-02-13 00:00:00 +00:00
|
|
|
var picked = ship.getRandomEquipment(random);
|
|
|
|
expect(picked).not.toBeNull();
|
|
|
|
expect(picked).toBe(ship.slots[0].attached);
|
|
|
|
|
2017-02-26 17:44:15 +00:00
|
|
|
random = new SkewedRandomGenerator([0.999999]);
|
2015-02-13 00:00:00 +00:00
|
|
|
picked = ship.getRandomEquipment(random);
|
|
|
|
expect(picked).not.toBeNull();
|
|
|
|
expect(picked).toBe(ship.slots[2].attached);
|
|
|
|
});
|
2017-01-12 00:36:34 +00:00
|
|
|
|
|
|
|
it("recover action points at end of turn", function () {
|
|
|
|
var ship = new Ship();
|
|
|
|
|
2017-04-18 19:51:23 +00:00
|
|
|
let power_generator = new Equipment(SlotType.Power);
|
|
|
|
power_generator.effects = [
|
|
|
|
new AttributeEffect("power_capacity", 8),
|
|
|
|
new AttributeEffect("power_recovery", 3),
|
|
|
|
new AttributeEffect("power_initial", 4)
|
|
|
|
]
|
|
|
|
ship.addSlot(SlotType.Power).attach(power_generator);
|
2017-01-12 00:36:34 +00:00
|
|
|
|
2017-02-07 19:15:21 +00:00
|
|
|
expect(ship.values.power.get()).toBe(0);
|
2017-01-12 00:36:34 +00:00
|
|
|
ship.initializeActionPoints();
|
2017-02-16 00:17:09 +00:00
|
|
|
expect(ship.values.power.get()).toBe(4);
|
|
|
|
ship.values.power.set(3);
|
|
|
|
expect(ship.values.power.get()).toBe(3);
|
2017-01-20 00:02:18 +00:00
|
|
|
ship.recoverActionPoints();
|
2017-02-07 19:15:21 +00:00
|
|
|
expect(ship.values.power.get()).toBe(6);
|
2017-01-20 00:02:18 +00:00
|
|
|
ship.recoverActionPoints();
|
2017-02-07 19:15:21 +00:00
|
|
|
expect(ship.values.power.get()).toBe(8);
|
2017-01-12 00:36:34 +00:00
|
|
|
});
|
2017-02-06 21:46:55 +00:00
|
|
|
|
|
|
|
it("checks if a ship is inside a given circle", function () {
|
|
|
|
let ship = new Ship();
|
|
|
|
ship.arena_x = 5;
|
|
|
|
ship.arena_y = 8;
|
|
|
|
|
|
|
|
expect(ship.isInCircle(5, 8, 0)).toBe(true);
|
|
|
|
expect(ship.isInCircle(5, 8, 1)).toBe(true);
|
|
|
|
expect(ship.isInCircle(5, 7, 1)).toBe(true);
|
|
|
|
expect(ship.isInCircle(6, 9, 1.7)).toBe(true);
|
|
|
|
expect(ship.isInCircle(5, 8.1, 0)).toBe(false);
|
|
|
|
expect(ship.isInCircle(5, 7, 0.9)).toBe(false);
|
|
|
|
expect(ship.isInCircle(12, -4, 5)).toBe(false);
|
|
|
|
});
|
2017-02-08 00:47:18 +00:00
|
|
|
|
2017-03-05 23:29:02 +00:00
|
|
|
it("stores items in cargo space", function () {
|
|
|
|
let ship = new Ship();
|
|
|
|
let equipment1 = new Equipment();
|
|
|
|
let equipment2 = new Equipment();
|
|
|
|
|
|
|
|
let result = ship.addCargo(equipment1);
|
|
|
|
expect(result).toBe(false);
|
|
|
|
expect(ship.cargo).toEqual([]);
|
2017-03-22 21:16:59 +00:00
|
|
|
expect(ship.getFreeCargoSpace()).toBe(0);
|
2017-03-05 23:29:02 +00:00
|
|
|
|
|
|
|
ship.setCargoSpace(1);
|
2017-03-22 21:16:59 +00:00
|
|
|
expect(ship.getFreeCargoSpace()).toBe(1);
|
2017-03-05 23:29:02 +00:00
|
|
|
|
|
|
|
result = ship.addCargo(equipment1);
|
|
|
|
expect(result).toBe(true);
|
|
|
|
expect(ship.cargo).toEqual([equipment1]);
|
2017-03-22 21:16:59 +00:00
|
|
|
expect(ship.getFreeCargoSpace()).toBe(0);
|
2017-03-05 23:29:02 +00:00
|
|
|
|
|
|
|
result = ship.addCargo(equipment1);
|
|
|
|
expect(result).toBe(false);
|
|
|
|
expect(ship.cargo).toEqual([equipment1]);
|
|
|
|
|
|
|
|
result = ship.addCargo(equipment2);
|
|
|
|
expect(result).toBe(false);
|
|
|
|
expect(ship.cargo).toEqual([equipment1]);
|
|
|
|
|
|
|
|
ship.setCargoSpace(2);
|
2017-03-22 21:16:59 +00:00
|
|
|
expect(ship.getFreeCargoSpace()).toBe(1);
|
2017-03-05 23:29:02 +00:00
|
|
|
|
|
|
|
result = ship.addCargo(equipment2);
|
|
|
|
expect(result).toBe(true);
|
|
|
|
expect(ship.cargo).toEqual([equipment1, equipment2]);
|
2017-03-22 21:16:59 +00:00
|
|
|
expect(ship.getFreeCargoSpace()).toBe(0);
|
2017-03-05 23:29:02 +00:00
|
|
|
|
|
|
|
ship.setCargoSpace(1);
|
|
|
|
expect(ship.cargo).toEqual([equipment1]);
|
2017-03-22 21:16:59 +00:00
|
|
|
expect(ship.getFreeCargoSpace()).toBe(0);
|
2017-03-05 23:29:02 +00:00
|
|
|
|
|
|
|
ship.setCargoSpace(2);
|
|
|
|
expect(ship.cargo).toEqual([equipment1]);
|
2017-03-22 21:16:59 +00:00
|
|
|
expect(ship.getFreeCargoSpace()).toBe(1);
|
2017-03-05 23:29:02 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
it("equips items from cargo", function () {
|
|
|
|
let ship = new Ship();
|
|
|
|
let equipment = new Equipment(SlotType.Weapon);
|
|
|
|
let slot = ship.addSlot(SlotType.Weapon);
|
|
|
|
expect(ship.listEquipment()).toEqual([]);
|
|
|
|
|
|
|
|
let result = ship.equip(equipment);
|
|
|
|
expect(result).toBe(false);
|
|
|
|
expect(ship.listEquipment()).toEqual([]);
|
|
|
|
|
|
|
|
ship.setCargoSpace(1);
|
|
|
|
ship.addCargo(equipment);
|
|
|
|
|
|
|
|
result = ship.equip(equipment);
|
|
|
|
expect(result).toBe(true);
|
|
|
|
expect(ship.listEquipment(SlotType.Weapon)).toEqual([equipment]);
|
|
|
|
expect(equipment.attached_to).toEqual(slot);
|
|
|
|
});
|
|
|
|
|
|
|
|
it("removes equipped items", function () {
|
|
|
|
let ship = new Ship();
|
|
|
|
let equipment = new Equipment(SlotType.Weapon);
|
|
|
|
let slot = ship.addSlot(SlotType.Weapon);
|
|
|
|
slot.attach(equipment);
|
|
|
|
|
|
|
|
expect(ship.listEquipment()).toEqual([equipment]);
|
|
|
|
expect(slot.attached).toBe(equipment);
|
|
|
|
expect(equipment.attached_to).toBe(slot);
|
|
|
|
|
|
|
|
let result = ship.unequip(equipment);
|
|
|
|
expect(result).toBe(false);
|
|
|
|
expect(ship.listEquipment()).toEqual([equipment]);
|
|
|
|
expect(ship.cargo).toEqual([]);
|
|
|
|
|
|
|
|
ship.setCargoSpace(10);
|
|
|
|
|
|
|
|
result = ship.unequip(equipment);
|
|
|
|
expect(result).toBe(true);
|
|
|
|
expect(ship.listEquipment()).toEqual([]);
|
|
|
|
expect(ship.cargo).toEqual([equipment]);
|
|
|
|
expect(slot.attached).toBe(null);
|
|
|
|
expect(equipment.attached_to).toBe(null);
|
|
|
|
|
|
|
|
result = ship.unequip(equipment);
|
|
|
|
expect(result).toBe(false);
|
|
|
|
expect(ship.listEquipment()).toEqual([]);
|
|
|
|
expect(ship.cargo).toEqual([equipment]);
|
|
|
|
});
|
2017-03-17 00:07:00 +00:00
|
|
|
|
2017-04-25 18:24:43 +00:00
|
|
|
it("checks equipment requirements", function () {
|
|
|
|
let ship = new Ship();
|
|
|
|
let equipment = new Equipment(SlotType.Hull);
|
|
|
|
expect(ship.canEquip(equipment)).toBe(null);
|
|
|
|
|
|
|
|
ship.addSlot(SlotType.Engine);
|
|
|
|
expect(ship.canEquip(equipment)).toBe(null);
|
|
|
|
|
|
|
|
let slot = ship.addSlot(SlotType.Hull);
|
|
|
|
expect(ship.canEquip(equipment)).toBe(slot);
|
|
|
|
|
|
|
|
equipment.requirements["skill_energy"] = 2;
|
|
|
|
expect(ship.canEquip(equipment)).toBe(null);
|
|
|
|
|
|
|
|
ship.upgradeSkill("skill_energy");
|
|
|
|
expect(ship.canEquip(equipment)).toBe(null);
|
|
|
|
|
|
|
|
ship.upgradeSkill("skill_energy");
|
|
|
|
expect(ship.canEquip(equipment)).toBe(slot);
|
|
|
|
|
|
|
|
slot.attach(new Equipment(SlotType.Hull));
|
|
|
|
expect(ship.canEquip(equipment)).toBe(null);
|
|
|
|
});
|
|
|
|
|
2017-03-17 00:07:00 +00:00
|
|
|
it("allow skills upgrading from current level", function () {
|
|
|
|
let ship = new Ship();
|
|
|
|
expect(ship.level.get()).toBe(1);
|
|
|
|
expect(ship.getAvailableUpgradePoints()).toBe(10);
|
|
|
|
|
|
|
|
ship.level.forceLevel(2);
|
|
|
|
expect(ship.level.get()).toBe(2);
|
|
|
|
expect(ship.getAvailableUpgradePoints()).toBe(15);
|
|
|
|
|
|
|
|
expect(ship.getAttribute("skill_energy")).toBe(0);
|
|
|
|
ship.upgradeSkill("skill_energy");
|
|
|
|
expect(ship.getAttribute("skill_energy")).toBe(1);
|
|
|
|
|
|
|
|
range(50).forEach(() => ship.upgradeSkill("skill_gravity"));
|
|
|
|
expect(ship.getAttribute("skill_energy")).toBe(1);
|
|
|
|
expect(ship.getAttribute("skill_gravity")).toBe(14);
|
|
|
|
expect(ship.getAvailableUpgradePoints()).toBe(0);
|
|
|
|
|
|
|
|
ship.updateAttributes();
|
|
|
|
expect(ship.getAttribute("skill_energy")).toBe(1);
|
|
|
|
expect(ship.getAttribute("skill_gravity")).toBe(14);
|
|
|
|
});
|
2017-05-10 17:16:57 +00:00
|
|
|
|
|
|
|
it("restores as new at the end of battle", function () {
|
|
|
|
let ship = new Ship();
|
|
|
|
TestTools.setShipHP(ship, 10, 20);
|
|
|
|
TestTools.setShipAP(ship, 5, 0);
|
|
|
|
ship.addDamage(5, 5);
|
|
|
|
ship.addStickyEffect(new StickyEffect(new DamageEffect(10), 8));
|
|
|
|
ship.addStickyEffect(new StickyEffect(new AttributeLimitEffect("power_capacity", 3), 12));
|
|
|
|
ship.updateAttributes();
|
|
|
|
|
|
|
|
expect(ship.getValue("hull")).toEqual(5);
|
|
|
|
expect(ship.getValue("shield")).toEqual(15);
|
|
|
|
expect(ship.getValue("power")).toEqual(3);
|
|
|
|
expect(ship.sticky_effects.length).toEqual(2);
|
|
|
|
expect(ship.getAttribute("power_capacity")).toEqual(3);
|
|
|
|
|
|
|
|
ship.endBattle(1);
|
|
|
|
|
|
|
|
expect(ship.getValue("hull")).toEqual(10);
|
|
|
|
expect(ship.getValue("shield")).toEqual(20);
|
|
|
|
expect(ship.getValue("power")).toEqual(5);
|
|
|
|
expect(ship.sticky_effects.length).toEqual(0);
|
|
|
|
expect(ship.getAttribute("power_capacity")).toEqual(5);
|
|
|
|
});
|
2014-12-31 00:00:00 +00:00
|
|
|
});
|
2015-01-07 00:00:00 +00:00
|
|
|
}
|