Javascript - Structure for a Reference Table

Of course, you can always create an array of hard keys of all points, however you can also just code for exceptions and stick with the algorithm whenever you can.

Just an idea ... this would require your hero to keep track of his scores rather than recompiling them dynamically, but that's probably a good thing.

//have a map for exceptions
var pointExceptionsMap = {
    '9': {
        off: 3 //3 points of offense on level 9
    }
};

Sylin.prototype.levelUp = function () {
    var ex = pointExceptionsMap[++this.level];

    //update offense points (should be in another function)
    this.offense += (ex && typeof ex.off === 'number')? 
        ex.o /*exception points*/: 
        this.level % 2? 0 : 2; //2 points every 2 levels

};

      

        
        
        
      

    

Then, to level up, you make hero.levelUp()

and get points hero.offense

. I haven't tested anything but this idea. However, if you need to set the level directly, you can either have a function setLevel

that will call the levelUp

desired number of times, but you will have to use a modifier so that you can level up as well.

You can also use my current idea and find an efficient way to implement exceptional algorithms. For example, you could dynamically compile the number of points of violation and then add or remove points from that result based on exceptions. So if you need 2 points every 2 levels, but 3 for level 9, that means adding 1 extra point to the compiled points. However, since when you reach higher levels you want to keep this exception, you will also need to keep track of any added exclusion points.

EDIT: Also, there is nothing stopping you from using the function as a new exclusive algorithm instead of a simple number, and if you plan on tweaking the algorithms, you can simply allow users to override the defaults. For example, you might have a public function updateOffense

that encapsulates logic so that you can override it. It would be like a strategy design pattern .

EDIT2: Here's a complete example of what I was trying to explain, hope it helps!

var Hero = (function () {

    function Hero() {
        this.level = 0;
        this.stats = {
            off: 1,
            def: 0
        };
    }

    Hero.prototype = {
        statsExceptions: {
            '3': {
                off: 3 //get 3 points
            },
            '6': {
                def: function () {
                    //some algorithm, here we just return 4 def points
                    return 4;
                }
            }
        },
        levelUp: function () {
            ++this.level;
            updateStats.call(this, 1);

        },
        levelDown: function () {
            updateStats.call(this, -1);
            --this.level;
        },
        setLevel: function (level) {
            var levelFn = 'level' + (this.level < level? 'Up' : 'Down');

            while (this.level !== level) {
                this[levelFn]();
            }
        },

        statsFns: {
            off: function () {
                return (this.level % 2? 0 : 2);
            },
            def: function () {
                return 1;
            }
        }
    };

    function updateStats(modifier) {
        var stats = this.stats,
            fns = this.statsFns,
            exs = this.statsExceptions,
            level = this.level,
            k, ex, exType;

        for (k in stats) {
            if (stats.hasOwnProperty(k)) {
                ex = exs[level];
                ex = ex? ex[k] : void(0);
                exType = typeof ex;

                stats[k] += (exType === 'undefined'?
                    /*no exception*/
                    fns[k].call(this) :
                    /*exception*/
                    exType === 'function' ? ex.call(this) : ex) * modifier;
            }
        }
    }

    return Hero;
})();

var h = new Hero();

console.log(h.stats);

h.setLevel(6);

console.log(h.stats);

h.setLevel(0);

console.log(h.stats);

h.levelUp();

console.log(h.stats);

//create another type of Hero, with other rules
function ChuckNorris() {
    Hero.call(this); //call parent constructor
}

ChuckNorris.prototype = Object.create(Hero.prototype);

//Chuck gets 200 offense points per level y default
ChuckNorris.prototype.statsFns.off = function () {
    return 200;
};

//Not exceptions for him!
ChuckNorris.prototype.statsExceptions = {};

console.info('Chuck is coming!');

var c = new ChuckNorris();

c.setLevel(10);

console.log(c.stats);