wynnbuilder-forked-for-changes/skillpoints.js

208 lines
7.9 KiB
JavaScript
Raw Normal View History

2021-01-07 06:41:41 +00:00
function calculate_skillpoints(equipment, weapon) {
// Calculate equipment equipping order and required skillpoints.
// Return value: [equip_order, best_skillpoints, final_skillpoints, best_total];
let fixed = [];
let consider = [];
let noboost = [];
2021-02-13 00:43:21 +00:00
let crafted = [];
2021-01-07 06:41:41 +00:00
for (const item of equipment) {
2021-02-14 23:33:37 +00:00
if (item.get("crafted")) {
2021-02-13 00:43:21 +00:00
crafted.push(item);
}
2021-03-21 04:00:34 +00:00
else if (item.get("reqs").every(x => x === 0) && item.get("skillpoints").every(x => x >= 0)) {
// All reqless item without -skillpoints.
2021-02-14 23:33:37 +00:00
fixed.push(item);
}
// TODO hack: We will treat ALL set items as unsafe :(
else if (item.get("skillpoints").every(x => x === 0) && item.get("set") === null) {
2021-01-07 06:41:41 +00:00
noboost.push(item);
}
else {
consider.push(item);
}
}
function apply_skillpoints(skillpoints, item, activeSetCounts) {
2021-01-07 06:41:41 +00:00
for (let i = 0; i < 5; i++) {
skillpoints[i] += item.get("skillpoints")[i];
2021-01-07 06:41:41 +00:00
}
const setName = item.get("set");
if (setName) { // undefined/null means no set.
let setCount = activeSetCounts.get(setName);
let old_bonus = {};
if (setCount) {
old_bonus = sets[setName].bonuses[setCount-1];
activeSetCounts.set(setName, setCount + 1);
}
else {
setCount = 0;
activeSetCounts.set(setName, 1);
}
const new_bonus = sets[setName].bonuses[setCount];
//let skp_order = ["str","dex","int","def","agi"];
for (const i in skp_order) {
const delta = (new_bonus[skp_order[i]] || 0) - (old_bonus[skp_order[i]] || 0);
skillpoints[i] += delta;
}
2021-01-07 06:41:41 +00:00
}
}
function apply_to_fit(skillpoints, item, skillpoint_min, activeSetCounts) {
2021-01-07 06:41:41 +00:00
let applied = [0, 0, 0, 0, 0];
let total = 0;
for (let i = 0; i < 5; i++) {
if (item.get("skillpoints")[i] < 0 && skillpoint_min[i]) {
2021-03-19 10:00:01 +00:00
const unadjusted = skillpoints[i] + item.get("skillpoints")[i];
const delta = skillpoint_min[i] - unadjusted;
if (delta > 0) {
applied[i] += delta;
total += delta;
}
2021-01-07 08:34:31 +00:00
}
if (item.get("reqs")[i] == 0) continue;
2021-03-21 04:00:34 +00:00
skillpoint_min[i] = Math.max(skillpoint_min[i], item.get("reqs")[i]);// + item.get("skillpoints")[i]);
const req = item.get("reqs")[i];
2021-01-07 06:41:41 +00:00
const cur = skillpoints[i];
if (req > cur) {
const diff = req - cur;
applied[i] += diff;
total += diff;
}
}
const setName = item.get("set");
if (setName) { // undefined/null means no set.
const setCount = activeSetCounts.get(setName);
if (setCount) {
const old_bonus = sets[setName].bonuses[setCount-1];
const new_bonus = sets[setName].bonuses[setCount];
//let skp_order = ["str","dex","int","def","agi"];
for (const i in skp_order) {
2021-03-19 10:00:01 +00:00
const set_delta = (new_bonus[skp_order[i]] || 0) - (old_bonus[skp_order[i]] || 0);
if (set_delta < 0 && skillpoint_min[i]) {
const unadjusted = skillpoints[i] + set_delta;
const delta = skillpoint_min[i] - unadjusted;
if (delta > 0) {
applied[i] += delta;
total += delta;
}
}
}
}
}
2021-01-07 06:41:41 +00:00
return [applied, total];
}
// Separate out the no req items and add them to the static skillpoint base.
let static_skillpoints_base = [0, 0, 0, 0, 0]
let static_activeSetCounts = new Map()
2021-01-07 06:41:41 +00:00
for (const item of fixed) {
apply_skillpoints(static_skillpoints_base, item, static_activeSetCounts);
2021-01-07 06:41:41 +00:00
}
2021-01-08 20:36:03 +00:00
let best = consider.concat(noboost);
let final_skillpoints = static_skillpoints_base.slice();
2021-01-07 06:41:41 +00:00
let best_skillpoints = [0, 0, 0, 0, 0];
let best_total = Infinity;
let best_activeSetCounts = static_activeSetCounts;
2021-01-07 06:41:41 +00:00
2021-02-13 00:43:21 +00:00
let allFalse = [0, 0, 0, 0, 0];
if (consider.length > 0 || noboost.length > 0 || crafted.length > 0) {
2021-01-07 06:41:41 +00:00
// Try every combination and pick the best one.
for (let permutation of perm(consider)) {
let activeSetCounts = new Map(static_activeSetCounts);
let has_skillpoint = allFalse.slice();
2021-01-07 06:41:41 +00:00
permutation = permutation.concat(noboost);
let skillpoints_applied = [0, 0, 0, 0, 0];
// Complete slice is a shallow copy.
let skillpoints = static_skillpoints_base.slice();
let total_applied = 0;
let result;
let needed_skillpoints;
let total_diff;
for (const item of permutation) {
result = apply_to_fit(skillpoints, item, has_skillpoint, activeSetCounts);
2021-01-07 06:41:41 +00:00
needed_skillpoints = result[0];
total_diff = result[1];
for (let i = 0; i < 5; ++i) {
skillpoints_applied[i] += needed_skillpoints[i];
skillpoints[i] += needed_skillpoints[i];
}
apply_skillpoints(skillpoints, item, activeSetCounts);
2021-01-07 06:41:41 +00:00
total_applied += total_diff;
if (total_applied >= best_total) {
break;
}
}
2021-02-13 00:43:21 +00:00
// Crafted skillpoint does not count initially.
for (const item of crafted) {
//console.log(item)
2021-02-22 07:23:00 +00:00
result = apply_to_fit(skillpoints, item, allFalse.slice(), activeSetCounts);
//console.log(result)
2021-02-13 00:43:21 +00:00
needed_skillpoints = result[0];
total_diff = result[1];
for (let i = 0; i < 5; ++i) {
skillpoints_applied[i] += needed_skillpoints[i];
skillpoints[i] += needed_skillpoints[i];
}
2021-02-22 07:23:00 +00:00
total_applied += total_diff;
2021-02-13 00:43:21 +00:00
}
if (total_applied >= best_total) {
continue;
}
let pre = skillpoints.slice();
result = apply_to_fit(skillpoints, weapon, allFalse.slice(), activeSetCounts);
2021-01-07 06:41:41 +00:00
needed_skillpoints = result[0];
total_diff = result[1];
for (let i = 0; i < 5; ++i) {
skillpoints_applied[i] += needed_skillpoints[i];
skillpoints[i] += needed_skillpoints[i];
}
apply_skillpoints(skillpoints, weapon, activeSetCounts);
2021-01-07 06:41:41 +00:00
total_applied += total_diff;
2021-02-13 00:43:21 +00:00
// Applying crafted item skill points last.
for (const item of crafted) {
apply_skillpoints(skillpoints, item, activeSetCounts);
//total_applied += total_diff;
2021-02-13 00:43:21 +00:00
}
2021-01-07 06:41:41 +00:00
if (total_applied < best_total) {
best = permutation;
final_skillpoints = skillpoints;
best_skillpoints = skillpoints_applied;
best_total = total_applied;
best_activeSetCounts = activeSetCounts;
2021-01-07 06:41:41 +00:00
}
}
}
else {
2021-01-08 20:36:03 +00:00
best_total = 0;
result = apply_to_fit(final_skillpoints, weapon, allFalse.slice(), best_activeSetCounts);
needed_skillpoints = result[0];
total_diff = result[1];
for (let i = 0; i < 5; ++i) {
2021-01-08 20:36:03 +00:00
best_skillpoints[i] += needed_skillpoints[i];
final_skillpoints[i] += needed_skillpoints[i];
}
apply_skillpoints(final_skillpoints, weapon, best_activeSetCounts);
2021-01-08 20:36:03 +00:00
best_total += total_diff;
2021-01-07 06:41:41 +00:00
}
2021-02-14 23:33:37 +00:00
let equip_order = fixed.concat(best).concat(crafted);
return [equip_order, best_skillpoints, final_skillpoints, best_total, best_activeSetCounts];
2021-01-07 06:41:41 +00:00
}