From 9f4efc31ed2c16c9a7a3cec8efc82617a3b7009d Mon Sep 17 00:00:00 2001 From: Sabe Jones Date: Mon, 30 Dec 2013 11:39:53 -0600 Subject: [PATCH] Break out autoAllocate to its own function --- dist/habitrpg-shared.js | 130 +++++++++++++++++++++------------------- script/index.coffee | 62 ++++++++++--------- 2 files changed, 100 insertions(+), 92 deletions(-) diff --git a/dist/habitrpg-shared.js b/dist/habitrpg-shared.js index 518e0b51f3..19b4142610 100644 --- a/dist/habitrpg-shared.js +++ b/dist/habitrpg-shared.js @@ -11962,8 +11962,72 @@ var process=require("__browserify_process");(function() { {update} if aggregated changes, pass in userObj as update. otherwise commits will be made immediately */ + autoAllocate: function() { + var diff, ideal, preference, suggested, tallies; + switch (user.preferences.allocationMode) { + case "flat": + suggested = Math.min(user.stats.str, user.stats.int, user.stats.con, user.stats.per); + if (user.stats.int === suggested) { + return "int"; + } else if (user.stats.per === suggested) { + return "per"; + } else if (user.stats.str === suggested) { + return "per"; + } else { + return "con"; + } + break; + case "classbased": + ideal = [user.stats.lvl / 7 * 3, user.stats.lvl / 7 * 2, user.stats.lvl / 7, user.stats.lvl / 7]; + switch (user.stats["class"]) { + case "wizard": + preference = ["int", "per", "con", "str"]; + break; + case "rogue": + preference = ["per", "str", "int", "con"]; + break; + case "healer": + preference = ["con", "int", "str", "per"]; + break; + default: + preference = ["str", "con", "per", "int"]; + } + diff = [user.stats[preference[0]] - ideal[0], user.stats[preference[1]] - ideal[1], user.stats[preference[2]] - ideal[2], user.stats[preference[3]] - ideal[3]]; + suggested = _.findIndex(diff, (function(val) { + if (val === _.min(diff)) { + return true; + } + })); + if (suggested === -1) { + return "str"; + } else { + return preference[suggested]; + } + break; + case "taskbased": + tallies = _.reduce(user.tasks, (function(m, v) { + m[v.attribute || 'str'] += v.value; + return m; + }), { + str: 0, + int: 0, + con: 0, + per: 0 + }); + suggested = _.reduce(tallies, (function(m, v, k) { + if (v > tallies[m]) { + return k; + } else { + return m; + } + }), 'str'); + return suggested; + default: + return "str"; + } + }, updateStats: function(stats) { - var diff, ideal, preference, suggested, tallies, tnl; + var suggested, tnl; if (stats.hp <= 0) { return user.stats.hp = 0; } @@ -11982,68 +12046,8 @@ var process=require("__browserify_process");(function() { user.stats.lvl++; tnl = api.tnl(user.stats.lvl); if (user.preferences.automaticAllocation) { - switch (user.preferences.allocationMode) { - case "flat": - suggested = Math.min(user.stats.str, user.stats.int, user.stats.con, user.stats.per); - if (user.stats.int === suggested) { - user.stats.int++; - } else if (user.stats.per === suggested) { - user.stats.per++; - } else if (user.stats.str === suggested) { - user.stats.str++; - } else { - user.stats.con++; - } - break; - case "classbased": - ideal = [user.stats.lvl / 7 * 3, user.stats.lvl / 7 * 2, user.stats.lvl / 7, user.stats.lvl / 7]; - switch (user.stats["class"]) { - case "wizard": - preference = ["int", "per", "con", "str"]; - break; - case "rogue": - preference = ["per", "str", "int", "con"]; - break; - case "healer": - preference = ["con", "int", "str", "per"]; - break; - default: - preference = ["str", "con", "per", "int"]; - } - diff = [user.stats[preference[0]] - ideal[0], user.stats[preference[1]] - ideal[1], user.stats[preference[2]] - ideal[2], user.stats[preference[3]] - ideal[3]]; - suggested = _.findIndex(diff, (function(val) { - if (val === _.min(diff)) { - return true; - } - })); - if (suggested === -1) { - user.stats.str++; - } else { - user.stats[preference[suggested]]++; - } - break; - case "taskbased": - tallies = _.reduce(user.tasks, (function(m, v) { - m[v.attribute || 'str'] += v.value; - return m; - }), { - str: 0, - int: 0, - con: 0, - per: 0 - }); - suggested = _.reduce(tallies, (function(m, v, k) { - if (v > tallies[m]) { - return k; - } else { - return m; - } - }), 'str'); - user.stats[suggested]++; - break; - default: - user.stats.str++; - } + suggested = user.fns.autoAllocate(); + user.stats[suggested]++; } else { user.stats.points = user.stats.lvl - (user.stats.con + user.stats.str + user.stats.per + user.stats.int); } diff --git a/script/index.coffee b/script/index.coffee index eb6d254a56..da65b9ac0f 100644 --- a/script/index.coffee +++ b/script/index.coffee @@ -941,6 +941,37 @@ api.wrap = (user) -> {stats} new stats {update} if aggregated changes, pass in userObj as update. otherwise commits will be made immediately ### + autoAllocate: -> + switch user.preferences.allocationMode + when "flat" + suggested = Math.min(user.stats.str, user.stats.int, user.stats.con, user.stats.per) + if user.stats.int is suggested # In case of ties, favor INT first, to get the next point sooner + return "int" + else if user.stats.per is suggested # Then favor PER, it's a god stat + return "per" + else if user.stats.str is suggested # Then favor STR, everyone loves crits + return "per" + else + return "con" # CON, the unsexiest of attributes + when "classbased" + # Attributes get 3:2:1:1 per 7 levels. + ideal = [(user.stats.lvl / 7 * 3), (user.stats.lvl / 7 * 2), (user.stats.lvl / 7), (user.stats.lvl / 7)] + # Primary, secondary etc. attributes aren't explicitly defined, so hardcode them. In order as above + switch user.stats.class + when "wizard" then preference = ["int", "per", "con", "str"] + when "rogue" then preference = ["per", "str", "int", "con"] + when "healer" then preference = ["con", "int", "str", "per"] + else preference = ["str", "con", "per", "int"] + # Get the difference between the ideal attribute spread according to level, and the user's current spread. + diff = [(user.stats[preference[0]]-ideal[0]),(user.stats[preference[1]]-ideal[1]),(user.stats[preference[2]]-ideal[2]),(user.stats[preference[3]]-ideal[3])] + suggested = _.findIndex(diff, ((val) -> if val is _.min(diff) then true)) # Returns the index of the first attribute that's furthest behind the ideal + if suggested is -1 then return "str" else return preference[suggested] # If _findIndex failed, we'd get a -1... + when "taskbased" # old logic, temp + tallies = _.reduce user.tasks, ((m,v)-> m[v.attribute or 'str'] += v.value;m), {str:0,int:0,con:0,per:0} + suggested = _.reduce tallies, ((m,v,k)-> if v>tallies[m] then k else m), 'str' + return suggested + else return "str" # if all else fails, dump into STR + updateStats: (stats) -> # Game Over return user.stats.hp=0 if stats.hp <= 0 @@ -966,35 +997,8 @@ api.wrap = (user) -> # Auto-allocate a point, or give them a new manual point if user.preferences.automaticAllocation - switch user.preferences.allocationMode - when "flat" - suggested = Math.min(user.stats.str, user.stats.int, user.stats.con, user.stats.per) - if user.stats.int is suggested # In case of ties, favor INT first, to get the next point sooner - user.stats.int++ - else if user.stats.per is suggested # Then favor PER, it's a god stat - user.stats.per++ - else if user.stats.str is suggested # Then favor STR, everyone loves crits - user.stats.str++ - else - user.stats.con++ # CON, the unsexiest of attributes - when "classbased" - # Attributes get 3:2:1:1 per 7 levels. - ideal = [(user.stats.lvl / 7 * 3), (user.stats.lvl / 7 * 2), (user.stats.lvl / 7), (user.stats.lvl / 7)] - # Primary, secondary etc. attributes aren't explicitly defined, so hardcode them. In order per above - switch user.stats.class - when "wizard" then preference = ["int", "per", "con", "str"] - when "rogue" then preference = ["per", "str", "int", "con"] - when "healer" then preference = ["con", "int", "str", "per"] - else preference = ["str", "con", "per", "int"] - # Get the difference between the ideal attribute spread according to level, and the user's current spread. - diff = [(user.stats[preference[0]]-ideal[0]),(user.stats[preference[1]]-ideal[1]),(user.stats[preference[2]]-ideal[2]),(user.stats[preference[3]]-ideal[3])] - suggested = _.findIndex(diff, ((val) -> if val is _.min(diff) then true)) # Returns the index of the first attribute that's furthest behind the ideal - if suggested is -1 then user.stats.str++ else user.stats[preference[suggested]]++ # If _findIndex failed, we'd get a -1... - when "taskbased" # old logic, temp - tallies = _.reduce user.tasks, ((m,v)-> m[v.attribute or 'str'] += v.value;m), {str:0,int:0,con:0,per:0} - suggested = _.reduce tallies, ((m,v,k)-> if v>tallies[m] then k else m), 'str' - user.stats[suggested]++ - else user.stats.str++ # if all else fails, dump into STR + suggested = user.fns.autoAllocate() + user.stats[suggested]++ else # add new allocatable points. We could do user.stats.points++, but this does a fail-safe just in case user.stats.points = user.stats.lvl - (user.stats.con + user.stats.str + user.stats.per + user.stats.int);