1354 lines
40 KiB
JavaScript
1354 lines
40 KiB
JavaScript
let armor_powder_node = new (class extends ComputeNode {
|
|
constructor() {
|
|
super("builder-armor-powder-input");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
let damage_boost = 0;
|
|
let def_boost = 0;
|
|
let statMap = new Map();
|
|
for (const [e, elem] of zip2(skp_elements, skp_order)) {
|
|
let val = parseInt(document.getElementById(elem + "_boost_armor").value);
|
|
statMap.set(e + "DamPct", val);
|
|
}
|
|
return statMap;
|
|
}
|
|
})();
|
|
|
|
let boosts_node = new (class extends ComputeNode {
|
|
constructor() {
|
|
super("builder-boost-input");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
let damage_boost = 0;
|
|
let def_boost = 0;
|
|
for (const [key, value] of damageMultipliers) {
|
|
let elem = document.getElementById(key + "-boost");
|
|
if (elem.classList.contains("toggleOn")) {
|
|
damage_boost += value;
|
|
if (key === "warscream") {
|
|
def_boost += 0.1;
|
|
}
|
|
if (key === "vanish") {
|
|
def_boost += 0.15;
|
|
}
|
|
}
|
|
}
|
|
let res = new Map();
|
|
res.set("damMult.Potion", 100 * damage_boost);
|
|
res.set("defMult.Potion", 100 * def_boost);
|
|
return res;
|
|
}
|
|
})().update();
|
|
|
|
/* Updates all spell boosts
|
|
*/
|
|
function update_boosts(buttonId) {
|
|
let elem = document.getElementById(buttonId);
|
|
if (elem.classList.contains("toggleOn")) {
|
|
elem.classList.remove("toggleOn");
|
|
} else {
|
|
elem.classList.add("toggleOn");
|
|
}
|
|
boosts_node.mark_dirty().update();
|
|
}
|
|
|
|
let specialNames = [
|
|
"Quake",
|
|
"Chain Lightning",
|
|
"Curse",
|
|
"Courage",
|
|
"Wind Prison",
|
|
];
|
|
let powder_special_input = new (class extends ComputeNode {
|
|
constructor() {
|
|
super("builder-powder-special-input");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
let powder_specials = []; // [ [special, power], [special, power]]
|
|
for (const sName of specialNames) {
|
|
for (let i = 1; i < 6; i++) {
|
|
if (
|
|
document
|
|
.getElementById(sName.replace(" ", "_") + "-" + i)
|
|
.classList.contains("toggleOn")
|
|
) {
|
|
let powder_special =
|
|
powderSpecialStats[specialNames.indexOf(sName.replace("_", " "))];
|
|
powder_specials.push([powder_special, i]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return powder_specials;
|
|
}
|
|
})();
|
|
|
|
function updatePowderSpecials(buttonId) {
|
|
let prefix = buttonId.split("-")[0].replace(" ", "_") + "-";
|
|
let elem = document.getElementById(buttonId);
|
|
if (elem.classList.contains("toggleOn")) {
|
|
elem.classList.remove("toggleOn");
|
|
} else {
|
|
for (let i = 1; i < 6; i++) {
|
|
//toggle all pressed buttons of the same powder special off
|
|
//name is same, power is i
|
|
const elem2 = document.getElementById(prefix + i);
|
|
if (elem2.classList.contains("toggleOn")) {
|
|
elem2.classList.remove("toggleOn");
|
|
}
|
|
}
|
|
//toggle the pressed button on
|
|
elem.classList.add("toggleOn");
|
|
}
|
|
powder_special_input.mark_dirty().update();
|
|
}
|
|
|
|
class PowderSpecialCalcNode extends ComputeNode {
|
|
constructor() {
|
|
super("builder-powder-special-apply");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
const powder_specials = input_map.get("powder-specials");
|
|
let stats = new Map();
|
|
for (const [special, power] of powder_specials) {
|
|
if (special["weaponSpecialEffects"].has("Damage Boost")) {
|
|
let name = special["weaponSpecialName"];
|
|
if (name === "Courage" || name === "Curse") {
|
|
//courage and curse are is universal damage boost
|
|
stats.set(
|
|
"sdPct",
|
|
special.weaponSpecialEffects.get("Damage Boost")[power - 1]
|
|
);
|
|
stats.set(
|
|
"mdPct",
|
|
special.weaponSpecialEffects.get("Damage Boost")[power - 1]
|
|
);
|
|
stats.set(
|
|
"poisonPct",
|
|
special.weaponSpecialEffects.get("Damage Boost")[power - 1]
|
|
);
|
|
} else if (name === "Wind Prison") {
|
|
stats.set(
|
|
"aDamPct",
|
|
special.weaponSpecialEffects.get("Damage Boost")[power - 1]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return stats;
|
|
}
|
|
}
|
|
|
|
class PowderSpecialDisplayNode extends ComputeNode {
|
|
// TODO: Refactor this entirely to be adding more spells to the spell list
|
|
constructor() {
|
|
super("builder-powder-special-display");
|
|
this.fail_cb = true;
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
const powder_specials = input_map.get("powder-specials");
|
|
const stats = input_map.get("stats");
|
|
const weapon = input_map.get("build").weapon;
|
|
displayPowderSpecials(
|
|
document.getElementById("powder-special-stats"),
|
|
powder_specials,
|
|
stats,
|
|
weapon.statMap,
|
|
true
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Node for getting an item's stats from an item input field.
|
|
*
|
|
* Signature: ItemInputNode(powdering: Optional[list[powder]]) => Item | null
|
|
*/
|
|
class ItemInputNode extends InputNode {
|
|
/**
|
|
* Make an item stat pulling compute node.
|
|
*
|
|
* @param name: Name of this node.
|
|
* @param item_input_field: Input field (html element) to listen for item names from.
|
|
* @param none_item: Item object to use as the "none" for this field.
|
|
*/
|
|
constructor(name, item_input_field, none_item) {
|
|
super(name, item_input_field);
|
|
this.none_item = new Item(none_item);
|
|
this.category = this.none_item.statMap.get("category");
|
|
if (this.category == "armor" || this.category == "weapon") {
|
|
this.none_item.statMap.set("powders", []);
|
|
apply_weapon_powders(this.none_item.statMap); // Needed to put in damagecalc zeros
|
|
}
|
|
this.none_item.statMap.set("NONE", true);
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
const powdering = input_map.get("powdering");
|
|
|
|
// built on the assumption of no one will type in CI/CR letter by letter
|
|
let item_text = this.input_field.value;
|
|
if (!item_text) {
|
|
return this.none_item;
|
|
}
|
|
|
|
let item;
|
|
if (item_text.slice(0, 3) == "CI-") {
|
|
item = getCustomFromHash(item_text);
|
|
} else if (item_text.slice(0, 3) == "CR-") {
|
|
item = getCraftFromHash(item_text);
|
|
} else if (itemMap.has(item_text)) {
|
|
item = new Item(itemMap.get(item_text));
|
|
} else if (tomeMap.has(item_text)) {
|
|
item = new Item(tomeMap.get(item_text));
|
|
}
|
|
|
|
if (item) {
|
|
if (powdering !== undefined) {
|
|
const max_slots = item.statMap.get("slots");
|
|
item.statMap.set("powders", powdering.slice(0, max_slots));
|
|
}
|
|
let type_match;
|
|
if (this.category == "weapon") {
|
|
type_match = item.statMap.get("category") == "weapon";
|
|
} else {
|
|
type_match =
|
|
item.statMap.get("type") == this.none_item.statMap.get("type");
|
|
}
|
|
if (type_match) {
|
|
if (item.statMap.get("category") == "armor") {
|
|
applyArmorPowders(item.statMap);
|
|
} else if (item.statMap.get("category") == "weapon") {
|
|
apply_weapon_powders(item.statMap);
|
|
}
|
|
return item;
|
|
}
|
|
} else if (
|
|
this.none_item.statMap.get("category") === "weapon" &&
|
|
item_text.startsWith("Morph-")
|
|
) {
|
|
let replace_items = [
|
|
"Morph-Stardust",
|
|
"Morph-Steel",
|
|
"Morph-Iron",
|
|
"Morph-Gold",
|
|
"Morph-Topaz",
|
|
"Morph-Emerald",
|
|
"Morph-Amethyst",
|
|
"Morph-Ruby",
|
|
item_text.substring(6),
|
|
];
|
|
|
|
for (const [i, x] of zip2(equipment_inputs, replace_items)) {
|
|
setValue(i, x);
|
|
}
|
|
|
|
for (const node of item_nodes) {
|
|
if (node !== this) {
|
|
// save a tiny bit of compute
|
|
calcSchedule(node, 10);
|
|
}
|
|
}
|
|
// Needed to push the weapon node's updates forward
|
|
return this.compute_func(input_map);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Node for updating item input fields from parsed items.
|
|
*
|
|
* Signature: ItemInputDisplayNode(item: Item) => null
|
|
*/
|
|
class ItemInputDisplayNode extends ComputeNode {
|
|
constructor(name, eq, item_image) {
|
|
super(name);
|
|
this.input_field = document.getElementById(eq + "-choice");
|
|
this.health_field = document.getElementById(eq + "-health");
|
|
this.level_field = document.getElementById(eq + "-lv");
|
|
this.powder_field = document.getElementById(eq + "-powder"); // possibly None
|
|
this.image = item_image;
|
|
this.fail_cb = true;
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
if (input_map.size !== 1) {
|
|
throw "ItemInputDisplayNode accepts exactly one input (item)";
|
|
}
|
|
const [item] = input_map.values(); // Extract values, pattern match it into size one list and bind to first element
|
|
|
|
this.input_field.classList.remove(
|
|
"text-light",
|
|
"is-invalid",
|
|
"Normal",
|
|
"Unique",
|
|
"Rare",
|
|
"Legendary",
|
|
"Fabled",
|
|
"Mythic",
|
|
"Set",
|
|
"Crafted",
|
|
"Custom"
|
|
);
|
|
this.input_field.classList.add("text-light");
|
|
this.image.classList.remove(
|
|
"Normal-shadow",
|
|
"Unique-shadow",
|
|
"Rare-shadow",
|
|
"Legendary-shadow",
|
|
"Fabled-shadow",
|
|
"Mythic-shadow",
|
|
"Set-shadow",
|
|
"Crafted-shadow",
|
|
"Custom-shadow"
|
|
);
|
|
|
|
if (this.health_field) {
|
|
// Doesn't exist for weapons.
|
|
this.health_field.textContent = "0";
|
|
}
|
|
if (this.level_field) {
|
|
// Doesn't exist for tomes.
|
|
this.level_field.textContent = "0";
|
|
}
|
|
if (!item) {
|
|
this.input_field.classList.add("is-invalid");
|
|
return null;
|
|
}
|
|
if (this.powder_field && item.statMap.has("powders")) {
|
|
this.powder_field.placeholder = "powders";
|
|
}
|
|
|
|
if (item.statMap.has("NONE")) {
|
|
return null;
|
|
}
|
|
|
|
if (this.powder_field && item.statMap.has("powders")) {
|
|
this.powder_field.placeholder = item.statMap.get("slots") + " slots";
|
|
}
|
|
|
|
const tier = item.statMap.get("tier");
|
|
this.input_field.classList.add(tier);
|
|
if (this.health_field) {
|
|
// Doesn't exist for weapons.
|
|
this.health_field.textContent = item.statMap.get("hp");
|
|
}
|
|
if (this.level_field) {
|
|
// Doesn't exist for tomes.
|
|
this.level_field.textContent = item.statMap.get("lvl");
|
|
}
|
|
this.image.classList.add(tier + "-shadow");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Node for rendering an item.
|
|
*
|
|
* Signature: ItemDisplayNode(item: Item) => null
|
|
*/
|
|
class ItemDisplayNode extends ComputeNode {
|
|
constructor(name, target_elem) {
|
|
super(name);
|
|
this.target_elem = target_elem;
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
if (input_map.size !== 1) {
|
|
throw "ItemInputDisplayNode accepts exactly one input (item)";
|
|
}
|
|
const [item] = input_map.values(); // Extract values, pattern match it into size one list and bind to first element
|
|
|
|
displayExpandedItem(item.statMap, this.target_elem);
|
|
collapse_element("#" + this.target_elem);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Change the weapon to match correct type.
|
|
*
|
|
* Signature: WeaponInputDisplayNode(item: Item) => null
|
|
*/
|
|
class WeaponInputDisplayNode extends ComputeNode {
|
|
constructor(name, image_field, dps_field) {
|
|
super(name);
|
|
this.image = image_field;
|
|
this.dps_field = dps_field;
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
if (input_map.size !== 1) {
|
|
throw "WeaponDisplayNode accepts exactly one input (item)";
|
|
}
|
|
const [item] = input_map.values(); // Extract values, pattern match it into size one list and bind to first element
|
|
|
|
const type = item.statMap.get("type");
|
|
this.image.setAttribute(
|
|
"src",
|
|
"../media/items/new/generic-" + type + ".png"
|
|
);
|
|
let dps = get_base_dps(item.statMap);
|
|
if (isNaN(dps)) {
|
|
dps = dps[1];
|
|
if (isNaN(dps)) dps = 0;
|
|
}
|
|
this.dps_field.textContent = Math.round(dps);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Encode the build into a url-able string.
|
|
*
|
|
* Signature: BuildEncodeNode(build: Build,
|
|
* helmet-powder: List[powder],
|
|
* chestplate-powder: List[powder],
|
|
* leggings-powder: List[powder],
|
|
* boots-powder: List[powder],
|
|
* weapon-powder: List[powder]) => str
|
|
*/
|
|
class BuildEncodeNode extends ComputeNode {
|
|
constructor() {
|
|
super("builder-encode");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
const build = input_map.get("build");
|
|
const atree = input_map.get("atree");
|
|
const atree_state = input_map.get("atree-state");
|
|
let powders = [
|
|
input_map.get("helmet-powder"),
|
|
input_map.get("chestplate-powder"),
|
|
input_map.get("leggings-powder"),
|
|
input_map.get("boots-powder"),
|
|
input_map.get("weapon-powder"),
|
|
];
|
|
const skillpoints = [
|
|
input_map.get("str"),
|
|
input_map.get("dex"),
|
|
input_map.get("int"),
|
|
input_map.get("def"),
|
|
input_map.get("agi"),
|
|
];
|
|
// TODO: grr global state for copy button..
|
|
player_build = build;
|
|
build_powders = powders;
|
|
return encodeBuild(build, powders, skillpoints, atree, atree_state);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update the window's URL.
|
|
*
|
|
* Signature: URLUpdateNode(build_str: str) => null
|
|
*/
|
|
class URLUpdateNode extends ComputeNode {
|
|
constructor() {
|
|
super("builder-url-update");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
if (input_map.size !== 1) {
|
|
throw "URLUpdateNode accepts exactly one input (build_str)";
|
|
}
|
|
const [build_str] = input_map.values(); // Extract values, pattern match it into size one list and bind to first element
|
|
location.hash = build_str;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a "build" object from a set of equipments.
|
|
* Returns a new Build object, or null if all items are NONE items.
|
|
*
|
|
* Signature: BuildAssembleNode(helmet-input: Item,
|
|
* chestplate-input: Item,
|
|
* leggings-input: Item,
|
|
* boots-input: Item,
|
|
* ring1-input: Item,
|
|
* ring2-input: Item,
|
|
* bracelet-input: Item,
|
|
* necklace-input: Item,
|
|
* weapon-input: Item,
|
|
* level-input: int) => Build | null
|
|
*/
|
|
class BuildAssembleNode extends ComputeNode {
|
|
constructor() {
|
|
super("builder-make-build");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
let equipments = [
|
|
input_map.get("helmet-input"),
|
|
input_map.get("chestplate-input"),
|
|
input_map.get("leggings-input"),
|
|
input_map.get("boots-input"),
|
|
input_map.get("ring1-input"),
|
|
input_map.get("ring2-input"),
|
|
input_map.get("bracelet-input"),
|
|
input_map.get("necklace-input"),
|
|
input_map.get("weaponTome1-input"),
|
|
input_map.get("weaponTome2-input"),
|
|
input_map.get("armorTome1-input"),
|
|
input_map.get("armorTome2-input"),
|
|
input_map.get("armorTome3-input"),
|
|
input_map.get("armorTome4-input"),
|
|
input_map.get("guildTome1-input"),
|
|
];
|
|
let weapon = input_map.get("weapon-input");
|
|
let level = parseInt(input_map.get("level-input"));
|
|
if (isNaN(level)) {
|
|
level = 106;
|
|
}
|
|
|
|
let all_none = weapon.statMap.has("NONE");
|
|
for (const item of equipments) {
|
|
all_none = all_none && item.statMap.has("NONE");
|
|
}
|
|
if (all_none && !location.hash) {
|
|
return null;
|
|
}
|
|
return new Build(level, equipments, weapon);
|
|
}
|
|
}
|
|
|
|
class PlayerClassNode extends ValueCheckComputeNode {
|
|
constructor(name) {
|
|
super(name);
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
if (input_map.size !== 1) {
|
|
throw "PlayerClassNode accepts exactly one input (build)";
|
|
}
|
|
const [build] = input_map.values(); // Extract values, pattern match it into size one list and bind to first element
|
|
return wep_to_class.get(build.weapon.statMap.get("type"));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Read an input field and parse into a list of powderings.
|
|
* Every two characters makes one powder. If parsing fails, NULL is returned.
|
|
*
|
|
* Signature: PowderInputNode() => List[powder] | null
|
|
*/
|
|
class PowderInputNode extends InputNode {
|
|
constructor(name, input_field) {
|
|
super(name, input_field);
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
// TODO: haha improve efficiency to O(n) dumb
|
|
let input = this.input_field.value.trim();
|
|
let powdering = [];
|
|
let errorederrors = [];
|
|
while (input) {
|
|
let first = input.slice(0, 2);
|
|
let powder = powderIDs.get(first);
|
|
if (powder === undefined) {
|
|
if (first.length > 0) {
|
|
errorederrors.push(first);
|
|
} else {
|
|
break;
|
|
}
|
|
} else {
|
|
powdering.push(powder);
|
|
}
|
|
input = input.slice(2);
|
|
}
|
|
|
|
if (this.input_field.getAttribute("placeholder") != null) {
|
|
let placeholder = this.input_field.getAttribute("placeholder");
|
|
if (
|
|
placeholder.includes(" slots") &&
|
|
parseInt(placeholder.substring(0, placeholder.indexOf(" "))) <
|
|
powdering.length
|
|
)
|
|
errorederrors.push("Too many powders: " + powdering.length);
|
|
}
|
|
|
|
if (errorederrors.length) {
|
|
this.input_field.classList.add("is-invalid");
|
|
} else {
|
|
this.input_field.classList.remove("is-invalid");
|
|
}
|
|
|
|
return powdering;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Select a spell+spell "variation" based on a build / spell idx.
|
|
* Right now this isn't much logic and is only used to abstract away major id interactions
|
|
* but will become significantly more complex in wynn2.
|
|
*
|
|
* Signature: SpellSelectNode<int>(build: Build) => [Spell, SpellParts]
|
|
*/
|
|
class SpellSelectNode extends ComputeNode {
|
|
constructor(spell) {
|
|
super("builder-spell" + spell.base_spell + "-select");
|
|
this.spell = spell;
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
const build = input_map.get("build");
|
|
let stats = build.statMap;
|
|
// TODO: apply major ids... DOOM.....
|
|
|
|
return [this.spell, this.spell.parts];
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Get all defensive stats for this build.
|
|
*/
|
|
function getDefenseStats(stats) {
|
|
let defenseStats = [];
|
|
let def_pct =
|
|
skillPointsToPercentage(stats.get("def")) * skillpoint_final_mult[3];
|
|
let agi_pct =
|
|
skillPointsToPercentage(stats.get("agi")) * skillpoint_final_mult[4];
|
|
//total hp
|
|
let totalHp = stats.get("hp") + stats.get("hpBonus");
|
|
if (totalHp < 5) totalHp = 5;
|
|
defenseStats.push(totalHp);
|
|
//EHP
|
|
let ehp = [totalHp, totalHp];
|
|
let defMult = 2 - stats.get("classDef");
|
|
for (const [k, v] of stats.get("defMult").entries()) {
|
|
defMult *= 1 - v / 100;
|
|
}
|
|
// newehp = oldehp / [0.1 * A(x) + (1 - A(x)) * (1 - D(x))]
|
|
ehp[0] = ehp[0] / (0.1 * agi_pct + (1 - agi_pct) * (1 - def_pct));
|
|
ehp[0] /= defMult;
|
|
// ehp[0] /= (1-def_pct)*(1-agi_pct)*defMult;
|
|
ehp[1] /= (1 - def_pct) * defMult;
|
|
defenseStats.push(ehp);
|
|
//HPR
|
|
let totalHpr = rawToPct(stats.get("hprRaw"), stats.get("hprPct") / 100);
|
|
defenseStats.push(totalHpr);
|
|
//EHPR
|
|
let ehpr = [totalHpr, totalHpr];
|
|
ehpr[0] /= (1 - def_pct) * (1 - agi_pct) * defMult;
|
|
ehpr[1] /= (1 - def_pct) * defMult;
|
|
defenseStats.push(ehpr);
|
|
//skp stats
|
|
defenseStats.push([def_pct * 100, agi_pct * 100]);
|
|
//eledefs - TODO POWDERS
|
|
let eledefs = [0, 0, 0, 0, 0];
|
|
for (const i in skp_elements) {
|
|
//kinda jank but ok
|
|
eledefs[i] = rawToPct(
|
|
stats.get(skp_elements[i] + "Def"),
|
|
stats.get(skp_elements[i] + "DefPct") / 100
|
|
);
|
|
}
|
|
defenseStats.push(eledefs);
|
|
|
|
//[total hp, [ehp w/ agi, ehp w/o agi], total hpr, [ehpr w/ agi, ehpr w/o agi], [def%, agi%], [edef,tdef,wdef,fdef,adef]]
|
|
return defenseStats;
|
|
}
|
|
|
|
/**
|
|
* Compute spell damage of spell parts.
|
|
* Currently kinda janky / TODO while we rework the internal rep. of spells.
|
|
*
|
|
* Signature: SpellDamageCalcNode(weapon-input: Item,
|
|
* stats: StatMap,
|
|
* spell-info: [Spell, SpellParts]) => List[SpellDamage]
|
|
*/
|
|
class SpellDamageCalcNode extends ComputeNode {
|
|
constructor(spell_num) {
|
|
super("builder-spell" + spell_num + "-calc");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
const weapon = input_map.get("build").weapon.statMap;
|
|
const spell_info = input_map.get("spell-info");
|
|
const spell = spell_info[0];
|
|
const spell_parts = spell_info[1];
|
|
const stats = input_map.get("stats");
|
|
const skillpoints = [
|
|
stats.get("str"),
|
|
stats.get("dex"),
|
|
stats.get("int"),
|
|
stats.get("def"),
|
|
stats.get("agi"),
|
|
];
|
|
let spell_results = [];
|
|
let spell_result_map = new Map();
|
|
const use_speed = "use_atkspd" in spell ? spell.use_atkspd : true;
|
|
const use_spell = "scaling" in spell ? spell.scaling === "spell" : true;
|
|
|
|
// TODO: move preprocessing to separate node/node chain
|
|
for (const part of spell_parts) {
|
|
let spell_result;
|
|
if ("multipliers" in part) {
|
|
// damage type spell
|
|
let results = calculateSpellDamage(
|
|
stats,
|
|
weapon,
|
|
part.multipliers,
|
|
use_spell,
|
|
!use_speed,
|
|
spell.base_spell + "." + part.name
|
|
);
|
|
spell_result = {
|
|
type: "damage",
|
|
normal_min: results[2].map((x) => x[0]),
|
|
normal_max: results[2].map((x) => x[1]),
|
|
normal_total: results[0],
|
|
crit_min: results[2].map((x) => x[2]),
|
|
crit_max: results[2].map((x) => x[3]),
|
|
crit_total: results[1],
|
|
};
|
|
} else if ("power" in part) {
|
|
// TODO: wynn2 formula
|
|
let _heal_amount =
|
|
part.power * getDefenseStats(stats)[0] * (stats.get("healPct") / 100);
|
|
spell_result = {
|
|
type: "heal",
|
|
heal_amount: _heal_amount,
|
|
};
|
|
} else {
|
|
continue;
|
|
}
|
|
spell_result.name = part.name;
|
|
spell_results.push(spell_result);
|
|
spell_result_map.set(part.name, spell_result);
|
|
}
|
|
for (const part of spell_parts) {
|
|
if ("hits" in part) {
|
|
let spell_result = {
|
|
normal_min: [0, 0, 0, 0, 0, 0],
|
|
normal_max: [0, 0, 0, 0, 0, 0],
|
|
normal_total: [0, 0],
|
|
crit_min: [0, 0, 0, 0, 0, 0],
|
|
crit_max: [0, 0, 0, 0, 0, 0],
|
|
crit_total: [0, 0],
|
|
heal_amount: 0,
|
|
};
|
|
const dam_res_keys = [
|
|
"normal_min",
|
|
"normal_max",
|
|
"normal_total",
|
|
"crit_min",
|
|
"crit_max",
|
|
"crit_total",
|
|
];
|
|
for (const [subpart_name, hits] of Object.entries(part.hits)) {
|
|
const subpart = spell_result_map.get(subpart_name);
|
|
if (!subpart) {
|
|
continue;
|
|
}
|
|
if (spell_result.type) {
|
|
if (subpart.type !== spell_result.type) {
|
|
throw "SpellCalc total subpart type mismatch";
|
|
}
|
|
} else {
|
|
spell_result.type = subpart.type;
|
|
}
|
|
if (spell_result.type === "damage") {
|
|
for (const key of dam_res_keys) {
|
|
for (let i in spell_result.normal_min) {
|
|
spell_result[key][i] += subpart[key][i] * hits;
|
|
}
|
|
}
|
|
} else {
|
|
spell_result.heal_amount += subpart.heal_amount;
|
|
}
|
|
}
|
|
spell_result.name = part.name;
|
|
spell_results.push(spell_result);
|
|
spell_result_map.set(part.name, spell_result);
|
|
}
|
|
}
|
|
return spell_results;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Display spell damage from spell parts.
|
|
* Currently kinda janky / TODO while we rework the internal rep. of spells.
|
|
*
|
|
* Signature: SpellDisplayNode(stats: StatMap,
|
|
* spell-info: [Spell, SpellParts],
|
|
* spell-damage: List[SpellDamage]) => null
|
|
*/
|
|
class SpellDisplayNode extends ComputeNode {
|
|
constructor(spell_num) {
|
|
super("builder-spell" + spell_num + "-display");
|
|
this.spell_idx = spell_num;
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
const stats = input_map.get("stats");
|
|
const spell_info = input_map.get("spell-info");
|
|
const damages = input_map.get("spell-damage");
|
|
const spell = spell_info[0];
|
|
|
|
const i = this.spell_idx;
|
|
let parent_elem = document.getElementById("spell" + i + "-info");
|
|
let overallparent_elem = document.getElementById("spell" + i + "-infoAvg");
|
|
displaySpellDamage(
|
|
parent_elem,
|
|
overallparent_elem,
|
|
stats,
|
|
spell,
|
|
i,
|
|
damages
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Display build stats.
|
|
*
|
|
* Signature: BuildDisplayNode(build: Build) => null
|
|
*/
|
|
class BuildDisplayNode extends ComputeNode {
|
|
constructor() {
|
|
super("builder-stats-display");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
const build = input_map.get("build");
|
|
const stats = input_map.get("stats");
|
|
displayBuildStats(
|
|
"overall-stats",
|
|
build,
|
|
build_all_display_commands,
|
|
stats
|
|
);
|
|
displayBuildStats(
|
|
"offensive-stats",
|
|
build,
|
|
build_offensive_display_commands,
|
|
stats
|
|
);
|
|
displaySetBonuses("set-info", build);
|
|
// TODO: move weapon out?
|
|
displayDefenseStats(document.getElementById("defensive-stats"), stats);
|
|
|
|
displayPoisonDamage(document.getElementById("build-poison-stats"), build);
|
|
displayEquipOrder(
|
|
document.getElementById("build-order"),
|
|
build.equip_order
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Show warnings for skillpoints, level, set bonus for a build
|
|
* Also shosw skill point remaining and other misc. info
|
|
*
|
|
* Signature: DisplayBuildWarningNode(build: Build, str: int, dex: int, int: int, def: int, agi: int) => null
|
|
*/
|
|
class DisplayBuildWarningsNode extends ComputeNode {
|
|
constructor() {
|
|
super("builder-show-warnings");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
const build = input_map.get("build");
|
|
const min_assigned = build.base_skillpoints;
|
|
const base_totals = build.total_skillpoints;
|
|
const skillpoints = [
|
|
input_map.get("str"),
|
|
input_map.get("dex"),
|
|
input_map.get("int"),
|
|
input_map.get("def"),
|
|
input_map.get("agi"),
|
|
];
|
|
let skp_effects = [
|
|
"% more damage dealt.",
|
|
"% chance to crit.",
|
|
"% spell cost reduction.",
|
|
"% less damage taken.",
|
|
"% chance to dodge.",
|
|
];
|
|
let total_assigned = 0;
|
|
for (let i in skp_order) {
|
|
//big bren
|
|
const assigned = skillpoints[i] - base_totals[i] + min_assigned[i];
|
|
setText(skp_order[i] + "-skp-base", "Original: " + base_totals[i]);
|
|
setText(skp_order[i] + "-skp-assign", "Assign: " + assigned);
|
|
setValue(skp_order[i] + "-skp", skillpoints[i]);
|
|
let linebreak = document.createElement("br");
|
|
linebreak.classList.add("itemp");
|
|
setText(
|
|
skp_order[i] + "-skp-pct",
|
|
(
|
|
skillPointsToPercentage(skillpoints[i]) *
|
|
100 *
|
|
skillpoint_final_mult[i]
|
|
)
|
|
.toFixed(1)
|
|
.concat(skp_effects[i])
|
|
);
|
|
document.getElementById(skp_order[i] + "-warnings").textContent = "";
|
|
if (assigned > 100) {
|
|
let skp_warning = document.createElement("p");
|
|
skp_warning.classList.add("warning", "small-text");
|
|
skp_warning.textContent +=
|
|
"Cannot assign " +
|
|
assigned +
|
|
" skillpoints in " +
|
|
["Strength", "Dexterity", "Intelligence", "Defense", "Agility"][i] +
|
|
" manually.";
|
|
document
|
|
.getElementById(skp_order[i] + "-warnings")
|
|
.appendChild(skp_warning);
|
|
}
|
|
total_assigned += assigned;
|
|
}
|
|
|
|
let summarybox = document.getElementById("summary-box");
|
|
summarybox.textContent = "";
|
|
let skpRow = document.createElement("p");
|
|
|
|
let remainingSkp = document.createElement("p");
|
|
remainingSkp.classList.add("scaled-font");
|
|
let remainingSkpTitle = document.createElement("b");
|
|
remainingSkpTitle.textContent =
|
|
"Assigned " + total_assigned + " skillpoints. Remaining skillpoints: ";
|
|
let remainingSkpContent = document.createElement("b");
|
|
remainingSkpContent.textContent =
|
|
"" + (levelToSkillPoints(build.level) - total_assigned);
|
|
remainingSkpContent.classList.add(
|
|
levelToSkillPoints(build.level) - total_assigned < 0
|
|
? "negative"
|
|
: "positive"
|
|
);
|
|
|
|
remainingSkp.appendChild(remainingSkpTitle);
|
|
remainingSkp.appendChild(remainingSkpContent);
|
|
|
|
summarybox.append(skpRow);
|
|
summarybox.append(remainingSkp);
|
|
if (total_assigned > levelToSkillPoints(build.level)) {
|
|
let skpWarning = document.createElement("span");
|
|
//skpWarning.classList.add("itemp");
|
|
skpWarning.classList.add("warning");
|
|
skpWarning.textContent =
|
|
"WARNING: Too many skillpoints need to be assigned!";
|
|
let skpCount = document.createElement("p");
|
|
skpCount.classList.add("warning");
|
|
skpCount.textContent =
|
|
"For level " +
|
|
(build.level > 101 ? "101+" : build.level) +
|
|
", there are only " +
|
|
levelToSkillPoints(build.level) +
|
|
" skill points available.";
|
|
summarybox.append(skpWarning);
|
|
summarybox.append(skpCount);
|
|
}
|
|
let lvlWarning;
|
|
for (const item of build.items) {
|
|
let item_lvl;
|
|
if (item.statMap.get("crafted")) {
|
|
//item_lvl = item.get("lvlLow") + "-" + item.get("lvl");
|
|
item_lvl = item.statMap.get("lvlLow");
|
|
} else {
|
|
item_lvl = item.statMap.get("lvl");
|
|
}
|
|
|
|
if (build.level < item_lvl) {
|
|
if (!lvlWarning) {
|
|
lvlWarning = document.createElement("p");
|
|
lvlWarning.classList.add("itemp");
|
|
lvlWarning.classList.add("warning");
|
|
lvlWarning.textContent =
|
|
"WARNING: A level " +
|
|
build.level +
|
|
" player cannot use some piece(s) of this build.";
|
|
}
|
|
let baditem = document.createElement("p");
|
|
baditem.classList.add("nocolor");
|
|
baditem.classList.add("itemp");
|
|
baditem.textContent =
|
|
item.statMap.get("displayName") +
|
|
" requires level " +
|
|
item_lvl +
|
|
" to use.";
|
|
lvlWarning.appendChild(baditem);
|
|
}
|
|
}
|
|
if (lvlWarning) {
|
|
summarybox.append(lvlWarning);
|
|
}
|
|
for (const [setName, count] of build.activeSetCounts) {
|
|
const bonus = sets.get(setName).bonuses[count - 1];
|
|
if (bonus["illegal"]) {
|
|
let setWarning = document.createElement("p");
|
|
setWarning.classList.add("itemp");
|
|
setWarning.classList.add("warning");
|
|
setWarning.textContent =
|
|
"WARNING: illegal item combination: " + setName;
|
|
summarybox.append(setWarning);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Aggregate stats from all inputs (merges statmaps).
|
|
*
|
|
* Signature: AggregateStatsNode(*args) => StatMap
|
|
*/
|
|
class AggregateStatsNode extends ComputeNode {
|
|
constructor() {
|
|
super("builder-aggregate-stats");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
const output_stats = new Map();
|
|
for (const [k, v] of input_map.entries()) {
|
|
for (const [k2, v2] of v.entries()) {
|
|
merge_stat(output_stats, k2, v2);
|
|
}
|
|
}
|
|
return output_stats;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Aggregate editable ID stats with build and weapon type.
|
|
*
|
|
* Signature: AggregateEditableIDNode(build: Build, weapon: Item, *args) => StatMap
|
|
*/
|
|
class AggregateEditableIDNode extends ComputeNode {
|
|
constructor() {
|
|
super("builder-aggregate-inputs");
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
const build = input_map.get("build");
|
|
input_map.delete("build");
|
|
|
|
const output_stats = new Map(build.statMap);
|
|
for (const [k, v] of input_map.entries()) {
|
|
output_stats.set(k, v);
|
|
}
|
|
|
|
output_stats.set(
|
|
"classDef",
|
|
classDefenseMultipliers.get(build.weapon.statMap.get("type"))
|
|
);
|
|
return output_stats;
|
|
}
|
|
}
|
|
|
|
let edit_id_output;
|
|
function resetEditableIDs() {
|
|
edit_id_output.notify();
|
|
}
|
|
/**
|
|
* Set the editble id fields.
|
|
*
|
|
* Signature: EditableIDSetterNode(build: Build) => null
|
|
*/
|
|
class EditableIDSetterNode extends ComputeNode {
|
|
constructor(notify_nodes) {
|
|
super("builder-id-setter");
|
|
this.notify_nodes = notify_nodes.slice();
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
if (input_map.size !== 1) {
|
|
throw "EditableIDSetterNode accepts exactly one input (build)";
|
|
}
|
|
const [build] = input_map.values(); // Extract values, pattern match it into size one list and bind to first element
|
|
for (const id of editable_item_fields) {
|
|
const val = build.statMap.get(id);
|
|
document.getElementById(id).value = val;
|
|
document.getElementById(id + "-base").textContent =
|
|
"Original Value: " + val;
|
|
}
|
|
}
|
|
|
|
notify() {
|
|
this.mark_dirty();
|
|
this.update();
|
|
// NOTE: DO NOT merge these loops for performance reasons!!!
|
|
for (const node of this.notify_nodes) {
|
|
node.mark_dirty();
|
|
}
|
|
for (const node of this.notify_nodes) {
|
|
node.update();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set skillpoint fields from build.
|
|
* This is separate because..... because of the way we work with edit ids vs skill points during the load sequence....
|
|
*
|
|
* Signature: SkillPointSetterNode(build: Build) => null
|
|
*/
|
|
class SkillPointSetterNode extends ComputeNode {
|
|
constructor(notify_nodes) {
|
|
super("builder-skillpoint-setter");
|
|
this.notify_nodes = notify_nodes.slice();
|
|
}
|
|
|
|
compute_func(input_map) {
|
|
if (input_map.size !== 1) {
|
|
throw "SkillPointSetterNode accepts exactly one input (build)";
|
|
}
|
|
const [build] = input_map.values(); // Extract values, pattern match it into size one list and bind to first element
|
|
for (const [idx, elem] of skp_order.entries()) {
|
|
document.getElementById(elem + "-skp").value =
|
|
build.total_skillpoints[idx];
|
|
}
|
|
// NOTE: DO NOT merge these loops for performance reasons!!!
|
|
for (const node of this.notify_nodes) {
|
|
node.mark_dirty();
|
|
}
|
|
for (const node of this.notify_nodes) {
|
|
node.update();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get number (possibly summed) from a text input.
|
|
*
|
|
* Signature: SumNumberInputNode() => int
|
|
*/
|
|
class SumNumberInputNode extends InputNode {
|
|
compute_func(input_map) {
|
|
let value = this.input_field.value;
|
|
if (value === "") {
|
|
value = "0";
|
|
}
|
|
|
|
let input_num = 0;
|
|
if (value.includes("+")) {
|
|
let skp = value.split("+");
|
|
for (const s of skp) {
|
|
const val = parseInt(s, 10);
|
|
if (isNaN(val)) {
|
|
return null;
|
|
}
|
|
input_num += val;
|
|
}
|
|
} else {
|
|
input_num = parseInt(value, 10);
|
|
if (isNaN(input_num)) {
|
|
return null;
|
|
}
|
|
}
|
|
return input_num;
|
|
}
|
|
}
|
|
|
|
let item_nodes = [];
|
|
let powder_nodes = [];
|
|
let edit_input_nodes = [];
|
|
let skp_inputs = [];
|
|
let build_node;
|
|
let stat_agg_node;
|
|
let edit_agg_node;
|
|
let atree_graph_creator;
|
|
|
|
function builder_graph_init() {
|
|
// Phase 1/3: Set up item input, propagate updates, etc.
|
|
|
|
// Bind item input fields to input nodes, and some display stuff (for auto colorizing stuff).
|
|
for (const [eq, display_elem, none_item] of zip3(
|
|
equipment_fields,
|
|
build_fields,
|
|
none_items
|
|
)) {
|
|
let input_field = document.getElementById(eq + "-choice");
|
|
let item_image = document.getElementById(eq + "-img");
|
|
|
|
let item_input = new ItemInputNode(eq + "-input", input_field, none_item);
|
|
item_nodes.push(item_input);
|
|
new ItemInputDisplayNode(eq + "-input-display", eq, item_image).link_to(
|
|
item_input
|
|
);
|
|
new ItemDisplayNode(eq + "-item-display", display_elem).link_to(item_input);
|
|
//new PrintNode(eq+'-debug').link_to(item_input);
|
|
//document.querySelector("#"+eq+"-tooltip").setAttribute("onclick", "collapse_element('#"+ eq +"-tooltip');"); //toggle_plus_minus('" + eq + "-pm');
|
|
}
|
|
for (const [eq, none_item] of zip2(tome_fields, [
|
|
none_tomes[0],
|
|
none_tomes[0],
|
|
none_tomes[1],
|
|
none_tomes[1],
|
|
none_tomes[1],
|
|
none_tomes[1],
|
|
none_tomes[2],
|
|
])) {
|
|
let input_field = document.getElementById(eq + "-choice");
|
|
let item_image = document.getElementById(eq + "-img");
|
|
|
|
let item_input = new ItemInputNode(eq + "-input", input_field, none_item);
|
|
item_nodes.push(item_input);
|
|
new ItemInputDisplayNode(eq + "-input-display", eq, item_image).link_to(
|
|
item_input
|
|
);
|
|
}
|
|
|
|
// weapon image changer node.
|
|
let weapon_image = document.getElementById("weapon-img");
|
|
let weapon_dps = document.getElementById("weapon-dps");
|
|
new WeaponInputDisplayNode("weapon-type", weapon_image, weapon_dps).link_to(
|
|
item_nodes[8]
|
|
);
|
|
|
|
// Level input node.
|
|
let level_input = new InputNode(
|
|
"level-input",
|
|
document.getElementById("level-choice")
|
|
);
|
|
|
|
// linking to atree verification
|
|
atree_validate.link_to(level_input, "level");
|
|
|
|
// "Build" now only refers to equipment and level (no powders). Powders are injected before damage calculation / stat display.
|
|
build_node = new BuildAssembleNode();
|
|
for (const input of item_nodes) {
|
|
build_node.link_to(input);
|
|
}
|
|
build_node.link_to(level_input);
|
|
|
|
let build_encode_node = new BuildEncodeNode();
|
|
build_encode_node.link_to(build_node, "build");
|
|
|
|
let url_update_node = new URLUpdateNode();
|
|
url_update_node.link_to(build_encode_node, "build-str");
|
|
|
|
for (const input of powder_inputs) {
|
|
let powder_node = new PowderInputNode(
|
|
input,
|
|
document.getElementById(input)
|
|
);
|
|
powder_nodes.push(powder_node);
|
|
build_encode_node.link_to(powder_node, input);
|
|
}
|
|
|
|
item_nodes[0].link_to(powder_nodes[0], "powdering");
|
|
item_nodes[1].link_to(powder_nodes[1], "powdering");
|
|
item_nodes[2].link_to(powder_nodes[2], "powdering");
|
|
item_nodes[3].link_to(powder_nodes[3], "powdering");
|
|
item_nodes[8].link_to(powder_nodes[4], "powdering");
|
|
|
|
// Phase 2/3: Set up editable IDs, skill points; use decodeBuild() skill points, calculate damage
|
|
|
|
// Create one node that will be the "aggregator node" (listen to all the editable id nodes, as well as the build_node (for non editable stats) and collect them into one statmap)
|
|
stat_agg_node = new AggregateStatsNode();
|
|
edit_agg_node = new AggregateEditableIDNode();
|
|
edit_agg_node.link_to(build_node, "build");
|
|
for (const field of editable_item_fields) {
|
|
// Create nodes that listens to each editable id input, the node name should match the "id"
|
|
const elem = document.getElementById(field);
|
|
const node = new SumNumberInputNode("builder-" + field + "-input", elem);
|
|
|
|
edit_agg_node.link_to(node, field);
|
|
edit_input_nodes.push(node);
|
|
}
|
|
// Edit IDs setter declared up here to set ids so they will be populated by default.
|
|
edit_id_output = new EditableIDSetterNode(edit_input_nodes); // Makes shallow copy of list.
|
|
edit_id_output.link_to(build_node);
|
|
|
|
for (const skp of skp_order) {
|
|
const elem = document.getElementById(skp + "-skp");
|
|
const node = new SumNumberInputNode("builder-" + skp + "-input", elem);
|
|
|
|
edit_agg_node.link_to(node, skp);
|
|
build_encode_node.link_to(node, skp);
|
|
edit_input_nodes.push(node);
|
|
skp_inputs.push(node);
|
|
}
|
|
stat_agg_node.link_to(edit_agg_node);
|
|
|
|
// Phase 3/3: Set up atree stuff.
|
|
|
|
let class_node = new PlayerClassNode("builder-class").link_to(build_node);
|
|
// These two are defined in `atree.js`
|
|
atree_node.link_to(class_node, "player-class");
|
|
atree_merge.link_to(class_node, "player-class");
|
|
atree_stats.link_to(build_node, "build");
|
|
stat_agg_node.link_to(atree_stats, "atree-stats");
|
|
|
|
build_encode_node
|
|
.link_to(atree_node, "atree")
|
|
.link_to(atree_state_node, "atree-state");
|
|
|
|
// ---------------------------------------------------------------
|
|
// Trigger the update cascade for build!
|
|
// ---------------------------------------------------------------
|
|
for (const input_node of item_nodes.concat(powder_nodes)) {
|
|
input_node.update();
|
|
}
|
|
armor_powder_node.update();
|
|
level_input.update();
|
|
|
|
atree_graph_creator = new AbilityTreeEnsureNodesNode(
|
|
build_node,
|
|
stat_agg_node
|
|
).link_to(atree_collect_spells, "spells");
|
|
|
|
// kinda janky, manually set atree and update. Some wasted compute here
|
|
if (atree_data !== null && atree_node.value !== null) {
|
|
// janky check if atree is valid
|
|
const atree_state = atree_state_node.value;
|
|
if (atree_data.length > 0) {
|
|
const active_nodes = decode_atree(atree_node.value, atree_data);
|
|
for (const node of active_nodes) {
|
|
atree_set_state(atree_state.get(node.ability.id), true);
|
|
}
|
|
atree_state_node.mark_dirty().update();
|
|
}
|
|
}
|
|
|
|
// Powder specials.
|
|
let powder_special_calc = new PowderSpecialCalcNode().link_to(
|
|
powder_special_input,
|
|
"powder-specials"
|
|
);
|
|
new PowderSpecialDisplayNode()
|
|
.link_to(powder_special_input, "powder-specials")
|
|
.link_to(stat_agg_node, "stats")
|
|
.link_to(build_node, "build");
|
|
stat_agg_node.link_to(powder_special_calc, "powder-boost");
|
|
stat_agg_node.link_to(armor_powder_node, "armor-powder");
|
|
powder_special_input.update();
|
|
|
|
// Potion boost.
|
|
stat_agg_node.link_to(boosts_node, "potion-boost");
|
|
|
|
// Also do something similar for skill points
|
|
|
|
let build_disp_node = new BuildDisplayNode();
|
|
build_disp_node.link_to(build_node, "build");
|
|
build_disp_node.link_to(stat_agg_node, "stats");
|
|
|
|
for (const node of edit_input_nodes) {
|
|
node.update();
|
|
}
|
|
|
|
let skp_output = new SkillPointSetterNode(edit_input_nodes);
|
|
skp_output.link_to(build_node);
|
|
|
|
let build_warnings_node = new DisplayBuildWarningsNode();
|
|
build_warnings_node.link_to(build_node, "build");
|
|
for (const [skp_input, skp] of zip2(skp_inputs, skp_order)) {
|
|
build_warnings_node.link_to(skp_input, skp);
|
|
}
|
|
build_warnings_node.update();
|
|
|
|
// call node.update() for each skillpoint node and stat edit listener node manually
|
|
// NOTE: the text boxes for skill points are already filled out by decodeBuild() so this will fix them
|
|
// this will propagate the update to the `stat_agg_node`, and then to damage calc
|
|
|
|
console.log("Set up graph");
|
|
graph_live_update = true;
|
|
}
|