Players.mod()

Players.mod(key, value, accessor, target, refresh, self);

// add a spectators property to the Players[] array
// will return an array of spectators player objects
Players.mod(
  // key name
  "spectators",
 
  // value: getter function
  function() {
	// note: see Players.js source for examples of caching the list
    return this.filter(function(player) {
      return player.isSpectator;
    });
  },
 
  // accessor? true = read-only (no setter function)
  true,
 
  // target players objects?: false = target main Players[] array
  false
);
 
// Let's use our new accessor:
Players.spectators // an array of spectator players objects

// add .isMe to all players objects (no target specified)
// will return true if that player is me, otherwise false
Players.mod(
  // key name
  "isMe",
  // value: getter function
  function() {
    return this.id == me;
  },
 
  // accessor? true = read-only (no setter function)
  true
 
  // target not specified, so default to all players objects (true)
);
 
// Let's use our new accessor:
Players.forEach(function(player) {
  player.isMe // true if player.id == me, otherwise false
});

var found = false; // cache result in the closure
 
// add .isUSM only to Scavenger players object
// will return true if Ultimate Scavenger Mod is detected
Players.mod(
  // key name
  "isUSM",
 
  // value: getter function
  function() {
    // might take several attempts to spot something USM-like
    // so can't really treat isUSM == false as certain
    if (found) return true;
    // only USM has Cranes...
    return (enumDroid(this.id, DROID_CONSTRUCT).some(function(truck) {
      if (truck.name == "Crane") {
        found = true; // cache that we detected USM
        return true;
      }
    }));
  },
 
  // accessor? true = read-only (no setter function)
  null,
 
  // target = only players objects this function approves
  function(player) {
    return player.isScavenger; // approve if player.isScavenger
  }
);
 

// Let's use our new accessor:
Players.scavenger.isUSM // true if USM, otherwise false
 
// Other players objects didn't get approved:
Players.me.isUSM // ReferenceError (property not defined)

void (function exampleMod() { // sandbox
 
  // self descriptor object
  var self = {
    file: "exampleMod.js",
    ver : 0.1
  };
  // define dependencies
  var dependencies = {
    "Players.js": 1.0 // obviously set to the right version
  }
  // check dependencies available (throws error if not)
  uNeed(self, dependencies); // Util.js
 
  // a place to store some values
  // will be accessible to all functions in this sandbox,
  // even when they are put in to the Players API
  // (learn about 'closures' if you don't know why)
  var values = {};
  
  // define our getter function
  var getter = function() {
    // 'this' will be the players object the getter is invoked on
    return values[this.id];
  }
 
  // define or setter function
  var setter = function(value) {
    values[this.id] = value;
  }
 
  // define a refresh function that clears all our notes
  // this will be invoked after Players.refresh() is invoked
  // so we can safely use Players.forEach()
  var refresh = function() {
    Players.forEach(function(player) {
      values[player.id] = null;
    });
  }
 
  // initialise our values (set them all to null)
  refresh();
 
  // mod the players API (will throw an error if something is wrong)
  Players.mod(
    "notes", // key name
    getter,  // value: getter function
    setter,  // accessor? yes, with setter function
    true,    // target = all players objects
    refresh, // refresh function
    self     // self descriptor
  );
 
  // indicate our mod is available
  uProvide(self);
 
})(); // close sandbox and run it
 
// Let's use our new accessor:
Players.me.notes = "This is me!!";
 
console(Players.me.notes); // "This is me!!"
 
Players.refresh(); // invokes our refresh function, so all notes cleared
 
console(Players.me.notes); // "null"
 
// Optionally we can check the mod was applied before using the 'notes' accessor:
if (uHas("exampleMod.js")) {
  // this code only runs if the mod was applied
  Players.scavenger.notes = "Those pesky marauders!";
  console(Players.scavenger.notes); // "Those pesky marauders!"
}

Players.mod(
  "fish",    // key
  "haddock", // value
  false,     // accessor? no, it's a data property
  false      // target = Players[]
);
 
console(Players.fish);   // "haddock"
Players.fish = "kipper"; // .fish is read-only
console(Players.fish);   // still "haddock"

var method = function() {
  // note: 'this' in a method = object the method is added to
  return "halibut";
}
 
Players.mod(
  "fish", // key
  method, // value: function
  false,  // accessor? no, it's a data property
  false   // target = Players[]
);
 
console( Players.fish   ); // "function" because treated as a data property
console( Players.fish() ); // "halibut"  because invoked as a method() property