robot.js

var __extend = new Extender();

var Robot = function(robot) {

};

__extend( Robot.prototype, {
  
  onIdle: function(e) {
    var robot = e.robot;
    robot.ahead(100);
    robot.rotateCannon(360);
    robot.back(100);
    robot.rotateCannon(360);
	},
  
  onWallCollision: function(e) {
    var robot = e.robot;
  },
  
  onRobotCollision: function(e) {
    var robot = e.robot;
  },
  
  onScannedRobot: function(e) {
    var robot = e.robot;
    robot.stop();
    robot.fire();
	},
  
  onHitByBullet: function(e) {
    var robot = e.robot;
    robot.turn(45);
    robot.move(5, 1);
  }
  
});

function Extender(){
  function type(obj){
    var checker = {};
    var types = "Boolean Number String Function Array Date RegExp Object".split(" ");
    for(var i in types){
      checker[ "[object " + types[i] + "]" ] = types[i].toLowerCase();
    }
    return obj == null ?
        String( obj ) :
        checker[ Object.prototype.toString.call(obj) ] || "object";
  }
  function isFunction(obj){
    return type(obj) === "function";
  }
  function isWindow(obj){
    return obj != null && obj == obj.window;
  }
  function isPlainObject( obj ) {
    var hasOwn = Object.prototype.hasOwnProperty;
    // Must be an Object.
    // Because of IE, we also have to check the presence of the constructor property.
    // Make sure that DOM nodes and window objects don't pass through, as well
    if ( !obj || type(obj) !== "object" || obj.nodeType || isWindow( obj ) ) {
      return false;
    }
 
    try {
      // Not own constructor property must be Object
      if ( obj.constructor &&
        !hasOwn.call(obj, "constructor") &&
        !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
        return false;
      }
    } catch ( e ) {
      // IE8,9 Will throw exceptions on certain host objects #9897
      return false;
    }
 
    // Own properties are enumerated firstly, so to speed up,
    // if last one is own, then all properties are own.
    var key;
    for ( key in obj ) {}
    return key === undefined || hasOwn.call( obj, key );
  }
  function isArray(obj){
    return type(obj) === "array";
  }
  // Make this public
  this.extend = function() {
    var options, name, src, copy, copyIsArray, clone,
      target = arguments[0] || {},
      i = 1,
      length = arguments.length,
      deep = false;
 
    // Handle a deep copy situation
    if ( typeof target === "boolean" ) {
      deep = target;
      target = arguments[1] || {};
      // skip the boolean and the target
      i = 2;
    }
 
    // Handle case when target is a string or something (possible in deep copy)
    if ( typeof target !== "object" && !isFunction(target) ) {
      target = {};
    }
 
    for ( ; i < length; i++ ) {
      // Only deal with non-null/undefined values
      if ( (options = arguments[ i ]) != null ) {
        // Extend the base object
        for ( name in options ) {
          src = target[ name ];
          copy = options[ name ];
 
          // Prevent never-ending loop
          if ( target === copy ) {
            continue;
          }
 
          // Recurse if we're merging plain objects or arrays
          if ( deep && copy && ( isPlainObject(copy) || (copyIsArray = isArray(copy)) ) ) {
            if ( copyIsArray ) {
              copyIsArray = false;
              clone = src && isArray(src) ? src : [];
 
            } else {
              clone = src && isPlainObject(src) ? src : {};
            }
            // Never move original objects, clone them
            target[ name ] = this.extend( deep, clone, copy );
 
          // Don't bring in undefined values
          } else if ( copy !== undefined ) {
            target[ name ] = copy;
          }
        }
      }
    }
 
    // Return the modified object
    return target;
  };
 
  return this.extend;
}