796 lines
26 KiB
TypeScript
796 lines
26 KiB
TypeScript
module TS.SpaceTac {
|
|
/**
|
|
* A single ship in a fleet
|
|
*/
|
|
export class Ship {
|
|
// Fleet this ship is a member of
|
|
fleet: Fleet
|
|
|
|
// Level of this ship
|
|
level = new ShipLevel()
|
|
skills = new ShipSkills()
|
|
|
|
// Name of the ship
|
|
name: string
|
|
|
|
// Code of the ShipModel used to create it
|
|
model: ShipModel
|
|
|
|
// Flag indicating if the ship is alive
|
|
alive: boolean
|
|
|
|
// Flag indicating that the ship is mission critical (escorted ship)
|
|
critical = false
|
|
|
|
// Position in the arena
|
|
arena_x: number
|
|
arena_y: number
|
|
|
|
// Facing direction in the arena
|
|
arena_angle: number
|
|
|
|
// Sticky effects that applies a given number of times
|
|
sticky_effects: StickyEffect[]
|
|
|
|
// List of slots, able to contain equipment
|
|
slots: Slot[]
|
|
|
|
// Cargo
|
|
cargo_space: number = 0
|
|
cargo: Equipment[] = []
|
|
|
|
// Ship attributes
|
|
attributes = new ShipAttributes()
|
|
|
|
// Ship values
|
|
values = new ShipValues()
|
|
|
|
// Boolean set to true if the ship is currently playing its turn
|
|
playing = false
|
|
|
|
// Priority in play_order
|
|
play_priority = 0;
|
|
|
|
// Create a new ship inside a fleet
|
|
constructor(fleet: Fleet | null = null, name = "unnamed", model = new ShipModel("default", "Default", 1, 0, false, 0)) {
|
|
this.fleet = fleet || new Fleet();
|
|
this.name = name;
|
|
this.alive = true;
|
|
this.sticky_effects = [];
|
|
this.slots = [];
|
|
|
|
this.arena_x = 0;
|
|
this.arena_y = 0;
|
|
this.arena_angle = 0;
|
|
|
|
this.fleet.addShip(this);
|
|
|
|
this.model = model;
|
|
this.setCargoSpace(model.cargo);
|
|
model.slots.forEach(slot => this.addSlot(slot));
|
|
}
|
|
|
|
/**
|
|
* Return the current location and angle of this ship
|
|
*/
|
|
get location(): ArenaLocationAngle {
|
|
return new ArenaLocationAngle(this.arena_x, this.arena_y, this.arena_angle);
|
|
}
|
|
|
|
/**
|
|
* Returns the full name of this ship
|
|
*/
|
|
getFullName(owner = true): string {
|
|
let result = `Level ${this.level.get()} ${this.name}`;
|
|
return owner ? `${this.fleet.player.name}'s ${result}` : result;
|
|
}
|
|
|
|
// Returns true if the ship is able to play
|
|
// If *check_ap* is true, ap_current=0 will make this function return false
|
|
isAbleToPlay(check_ap: boolean = true): boolean {
|
|
var ap_checked = !check_ap || this.values.power.get() > 0;
|
|
return this.alive && ap_checked;
|
|
}
|
|
|
|
// Set position in the arena
|
|
// This does not consumes action points
|
|
setArenaPosition(x: number, y: number) {
|
|
this.arena_x = x;
|
|
this.arena_y = y;
|
|
}
|
|
|
|
// Set facing angle in the arena
|
|
setArenaFacingAngle(angle: number) {
|
|
this.arena_angle = angle;
|
|
}
|
|
|
|
// String repr
|
|
jasmineToString(): string {
|
|
return "Ship " + this.name;
|
|
}
|
|
|
|
// Make an initiative throw, to resolve play order in a battle
|
|
throwInitiative(gen: RandomGenerator): void {
|
|
this.play_priority = gen.random() * this.attributes.maneuvrability.get();
|
|
}
|
|
|
|
// Return the player owning this ship
|
|
getPlayer(): Player {
|
|
return this.fleet.player;
|
|
}
|
|
|
|
// get the current battle this ship is engaged in
|
|
getBattle(): Battle | null {
|
|
return this.fleet.battle;
|
|
}
|
|
|
|
/**
|
|
* Get the list of actions available
|
|
*
|
|
* This list does not filter out actions unavailable due to insufficient AP, it only filters out actions that
|
|
* are not allowed/available at all on the ship
|
|
*/
|
|
getAvailableActions(): BaseAction[] {
|
|
var actions: BaseAction[] = [];
|
|
|
|
if (this.alive) {
|
|
let slots = [SlotType.Engine, SlotType.Power, SlotType.Hull, SlotType.Shield, SlotType.Weapon];
|
|
slots.forEach(slot => {
|
|
this.listEquipment(slot).forEach(equipment => {
|
|
if (equipment.action) {
|
|
actions.push(equipment.action)
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
actions.push(new EndTurnAction());
|
|
return actions;
|
|
}
|
|
|
|
/**
|
|
* Get the number of upgrade points available to improve skills
|
|
*/
|
|
getAvailableUpgradePoints(): number {
|
|
let used = keys(SHIP_SKILLS).map(skill => this.skills[skill].get()).reduce((a, b) => a + b, 0);
|
|
return this.level.getSkillPoints() - used;
|
|
}
|
|
|
|
/**
|
|
* Try to upgrade a skill by 1 point or more
|
|
*/
|
|
upgradeSkill(skill: keyof ShipSkills, points = 1) {
|
|
if (this.getAvailableUpgradePoints() >= points) {
|
|
this.skills[skill].add(points);
|
|
this.updateAttributes();
|
|
}
|
|
}
|
|
|
|
// Add an event to the battle log, if any
|
|
addBattleEvent(event: BaseBattleEvent): void {
|
|
var battle = this.getBattle();
|
|
if (battle && battle.log) {
|
|
battle.log.add(event);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a ship value
|
|
*/
|
|
getValue(name: keyof ShipValues): number {
|
|
if (!this.values.hasOwnProperty(name)) {
|
|
console.error(`No such ship value: ${name}`);
|
|
return 0;
|
|
}
|
|
return this.values[name].get();
|
|
}
|
|
|
|
/**
|
|
* Set a ship value
|
|
*
|
|
* If *offset* is true, the value will be added to current value.
|
|
* If *log* is true, an attribute event will be added to the battle log
|
|
*
|
|
* Returns true if the value changed.
|
|
*/
|
|
setValue(name: keyof ShipValues, value: number, offset = false, log = true): boolean {
|
|
let diff = 0;
|
|
let val = this.values[name];
|
|
|
|
if (offset) {
|
|
diff = val.add(value);
|
|
} else {
|
|
diff = val.set(value);
|
|
}
|
|
|
|
if (log && diff != 0 && this.alive) {
|
|
this.addBattleEvent(new ValueChangeEvent(this, val, diff));
|
|
}
|
|
|
|
return diff != 0;
|
|
}
|
|
|
|
/**
|
|
* Set a value's maximal capacity
|
|
*/
|
|
setValueCapacity(name: keyof ShipValues, maximal: number, log = true): void {
|
|
if (this.getValue(name) > maximal) {
|
|
this.setValue(name, maximal, false, log);
|
|
}
|
|
this.values[name].setMaximal(maximal);
|
|
}
|
|
|
|
/**
|
|
* Get a ship attribute's current value
|
|
*/
|
|
getAttribute(name: keyof ShipAttributes): number {
|
|
if (!this.attributes.hasOwnProperty(name)) {
|
|
console.error(`No such ship attribute: ${name}`);
|
|
return 0;
|
|
}
|
|
return this.attributes[name].get();
|
|
}
|
|
|
|
/**
|
|
* Set a ship attribute
|
|
*
|
|
* If *log* is true, an attribute event will be added to the battle log
|
|
*
|
|
* Returns true if the value changed.
|
|
*/
|
|
setAttribute(name: keyof ShipAttributes, value: number, log = true): boolean {
|
|
let attr = this.attributes[name];
|
|
let diff = attr.set(value);
|
|
|
|
// TODO more generic
|
|
if (name == "power_capacity") {
|
|
this.setValueCapacity("power", attr.get());
|
|
} else if (name == "shield_capacity") {
|
|
this.setValueCapacity("shield", attr.get());
|
|
} else if (name == "hull_capacity") {
|
|
this.setValueCapacity("hull", attr.get());
|
|
}
|
|
|
|
if (log && diff != 0 && this.alive) {
|
|
this.addBattleEvent(new ValueChangeEvent(this, attr, diff));
|
|
}
|
|
|
|
return diff != 0;
|
|
}
|
|
|
|
// Initialize the action points counter
|
|
// This should be called once at the start of a battle
|
|
// If no value is provided, the attribute ap_initial will be used
|
|
initializeActionPoints(value: number | null = null): void {
|
|
if (value === null) {
|
|
value = this.attributes.power_capacity.get();
|
|
}
|
|
this.setValue("power", value);
|
|
}
|
|
|
|
// Recover action points
|
|
// This should be called once at the end of a turn
|
|
// If no value is provided, the current attribute ap_recovery will be used
|
|
recoverActionPoints(value: number | null = null): void {
|
|
if (this.alive) {
|
|
if (value === null) {
|
|
value = this.attributes.power_generation.get();
|
|
}
|
|
this.setValue("power", value, true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Consumes action points
|
|
*
|
|
* Return true if it was possible, false if there wasn't enough points.
|
|
*/
|
|
useActionPoints(value: number): boolean {
|
|
if (this.getValue("power") >= value) {
|
|
this.setValue("power", -value, true);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Method called at the start of battle
|
|
*/
|
|
startBattle() {
|
|
this.alive = true;
|
|
this.sticky_effects = [];
|
|
this.updateAttributes();
|
|
this.restoreHealth();
|
|
this.initializeActionPoints();
|
|
this.listEquipment().forEach(equipment => equipment.cooldown.reset());
|
|
}
|
|
|
|
/**
|
|
* Method called at the end of battle
|
|
*/
|
|
endBattle(turncount: number) {
|
|
// Restore as pristine
|
|
this.startBattle();
|
|
|
|
// Wear down equipment
|
|
this.listEquipment().forEach(equipment => {
|
|
equipment.addWear(turncount);
|
|
});
|
|
}
|
|
|
|
// Method called at the start of this ship turn
|
|
startTurn(): void {
|
|
if (this.playing) {
|
|
console.error("startTurn called twice", this);
|
|
return;
|
|
}
|
|
this.playing = true;
|
|
|
|
if (this.alive) {
|
|
// Recompute attributes
|
|
this.updateAttributes();
|
|
|
|
// Apply sticky effects
|
|
this.sticky_effects.forEach(effect => effect.startTurn(this));
|
|
this.cleanStickyEffects();
|
|
|
|
// Reset toggle actions state
|
|
this.listEquipment().forEach(equipment => {
|
|
if (equipment.action instanceof ToggleAction && equipment.action.activated) {
|
|
equipment.action.apply(this);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
// Method called at the end of this ship turn
|
|
endTurn(): void {
|
|
if (!this.playing) {
|
|
console.error("endTurn called before startTurn", this);
|
|
return;
|
|
}
|
|
this.playing = false;
|
|
|
|
if (this.alive) {
|
|
// Recover action points for next turn
|
|
this.updateAttributes();
|
|
this.recoverActionPoints();
|
|
|
|
// Apply sticky effects
|
|
this.sticky_effects.forEach(effect => effect.endTurn(this));
|
|
this.cleanStickyEffects();
|
|
|
|
// Cool down equipment
|
|
this.listEquipment().forEach(equipment => equipment.cooldown.cool());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register a sticky effect
|
|
*
|
|
* Pay attention to pass a copy, not the original equipment effect, because it will be modified
|
|
*/
|
|
addStickyEffect(effect: StickyEffect, log = true): void {
|
|
if (this.alive) {
|
|
this.sticky_effects.push(effect);
|
|
if (log) {
|
|
this.setActiveEffectsChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Clean sticky effects that are no longer active
|
|
*/
|
|
cleanStickyEffects() {
|
|
let [active, ended] = binpartition(this.sticky_effects, effect => this.alive && effect.duration > 0);
|
|
this.sticky_effects = active;
|
|
if (ended.length) {
|
|
this.setActiveEffectsChanged();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if the ship is inside a given circular area
|
|
*/
|
|
isInCircle(x: number, y: number, radius: number): boolean {
|
|
let dx = this.arena_x - x;
|
|
let dy = this.arena_y - y;
|
|
let distance = Math.sqrt(dx * dx + dy * dy);
|
|
return distance <= radius;
|
|
}
|
|
|
|
/**
|
|
* Get the distance to another ship
|
|
*/
|
|
getDistanceTo(other: Ship): number {
|
|
return Target.newFromShip(this).getDistanceTo(Target.newFromShip(other));
|
|
}
|
|
|
|
/**
|
|
* Rotate the ship in place to face a direction
|
|
*/
|
|
rotate(angle: number, engine: Equipment | null = null, log = true) {
|
|
if (angle != this.arena_angle) {
|
|
let start = copy(this.location);
|
|
this.setArenaFacingAngle(angle);
|
|
|
|
if (log) {
|
|
this.addBattleEvent(new MoveEvent(this, start, copy(this.location), engine));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Move the ship to another location
|
|
*
|
|
* This does not check or consume action points, but will update area effects (for this ship and the others).
|
|
*
|
|
* If *engine* is specified, the facing angle will be updated to simulate an engine maneuver.
|
|
*/
|
|
moveTo(x: number, y: number, engine: Equipment | null = null, log = true): void {
|
|
let dx = x - this.arena_x;
|
|
let dy = y - this.arena_y;
|
|
if (dx != 0 || dy != 0) {
|
|
let start = copy(this.location);
|
|
|
|
let area_effects = imaterialize(this.iToggleActions(true));
|
|
let old_impacted_ships = area_effects.map(action => action.getAffectedShips(this));
|
|
let old_area_effects = this.getActiveEffects().area;
|
|
|
|
if (engine) {
|
|
let angle = Math.atan2(dy, dx);
|
|
this.setArenaFacingAngle(angle);
|
|
}
|
|
|
|
this.setArenaPosition(x, y);
|
|
|
|
if (log) {
|
|
this.addBattleEvent(new MoveEvent(this, start, copy(this.location), engine));
|
|
}
|
|
|
|
let new_impacted_ships = area_effects.map(action => action.getAffectedShips(this));
|
|
let diff_impacted_ships = flatten(zip(old_impacted_ships, new_impacted_ships).map(([a, b]) => disjunctunion(a, b)));
|
|
let new_area_effects = this.getActiveEffects().area;
|
|
if (disjunctunion(old_area_effects, new_area_effects).length > 0) {
|
|
diff_impacted_ships.push(this);
|
|
}
|
|
unique(diff_impacted_ships).forEach(ship => ship.setActiveEffectsChanged());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the death status on this ship
|
|
*/
|
|
setDead(log: boolean = true): void {
|
|
this.alive = false;
|
|
this.values.hull.set(0);
|
|
this.values.shield.set(0);
|
|
this.values.power.set(0);
|
|
|
|
this.sticky_effects = [];
|
|
this.setActiveEffectsChanged();
|
|
|
|
if (log) {
|
|
this.addBattleEvent(new DeathEvent(this));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Apply damages to hull and/or shield
|
|
*
|
|
* Also apply wear to impacted equipment
|
|
*/
|
|
addDamage(hull: number, shield: number, log: boolean = true): void {
|
|
if (shield > 0) {
|
|
this.setValue("shield", -shield, true, log);
|
|
}
|
|
|
|
if (hull > 0) {
|
|
this.setValue("hull", -hull, true, log);
|
|
}
|
|
|
|
if (log) {
|
|
this.addBattleEvent(new DamageEvent(this, hull, shield));
|
|
}
|
|
|
|
if (this.values.hull.get() === 0) {
|
|
// Ship is dead
|
|
this.setDead(log);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get cargo space not occupied by items
|
|
*/
|
|
getFreeCargoSpace(): number {
|
|
return this.cargo_space - this.cargo.length;
|
|
}
|
|
|
|
/**
|
|
* Set the available cargo space.
|
|
*/
|
|
setCargoSpace(cargo: number) {
|
|
this.cargo_space = cargo;
|
|
this.cargo.splice(this.cargo_space);
|
|
}
|
|
|
|
/**
|
|
* Add an equipment to cargo space
|
|
*
|
|
* Returns true if successful
|
|
*/
|
|
addCargo(item: Equipment): boolean {
|
|
if (this.cargo.length < this.cargo_space) {
|
|
return add(this.cargo, item);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove an item from cargo space
|
|
*
|
|
* Returns true if successful
|
|
*/
|
|
removeCargo(item: Equipment): boolean {
|
|
return remove(this.cargo, item);
|
|
}
|
|
|
|
/**
|
|
* Equip an item from cargo to the first available slot
|
|
*
|
|
* Returns true if successful
|
|
*/
|
|
equip(item: Equipment, from_cargo = true): boolean {
|
|
let free_slot = this.canEquip(item);
|
|
|
|
if (free_slot && (!from_cargo || remove(this.cargo, item))) {
|
|
free_slot.attach(item);
|
|
if (item.attached_to == free_slot && free_slot.attached == item) {
|
|
this.updateAttributes();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if a ship is able to equip en item, and return the slot it may fit in, or null
|
|
*/
|
|
canEquip(item: Equipment): Slot | null {
|
|
let free_slot = first(this.slots, slot => slot.type == item.slot_type && !slot.attached);
|
|
if (free_slot) {
|
|
if (item.canBeEquipped(this.attributes)) {
|
|
return free_slot;
|
|
} else {
|
|
return null;
|
|
}
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove an equipped item, returning it to cargo
|
|
*
|
|
* Returns true if successful
|
|
*/
|
|
unequip(item: Equipment, to_cargo = true): boolean {
|
|
if (item.attached_to && item.attached_to.attached == item && (!to_cargo || this.cargo.length < this.cargo_space)) {
|
|
item.detach();
|
|
if (to_cargo) {
|
|
add(this.cargo, item);
|
|
}
|
|
|
|
this.updateAttributes();
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add an empty equipment slot of the given type
|
|
*/
|
|
addSlot(type: SlotType): Slot {
|
|
var result = new Slot(this, type);
|
|
this.slots.push(result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* List all equipments attached to slots of a given type (any slot type if null)
|
|
*/
|
|
listEquipment(slottype: SlotType | null = null): Equipment[] {
|
|
return nna(this.slots.filter(slot => slot.attached && (slottype == null || slot.type == slottype)).map(slot => slot.attached));
|
|
}
|
|
|
|
/**
|
|
* Get the first free slot of a given type, null if none is available
|
|
*/
|
|
getFreeSlot(type: SlotType): Slot | null {
|
|
return first(this.slots, slot => slot.type == type && slot.attached == null);
|
|
}
|
|
|
|
// Get the number of attached equipments
|
|
getEquipmentCount(): number {
|
|
var result = 0;
|
|
this.slots.forEach((slot: Slot) => {
|
|
if (slot.attached) {
|
|
result++;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
// Get a random attached equipment, null if no equipment is attached
|
|
getRandomEquipment(random = RandomGenerator.global): Equipment | null {
|
|
var count = this.getEquipmentCount();
|
|
if (count === 0) {
|
|
return null;
|
|
} else {
|
|
var picked = random.randInt(0, count - 1);
|
|
var result: Equipment | null = null;
|
|
var index = 0;
|
|
this.slots.forEach((slot: Slot) => {
|
|
if (slot.attached) {
|
|
if (index === picked) {
|
|
result = slot.attached;
|
|
}
|
|
index++;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// Update attributes, taking into account attached equipment and active effects
|
|
updateAttributes(): void {
|
|
let new_attrs = new ShipAttributes();
|
|
|
|
if (this.alive) {
|
|
// TODO better typing for iteritems
|
|
|
|
// Apply base skills
|
|
iteritems(<any>this.skills, (key: keyof ShipAttributes, skill: ShipAttribute) => {
|
|
new_attrs[key].add(skill.get());
|
|
});
|
|
|
|
// Sum all attribute effects
|
|
this.collectEffects("attr").forEach((effect: AttributeEffect) => {
|
|
new_attrs[effect.attrcode].add(effect.value);
|
|
});
|
|
|
|
// Apply limit attributes
|
|
this.collectEffects("attrlimit").forEach((effect: AttributeLimitEffect) => {
|
|
new_attrs[effect.attrcode].setMaximal(effect.value);
|
|
});
|
|
}
|
|
|
|
// Set final attributes
|
|
iteritems(<any>new_attrs, (key, value) => {
|
|
this.setAttribute(<keyof ShipAttributes>key, (<ShipAttribute>value).get());
|
|
});
|
|
}
|
|
|
|
// Fully restore hull and shield
|
|
restoreHealth(): void {
|
|
if (this.alive) {
|
|
this.values.hull.set(this.attributes.hull_capacity.get());
|
|
this.values.shield.set(this.attributes.shield_capacity.get());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the list of all effects applied on this ship
|
|
*
|
|
* This includes:
|
|
* - Permanent equipment effects
|
|
* - Sticky effects
|
|
* - Area effects at current location
|
|
*/
|
|
getActiveEffects(): ActiveEffectsEvent {
|
|
let result = new ActiveEffectsEvent(this);
|
|
if (this.alive) {
|
|
result.equipment = flatten(this.slots.map(slot => slot.attached ? slot.attached.effects : []));
|
|
result.sticky = this.sticky_effects;
|
|
let battle = this.getBattle();
|
|
result.area = battle ? imaterialize(battle.iAreaEffects(this.arena_x, this.arena_y)) : [];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Indicate a change in active effects to the log
|
|
*/
|
|
setActiveEffectsChanged(): void {
|
|
this.addBattleEvent(this.getActiveEffects());
|
|
this.updateAttributes();
|
|
}
|
|
|
|
/**
|
|
* Iterator over all effects active for this ship.
|
|
*/
|
|
ieffects(): Iterator<BaseEffect> {
|
|
let battle = this.getBattle();
|
|
let area_effects = battle ? battle.iAreaEffects(this.arena_x, this.arena_y) : IEMPTY;
|
|
return ichain(
|
|
ichainit(imap(iarray(this.slots), slot => slot.attached ? iarray(slot.attached.effects) : IEMPTY)),
|
|
imap(iarray(this.sticky_effects), effect => effect.base),
|
|
area_effects
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Iterator over toggle actions
|
|
*/
|
|
iToggleActions(only_active = false): Iterator<ToggleAction> {
|
|
return <Iterator<ToggleAction>>ifilter(iarray(this.getAvailableActions()), action => {
|
|
return (action instanceof ToggleAction && (action.activated || !only_active));
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Iterator over area effects from this ship impacting a location
|
|
*/
|
|
iAreaEffects(x: number, y: number): Iterator<BaseEffect> {
|
|
let distance = Target.newFromShip(this).getDistanceTo({ x: x, y: y });
|
|
return ichainit(imap(this.iToggleActions(true), action => {
|
|
if (distance <= action.radius) {
|
|
return iarray(action.effects);
|
|
} else {
|
|
return IEMPTY;
|
|
}
|
|
}));
|
|
}
|
|
|
|
// Collect all effects to apply for updateAttributes
|
|
private collectEffects(code: string): BaseEffect[] {
|
|
return imaterialize(ifilter(this.ieffects(), effect => effect.code == code));
|
|
}
|
|
|
|
/**
|
|
* Get a textual description of an attribute, and the origin of its value
|
|
*/
|
|
getAttributeDescription(attribute: keyof ShipAttributes): string {
|
|
let result = this.attributes[attribute].description;
|
|
|
|
let diffs: string[] = [];
|
|
let limits: string[] = [];
|
|
|
|
function addEffect(base: string, effect: BaseEffect) {
|
|
if (effect instanceof AttributeEffect && effect.attrcode == attribute) {
|
|
diffs.push(`${base}: ${effect.value > 0 ? "+" + effect.value.toString() : effect.value}`);
|
|
} else if (effect instanceof AttributeLimitEffect && effect.attrcode == attribute) {
|
|
limits.push(`${base}: limit to ${effect.value}`);
|
|
}
|
|
}
|
|
|
|
if (attribute in this.skills) {
|
|
let skill = this.skills[<keyof ShipSkills>attribute];
|
|
if (skill.get()) {
|
|
diffs.push(`Levelled up: +${skill.get()}`);
|
|
}
|
|
}
|
|
|
|
this.slots.forEach(slot => {
|
|
if (slot.attached) {
|
|
let equipment = slot.attached;
|
|
equipment.effects.forEach(effect => addEffect(equipment.getFullName(), effect));
|
|
}
|
|
});
|
|
|
|
this.sticky_effects.forEach(effect => addEffect("???", effect.base));
|
|
|
|
let sources = diffs.concat(limits).join("\n");
|
|
return sources ? (result + "\n\n" + sources) : result;
|
|
}
|
|
}
|
|
}
|