Risk board game - best practices, private vs public variables and methods
If you stop worrying about &quot;privates&quot; everything becomes much cleaner.

By using closure with my &quot;country&quot; object am I wasting memory, and hence should be using prototypical inheritance?

The closure is a small performance hit. For a board game it won't matter. But if you decide not to use local variables in closures (AKA &quot;privates&quot;) then you can get rid of the closure and use a constructor function / prototype.
One benefit of doing that is that it will give tools like eclipse, webkit inspector, etc. a clue as to how things are represented in your code so they can annotate stuff for you, provide pop-up help, autocompletion, things like that.

My jsonify code seems redundant, I assume there's a more correct way to do this?
Mixing private instance variables like &quot;countries&quot; and public instance variables looks ugly, is that how it's supposed to be done?

Getting rid of &quot;privates&quot; and making these all properties would be the easiest way to fix both of these issues. In that case the get_* functions could also go.
A few other points:

Usually javascript identifiers are written as camelCase, not underscore_separated.

The quotes around the property names in the object literal are not needed for character sequences that would otherwise be valid identifiers.

to is a confusing variable name, try to find something more descriptive. I changed it to country in the example below.



I would probably write it something like this:
function Country (name, connectedTo){
    this.name = name;
    this.connectedTo = connectedTo;
    // other constructor stuff...
}

Country.prototype = {
    
    // default properties
    
    numTroops: 0,

    player: null,
    
    // functions
    
    isOwnedBy: function(inPlayer){
        return inPlayer == this.player;
    },
    isTouching: function(country){
        // best to avoid typeof if possible
        if (country.name){ 
            country = country.name;
        }
        // this performs somewhat better than evaluating foo.length every iteration
        for (var i = 0, len = this.connectedTo.length; i &lt; len; i++){
            if (this.connectedTo[i] === country){
                return true;
            }
        }
        return false;
    },
    setState: function(inPlayer, inNumTroops){
        this.player = inPlayer;
        this.numTroops = inNumTroops;
    },
    toString: function(){
        return '[country '+this.name+']';
    },
    getAscii: function(){
        return this.name + ' owned by ' + this.player + ' with '+ this.numTroops +
            '\n        connected to ' + this.connectedTo;
    }
};


If setState is only called once per object, you might consider making that code part of the constructor and getting rid of setState.