this.creatine = this.creatine || {};

if (typeof this.tine === 'undefined') {
  this.tine = this.creatine;
}

(function() {
  "use strict";

  creatine.DEFAULT_CONFIG = {
    project          : 'creatine_game',
    width            : 800,
    height           : 600,
    container        : null,
    framerate        : 60,
    showfps          : false,
    background_color : '#000',
    resources        : {
      base_path : './'
    }
  }
  
  creatine.version       = '1.0.0';
  creatine.TOPLEFT       = 'topleft';
  creatine.TOPRIGHT      = 'topright';
  creatine.BOTTOMLEFT    = 'bottomleft';
  creatine.BOTTOMRIGHT   = 'bottomright';
  creatine.TOP           = 'top';
  creatine.BOTTOM        = 'bottom';
  creatine.LEFT          = 'left';
  creatine.RIGHT         = 'right';
  creatine.CENTER        = 'center';
  
  creatine.HORIZONTAL    = 10;
  creatine.VERTICAL      = 11;
  
  creatine.LEFT_TO_RIGHT = 12;
  creatine.RIGHT_TO_LEFT = 13;
  creatine.TOP_TO_BOTTOM = 14;
  creatine.BOTTOM_TO_TOP = 15;
  
  creatine.STRETCH       = 16;
  creatine.FIT           = 17;
  creatine.FILL          = 18;
  creatine.NOSCALE       = 19;

})();
creatine.randomInt = function(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

creatine.clip = function(v, min, max) {
  return Math.max(Math.min(v, max), min);
}

creatine.degrees = function(radians) {
  return radians*57.2957795;
}

creatine.radians = function(degrees) {
  return degrees*0.0174532925;
}

/** a1=from, a2=to. Degrees */
creatine.angleDistance = function(a1, a2) {
  a1 = (a1<0)? 360+a1%360 : a1%360;
  a2 = (a2<0)? 360+a2%360 : a2%360;

  var d = a2-a1;
  if (d<0) d+=360;
  if (d>180) d = 360-d;

  return d;
}
creatine.angleMinDirection = function(a1, a2) {
  a1 = (a1<0)? 360+a1%360 : a1%360;
  a2 = (a2<0)? 360+a2%360 : a2%360;

  var d = a2-a1;
  if (d<0) d+=360;
  if (d>180) {
    return -1;
  } else {
    return 1;
  }
}

// http://stackoverflow.com/questions/11197247/javascript-equivalent-of-jquerys-extend-method
creatine.merge = function() {
  for(var i=1; i<arguments.length; i++) {
    for(var key in arguments[i]) {
      if(arguments[i].hasOwnProperty(key)) {
        if(typeof key === 'object') {
          arguments[0][key] = creatine.merge.call(null, arguments[0][key]||{}, arguments[i][key]);
        } else {
          arguments[0][key] = arguments[i][key];
        }
      }
    }
  }

  return arguments[0];
}

// http://ondrek.me/post/84819614785/how-to-get-json-xml-in-jquery-and-in-vanilla
creatine.getJSON = function(path, success) {
  function callback(data) {
    if (data && typeof success === 'function') {
      success(JSON.parse(data));
    }
  }

  var xmlhttp = new XMLHttpRequest();                 
  xmlhttp.overrideMimeType('application/json');  
  xmlhttp.onreadystatechange = function() {
      ready = (xmlhttp.readyState === 4 && xmlhttp.status === 200);
      callback(ready?xmlhttp.responseText:false);
  };
  xmlhttp.open('GET', path, true);
  xmlhttp.send();
}

creatine.__lastID=0;
creatine.newId = function() {
  return ++creatine.__lastID;
};this.creatine = this.creatine || {};

(function() {
  "use strict";

  /** Game class. */
  var Game = function(config, bootstrap) {
    this.config    = null;
    this.bootstrap = null;
    
    this.canvas     = null;
    this.stage      = null;
    this.create     = null;
    this.load       = null;
    this.keyboard   = null;
    this.mouse      = null;
    this.touch      = null;
    this.gamepad    = null;
    this.sound      = null;
    this.physics    = null;
    this.particles  = null;
    this.plugins    = null;
    this.device     = null;
    this.display    = null;
    this.director   = null;
    this.storage    = null;
    this.time       = null;

    // if config is a string, consider as a path for a JSON file.
    if (typeof config === 'string') {
      var self = this;
      creatine.getJSON(config, function(data) {
        self._initialize(data, bootstrap);
      })

    // otherwise it considers as an object.
    } else {
      this._initialize(config, bootstrap);
    }
  }
  var p = Game.prototype;


  //---------------------------------------------------------------------------
  // INITIALIZATION METHODS (CALLED WHEN CREATING GAME)
  //---------------------------------------------------------------------------
  /** Parse and validate the config object. */
  p._initializeConfig = function(config) {
    if (!config) {
      config = creatine.DEFAULT_CONFIG;
    } else {
      config = creatine.merge({}, creatine.DEFAULT_CONFIG, config);
      
      // project
      if (typeof config.project !== 'string') {
        throw Error('Invalid project name. Please use a string.');
      } else if (!/^\w+$/i.test(config.project)) {
        throw Error('Invalid project name. Please only use letters, numbers and underscore');
      }

      // width
      if (config.width !== parseInt(config.width, 10) || config.width === 0) {
        config.width = creatine.DEFAULT_CONFIG['width'];
      }

      // height
      if (config.height !== parseInt(config.height, 10) || config.height === 0) {
        config.height = creatine.DEFAULT_CONFIG['height'];
      }

      // framerate
      if (config.framerate !== parseInt(config.framerate, 10) || config.framerate === 0) {
        config.framerate = creatine.DEFAULT_CONFIG['framerate'];
      }

      // debug
      config.debug = Boolean(config.debug);

      // showfps
      config.showfps = Boolean(config.showfps);
    }

    this.config = config;
    return config;
  }
  
  /** Parse and validate the bootstrap methods. */
  p._initializeBootstrap = function(bootstrap) {
    function isFunction(value) {
      return typeof value === 'function';
    }

    if (!bootstrap) bootstrap = {};
    if (!isFunction(bootstrap.boot)) delete bootstrap.boot;
    if (!isFunction(bootstrap.preload)) delete bootstrap.preload;
    if (!isFunction(bootstrap.create)) delete bootstrap.create;
    if (!isFunction(bootstrap.update)) delete bootstrap.update;
    if (!isFunction(bootstrap.draw)) delete bootstrap.draw;

    this.bootstrap = bootstrap;
  }

  /** Intialize the game core objects. */
  p._initialize = function(config, bootstrap) {
    // Configuration
    var config = this._initializeConfig(config);
    this._initializeBootstrap(bootstrap);

    // Canvas
    this.canvas = document.createElement('canvas');
    this.canvas.width = config.width;
    this.canvas.height = config.height;
    this.canvas.style.backgroundColor = config.background_color;
    this.canvas.style.outline = 'none';
    this.canvas.setAttribute('tabindex','0');
    this.canvas.addEventListener("mousedown", this.canvas.focus, false);

    var container = document.getElementById(config.container) || document.body;
    container.appendChild(this.canvas);
    this.canvas.focus();

    // CreateJS core
    this.stage = new createjs.Stage(this.canvas);
    this.stage.snapToPixelEnabled = true;
    createjs.Ticker.framerate = config.framerate;
    createjs.Touch.enable(this.stage);
    createjs.Sound.initializeDefaultPlugins();

    // Managers
    this.time = new creatine.TimeManager(this);
    this.load = new creatine.ResourceManager(this);
    this.create = new creatine.FactoryManager(this);
    this.director = new creatine.SceneManager(this);
    this.storage = new creatine.StorageManager(this);
    this.sound = new creatine.SoundManager(this);
    this.keyboard = new creatine.KeyboardManager(this);
    this.mouse = new creatine.MouseManager(this);
    this.gamepad = new creatine.GamepadManager(this);
    this.touch = new creatine.TouchManager(this);
    this.plugins = new creatine.PluginManager(this);

    this.time.on('tick', this._mainLoop, this);
    
    // VARS
    this._started = false;

    // Start the game
    var self = this;
    setTimeout(function() {self._boot()}, 0);
  }


  //---------------------------------------------------------------------------
  // MAIN LOOP METHODS
  //---------------------------------------------------------------------------
  /** Boot wrapper. */
  p._boot = function() {
    if (this.bootstrap.boot) this.bootstrap.boot(this);
    
    this._preload();
  }

  /** Preload wrapper. */
  p._preload = function() {
    if (this.bootstrap.preload) this.bootstrap.preload(this);

    // If all items loaded/no item to load and no manifest
    if (this.load.isFinished() && !this.config.resources.manifest) {
      this._create();

    // Loading item or have manifest
    } else {
      this.load.on('complete', this._create, this);
      if (this.config.resources.manifest) {
        this.load.manifest(this.config.resources.manifest);
      }
      this.load.load();
    }
  }

  /** Create wrapper. */
  p._create = function() {
    if (this.bootstrap.create) this.bootstrap.create(this);
    this._started = true;
  }

  /** Update wrapper. */
  p._update = function() {
    // pre update
    this.mouse.preUpdate();
    this.gamepad.preUpdate();
    this.plugins.preUpdate();
    
    if (this._started && this.bootstrap.update)
      this.bootstrap.update(this);
    // update
    this.director.update();
    this.plugins.update();

    // pos update
    this.keyboard.postUpdate();
    this.mouse.postUpdate();
    this.gamepad.postUpdate();
    this.plugins.postUpdate();
  }

  /** Draw wrapper. */
  p._draw = function() {
    // pre draw
    this.plugins.preDraw();

    // draw
    if (this.bootstrap.draw) this.bootstrap.draw(this);
    this.plugins.draw();
    this.stage.update();

    // post draw
    this.plugins.postDraw();
  }

  /** Main loop, called every tick. */
  p._mainLoop = function() {
    this._update();
    this._draw();
  }

  creatine.Game = Game;

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  var DeviceManager = function(game) {
    this.game = game;
  }
  var p = DeviceManager.prototype;

  //---------------------------------------------------------------------------
  // PUBLIC ACCESS
  //---------------------------------------------------------------------------

  creatine.DeviceManager = DeviceManager;

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  var DisplayManager = function(game) {
    this.game = game;
    this.canvas = null;

    this.width = null;
    this.height = null;
  }
  var p = DisplayManager.prototype;

  //---------------------------------------------------------------------------
  // PUBLIC ACCESS
  //---------------------------------------------------------------------------

  creatine.DisplayManager = DisplayManager;

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  /** Factory Manager class. */
  var FactoryManager = function(game) {
    this.game = game;
  }
  var p = FactoryManager.prototype;
  
  //---------------------------------------------------------------------------
  // INTERNAL METHODS
  //---------------------------------------------------------------------------
  /** Set anchor of an object, can use anchor constants. */
  p._setAnchor = function(object, regX, regY) {
    var bounds = object.getBounds();
    if (!bounds) return;

    if (regX===creatine.LEFT) {
      object.regX = 0;
    } else if (regX===creatine.CENTER) {
      object.regX = bounds.width/2;
    } else if (regX===creatine.RIGHT) {
      object.regX = bounds.width;
    } else {
      object.regX = regX
    }

    if (regY===creatine.TOP) {
      object.regY = 0;
    } else if (regY===creatine.CENTER) {
      object.regY = bounds.width/2;
    } else if (regY===creatine.BOTTOM) {
      object.regY = bounds.width;
    } else {
      object.regY = regY
    }
  }

  p._setProperties = function(object, properties) {
    for (var key in properties) {
      if (key === 'regX' || key === 'regY') continue;
      object[key] = properties[key];
    }
    this._setAnchor(object, properties['regX'], properties['regY'])
  }

  /** Gets a resource from load if string. */
  p._getResource = function(idOrData) {
    var resource = idOrData;
    if (typeof idOrData === 'string') {
      resource = this.game.load.get(idOrData);
      if (!resource && !idOrData.startsWith('data:')) {
        throw Error('Resource "'+idOrData+'" couldn\'t be found.');
      }
    }

    return resource;
  }

  //---------------------------------------------------------------------------
  // PUBLIC FACTORY METHODS
  //---------------------------------------------------------------------------
  /** Creates a new createjs.Bitmap. */
  p.bitmap = function(idOrData, properties) {
    var image = this._getResource(idOrData);
    var bitmap = new createjs.Bitmap(image);
    if (properties) this._setProperties(bitmap, properties);
    return bitmap;
  }

  /** Creates a new createjs.SpriteSheet. */
  p.spritesheet = function(idOrData, properties) {
    var data = this._getResource(idOrData);
    if (properties) this._setProperties(data, properties);
    return new createjs.SpriteSheet(data);
  }

  /** Creates a new createjs.Sprite. */
  p.sprite = function(idOrData, animation, properties) {
    var image = this._getResource(idOrData);
    var sprite = new createjs.Sprite(image, animation);
    if (properties) this._setProperties(sprite, properties);
    return sprite;
  }

  /** Creates a new creatine.TMXMap. */
  p.tilemap = function(idOrData, properties) {
    var data = this._getResource(idOrData);
    var map = new creatine.TMXMap(data);
    if (properties) this._setProperties(map, properties);
    return map;
  }

  /** Creates a new createjs.BitmapText. */
  p.bitmaptext = function(id, text, properties) {
    var image = this._getResource(idOrData);
    var bitmap = new createjs.BitmapText(text, image);
    if (properties) this._setProperties(bitmap, properties);
    return bitmap;
  }

  /** Creates a new createjs.Text. */
  p.text = function(text, properties) {
    var obj = new createjs.Text(text);
    if (properties) this._setProperties(obj, properties);
    return obj;
  }

  /** Creates a new createjs.Shape. */
  p.shape = function(properties) {
    var shape = new createjs.Shape()
    if (properties) this._setProperties(shape, properties);
    return shape;
  }

  creatine.FactoryManager = FactoryManager;
})();
this.creatine = this.creatine || {};

(function() {
  "use strict";

  /**
   * Resource Manager class.
   */
  var ResourceManager = function(game) {
    /** @attribute {creatine.Game} the game instance. */
    this.game = game;

    /** @attribute {Object} id map for processed types, such as sprite sheets. */
    this._cache = {};

    /** @attribute {Array} queue of objects to be processed after loading. */
    this._processQueue = [];
  
    this.basePath = '';

    this._initializeConfig(game.config['resources']||{})

    /** @attribute {createjs.LoadQueue} the createjs load queue. */
    this._loader = new createjs.LoadQueue(false);
    this._loader.installPlugin(createjs.Sound);
    this._loader.on('complete', this._postProcess, this);
  }
  var p = ResourceManager.prototype;


  // --------------------------------------------------------------------------
  // INTERNAL METHODS
  // --------------------------------------------------------------------------
  p._initializeConfig = function(config) {
    if (config.base_path && typeof config.base_path === 'string') {
      this.basePath = config.base_path;
      if (!this.basePath.endsWith('/')) { this.basePath += '/'; }
    }
  }

  /** Process some types after loading complete. */
  p._postProcess = function() {
    for (var i=0; i<this._processQueue.length; i++) {
      var toProcess = this._processQueue[i];
      var tempObject = this._loader.getResult(toProcess.id);

      switch (toProcess.type) {
        case 'spritesheet':
          toProcess.data['images'] = [tempObject];
          var finalObject = new createjs.SpriteSheet(toProcess.data);
          break;
      }

      this._cache[toProcess.id] = finalObject;
    }
  }


  // --------------------------------------------------------------------------
  // PUBLIC COMMON METHODS
  // --------------------------------------------------------------------------
  /** Register events to loader. */
  p.on = function(event, callback, context) {
    this._loader.on(event, callback, context);
  }

  /** Unregister events to loader. */
  p.off = function(event, callback) {
    this._loader.off(event, callback);
  }

  /** Initialize the loading process. Used internally by Game. */
  p.load = function() {
    this._loader.load();
  }

  /** Returns a loaded item. Look first in cache then in createjs.LoadQueue. */
  p.get = function(id) {
    if (typeof this._cache[id] !== 'undefined') {
      return this._cache[id];
    }

    return this._loader.getResult(id);
  }

  /** Verifies if loading is completed. */
  p.isFinished = function() {
    return this._loader._numItems === this._loader._numItemsLoaded;
  }


  // --------------------------------------------------------------------------
  // PUBLIC TYPE METHODS (USE THIS TO REGISTER ITENS TO BE LOADED)
  // --------------------------------------------------------------------------
  /** Loads an image. */
  p.image = function(id, src) {
    this._loader.loadFile({id:id, src:this.basePath+src, type:'image'}, false);
  }

  /** Loads a spritesheet. */
  p.spritesheet = function(id, src, data) {
    if (typeof src === 'string' && src.endsWith('.json')) {
      this._loader.loadFile({id:id, src:this.basePath+src, type:'spritesheet'}, false);
    } else {
      this._loader.loadFile({id:id, src:this.basePath+src, data:data}, false);
      this._processQueue.push({id:id, data:data, type:'spritesheet'});
    }
  }

  /** Loads an audio. */
  p.audio = function(id, src) {
    this._loader.loadFile({id:id, src:this.basePath+src}, false)
  }

  /** Loads an audio sprite. */
  p.audiosprite = function(id, src, data) {
    this._loader.loadFile({id:id, src:this.basePath+src}, false);
    var _data = [];
    for (var i=0; i<data.length; i++) {
      var d = data[i];
      _data.push({id:d.id, startTime:d.start, duration:d.duration})
    }

    createjs.Sound.registerSounds([{src:this.basePath+src, data:{audioSprite:_data}}], '');
  }

  /** Loads a JSON. */
  p.json = function(id, src) {
    this._loader.loadFile({id:id, src:this.basePath+src}, false);
  }

  /** Loads a javascript file. */
  p.script = function(id, src) {
    this._loader.loadFile({id:id, src:this.basePath+src}, false);
  }

  /** Loads a stylesheet file. */
  p.css = function(id, src) {
    this._loader.loadFile({id:id, src:this.basePath+src}, false);
  }

  /** Loads a creatine manifest. */
  p.manifest = function(data) {
    for (var i=0; i<data.length; i++) {
      var d = data[i];
      if (d.type === 'audiosprite') {
        this.audiosprite(d.id, d.src, d.data);
      } else if (d.type === 'spritesheet') {
        this.spritesheet(d.id, d.src, d.data);
      } else {
        this.raw(d);
      }
    }
    this._loader.loadManifest(data, false);
  }

  /** Loads a file using createjs item data. */
  p.raw = function(itemData) {
    this._loader.loadFile(itemData, false);
  }

  creatine.ResourceManager = ResourceManager;
})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  var SoundManager = function(game) {
    /** @attribute {creatine.Game} the game instance. */
    this.game = game;
    this._persistent = true;
    this._storage = game.storage;

    this._groups = {};
    this._sfxVolume = 1.0;
    this._musicVolume = 1.0;

    if (this._persistent) {
      var sfxVolume = this._storage.iget('sound', 'sfxvolume');
      var musicVolume = this._storage.iget('sound', 'musicvolume');
      var masterVolume = this._storage.iget('sound', 'mastervolume');
      var mute = this._storage.iget('sound', 'mute');

      if (sfxVolume === parseFloat(sfxVolume)) this.sfxVolume = sfxVolume;
      if (musicVolume === parseFloat(musicVolume)) this.musicVolume = musicVolume;
      if (masterVolume === parseFloat(masterVolume)) this.masterVolume = masterVolume;
      createjs.Sound.setMute(mute || false);
    }
  }
  var p = SoundManager.prototype;

  //---------------------------------------------------------------------------
  // PROPERTIES
  //---------------------------------------------------------------------------
  p.getSfxVolume = function() {
    return this._sfxVolume;
  }
  p.setSfxVolume = function(value) {
    this._sfxVolume = creatine.clip(value, 0, 1);
    if (this._persistent) {
      this._storage.iset('sound', 'sfxvolume', this._sfxVolume);
    };
  }

  p.getMusicVolume = function() {
    return this._musicVolume;
  }
  p.setMusicVolume = function(value) {
    this._musicVolume = creatine.clip(value, 0, 1);
    if (this._persistent) {
      this._storage.iset('sound', 'musicvolume', this._musicVolume);
    };
  }

  p.getMasterVolume = function() {
    return createjs.Sound.getVolume();
  }
  p.setMasterVolume = function(value) {
    var value = creatine.clip(value, 0, 1);
    createjs.Sound.setVolume(value);
    if (this._persistent) {
      this._storage.iset('sound', 'mastervolume', value);
    };
  }

  p.getPersistent = function() {
    return this._persistent;
  }
  p.setPersistent = function(value) {
    this._persistent = value;
    if (this._persistent) {
      this._storage.iset('sound', 'sfxvolume', this._sfxVolume);
      this._storage.iset('sound', 'musicvolume', this._musicVolume);
      this._storage.iset('sound', 'mastervolume', this.getMasterVolume);
    }
  }


  //---------------------------------------------------------------------------
  // GROUP ACCESS (FOR RANDOM PLAY)
  //---------------------------------------------------------------------------
  p.addSound = function(sound, group) {
    if (!sound) throw new Error('Sound name is mandatory.');
    if (!group) throw new Error('Group name is mandatory.');

    if (!this._groups[group]) {
      this._groups[group] = [];
    }

    this._groups[group].push(sound);
  }
  p.removeSound = function(sound, group) {
    if (!sound) throw new Error('Sound name is mandatory.');
    if (!group) throw new Error('Group name is mandatory.');

    var sounds = this._groups[group]
    if (!sounds) return;
    
    for (var i=0; i<sounds.length; i++) {
      if (sounds[i] == sound) {
        sounds.splice(i, 1);
        return;
      }
   }
  }


  //---------------------------------------------------------------------------
  // CORE METHODS
  //---------------------------------------------------------------------------
  p.playSfx = function(name, interrupt, delay, offset, loop, pan) {
    var group = this._groups[name];

    if (group) {
      var idx = creatine.randomInt(0, group.length-1);
      name = group[idx];
    }

    return createjs.Sound.play(name, interrupt, delay, offset, loop, 
                               this._sfxVolume, pan);
  }
  p.playMusic = function(name, interrupt, delay, offset, loop, pan) {
    var group = this._groups[name];

    if (group) {
      var idx = creatine.randomInt(0, group.length-1);
      name = group[idx];
    }

    return createjs.Sound.play(name, interrupt, delay, offset, loop, 
                               this._musicVolume, pan);
  }
  p.toogleMute = function() {
    if (createjs.Sound.getMute()) {
      var value = false;
    } else {
      var value = true;
    }
    createjs.Sound.setMute(value);
    this._storage.iset('sound', 'mute', value);
  }
  p.isMute = function() {
    return createjs.Sound.getMute();
  }


  //---------------------------------------------------------------------------
  // PROPERTIES CONFIGURATION
  //---------------------------------------------------------------------------
  try {
    Object.defineProperties(p, {
      musicVolume  : {get:p.getMusicVolume, set:p.setMusicVolume},
      sfxVolume    : {get:p.getSfxVolume, set:p.setSfxVolume},
      masterVolume : {get:p.getMasterVolume, set:p.setMasterVolume},
      persistent   : {get:p.getPersistent, set:p.setPersistent},
    });
  } catch (e) {}

  creatine.SoundManager = SoundManager;

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  var TimeManager = function(game) {
    this.EventDispatcher_constructor();
    this.game = game;
    this.delta = 0;
    this.fdelta = 0;

    createjs.Ticker.on('tick', this._onTick, this);
  }
  var p = createjs.extend(TimeManager, createjs.EventDispatcher);

  p._onTick = function(e) {
    this.delta = e.delta;
    this.fdelta = e.delta/1000.;

    this.dispatchEvent(e);
  }

  creatine.TimeManager = createjs.promote(TimeManager, 'EventDispatcher');

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  var StorageManager = function(game) {
    /** @attribute {creatine.Game} the game instance. */
    this.game = game;

    this._memory = localStorage;
    this._namespace = game.config.project;

    try {
      !!localStorage.getItem;
    } catch (e) {
      this._memory = {};
    }
  }
  var p = StorageManager.prototype;

  //---------------------------------------------------------------------------
  // CORE ACCESS (INTERNAL)
  //---------------------------------------------------------------------------
  p.iset = function(module, key, value) { this.set('['+module+']'+key, value); }
  p.iget = function(module, key) { return this.get('['+module+']'+key); }
  p.iremove = function(module, key) { this.remove('['+module+']'+key); }


  //---------------------------------------------------------------------------
  // PUBLIC ACCESS
  //---------------------------------------------------------------------------
  p.set = function(key, value) {
    try {
      value = JSON.stringify(value);
    } catch (e) {}

    this._memory[this._namespace+key] = value;
  }

  p.get = function(key) {
    var value = this._memory[this._namespace+key];
    try {
      value = JSON.parse(value);
    } catch (e) {}

    return value;
  }

  p.remove = function(key) {
    delete this._memory[this._namespace+key];
  }

  creatine.StorageManager = StorageManager;

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  var PluginManager = function(game) {
    this.game = game;
    this._plugins = {};
  }
  var p = PluginManager.prototype;

  p.preUpdate = function() {
    for (var id in this._plugins) {
      if (this._plugins[id].active && this._plugins[id].hasPreUpdate) {
        this._plugins[id].preUpdate();
      }
    }
  }
  p.update = function() {
    for (var id in this._plugins) {
      if (this._plugins[id].active && this._plugins[id].hasUpdate) {
        this._plugins[id].update();
      }
    }
  }
  p.postUpdate = function() {
    for (var id in this._plugins) {
      if (this._plugins[id].active && this._plugins[id].hasPostUpdate) {
        this._plugins[id].postUpdate();
      }
    }
  }
  p.preDraw = function() {
    for (var id in this._plugins) {
      if (this._plugins[id].active && this._plugins[id].hasPreDraw) {
        this._plugins[id].preDraw();
      }
    }
  }
  p.draw = function() {
    for (var id in this._plugins) {
      if (this._plugins[id].active && this._plugins[id].hasDraw) {
        this._plugins[id].draw();
      }
    }
  }
  p.postDraw = function() {
    for (var id in this._plugins) {
      if (this._plugins[id].active && this._plugins[id].hasPostDraw) {
        this._plugins[id].postDraw();
      }
    }
  }


  //---------------------------------------------------------------------------
  // PUBLIC ACCESS
  //---------------------------------------------------------------------------
  p.add = function(id, plugin) {
    if (!id) throw Error('No id provided');
    if (!plugin) throw Error('No plugin provided');

    if (typeof plugin === 'function') {
      plugin = new plugin();
    }

    plugin.game = this.game;
    plugin.manager = this;

    if (plugin.preUpdate)   plugin.hasPreUpdate = true;
    if (plugin.update)      plugin.hasUpdate = true;
    if (plugin.postUpdate)  plugin.hasPostUpdate = true;
    if (plugin.preDraw)     plugin.hasPreDraw = true;
    if (plugin.draw)        plugin.hasDraw = true;
    if (plugin.postDraw)    plugin.hasPostDraw = true;

    if (this._plugins[id]) this.remove(id);
    this._plugins[id] = plugin;

    plugin.enter();
  }
  p.get = function(id) {
    return this._plugins[id];
  }
  p.remove = function(id) {
    var plugin = this._plugins[id];
    if (!plugin) return;

    plugin.exit();
    delete this._plugins[id];
  }
  p.removeAll = function() {
    for (var id in this._plugins) {
      this._plugins[id].exit();
    }

    this._plugins = {};
  }

  creatine.PluginManager = PluginManager;

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  var Plugin = function() {
    this.game;
    this.manager;
    this.active = true;
    this.initialize();

    this.hasPreUpdate = false;
    this.hasUpdate = false;
    this.hasPostUpdate = false;
    this.hasPreDraw = false;
    this.hasDraw = false;
    this.hasPostDraw = false;
  }
  var p = Plugin.prototype;

  p.initialize = function() {}
  p.enter = function() {}
  p.exit = function() {}

  creatine.Plugin = Plugin;

  // @SHORTCUT
  creatine._plugin = function(properties) {
    var S = function() { this.Plugin_constructor(); }
    var p = createjs.extend(S, creatine.Plugin);
    for (var k in properties) { p[k] = properties[k]; }
    return createjs.promote(S, 'Plugin');
  }
})();this.creatine.buttons = {
  // MOUSE
  LEFT       : 0,
  MIDDLE     : 1,
  RIGHT      : 2,
};this.creatine.keys = {
  // KEYBOARD
  BACKSPACE      : 8,
  TAB            : 9,
  ENTER          : 13,
  SHIFT          : 16,
  CTRL           : 17,
  ALT            : 18,
  PAUSE          : 19,
  CAPSLOCK       : 20,
  ESC            : 27,
  SPACE          : 32,
  PAGEUP         : 33,
  PAGEDOWN       : 34,
  END            : 35,
  HOME           : 36,
  LEFT           : 37,
  UP             : 38,
  RIGHT          : 39,
  DOWN           : 40,
  INSERT         : 45,
  DELETE         : 46,
  NUM0           : 48,
  NUM1           : 49,
  NUM2           : 50,
  NUM3           : 51,
  NUM4           : 52,
  NUM5           : 53,
  NUM6           : 54,
  NUM7           : 55,
  NUM8           : 56,
  NUM9           : 57,
  A              : 65,
  B              : 66,
  C              : 67,
  D              : 68,
  E              : 69,
  F              : 70,
  G              : 71,
  H              : 72,
  I              : 73,
  J              : 74,
  K              : 75,
  L              : 76,
  M              : 77,
  N              : 78,
  O              : 79,
  P              : 80,
  Q              : 81,
  R              : 82,
  S              : 83,
  T              : 84,
  U              : 85,
  V              : 86,
  W              : 87,
  X              : 88,
  Y              : 89,
  Z              : 90,
  LEFTWINDOWKEY  : 91,
  RIGHTWINDOWKEY : 92,
  CONTEXTMENU    : 93,
  NUMPAD0        : 96,
  NUMPAD1        : 97,
  NUMPAD2        : 98,
  NUMPAD3        : 99,
  NUMPAD4        : 100,
  NUMPAD5        : 101,
  NUMPAD6        : 102,
  NUMPAD7        : 103,
  NUMPAD8        : 104,
  NUMPAD9        : 105,
  MULTIPLY       : 106,
  ADD            : 107,
  SEPARATOR      : 108,
  SUBTRACT       : 109,
  DECIMAL        : 110,
  DIVIDE         : 111,
  F1             : 112,
  F2             : 113,
  F3             : 114,
  F4             : 115,
  F5             : 116,
  F6             : 117,
  F7             : 118,
  F8             : 119,
  F9             : 120,
  F10            : 121,
  F11            : 122,
  F12            : 123,
  F13            : 124,
  F14            : 125,
  F15            : 126,
  F16            : 127,
  F17            : 128,
  F18            : 129,
  F19            : 130,
  F20            : 131,
  F21            : 132,
  F22            : 133,
  F23            : 134,
  F24            : 135,
  NUMLOCK        : 144,
  SCROLLLOCK     : 145,
  SEMICOLON      : 186,
  EQUAL          : 187,
  COMMA          : 188,
  DASH           : 189,
  PERIOD         : 190,
  SLASH          : 191,
  GRAVEACCENT    : 192,
  OPENBRACKET    : 219,
  BACKSLASH      : 220,
  CLOSEBRAKET    : 221,
  QUOTE          : 222,
};this.creatine.pad = {
  // GAMEPAD
  A          : 0,
  B          : 1,
  X          : 2,
  Y          : 3,
  LB         : 4,
  RB         : 5,
  LT         : 6,
  RT         : 7,
  SELECT     : 8,
  START      : 9,
  LEFTSTICK  : 10,
  RIGHTSTICK : 11,
  UP         : 12,
  DOWN       : 13,
  LEFT       : 14,
  RIGHT      : 15,
  META       : 16,
};this.creatine = this.creatine || {};

(function() {
  "use strict";

  /**
   * Events: gamepadconnected, gamepaddisconnected
   */

  var GamepadManager = function(game) {
    this.EventDispatcher_constructor();
    this.game = game;
    this._gamepads = [null, null, null, null];
    this.gamepads = [
      new creatine.Gamepad(this, game),
      new creatine.Gamepad(this, game),
      new creatine.Gamepad(this, game),
      new creatine.Gamepad(this, game),
    ]

    var self = this;
    window.addEventListener('gamepadconnected', function(e) {self._onGamepadConnected(e)}, false);
    window.addEventListener('gamepaddisconnected', function(e) {self._onGamepadDisconnected(e)}, false);

    var gamepads = this._getGamepads();
    for (var i=0; i<gamepads.length; i++) {
      if (gamepads[i]) {
        this._onGamepadConnected({gamepad:gamepads[i]});
      }
    }
  }
  var p = createjs.extend(GamepadManager, createjs.EventDispatcher);

  p._getGamepads = function() {
    if (navigator.getGamepads)
      var gamepads = navigator.getGamepads();
    else if(navigator.webkitGetGamepads){
      var gamepads = navigator.webkitGetGamepads();
    } else if(navigator.msGetGamepads) {
      var gamepads = navigator.msGetGamepads();
    } else if(navigator.webkitGamepads) {
      var gamepads = navigator.webkitGamepads();
    } else {
      var gamepads = [];
    }

    return gamepads;
  }

  p._makeEvent = function(name, e, gamepad) {
    var event = new createjs.Event(name);
    event.gamepad = gamepad;
    event.nativeEvent = e;
    return event;
  }
  p._onGamepadConnected = function(e) {
    for (var i=0; i<this.gamepads.length; i++) {
      if (!this.gamepads[i].connected) {
        this.gamepads[i].bind(e.gamepad);
        this.dispatchEvent(this._makeEvent('gamepadconnected', e, this.gamepads[i]));
        break;
      }
    }
  }
  p._onGamepadDisconnected = function(e) {
    for (var i=0; i<this.gamepads.length; i++) {
      if (this.gamepads[i]._gamepad === e.gamepad) {
        this.gamepads[i].unbind();
        this.dispatchEvent(this._makeEvent('gamepaddisconnected', e, this.gamepads[i]));
        break;
      }
    }
  }

  p.preUpdate = function() {
    // must call this to update gamepad properties on chrome
    this._gamepads = this._getGamepads();

    for (var i=0; i<this.gamepads.length; i++) {
      this.gamepads[i].preUpdate();
    }
  }
  p.update = function() {}
  p.postUpdate = function() {
    for (var i=0; i<this.gamepads.length; i++) {
      this.gamepads[i].postUpdate();
    }
  }

  p.get = function(i) {
    return this.gamepads[i];
  }
  p.getNumGamepads = function() {
    var n=0;
    for (var i=0; i<this.gamepads.length; i++) {
      if (this.gamepads[i].connected) { n++ }
    }
    return n;
  }
  p.getConnectedGamepads = function() {
    var r=[];
    for (var i=0; i<this.gamepads.length; i++) {
      if (this.gamepads[i].connected) { r.push(this.gamepads[i]); }
    }
    return r;
  }

  creatine.GamepadManager = createjs.promote(GamepadManager, 'EventDispatcher');

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  /**
   * Events: keydown, keyup, keyhold
   */

  var KeyboardManager = function(game) {
    this.EventDispatcher_constructor();
    this.game = game;

    this._lastState = [];
    this._state = [];
    this._commandMap = {};

    var self = this;
    this.game.canvas.addEventListener('blur', function(e) {self._onBlur(e)}, false);
    this.game.canvas.addEventListener('keydown', function(e) {self._onKeyDown(e)}, false);
    this.game.canvas.addEventListener('keypress', function(e) {self._onKeyPress(e)}, false);
    this.game.canvas.addEventListener('keyup', function(e) {self._onKeyUp(e)}, false);
  }
  var p = createjs.extend(KeyboardManager, createjs.EventDispatcher);

  p._makeEvent = function(name, e) {
    var event = new createjs.Event(name);
    event.code = e.keyCode;
    event.shift = e.shiftKey;
    event.ctrl = e.ctrlKey;
    event.meta = e.metaKey;
    event.alt = e.altKey;
    event.nativeEvent = e;
    return event;
  }
  p._onBlur = function(e) {
    this._state = [];
    this._lastState = [];
  }
  p._onKeyDown = function(e) {
    if (!e.repeat) {
      this._state.push(e.keyCode);
      var event = this._makeEvent('keydown', e);
    } else {
      var event = this._makeEvent('keyhold', e);
    }

    this.dispatchEvent(event);
    e.preventDefault();
    return false;
  }
  p._onKeyPress = function(e) {
    e.preventDefault();
    return false;
  }
  p._onKeyUp = function(e) {
    this._state.splice(this._state.indexOf(e.keyCode), 1);

    var event = this._makeEvent('keyup', e);
    this.dispatchEvent(event);

    e.preventDefault();
    return false;
  }

  p._get = function(key, state) {
    return state.indexOf(key) >= 0;
  }

  p.preUpdate = function() {
  }
  p.update = function() {}
  p.postUpdate = function() {
    this._lastState = this._state.slice();
  }

  //---------------------------------------------------------------------------
  // PUBLIC ACCESS
  //---------------------------------------------------------------------------
  // p.setCommand = function(command, keys) {
  //   // key code
  //   if (typeof keys === 'number') {
  //     keys = [keys];
  //   } else if (typeof keys !== 'array') {
  //     throw Error('Invalid command keys "'+keys+'". Please provide a keycode or array');
  //   }

  //   this._commandMap[command] = keys;
  // }
  // p.unsetCommand = function(command) {
  //   delete this._commandMap[command];
  // }
  p.get = function(key) {
    return this._get(key, this._state);
  }
  p.isDown = function(key) {
    return this._get(key, this._state);
  }
  p.isUp = function(key) {
    return !this._get(key, this._state);
  }
  p.isPressed = function(key) {
    return this._get(key, this._state) && !this._get(key, this._lastState);
  }
  p.isReleased = function(key) {
    return !this._get(key, this._state) && this._get(key, this._lastState);
  } 
  p.isAnyDown = function() {
    return this._state.length > 0;
  }
  p.isAnyPressed = function() {
    for (var i=0; i<this._state.length; i++) {
      var key = this._state[i];
      if (!this._get(key, this._lastState)) {
        return true;
      }
    }
    return false;
  }
  p.isAnyReleased = function() {
    for (var i=0; i<this._lastState.length; i++) {
      var key = this._lastState[i];
      if (!this._get(key, this._state)) {
        return true;
      }
    }
    return false; 
  }

  creatine.KeyboardManager = createjs.promote(KeyboardManager, 'EventDispatcher');

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  /**
   * Events: mousedown, mouseup, click, dblclick, mousemove, mouseover....
   */

  var MouseManager = function(game) {
    this.EventDispatcher_constructor();
    this.game = game;

    this._lastState = [];
    this._state = [];
    this._commandMap = {};
    this.x = 0;
    this.y = 0;

    var self = this;
    this.game.canvas.addEventListener('blur', function(e) {self._onBlur(e)}, false);
    this.game.canvas.addEventListener('click', function(e) {self._onClick(e)}, false)
    this.game.canvas.addEventListener('dblclick', function(e) {self._onDblClick(e)}, false)
    this.game.canvas.addEventListener('mousedown', function(e) {self._onMouseDown(e)}, false)
    this.game.canvas.addEventListener('mouseup', function(e) {self._onMouseUp(e)}, false)
    this.game.canvas.addEventListener('mousemove', function(e) {self._onMouseMove(e)}, false)
    this.game.canvas.addEventListener('mouseout', function(e) {self._onMouseOut(e)}, false)
    this.game.canvas.addEventListener('mouseover', function(e) {self._onMouseOver(e)}, false)
    this.game.canvas.addEventListener('wheel', function(e) {self._onWheel(e)}, false)
  }
  var p = createjs.extend(MouseManager, createjs.EventDispatcher);

  p._makeEvent = function(name, e) {
    var event = new createjs.Event(name);
    event.button = e.button;
    event.x = this.x;
    event.y = this.y;
    event.nativeEvent = e;
    return event;
  }
  p._onBlur = function(e) {
    this._state = [];
    this._lastState = [];
  }
  p._onClick = function(e) {
    var event = this._makeEvent('click', e);
    this.dispatchEvent(event);
    e.preventDefault();
    return false;
  }
  p._onDblClick = function(e) {
    var event = this._makeEvent('dblclick', e);
    this.dispatchEvent(event);
    e.preventDefault();
    return false;
  }
  p._onMouseDown = function(e) {
    var event = this._makeEvent('mousedown', e);
    this.dispatchEvent(event);
    this._state.push(e.button);
    e.preventDefault();
    return false;
  }
  p._onMouseUp = function(e) {
    var event = this._makeEvent('mouseup', e);
    this.dispatchEvent(event);
    this._state.splice(this._state.indexOf(e.button), 1);
    e.preventDefault();
    return false;
  }
  p._onMouseMove = function(e) {
    var event = this._makeEvent('mousemove', e);
    this.dispatchEvent(event);
    e.preventDefault();
    return false;
  }
  p._onMouseOut = function(e) {
    var event = this._makeEvent('mouseout', e);
    this.dispatchEvent(event);
    e.preventDefault();
    return false;
  }
  p._onMouseOver = function(e) {
    var event = this._makeEvent('mouseover', e);
    this.dispatchEvent(event);
    e.preventDefault();
    return false;
  }
  p._onWheel = function(e) {
    var event = new createjs.Event('wheel');
    event.deltaMode = e.deltaMode;
    event.deltaX = e.deltaX || e.wheelDeltaX;
    event.deltaY = e.deltaY || e.wheelDeltaY;
    event.deltaZ = e.deltaZ || e.wheelDeltaZ;
    event.x = e.x;
    event.y = e.y;
    this.dispatchEvent(event);
    e.preventDefault();
    return false;
  }

  p._get = function(key, state) {
    return state.indexOf(key) >= 0;
  }

  p.preUpdate = function() {
    this.x = this.game.stage.mouseX;
    this.y = this.game.stage.mouseY;
  }
  p.update = function() {}
  p.postUpdate = function() {
    this._lastState = this._state.slice();
  }

  //---------------------------------------------------------------------------
  // PUBLIC ACCESS
  //---------------------------------------------------------------------------
  p.get = function(key) {
    return this._get(key, this._state);
  }
  p.isDown = function(key) {
    return this._get(key, this._state);
  }
  p.isUp = function(key) {
    return !this._get(key, this._state);
  }
  p.isPressed = function(key) {
    return this._get(key, this._state) && !this._get(key, this._lastState);
  }
  p.isReleased = function(key) {
    return !this._get(key, this._state) && this._get(key, this._lastState);
  } 
  p.isAnyDown = function() {
    return this._state.length > 0;
  }
  p.isAnyPressed = function() {
    for (var i=0; i<this._state.length; i++) {
      var key = this._state[i];
      if (!this._get(key, this._lastState)) {
        return true;
      }
    }
    return false;
  }
  p.isAnyReleased = function() {
    for (var i=0; i<this._lastState.length; i++) {
      var key = this._lastState[i];
      if (!this._get(key, this._state)) {
        return true;
      }
    }
    return false; 
  }

  creatine.MouseManager = createjs.promote(MouseManager, 'EventDispatcher');

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  var TouchManager = function(game) {
    this.game = game;

    this._touchMap = {};
    this._touchList = [];
    this._touchPool = [];

    this._gestures = {};

    for (var i=0; i<10; i++) {
      this._touchPool.push(new creatine.Touch(this, game));
    }

    var self = this;
    this.game.canvas.addEventListener('blur', function(e) {self._onBlur(e)}, false);
    this.game.canvas.addEventListener('touchstart', function(e) {self._onTouchStart(e)}, false);
    this.game.canvas.addEventListener('touchmove', function(e) {self._onTouchMove(e)}, false);
    this.game.canvas.addEventListener('touchend', function(e) {self._onTouchEnd(e)}, false);
  }
  var p = createjs.extend(TouchManager, createjs.EventDispatcher);

  //---------------------------------------------------------------------------
  // INTERNAL
  //---------------------------------------------------------------------------
  // p._createEventData = function(e) {
  //   return {
  //     lastData: null,
  //     length: null,

  //     // time base
  //     time: null,
  //     delta: null,

  //     // center based
  //     centerX: null,
  //     centerY: null,
  //     deltaX: null,
  //     deltaY: null,
      
  //     // points based
  //     distance: null,
  //     scale: null,
  //     rotation: null,
  //   };
  // }
  // p._updateGestures = function(e) {
  //   var data = this._createEventData(e);

  //   for (var key in this._gestures) {
  //     var gesture = this._gestures[key];
  //     gesture._updateTouch(data);
  //   }
  // }

  //---------------------------------------------------------------------------
  // EVENTS
  //---------------------------------------------------------------------------
  p._onBlur = function(e) {
    for (var id in this._touchMap) {
      var touch = this._touchMap[id];
      this._touchPool.push(touch);
      touch._endTouch({});
    }
    this._touchMap = {};
    this._touchList = [];
  }
  p._onTouchStart = function(e) {
    for (var i=0; i<e.changedTouches.length; i++) {
      var id = e.changedTouches[i].identifier;

      var touch = this._touchPool.pop();
      this._touchMap[id] = touch;
      this._touchList.push(touch);
      touch._startTouch(e.changedTouches[i]);
    }

    e.preventDefault();
    return false;
  }
  p._onTouchMove = function(e) {
    for (var i=0; i<e.changedTouches.length; i++) {
      var id = e.changedTouches[i].identifier;
      this._touchMap[id]._updateTouch(e.changedTouches[i]);
    }

    e.preventDefault();
    return false;
  }
  p._onTouchEnd = function(e) {
    for (var i=0; i<e.changedTouches.length; i++) {
      var id = e.changedTouches[i].identifier;

      var touch = this._touchMap[id];
      this._touchList.splice(this._touchList.indexOf(touch), 1);
      delete this._touchMap[id];
      this._touchPool.push(touch);

      touch._endTouch(e.changedTouches[i]);
    }

    e.preventDefault();
    return false;
  }

  //---------------------------------------------------------------------------
  // GESTURES
  //---------------------------------------------------------------------------
  // p.addGesture = function(id, gesture) {
  //   this._gestures[id] = gesture;
  // }
  // p.getGesture = function(id) {
  //   return this._gestures[id];
  // }
  // p.removeGesture = function(id) {
  //   delete this._gestures[id];
  // }

  //---------------------------------------------------------------------------
  // PUBLIC ACCESS
  //---------------------------------------------------------------------------
  p.getNumTouches = function() {
    return this._touchList.length;
  }

  p.getTouches = function() {
    return this._touchList;
  }

  creatine.TouchManager = createjs.promote(TouchManager, 'EventDispatcher');

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  var Touch = function(manager, game) {
    this.game = game;
    this.manager = manager;

    this.down = false;
    this.identifier = 0;
    this.x = 0;
    this.y = 0;
    this.force = 0;
    this.radiusX = 0;
    this.radiusY = 0;
    this.rotation = 0;

  }
  var p = createjs.extend(Touch, createjs.EventDispatcher);

  p._makeEvent = function(name, e) {
    var event = new createjs.Event(name);
    event.target = this;
    return event;
  }

  p._update = function(touch) {
    var rect = this.game.stage._getElementRect(this.game.canvas);
    this.x = touch.pageX - rect.left;
    this.y = touch.pageY - rect.top;
    this.force = touch.force || touch.webkitForce || 0;
    this.radiusX = touch.radiusX || touch.webkitRadiusX || 0;
    this.radiusY = touch.radiusY || touch.webkitRadiusY || 0;
    this.rotation = touch.rotationAngle || touch.webkitRotationAngle || 0;
  }

  p._startTouch = function(touch) {
    this.down = true;
    this.identifier = touch.identifier;
    this._update(touch);
    this.dispatchEvent(this._makeEvent('start'));
  }
  p._updateTouch = function(touch) {
    this._update(touch);
    this.dispatchEvent(this._makeEvent('move'));
  }
  p._endTouch = function(touch) {
    this.down = false;
    if (touch) {
      this._update(touch);
    }
    this.dispatchEvent(this._makeEvent('end'));
  }

  //---------------------------------------------------------------------------
  // PUBLIC ACCESS
  //---------------------------------------------------------------------------
  p.isDown = function() { return this.down; }
  p.isUp = function() { return !this.down; }

  creatine.Touch = createjs.promote(Touch, 'EventDispatcher');

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  /**
   * Events: keydown, keyup, keyhold
   */

  var Gamepad = function(manager, game) {
    this.EventDispatcher_constructor();
    this.manager = manager;
    this.game = game;

    this.connected = false;

    this.rawLeftStickX = 0;
    this.rawLeftStickY = 0;
    this.leftStickX = 0;
    this.leftStickY = 0;
    this.leftStickForce = 0;
    
    this.rawRightStickX = 0;
    this.rawRightStickY = 0;
    this.rightStickX = 0;
    this.rightStickY = 0;
    this.rightStickForce = 0;

    this.leftTrigger = 0;
    this.rightTrigger = 0;

    this.deadZoneLeft = 0.25;
    this.deadZoneRight = 0.25;

    this._lastState = [];
    this._state = [];
    this._listening = true;

    var self = this;
    this.game.canvas.addEventListener('blur', function(e) {self._onBlur(e)}, false);
    this.game.canvas.addEventListener('focus', function(e) {self._onFocus(e)}, false);
  }
  var p = createjs.extend(Gamepad, createjs.EventDispatcher);

  p._onBlur = function(e) {
    this._state = [];
    this._lastState = [];
    this._listening = false;
  }
  p._onFocus = function(e) {
    this._listening = true;
  }
  p._get = function(key, state) {
    return state.indexOf(key) >= 0;
  }

  p._makeEvent = function(name, e) {
    var event = new createjs.Event(name);
    event.target = this;
    return event;
  }

  // --------------------------------------------------------------------------
  p.preUpdate = function() {
    if (this._gamepad && this._listening) {

      // get raw values for axes
      var lx = this.rawLeftStickX = this._gamepad.axes[0];
      var ly = this.rawLeftStickY = this._gamepad.axes[1];
      var rx = this.rawRightStickX = this._gamepad.axes[2];
      var ry = this.rawRightStickY = this._gamepad.axes[3];

      // compute the scaled radial dead zone
      // left stick
      var leftzone = this.deadZoneLeft;
      var leftnorm = Math.sqrt(lx*lx + ly*ly);
      if (leftnorm > leftzone) {
        var scale = ((leftnorm-leftzone)/(1-leftzone));
        this.leftStickX = lx = (lx/leftnorm)*scale;
        this.leftStickY = ly = (ly/leftnorm)*scale;
        this.leftStickForce = Math.sqrt(lx*lx + ly*ly);

        // normalize again if necessary (avoid box range)
        if (this.leftStickForce >= 1) {
          this.leftStickX /= this.leftStickForce;
          this.leftStickY /= this.leftStickForce;
          this.leftStickForce = 1;
        }
      } else {
        this.leftStickX = this.leftStickY = this.leftStickForce = 0;
      }

      // right stick
      var rightzone = this.deadZoneLeft;
      var rightnorm = Math.sqrt(rx*rx + ry*ry);
      if (rightnorm > rightzone) {
        var scale = ((rightnorm-rightzone)/(1-rightzone));
        this.rightStickX = rx = (rx/rightnorm)*scale;
        this.rightStickY = ry = (ry/rightnorm)*scale;
        this.rightStickForce = Math.sqrt(rx*rx + ry*ry);

        // normalize again if necessary (avoid box range)
        if (this.rightStickForce >= 1) {
          this.rightStickX /= this.rightStickForce;
          this.rightStickY /= this.rightStickForce;
          this.rightStickForce = 1;
        }
      } else {
        this.rightStickX = this.rightStickY = this.rightStickForce = 0;
      }

      // get button values
      this.leftTrigger = this._gamepad.buttons[6].value;
      this.rightTrigger = this._gamepad.buttons[7].value;
      this._state = [];
      for (var i=0; i<this._gamepad.buttons.length; i++) {
        if (this._gamepad.buttons[i].pressed) {
          this._state.push(i)
        }
      }
    }
  }
  p.update = function() {}
  p.postUpdate = function() {
    this._lastState = this._state.slice();
  }

  p.bind = function(gamepad) {
    this.dispatchEvent(this._makeEvent('connected'))

    this._gamepad = gamepad;
    this.connected = true;
  }
  p.unbind = function() {
    this.dispatchEvent(this._makeEvent('disconnected'))
    this._gamepad = null;
    this.connected = false;
    this.rawLeftStickX = 0;
    this.rawLeftStickY = 0;
    this.rawRightStickX = 0;
    this.rawRightStickY = 0;
    this.leftStickX = 0;
    this.leftStickY = 0;
    this.rightStickX = 0;
    this.rightStickY = 0;
    this.leftTrigger = 0;
    this.rightTrigger = 0;
    this._state = [];
  }

  //---------------------------------------------------------------------------
  // PUBLIC ACCESS
  //---------------------------------------------------------------------------
  p.get = function(key) {
    return this._get(key, this._state);
  }
  p.isDown = function(key) {
    return this._get(key, this._state);
  }
  p.isUp = function(key) {
    return !this._get(key, this._state);
  }
  p.isPressed = function(key) {
    return this._get(key, this._state) && !this._get(key, this._lastState);
  }
  p.isReleased = function(key) {
    return !this._get(key, this._state) && this._get(key, this._lastState);
  } 
  p.isAnyDown = function() {
    return this._state.length > 0;
  }
  p.isAnyPressed = function() {
    for (var i=0; i<this._state.length; i++) {
      var key = this._state[i];
      if (!this._get(key, this._lastState)) {
        return true;
      }
    }
    return false;
  }
  p.isAnyReleased = function() {
    for (var i=0; i<this._lastState.length; i++) {
      var key = this._lastState[i];
      if (!this._get(key, this._state)) {
        return true;
      }
    }
    return false; 
  }

  creatine.Gamepad = createjs.promote(Gamepad, 'EventDispatcher');

})();this.creatine = this.creatine || {};

(function() {
  "use strict";

  /** Scene Manager class. */
  var SceneManager = function(game) {

    /** Game instance. */
    this.game = game;

    /** Stage instance. */
    this.stage = game.stage;

    /** Current scene (it's not included in the stack). */
    this.scene = null;

    /** Next scene (while in transition). */
    this._nextScene = null;

    /** Non-current scene stack. */
    this._sceneStack = [];

    /** Registered scenes. */
    this._scenes = {};

    /** Current transition. */
    this._transition = null;
  }
  var p = SceneManager.prototype;

  //---------------------------------------------------------------------------
  // INTERNAL METHODS
  //---------------------------------------------------------------------------
  p._addScene = function(scene) {
    // if scene already in stage/stack then remove it
    var index = this._sceneStack.indexOf(scene);
    if (index >= 0) {
      this.stage.removeChild(this.scene);
      this._sceneStack.splice(index);
    }

    // verify in which position should add the new scene in the stage
    if (this.scene) {
      var i = this.stage.getChildIndex(this.scene);
      this.stage.addChildAt(scene, i+1);
    } else {
      this.stage.addChild(scene);
    }
  }
  p._startTransition = function(outScene, inScene, transition, callback) {
    if (transition) {
      this._transition = transition;
      transition.run(this, outScene||{}, inScene||{}, callback);
    } else {
      callback();
    }
  }
  p._isValidChange = function(scene) {
    return !(this._transition!==null || this.scene===scene || !scene);
  }
  p._exitCurrentScene = function() {
    if (!this.scene) return;

    this.scene.exit();
    this.stage.removeChild(this.scene);
  }
  p._pauseCurrentScene = function() {
    if (!this.scene) return;

    this.scene._pause();
    this._sceneStack.push(this.scene);
  }
  p._resumeNextScene = function() {
    if (!this._nextScene) return;

    this.scene = this._nextScene;
    this.scene._resume();
    this._sceneStack.pop();
    this._nextScene = null;
  }
  p._enterNextScene = function() {
    if (!this._nextScene) return;

    this.scene = this._nextScene;
    this.scene._enter();
    this._nextScene = null;
  }

  //---------------------------------------------------------------------------
  // CALLBACK (CALLED BY GAME)
  //---------------------------------------------------------------------------
  p.update = function() {
    if (this.scene && !this.scene.paused) this.scene._update();

    for (var i=0; i<this._sceneStack; i++) {
      var scene = this._sceneStack[i];
      if (!scene.paused) scene._update();
    }
  }

  //---------------------------------------------------------------------------
  // REGISTER AND UNREGISTER SCENES (LIKE A STATE MACHINE)
  //---------------------------------------------------------------------------
  p.add = function(id, scene) {
    this._scenes[id] = scene;
  }
  p.remove = function(id) {
    delete this._scenes[id];
  }
  p.get = function(idOrScene) {
    if (typeof idOrScene === 'string') {
      return this._scenes[idOrScene]
    } else {
      return idOrScene;
    }
  }

  //---------------------------------------------------------------------------
  // REPLACE, PUSH AND POP
  //---------------------------------------------------------------------------
  p.replace = function(idOrScene, transition) {
    var scene = this.get(idOrScene);
    if (!this._isValidChange(scene)) return false;

    // add the next scene
    this._addScene(scene);
    this._nextScene = scene;

    // pre-transition
    if (this.scene) { this.scene._beforeExit(); }
    this._nextScene._beforeEnter();

    // pos-transition
    var self = this;
    function callback() {
      self._transition = null;
      self._exitCurrentScene();
      self._enterNextScene();
    }

    // transition
    this._startTransition(this.scene, this._nextScene, transition, callback);

    return true;
  }
  p.push = function(idOrScene, transition) {
    var scene = this.get(idOrScene);
    if (!this._isValidChange(scene)) return false;

    // add the next scene
    this._addScene(scene);
    this._nextScene = scene;

    // pre-transition
    if (this.scene) { this.scene._beforePause(); }
    this._nextScene._beforeEnter();

    // pos-transition
    var self = this;
    function callback() {
      self._transition = null;
      self._pauseCurrentScene();
      self._enterNextScene();
    }

    // transition
    this._startTransition(this.scene, this._nextScene, transition, callback);

    return true;
  }
  p.pop = function(transition) {
    if (!this._isValidChange(true)) return false;

    // add the next scene
    this._nextScene = this._sceneStack[this._sceneStack.length-1] || null;

    // pre-transition
    if (this.scene) { this.scene._beforeExit(); }
    if (this._nextScene) { this._nextScene._beforeResume(); }

    // pos-transition
    var self = this;
    function callback() {
      self._transition = null;
      self._exitCurrentScene();
      self._resumeNextScene();
    }

    // transition
    this._startTransition(this.scene, this._nextScene, transition, callback);

    return true;
  }

  //---------------------------------------------------------------------------
  // UTILITIES (ESPECIALLY USEFUL FOR TRANSITIONS)
  //---------------------------------------------------------------------------
  p.swapScenes = function() {
    this.stage.swapChildrenAt(
      this.stage.getChildIndex(this.scene),
      this.stage.getChildIndex(this._nextScene)
    );
  }
  p.clearStack = function() {
    for (var i=0; i<this._sceneStack.length; i++) {
      this._sceneStack[i]._beforeExit();
      this._sceneStack[i]._exit();
      this.stage.removeChild(this._sceneStack[i]);
    }
    this._sceneStack = [];
  }
  p.inTransition = function() {
    return this._transition !== null;
  }

  creatine.SceneManager = SceneManager;
}());
this.creatine = this.creatine || {};

(function() {
  "use strict";
  var Scene = function() {
    this.Container_constructor();

    this.started = false;
    this.paused = false;
    this._objects = {};
    this._tags = {};
    this._layers = {};
    this._systemList = [];
    this._systemMap = {};

    this._initialize();
  }
  var p = createjs.extend(Scene, createjs.Container);

  //---------------------------------------------------------------------------
  // INTERNAL METHODS
  //---------------------------------------------------------------------------
  p._initialize = function() {
    this.initialize();
  }
  p._beforeEnter = function() {
    this.beforeEnter();
  }
  p._enter = function() {
    this.started = true;
    this.paused = false;
    this.enter();
  }
  p._beforeResume = function() {
    this.beforeResume();
  }
  p._resume = function() {
    this.paused = false;
    this.resume();
  }
  p._beforePause = function() {
    this.paused = true;
    this.beforePause;
  }
  p._pause = function() {
    this.pause();
  }
  p._beforeExit = function() {
    this.beforeExit();
  }
  p._exit = function() {
    this.started = false;
    this.exit();
  }
  p._update = function() {
    this.update();

    var systems = this.getSystems();
    for (var i=0; i<systems.length; i++) {
      systems[i].update();
    }
  }

  //---------------------------------------------------------------------------
  // CONTROL METHODS
  //---------------------------------------------------------------------------
  p.addLayer = function(id, mouseEvents) {
    if (this._layers[id]) throw Error('Layer "'+id+'" already in scene.');

    var layer = new createjs.Container();
    this._layers[id] = layer;
    this.addChild(layer);
  }
  p.getLayer = function(id) {
    return this._layers[id];
  }
  p.removeLayer = function(id) {
    var layer = this._layers[id];
    if (!layer) return;

    // TODO: remove objects from layer
    // 
    delete this._layers[id];
    this.removeChild(layer);
  }

  p.addObject = function(object, layer, tags) {
    if (!object) throw Error('Invalid object.');
    if (!object.__id__) object.__id__ = creatine.newId();
    if (this._objects[object.__id__]) throw Error('Object already in scene.');
    if (layer && !this._layers[layer]) throw Error('Layer "'+layer+'" not found.');

    layer = this._layers[layer] || this;

    if (typeof tags === 'string') {
      tags = [tags];
    } else {
      tags = tags || [];
    }

    this._objects[object.__id__] = {layer:layer, tags:tags};
    layer.addChild(object);
    for (var i=0; i<tags.length; i++) {
      var tag = tags[i];
      if (!this._tags[tag]) {
        this._tags[tag] = [object];
      } else {
        this._tags[tag].push(object);
      }
    }
  }
  p.removeObject = function(object) {
    if (!object) return;
    var spec = this._objects[object.__id__];
    if (!spec) return;

    spec.layer.removeChild(object);

    if (spec.tags) {
      for (var i=0; i<spec.tags.length; i++) {
        var tag = this._tags[spec.tags[i]];
        tag.splice(tag.indexOf(object), 1);
      }
    }
  }
  p.removeObjectsByTag = function(tag) {
    var objects = this.getObjectsByTag(tag);
    if (objects.length === 0) return;

    for (var i=0; i<objects.length; i++) {
      this.removeObject(objects[i]);
    }
  }
  p.removeObjectsByLayer = function(layer) {
    var objects = this.getObjectsByLayer(layer);
    for (var i=0; i<objects.length; i++) {
      this.removeObject(objects[i]);
    }
  }
  p.getObjectsByTag = function(tag) {
    var objects = this._tags[tag];
    if (!objects) {
      return [];
    } else {
      return objects.slice();
    }
  }
  p.getObjectsByLayer = function(layer) {
    layer = layer || this;
    var layer = this._layers[layer];
    if (!layer) return [];
    return layer.children.slice();
  }
  p.getObjects = function() {
    var result = [];
    for (var object in this._objects) {
      result.push(object);
    }

    return result;
  }

  p.addSystem = function(id, system) {
    if (this._systemMap[id]) throw Error('System "'+id+'" already in scene.');
    this._systemMap[id] = system;
    this._systemList.push(system);
  }
  p.getSystem = function(id) {
    return this._systemMap[id];
  }
  p.getSystems = function() {
    return this._systemList;
  }
  p.removeSystem = function(id) {
    system = this._systemMap[id];

    if (!system) return;
    delete this._systemMap[id];
    this._systemlist.splice(this._systemlist.indexOf(system), 1);
  }

  //---------------------------------------------------------------------------
  // CALLBACK METHODS (TO OVERRIDE)
  //---------------------------------------------------------------------------
  p.initialize = function() {}
  p.beforeEnter = function() {}
  p.beforeResume = function() {}
  p.beforePause = function() {}
  p.beforeExit = function() {}
  p.enter = function() {}
  p.resume = function() {}
  p.pause = function() {}
  p.exit = function() {}
  p.update = function() {}

  creatine.Scene = createjs.promote(Scene, 'Container');

  // @SHORTCUT
  creatine._scene = function(properties) {
    var S = function() { this.Scene_constructor(); }
    var p = createjs.extend(S, creatine.Scene);
    for (var k in properties) { p[k] = properties[k]; }
    return createjs.promote(S, 'Scene');
  }
}());
this.creatine = this.creatine || {};

(function() {
  "use strict";

  var System = function() {
    this.initialize();
  }
  var p = System.prototype;
  
  p.initialize = function() {}
  p.enter = function() {}
  p.pause = function() {}
  p.resume = function() {}
  p.update = function() {}
  p.exit = function() {}

  creatine.System = System;

  // @SHORTCUT
  creatine._system = function(properties) {
    var S = function() { this.System_constructor(); }
    var p = createjs.extend(S, creatine.System);
    for (k in properties) { p[k] = properties[k]; }
    return createjs.promote(S, 'System');
  }
}());
this.creatine = this.creatine || {};
this.creatine.transitions = this.creatine.transitions || {};

(function() {
  "use strict";
      
  var FadeIn = function(ease, time) {
    this.ease = ease || createjs.Ease.linear;
    this.time = time || 400;
  }
  var p = FadeIn.prototype;

  p.run = function(director, outScene, inScene, callback) {
    inScene.alpha = 0;

    var tween = createjs.Tween.get(inScene);
    tween.to({alpha:1}, this.time, this.ease);
    
    if (callback) {
      tween.call(callback);
    }
  }

  creatine.transitions.FadeIn = FadeIn;
}());
this.creatine = this.creatine || {};
this.creatine.transitions = this.creatine.transitions || {};

(function() {
  "use strict";
   
  var FadeInOut = function(ease, time) {
    this.ease = ease || createjs.Ease.linear;
    this.time = time || 1000;
  }
  var p = FadeInOut.prototype;

  p.run = function(director, outScene, inScene, callback) {
    var time = this.time/2;

    director.swapScenes();

    inScene.alpha = 0;
    var tween = createjs.Tween.get(inScene)
                              .wait(time)
                              .to({alpha:1}, time, this.ease);

    createjs.Tween.get(outScene)
                  .to({alpha:0}, time, this.ease);

    if (callback) {
      tween.call(callback);
    }
  }

  creatine.transitions.FadeInOut = FadeInOut;
}());
this.creatine = this.creatine || {};
this.creatine.transitions = this.creatine.transitions || {};

(function() {
  "use strict";

  var FadeOut = function(ease, time) {
    this.ease = ease || createjs.Ease.linear;
    this.time = time || 400;
  }
  var p = FadeOut.prototype;

  p.run = function(director, outScene, inScene, callback) {
    director.swapScenes();

    inScene.alpha = 1;
    var tween = createjs.Tween.get(outScene);
    tween.to({alpha:0}, this.time, this.ease);

    if (callback) {
      tween.call(callback);
    }
  }

  creatine.transitions.FadeOut = FadeOut;
}());
this.creatine = this.creatine || {};
this.creatine.transitions = this.creatine.transitions || {};

(function() {
  "use strict";

  var MoveIn = function(direction, ease, time) {
    this.direction = direction || creatine.LEFT;
    this.ease = ease || createjs.Ease.linear;
    this.time = time || 400;
  }
  var p = MoveIn.prototype;

  p.run = function(director, outScene, inScene, callback) {
    var canvas_w = director.stage.canvas.width;
    var canvas_h = director.stage.canvas.height;
    var properties = {};

    switch (this.direction) {
      case creatine.LEFT:
        inScene.x = -canvas_w;
        properties.x = 0;
        break;
      case creatine.RIGHT:
        inScene.x = canvas_w;
        properties.x = 0;
        break;
      case creatine.TOP:
        inScene.y = -canvas_h;
        properties.y = 0;
        break;
      case creatine.BOTTOM:
        inScene.y = canvas_h;
        properties.y = 0;
        break;
      case creatine.TOP_LEFT:
        inScene.x = -canvas_w;
        inScene.y = -canvas_h;
        properties.x = 0;
        properties.y = 0;
        break;
      case creatine.TOP_RIGHT:
        inScene.x = canvas_w;
        inScene.y = -canvas_h;
        properties.x = 0;
        properties.y = 0;
        break;
      case creatine.BOTTOM_LEFT:
        inScene.x = -canvas_w;
        inScene.y = canvas_h;
        properties.x = 0;
        properties.y = 0;
        break;
      case creatine.BOTTOM_RIGHT:
        inScene.x = canvas_w;
        inScene.y = canvas_h;
        properties.x = 0;
        properties.y = 0;
        break
    }

    var tween = createjs.Tween.get(inScene);
    tween.to(properties, this.time, this.ease);

    if (callback) {
      tween.call(callback);
    }
  }

  creatine.transitions.MoveIn = MoveIn;

}());
this.creatine = this.creatine || {};
this.creatine.transitions = this.creatine.transitions || {};

(function() {
  "use strict";

  var MoveOut = function(direction, ease, time) {
    this.direction = direction || creatine.LEFT;
    this.ease = ease || createjs.Ease.linear;
    this.time = time || 400;
  }
  var p = MoveOut.prototype;

  p.run = function(director, outScene, inScene, callback) {
    director.swapScenes();

    var canvas_w = director.stage.canvas.width;
    var canvas_h = director.stage.canvas.height;
    var properties = {};

    switch (this.direction) {
      case creatine.LEFT:
        properties.x = -canvas_w;
        break;
      case creatine.RIGHT:
        properties.x = canvas_w;
        break;
      case creatine.TOP:
        properties.y = -canvas_h;
        break;
      case creatine.BOTTOM:
        properties.y = canvas_h;
        break;
      case creatine.TOP_LEFT:
        properties.x = -canvas_w;
        properties.y = -canvas_h;
        break;
      case creatine.TOP_RIGHT:
        properties.x = canvas_w;
        properties.y = -canvas_h;
        break;
      case creatine.BOTTOM_LEFT:
        properties.x = -canvas_w;
        properties.y = canvas_h;
        break;
      case creatine.BOTTOM_RIGHT:
        properties.x = canvas_w;
        properties.y = canvas_h;
        break
    }

    inScene.x = 0;
    inScene.y = 0;

    var tween = createjs.Tween.get(outScene);
    tween.to(properties, this.time, this.ease);

    if (callback) {
      tween.call(callback);
    }
  }

  creatine.transitions.MoveOut = MoveOut;
}());
this.creatine = this.creatine || {};
this.creatine.transitions = this.creatine.transitions || {};

(function() {
  "use strict";

  var ScaleIn = function(ease, time) {
    this.ease = ease || createjs.Ease.linear;
    this.time = time || 400;
  }
  var p = ScaleIn.prototype;

  p.run = function(director, outScene, inScene, callback) {
    var canvas_w = director.stage.canvas.width;
    var canvas_h = director.stage.canvas.height;
    var properties = {};

    inScene.scaleX = 0;
    inScene.scaleY = 0;
    inScene.x = canvas_w/2;
    inScene.y = canvas_h/2;
    properties.scaleX = 1;
    properties.scaleY = 1;
    properties.x = 0;
    properties.y = 0;

    var tween = createjs.Tween.get(inScene);
    tween.to(properties, this.time, this.ease);
    if (callback) {
      tween.call(callback);
    }
  }

  creatine.transitions.ScaleIn = ScaleIn;
}());
this.creatine = this.creatine || {};
this.creatine.transitions = this.creatine.transitions || {};

(function() {
  "use strict";

  var ScaleInOut = function(ease, time) {
    this.ease = ease || createjs.Ease.linear;
    this.time = time || 1000;
  }
  var p = ScaleInOut.prototype;

  p.run = function(director, outScene, inScene, callback) {
    var time = this.time/2;
    var canvas_w = director.stage.canvas.width;
    var canvas_h = director.stage.canvas.height;
    var in_prop = {};
    var out_prop = {};

    inScene.x = canvas_w/2;
    inScene.y = canvas_h/2;
    inScene.scaleX = 0;
    inScene.scaleY = 0;
    in_prop.x = 0;
    in_prop.y = 0;
    in_prop.scaleX = 1;
    in_prop.scaleY = 1;

    out_prop.x = canvas_w/2;
    out_prop.y = canvas_h/2;
    out_prop.scaleX = 0;
    out_prop.scaleY = 0;

    createjs.Tween.get(outScene)
                  .to(out_prop, time, this.ease);

    var tween = createjs.Tween.get(inScene)
                              .wait(time)
                              .to(in_prop, time, this.ease);
    if (callback) {
      tween.call(callback);
    }
  }

  creatine.transitions.ScaleInOut = ScaleInOut;
}());
this.creatine = this.creatine || {};
this.creatine.transitions = this.creatine.transitions || {};

(function() {
  "use strict";

  var ScaleOut = function(ease, time) {
    this.ease = ease || createjs.Ease.linear;
    this.time = time || 400;
  }
  var p = ScaleOut.prototype;

  p.run = function(director, outScene, inScene, callback) {
    director.swapScenes();

    var canvas_w = director.stage.canvas.width;
    var canvas_h = director.stage.canvas.height;
    var properties = {};

    inScene.x = 0;
    inScene.y = 0;
    inScene.scaleX = 1;
    inScene.scaleY = 1;
    properties.scaleX = 0;
    properties.scaleY = 0;
    properties.x = canvas_w/2;
    properties.y = canvas_h/2;

    var tween = createjs.Tween.get(outScene);
    tween.to(properties, this.time, this.ease);
    if (callback) {
      tween.call(callback);
    }
  }

  creatine.transitions.ScaleOut = ScaleOut;
}());
this.creatine = this.creatine || {};
this.creatine.transitions = this.creatine.transitions || {};

(function() {
  "use strict";

  var Scroll = function(direction, ease, time) {
    this.direction = direction || creatine.LEFT;
    this.ease = ease || createjs.Ease.linear;
    this.time = time || 400;
  }
  var p = Scroll.prototype;

  p.run = function(director, out_scene, in_scene, callback) {
    director.swapScenes();

    var canvas_w = director.stage.canvas.width;
    var canvas_h = director.stage.canvas.height;
    var out_prop = {};
    var in_prop = {};

    switch (this.direction) {
      case creatine.LEFT:
        in_scene.x = canvas_w;
        in_scene.y = 0;
        in_prop.x = 0;
        out_prop.x = -canvas_w;
        break;
      case creatine.RIGHT:
        in_scene.x = -canvas_w;
        in_scene.y = 0;
        in_prop.x = 0;
        out_prop.x = canvas_w;
        break;
      case creatine.TOP:
        in_scene.x = 0;
        in_scene.y = canvas_h;
        in_prop.y = 0;
        out_prop.y = -canvas_h;
        break;
      case creatine.BOTTOM:
        in_scene.x = 0;
        in_scene.y = -canvas_h;
        in_prop.y = 0;
        out_prop.y = canvas_h;
        break;
    }

    var tween = createjs.Tween.get(in_scene);
    tween.to(in_prop, this.time, this.ease);
    if (callback) {
      tween.call(callback);
    }

    tween = createjs.Tween.get(out_scene);
    tween.to(out_prop, this.time, this.ease);
  }

  creatine.transitions.Scroll = Scroll;
}());
this.creatine = this.creatine || {};

(function() {
  "use strict";

  var Emitter = function(displayObject, maxParticles) {
    this.Container_constructor();

    this._particles = [];
    this._activeParticles = 0;

    this.maxParticles = maxParticles || 100;

    this.active = false;
    this.gravityX = 0;
    this.gravityY = 0;
    this.speed = 100;
    this.speedVar = 0;
    this.life = 1;
    this.lifeVar = 0;
    this.startAlpha = 1;
    this.startAlphaVar = 1;
    this.endAlpha = 0;
    this.andAlphaVar = 0;
    this.angle = 0;
    this.angleVar = 360;
    this.dirXVar = 0;//.5;
    this.dirYVar = 0;//.5;
    this.xVar = 0;
    this.yVar = 0;

    this.elapsed = 0;
    this.duration = -1;
    this.burstAmount = 15;
    this.emissionRate = 10;
    this.emitCounter = 0;
    this.emitX = 0;
    this.emitY = 0;

    // this.compositeOperation = 'lighter';

    for (var i=0; i<this.maxParticles; i++) {
      var obj = displayObject.clone();
      obj.dirX  = 0;
      obj.dirY  = 0;
      obj.speed = 0;
      obj.life  = 0;
      obj.gravityX = 0;
      obj.gravityY = 0;
      obj.startLife  = 0;
      obj.visible = false;
      this._particles.push(obj);
      this.addChild(obj);
    }
  }
  var p = createjs.extend(Emitter, createjs.Container);

  p.start = function(time, x, y) {
    time = time || -1;
    this.emitX = (typeof x==='undefined')?this.emitX:x;
    this.emitY = (typeof y==='undefined')?this.emitY:y;
    this.duration = time;
    this.elapsed = 0;
    this.active = true;
  }

  p.burst = function(x, y) {
    x = x||0;
    y = y||0;

    for (var i=0; i<this.burstAmount&&this._activeParticles<this.maxParticles; i++) {
      this.addParticle(x, y);
    }
  }

  p.addParticle = function(x, y) {
    var rot;
    var random = Math.random;
    var cos = Math.cos;
    var sin = Math.sin;
    var clip = tine.clip;
    var varl = this.lifeVar;
    var varsa = this.startAlphaVar;
    var varea = this.endAlphaVar;
    var vars = this.speedVar;
    var varx = this.xVar;
    var vary = this.yVar;
    var varr = this.angleVar;
    var vardx = this.dirXVar;
    var vardy = this.dirYVar;
    var p = this._particles[this._activeParticles++];

    p.visible   = true;
    p.startLife = p.life = clip(this.life + random()*varl*2-varl, 0, 100000);
    p.alpha     = clip(this.startAlpha + random()*varsa*2-varsa, 0, 1);
    p.endAlpha  = clip(this.endAlpha + random()*varea*2-varea, 0, 1);
    p.x         = x + random()*varx*2-varx;
    p.y         = y + random()*vary*2-vary;
    rot         = (this.angle + random()*varr*2-varr)*0.0174532925;
    p.dirX      = cos(rot) + random()*vardx*2-vardx;
    p.dirY      = sin(rot) + random()*vardy*2-vardy;
    p.speed     = this.speed + random()*vars*2-vars;
    p.gravityX  = this.gravityX;
    p.gravityY  = this.gravityY;
  }

  p.update = function(fdelta) {
    if (!fdelta) return;
    if (this.active) {
      var rate = 1.0/this.emissionRate;
      this.emitCounter += fdelta;

      while (this._activeParticles < this.maxParticles && this.emitCounter > rate) {
        this.addParticle(this.emitX, this.emitY);
        this.emitCounter -= rate;
      }

      this.elapsed += fdelta;
      if (this.duration != -1 && this.duration < this.elapsed) {
        this.active = false;
      }
    }

//     # update particle count
//     self.particle_count = numpy.sum(self.particle_life >= 0)

//     if self.active:
//         rate = 1.0 / self.emission_rate
//         self.emit_counter += delta

//         while self.particle_count < self.total_particles and self.emit_counter > rate:
//             self.add_particle()
//             self.emit_counter -= rate

//         self.elapsed += delta

//         if self.duration != -1 and self.duration < self.elapsed:
//             self.stop_system()



    var i=0, p, p_, step;
    var startAlpha = this.startAlpha;
    var endAlpha = this.endAlpha;
    var N = this._activeParticles;
    var particles = this._particles;

    while (i<N) {
      p = particles[i];
      
      p.life -= fdelta;
      if (p.life <= 0) {
        p.visible = false;
        N--;
        particles[i] = particles[N];
        particles[N] = p;
        continue;
      }
      step = p.life/p.startLife;
      p.dirX += p.gravityX*fdelta;
      p.dirY += p.gravityY*fdelta;
      p.alpha = endAlpha + step*(startAlpha - endAlpha);
      p.x += p.dirX*p.speed*fdelta;
      p.y += p.dirY*p.speed*fdelta;

      i++;
    }

    this._activeParticles = N;
  }

  creatine.Emitter = createjs.promote(Emitter, 'Container');

})();/*
* TMXTileset
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
  "use strict";

  /**
   * TMXTileset represents a Tileset in the TMX map.
   *
   * <h4>Data Format</h4>
   *
   * In relation to the tilesets properties, the data must be in the 
   * following format:
   * 
   *     var data = {
   *         'firstgid'    : [Integer], // mandatory
   *         'name'        : [String],  // mandatory
   *         'image'       : [String],  // mandatory
   *         'imagewidth'  : [Integer], // default to image.width
   *         'imageheight' : [Integer], // default to image.height
   *         'tilewidth'   : [Integer], // default to 32
   *         'tileheight'  : [Integer], // default to 32
   *         'spacing'     : [Integer], // default to 0
   *         'margin'      : [Integer], // default to 0
   *         'tileoffset'  : [Object],  // default to {x:0, y:0}
   *         'properties'  : [Object],
   *     }
   * 
   * Consult the official TMX description to known more:
   * https://github.com/bjorn/tiled/wiki/TMX-Map-Format
   *
   * @class TMXTileset
   * @param {Object} data The data object describing the tileset.
   * @constructor
  **/
  var TMXTileset = function(data) {

    /**
     * The first global tile ID of this tileset.
     *
     * @property firstgid
     * @type {Integer}
     * @readonly
    **/
    this.firstgid = null;

    /**
     * The name of this tileset.
     *
     * @property name
     * @type {String}
     * @readonly
    **/
    this.name = null;

    /**
     * The image width in pixels.
     *
     * @property width
     * @type {Integer}
     * @readonly
    **/
    this.width = null;

    /**
     * The image height in pixels.
     *
     * @property height
     * @type {Integer}
     * @readonly
    **/
    this.height = null;

    /**
     * The width of the tiles in this tileset.
     *
     * @property width
     * @type {Integer}
     * @readonly
    **/
    this.tileWidth = null;

    /**
     * The height of the tiles in this tileset.
     *
     * @property height
     * @type {Integer}
     * @readonly
    **/
    this.tileHeight = null;

    /**
     * The path to the image associated to this tilset.
     *
     * @property imagePath
     * @type {String}
     * @readonly
    **/
    this.imagePath = null;

    /**
     * The offsetX to the tile origin. Notice that, tiled assumes (0, 0) as
     * the left-bottom.
     *
     * @property tileOffsetX
     * @type {Integer}
     * @readonly
    **/
    this.tileOffsetX = null;

    /**
     * The offsetY to the tile origin. Notice that, tiled assumes (0, 0) as
     * the left-bottom.
     *
     * @property tileOffsetY
     * @type {Integer}
     * @readonly
    **/
    this.tileOffsetY = null;
    /**
     * The spacing between tiles on the image.
     *
     * @property spacing
     * @type {Integer}
     * @readonly
    **/
    this.spacing = null;

    /**
     * The margin of the image.
     *
     * @property spacing
     * @type {Integer}
     * @readonly
    **/
    this.margin = null;

    /**
     * An object with properties defined by user.
     *
     * @property properties
     * @type {Object}
     * @readonly
    **/
    this.properties = null;

    /**
     * An object with tile properties defined by user.
     *
     * @property properties
     * @type {Object}
     * @readonly
    **/
    this.tileProperties = null;

    /**
     * The spritesheet object loaded by this tileset.
     *
     * @property spritesheet
     * @type {createjs.SpriteSheet}
     * @readonly
    **/
    this.spritesheet = null;

    /**
     * Animation dict contained in the tileset.
     *
     * @property animations
     * @type {Object}
     * @readonly
    **/
    this.animations = null;

    this._initialize(data);
  }
  var p = TMXTileset.prototype;

  /**
   * Initialization method.
   * 
   * @method _initialize
   * @param {Object} data The data object describing the tileset.
   * @protected
  **/
  p._initialize = function(data) {
    this.firstgid       = data['firstgid'];
    this.name           = data['name'];
    this.imagePath      = data['image'];
    this.width          = data['imagewidth'];
    this.height         = data['imageheight'];
    this.tileWidth      = data['tilewidth'] || 32;
    this.tileHeight     = data['tileheight'] || 32;
    this.spacing        = data['spacing'] || 0;
    this.margin         = data['margin'] || 0;
    this.properties     = data['properties'];
    this.tileProperties = data['tileproperties'];
    this.tileOffsetX    = 0;
    this.tileOffsetY    = 0;
    this.animations     = {};
    
    if (data['tileoffset']) {
      this.tileOffsetX = data['tileoffset']['x'];
      this.tileOffsetY = data['tileoffset']['y'];
    }

    if (data['tiles']) {
      for (var key in data['tiles']) {
        var info = data['tiles'][key];

        if (info['animation']) {
          var frames = [];
          var speeds = [];

          for (var i=0; i<info['animation'].length; i++) {
            frames.push(info['animation'][i]['tileid']);
            speeds.push(info['animation'][i]['duration']);
          }
          this.animations['anim-'+key] = {
            'frames': frames,
            'speed': speeds[0]/1000
          }
        }
      }
    }

    this._loadSpriteSheet();
  }

  /**
   * Loads the spritesheet.
   * 
   * @method _loadSpriteSheet
   * @protected
  **/
  p._loadSpriteSheet = function() {
    if (!this.imagePath) return;

    var data = {
      'images': [this.imagePath],
      'frames': {
        'width'   : this.tileWidth,
        'height'  : this.tileHeight,
        'regX'    :-this.tileOffsetX,
        'regY'    : this.tileHeight - this.tileOffsetY, // at bottom
        'spacing' : this.spacing,
        'margin'  : this.margin
      },
      'animations': this.animations
    }
    this.spritesheet = new createjs.SpriteSheet(data);
  }

  creatine.TMXTileset = TMXTileset;
}());/*
* TMXTileLayer
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
    "use strict";

    /**
     * TMXTileLayer represents an abstract TileLayer in the TMX map. Creatine 
     * actually use this as base class to <code>TMXOrthogonalTileLayer</code>,
     * <code>TMXIsometricTileLayer</code> and 
     * <code>TMXStaggeredTileLayer</code>. The difference among projections is 
     * performed at layer-level, making new projections and extensions of the
     * current ones a lot simpler to be created. This also allows you to use
     * multiple projections to the same map (unfortunately, this isn't 
     * supported by Tiled yet). 
     *
     * @class TMXTileLayer
     * @param {creatine.TMXMap} map The map object.
     * @param {Object} data The data object (from tmx format).
     * @extends createjs.Container
     * @constructor
    **/
    var TMXTileLayer = function(map, data) {
        
        /**
         * Reference to the TMX map.
         *
         * @property map
         * @type {creatine.TMXMap}
         * @readonly
        **/
        this.map = null;

        /**
         * The name of the layer.
         *
         * @property name
         * @type {String}
         * @readonly
        **/
        this.name = null;

        /**
         * The list of tile ids in the layer.
         *
         * @property data
         * @type {Array}
         * @readonly
        **/
        this.data = null;

        /**
         * The amount of tiles in x axis.
         *
         * @property width
         * @type {Integer}
         * @readonly
        **/
        this.width = null;

        /**
         * The amount of tiles in y axis.
         *
         * @property y
         * @type {Integer}
         * @readonly
        **/
        this.height = null;

        this._initialize(map, data);
    }
    var p = createjs.extend(TMXTileLayer, createjs.Container);

    /**
     * Initialization method.
     * 
     * @method _initialize
     * @param {creatine.TMXMap} map The map object.
     * @param {Object} data The data object (from tmx format).
     * @protected
    **/
    p._initialize = function(map, data) {
        this.Container_constructor();

        if (!map) return;

        this.map     = map;
        this.name    = data['name'];
        this.data    = data['data'];
        this.x       = data['x'];
        this.y       = data['y'];
        this.width   = data['width'];
        this.height  = data['height'];
        this.visible = data['visible'];
        this.alpha   = data['opacity'];

        this._createTiles();
    }

    /**
     * Create the tiles.
     * 
     * Override this method on the child class.
     * 
     * @method _createTiles
     * @protected
    **/
    p._createTiles = function() {
        throw new Error('TMXTileLayer._createTiles not implemented.');
    }

    /**
     * Return the tile value, given a coord of a tile. 
     *
     * @method getTile
     * @param {Integer} x The column of a tile.
     * @param {Integer} y The row of a tile.
     * @return {Integer} The tile id.
    **/
    p.getTile = function(x, y) {
        return this.data[(this.width*y + x)]
    }

    /**
     * Set the tile value, given a coord of a tile. 
     *
     * @method getTile
     * @param {Integer} x The column of a tile.
     * @param {Integer} y The row of a tile.
     * @param {Integer} gid The global ID.
    **/
    p.setTile = function(x, y, gid) {
        var idx = (this.width*y + x);

        var tileset = this.map.getTilesetByGid(gid);
        var tileId = gid-tileset.firstgid;
        var tile = this.getChildAt(idx)

        this.data[idx] = tileId;
        if (tileset.animations['anim-'+(tileId)]) {
            tile.gotoAndPlay('anim-'+(tileId));
        } else {
            tile.gotoAndStop(tileId);
        }
    }

    /**
     * Return the coord of a tile given the local position. 
     * 
     * Override this method on the child class.
     *
     * @method getTile
     * @param {Integer} x The position x.
     * @param {Integer} y The position y.
     * @return {createjs.Point} The tile coord.
    **/
    p.getCoords = function(x, y) {
        throw new Error('TMXTileLayer.getCoords not implemented.');
    }

    /**
     * Return the top-left local position of a tile, considering its coords
     * (column and row).
     * 
     * Override this method on the child class.
     *
     * @method getTile
     * @param {Integer} x The column of the tile.
     * @param {Integer} y The row of the tile.
     * @return {createjs.Point} The top-left tile local position.
    **/
    p.getPosition = function(x, y) {
        throw new Error('TMXTileLayer.getPosition not implemented.');
    }

    creatine.TMXTileLayer = createjs.promote(TMXTileLayer, "Container");
}());/*
* TMXOrthogonalTileLayer
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
    "use strict";

    /**
     * TMXOrthogonalTileLayer represents a TileLayer in the TMX map.
     *
     * @class TMXOrthogonalTileLayer
     * @param {creatine.TMXMap} map The map object.
     * @param {Object} data The data object (from tmx format).
     * @extends creatine.TMXTileLayer
     * @constructor
    **/
    var TMXOrthogonalTileLayer = function(map, data) {
        this.TMXTileLayer_constructor(map, data);
    }
    var p = createjs.extend(TMXOrthogonalTileLayer, creatine.TMXTileLayer);

    /**
     * Create the tiles. Override this method on the child class.
     * 
     * @method _createTiles
     * @protected
    **/
    p._createTiles = function() {
        var order = this.map.renderOrder;
        var startX = 0;
        var startY = 0;
        var endX = this.width;
        var endY = this.height;
        var dirX = 1;
        var dirY = 1;
        var tW = this.map.tileWidth;
        var tH = this.map.tileHeight;

        if (order == 'left-down' || order=='left-up') {
            startX = this.width-1; endX = 0; dirX = -1;
        }
        
        if (order == 'right-up' || order=='left-up') {
            startY = this.height-1; endY = 0; dirY = -1
        }

        for (var y=startY; y!=endY; y+=dirY) {
            for (var x=startX; x!=endX; x+=dirX) {
                var i = (this.width*y + x)

                var gid = this.data[i];

                if (gid <= 0) continue;

                var tileset = this.map.getTilesetByGid(gid);
                var tile = new createjs.Sprite(tileset.spritesheet)
                var tileId = gid-tileset.firstgid;
                
                if (tileset.animations['anim-'+(tileId)]) {
                    tile.gotoAndPlay('anim-'+(tileId));
                } else {
                    tile.gotoAndStop(tileId);
                }

                tile.x = x*tW;
                tile.y = y*tW + tH;
                this.addChild(tile);
            }
        }
    }

    /**
     * Return the coord of a tile given the local position. 
     *
     * @method getTile
     * @param {Integer} x The position x.
     * @param {Integer} y The position y.
     * @return {createjs.Point} The tile coord.
    **/
    p.getCoords = function(x, y) {
        return new createjs.Point(
            Math.floor(x/this.map.tileWidth),
            Math.floor(y/this.map.tileHeight)
        );
    }

    /**
     * Return the top-left local position of a tile, considering its coords
     * (column and row).
     * 
     * @method getTile
     * @param {Integer} x The column of the tile.
     * @param {Integer} y The row of the tile.
     * @return {createjs.Point} The top-left tile local position.
    **/
    p.getPosition = function(x, y) {
        return new createjs.Point(
            Math.floor(x*this.map.tileWidth),
            Math.floor(y*this.map.tileHeight)
        );
    }

    creatine.TMXOrthogonalTileLayer = createjs.promote(TMXOrthogonalTileLayer, "TMXTileLayer");
}());/*
* TMXIsometricTileLayer
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
    "use strict";

    /**
     * TMXIsometricTileLayer represents a TileLayer in the TMX map.
     *
     * @class TMXIsometricTileLayer
     * @param {creatine.TMXMap} map The map object.
     * @param {Object} data The data object (from tmx format).
     * @extends creatine.TMXTileLayer
     * @constructor
    **/
    var TMXIsometricTileLayer = function(map, data) {
        this.TMXTileLayer_constructor(map, data);
    }
    var p = createjs.extend(TMXIsometricTileLayer, creatine.TMXTileLayer);

    /**
     * Create the tiles. Override this method on the child class.
     * 
     * @method _createTiles
     * @protected
    **/
    p._createTiles = function() {
        var order = this.map.renderOrder;
        var startX = 0;
        var startY = 0;
        var endX = this.width;
        var endY = this.height;
        var dirX = 1;
        var dirY = 1;
        var tW = this.map.tileWidth;
        var tH = this.map.tileHeight;

        if (order == 'left-down' || order=='left-up') {
            startX = this.width-1; endX = 0; dirX = -1;
        }
        
        if (order == 'right-up' || order=='left-up') {
            startY = this.height-1; endY = 0; dirY = -1
        }

        for (var y=startY; y!=endY; y+=dirY) {
            for (var x=startX; x!=endX; x+=dirX) {
                var i = (this.width*y + x)

                var gid = this.data[i];

                if (gid <= 0) continue;

                var tileset = this.map.getTilesetByGid(gid);
                var tile = new createjs.Sprite(tileset.spritesheet)
                var tileId = gid-tileset.firstgid;
                
                if (tileset.animations['anim-'+(tileId)]) {
                    tile.gotoAndPlay('anim-'+(tileId));
                } else {
                    tile.gotoAndStop(tileId);
                }

                tile.x = (x-y-1)*(this.map.tileWidth/2);
                tile.y = (x+y+2)*(this.map.tileHeight/2);

                this.addChild(tile);
            }
        }
    }

    /**
     * Return the coord of a tile given the local position. 
     * 
     * Override this method on the child class.
     *
     * @method getTile
     * @param {Integer} x The position x.
     * @param {Integer} y The position y.
     * @return {createjs.Point} The tile coord.
    **/
    p.getCoords = function(x, y) {
        return new createjs.Point(
            Math.floor(x/this.map.tileWidth + y/this.map.tileHeight),
            Math.floor(-x/this.map.tileWidth + y/this.map.tileHeight)
        );
    }

    /**
     * Return the top-left local position of a tile, considering its coords
     * (column and row).
     * 
     * Override this method on the child class.
     *
     * @method getTile
     * @param {Integer} x The column of the tile.
     * @param {Integer} y The row of the tile.
     * @return {createjs.Point} The top-left tile local position.
    **/
    p.getPosition = function(x, y) {
        return new createjs.Point(
            (x-y-1)*(this.map.tileWidth/2),
            (x+y+2)*(this.map.tileHeight/2)

        )
    }
    creatine.TMXIsometricTileLayer = createjs.promote(TMXIsometricTileLayer, "TMXTileLayer");
}());/*
* TMXStaggeredTileLayer
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
    "use strict";

    /**
     * TMXStaggeredTileLayer represents a TileLayer in the TMX map.
     *
     * @class TMXStaggeredTileLayer
     * @param {creatine.TMXMap} map The map object.
     * @param {Object} data The data object (from tmx format).
     * @extends creatine.TMXTileLayer
     * @constructor
    **/
    var TMXStaggeredTileLayer = function(map, data) {
        this.TMXTileLayer_constructor(map, data);
    }
    var p = createjs.extend(TMXStaggeredTileLayer, creatine.TMXTileLayer);

    /**
     * Create the tiles. Override this method on the child class.
     * 
     * @method _createTiles
     * @protected
    **/
    p._createTiles = function() {
        var order = this.map.renderOrder;
        var startX = 0;
        var startY = 0;
        var endX = this.width;
        var endY = this.height;
        var dirX = 1;
        var dirY = 1;
        var tW = this.map.tileWidth;
        var tH = this.map.tileHeight;

        if (order == 'left-down' || order=='left-up') {
            startX = this.width-1; endX = 0; dirX = -1;
        }
        
        if (order == 'right-up' || order=='left-up') {
            startY = this.height-1; endY = 0; dirY = -1
        }

        for (var y=startY; y!=endY; y+=dirY) {
            for (var x=startX; x!=endX; x+=dirX) {
        // for (var y=startY; y!=2; y+=dirY) {
            // for (var x=startX; x!=2; x+=dirX) {
                var i = (this.width*y + x)

                var gid = this.data[i];

                if (gid <= 0) continue;

                var tileset = this.map.getTilesetByGid(gid);
                var tile = new createjs.Sprite(tileset.spritesheet)
                var tileId = gid-tileset.firstgid;
                
                if (tileset.animations['anim-'+(tileId)]) {
                    tile.gotoAndPlay('anim-'+(tileId));
                } else {
                    tile.gotoAndStop(tileId);
                }

                tile.x = tW*(x + (y%2)/2 - 0.5);
                tile.y = tH*(y/2 + 1);


                // tile.x = tW*(x+(y%2)/2);
                // tile.y = tH + tH*y/2;


                this.addChild(tile);
            }
        }
    }

    /**
     * Return the coord of a tile given the local position. 
     * 
     * Override this method on the child class.
     *
     * @method getTile
     * @param {Integer} x The position x.
     * @param {Integer} y The position y.
     * @return {createjs.Point} The tile coord.
    **/
    p.getCoords = function(x, y) {
        // convert to iso first
        var x_ = Math.floor(x/this.map.tileWidth + y/this.map.tileHeight);
        var y_ = Math.floor(-x/this.map.tileWidth + y/this.map.tileHeight);

        // then from iso to stag
        x = Math.floor((x_-y_)/2);
        y = x_ + y_;
        return new createjs.Point(x, y);
    }

    /**
     * Return the top-left local position of a tile, considering its coords
     * (column and row).
     * 
     * Override this method on the child class.
     *
     * @method getTile
     * @param {Integer} x The column of the tile.
     * @param {Integer} y The row of the tile.
     * @return {createjs.Point} The top-left tile local position.
    **/
    p.getPosition = function(x, y) {
        return new createjs.Point(
            this.map.tileWidth*(x + (Math.abs(y)%2)/2 - 0.5),
            this.map.tileHeight*(y/2 + 1)
        )
    }
    creatine.TMXStaggeredTileLayer = createjs.promote(TMXStaggeredTileLayer, "TMXTileLayer");
}());/*
* TMXImageLayer
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
    "use strict";

    /**
     * TMXImageLayer represents an image layer on TMX map.
     *
     * @class TMXImageLayer
     * @param {creatine.TMXMap} map The map object.
     * @param {Object} data The data object (from tmx format).
     * @extends createjs.Bitmap
     * @constructor
    **/
    var TMXImageLayer = function(map, data) {
        /**
         * Reference to the TMX map.
         *
         * @property map
         * @type {creatine.TMXMap}
         * @readonly
        **/
        this.map = null;

        /**
         * The path for the image.
         *
         * @property imagePath
         * @type {String}
         * @readonly
        **/
        this.imagePath = null;

        /**
         * The name of the layer.
         *
         * @property name
         * @type {String}
         * @readonly
        **/
        this.name = null;

        /**
         * The amount of tiles in x axis. Not really useful here.
         *
         * @property width
         * @type {Integer}
         * @readonly
        **/
        this.width = null;

        /**
         * The amount of tiles in y axis. Not really useful here.
         *
         * @property y
         * @type {Integer}
         * @readonly
        **/
        this.height = null;

        this._initialize(map, data);
    }
    var p = createjs.extend(TMXImageLayer, createjs.Bitmap);

    /**
     * Initialization method.
     * 
     * @method _initialize
     * @param {creatine.TMXMap} map The map object.
     * @param {Object} data The data object (from tmx format).
     * @protected
    **/
    p._initialize = function(map, data) {
        if (!map) return;

        this.Bitmap_constructor(data['image']||null);

        this.map       = map;
        this.name      = data['name'];
        this.imagePath = data['image'];
        this.x         = data['x'];
        this.y         = data['y'];
        this.width     = data['width'];
        this.height    = data['height'];
        this.visible   = data['visible'];
        this.alpha     = data['opacity'];
    }

    creatine.TMXImageLayer = createjs.promote(TMXImageLayer, "Bitmap");
}());/*
* TMXObjectLayer
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
    "use strict";

    /**
     * TMXObjectLayer represents an Object Group in TMX maps.
     *
     * @class TMXObjectLayer
     * @param {creatine.TMXMap} map The map object.
     * @param {Object} data The data object (from tmx format).
     * @constructor
    **/
    var TMXObjectLayer = function(map, data) {
        /**
         * Reference to the TMX map.
         *
         * @property map
         * @type {creatine.TMXMap}
         * @readonly
        **/
        this.map = null;

        /**
         * The name of the layer.
         *
         * @property name
         * @type {String}
         * @readonly
        **/
        this.name = null;

        /**
         * List of objects in the layer.
         *
         * @property objects
         * @type {Array}
         * @readonly
        **/
        this.objects = null;

        /**
         * Is the layer visible?
         *
         * @property visible
         * @type {Boolean}
         * @readonly
        **/
        this.visible = null;

        /**
         * Opacity the layer.
         *
         * @property alpha
         * @type {Float}
         * @readonly
        **/
        this.alpha = null;

        this._initialize(map, data);
    }
    var p = TMXObjectLayer.prototype;

    /**
     * Initialization method.
     * 
     * @method initialize
     * @param {creatine.TMXMap} map The map object.
     * @param {Object} data The data object (from tmx format).
     * @protected
    **/
    p._initialize = function(map, data) {
        if (!map) return;

        this.map     = map;
        this.name    = data['name'];
        this.objects = data['objects'];
        this.visible = data['visible'];
        this.alpha   = data['opacity'];
    }

    creatine.TMXObjectLayer = TMXObjectLayer;
}());/*
* TMXMap
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
  "use strict";

  /**
   * TMXMap is the class that handle tile maps in the TMX format, specified 
   * by the tile software Tiled. A TMX map is composed of one or more layers 
   * (tile layers, object layers or image layers) and one or more tilesets 
   * (image atlases). Creatine supports all types of layers and projections 
   * described by the TMX specification: orthogonal, isometric and staggered.
   *
   * The TMXMap receives a data object following the TMX specification. This 
   * is usually loaded from a json map. 
   *
   * <h4>Example</h4>
   *
   * Notice that, TMXMap is a display object, inherited from 
   * <code>createjs.Container</code>, it means that, after loading the map 
   * you can simply add it to the stage:
   * 
   *     var map = new creatine.TMXMap(dataObject);
   *     stage.addChild(map);
   *
   * <h4>Data Format</h4>
   *
   * In relation to the map properties, the data must be in the following 
   * format:
   * 
   *     var data = {
   *         'version'     : [Integer], // default to 1
   *         'orientation' : [String],  // default to 'orthogonal'
   *         'renderorder' : [String],  // default to 'right-down'
   *         'height'      : [Integer], // default to 0
   *         'width'       : [Integer], // default to 0
   *         'tileheight'  : [Integer], // default to 0
   *         'tilewidth'   : [Integer], // default to 0
   *         'tilesets'    : [Array],   // mandatory
   *         'layers'      : [Array],   // mandatory
   *         'properties'  : [Object],
   *     }
   * 
   * Consult the specific classes for layer and tileset to known more about 
   * the data format for these structures or consult the official TMX 
   * description: https://github.com/bjorn/tiled/wiki/TMX-Map-Format
   *
   * @class TMXMap
   * @extends createjs.Container
   * @param {Object} data A data object describing the map.
   * @constructor
  **/
  var TMXMap = function(data) {
    /**
     * Map version
     *
     * @property version
     * @type {Integer}
     * @readonly
    **/
    this.version = null;

    /**
     * Orientation of the map, it supports "orthogonal", "isometric" and 
     * "staggered".
     *
     * @property orientation
     * @type {String}
     * @readonly
    **/
    this.orientation = null;

    /**
     * Order of rendering, supports "right-down", "right-up", "left-down" and
     * "left-up".
     *
     * @property renderOrder
     * @type {String}
     * @readonly
    **/
    this.renderOrder = null;

    /**
     * Describes how many tiles the map have in the y axis.
     *
     * @property height
     * @type {Integer}
     * @readonly
    **/
    this.height = null;

    /**
     * Describes how many tiles the map have in the x axis.
     *
     * @property width
     * @type {Integer}
     * @readonly
    **/
    this.width = null;

    /**
     * Height of tiles.
     *
     * @property tileHeight
     * @type {Integer}
     * @readonly
    **/
    this.tileHeight = null;

    /**
     * Width of tiles.
     *
     * @property tileWidth
     * @type {Integer}
     * @readonly
    **/
    this.tileWidth = null;

    /**
     * The list of tilesets in the map.
     *
     * @property tilesets
     * @type {Array}
     * @readonly
    **/
    this.tilesets = null;

    /**
     * The list of layers in the map.
     *
     * @property layers
     * @type {Array}
     * @readonly
    **/
    this.layers = null;

    /**
     * User defined properties object.
     *
     * @property properties
     * @type {Object}
     * @readonly
    **/
    this.properties = null;


    this._initialize(data);
  }
  var p = createjs.extend(TMXMap, createjs.Container);

  /**
   * Initialization method.
   * 
   * @method _initialize
   * @param {Object} data A data object describing the map.
   * @protected
  **/
  p._initialize = function(data) {
    this.Container_constructor();
    this.version     = data['version'] || 1;
    this.orientation = data['orientation'] || 'orthogonal';
    this.renderOrder = data['renderorder'] || 'right-down';
    this.height      = data['height'] || 0;
    this.width       = data['width'] || 0;
    this.tileHeight  = data['tileheight'] || 0;
    this.tileWidth   = data['tilewidth'] || 0;
    this.properties  = data['properties'];
    this.tilesets    = [];
    this.layers      = [];

    this._createTilesets(data);
    this._createLayers(data);
  }
  /**
   * Create the tileset objects.
   * 
   * @method _createTilesets
   * @param {Object} data An object following the TMX specification.
   * @protected
  **/
  p._createTilesets = function(data) {
    for (var i=0; i<data['tilesets'].length; i++) {
      this.tilesets.push(
        new creatine.TMXTileset(data['tilesets'][i])
      )
    }
  }

  /**
   * Create the layer objects.
   * 
   * @method _createLayers
   * @param {Object} data An object following the TMX specification.
   * @protected
  **/
  p._createLayers = function(data) {
    for (var i=0; i<data['layers'].length; i++) {
      var layerType = data['layers'][i].type;

      if (layerType == 'tilelayer') {
        if (this.orientation == 'orthogonal')
          var Layer = creatine.TMXOrthogonalTileLayer

        else if (this.orientation == 'isometric')
          var Layer = creatine.TMXIsometricTileLayer

        else if (this.orientation == 'staggered')
          var Layer = creatine.TMXStaggeredTileLayer

        else
          throw new Error('Unknown layer type: "'+layerType+'"');

        var layer = new Layer(this, data['layers'][i]);
        this.layers.push(layer);
        this.addChild(layer);

      } else if (layerType == 'objectgroup') {
        this.layers.push(
          new creatine.TMXObjectLayer(this, data['layers'][i])
        );
          
      } else if (layerType == 'imagelayer') {
        var layer = new creatine.TMXImageLayer(this, data['layers'][i])

        this.addChild(layer);
        this.layers.push(layer);
      }
    }
  }

  /**
   * Returns the tileset which holds the provided global ID.
   * 
   * @method getTilesetByGid
   * @param {Integer} gid A global ID.
  **/
  p.getTilesetByGid = function(gid) {
    for (var i=this.tilesets.length-1; i>=0; i--) {
      if (this.tilesets[i].firstgid <= gid) {
        return this.tilesets[i];
      }
    }
  }

  /**
   * Returns a layer by name
   * 
   * @method getLayerByName
   * @param {String} name Layer name.
  **/
  p.getLayerByName = function(name) {
    for (var i=0; i<this.layers.length; i++) {
      if (this.layers[i].name == name) {
        return this.layers[i];
      }
    }
  }

  creatine.TMXMap = createjs.promote(TMXMap, "Container");
}());/*
* BoxSizer
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
    "use strict";

    /**
     * The BoxSizer is a simple layout manager that organizes its components 
     * horizontally or vertically, depending on the <code>orientationat</code> 
     * parameter.
     * 
     * BoxSizer was create to organize the game interface using a basic 
     * geometry, e.g., in a single row or column. But several BoxSizers can be 
     * nested to create a more complex layout. Notice that, for regular grids, 
     * the best option is the GridSizer.
     * 
     * A BoxSizer requires an orientation parameter, which can be the constants
     * <code>HORIZONTAL</code> or <code>HORIZONTAL</code>. It also requires a
     * rectangle containing the information of how much space the sizer can use
     * to expand and organize its elements.
     * 
     * By specifying the proportion parameter when adding a child, the BoxSizer
     * will expand to occupy all the available area. By doing this, the sizer 
     * also can align the component using the anchor position. The anchor 
     * parameter can be specified using the following constants: <code>LEFT, 
     * RIGHT, TOP, BOTTOM, TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT, 
     * CENTER</code>.
     * 
     * Each component can also have an individual border, by setting the border
     * parameter when adding it to the sizer.
     * 
     * 
     * <h4>Example</h4>
     * 
     * A BoxSizer which grows horizontally and occupying all space of a canvas 
     * can be created as:
     * 
     *     var area = new createjs.Rectangle(0, 0, canvas.width, canvas.height);
     *     var hbox = new creatine.BoxSizer(creatine.HORIZONTAL, area);
     * 
     * And components can be added as:
     * 
     *     hbox.add(my_text, 1, 0, creatine.CENTER);
     *     hbox.add(my_sprite);
     *     hbox.layout()
     * 
     * In the example above, the <code>my_sprite</code> component will be put 
     * at the right while <code>my_text</code> will be moved the the center of 
     * the remaining area.
     * 
     * @class BoxSizer
     * @constructor
     * @param {Constant} orientation The orientation of the sizer (horizontal 
     *                   or vertical).
     * @param {createjs.Rectangle} area A rectangle containing the usable area 
     *                             of the sizer.
    **/
    var BoxSizer = function(orientation, area) {
        /**
         * The orientation of the sizer (use the HORIZONTAL or VERTICAL constants)
         *
         * @property orientation
         * @type {Constant}
        **/
        this.orientation = orientation;

        /**
         * The list within all items in this sizer together with their proportions,
         * border, and anchor.
         * 
         * @property children
         * @type {Array}
         * @private
        **/
        this.children = [];

        /**
         * A rectangle representing the area of which the sizer can use.
         *
         * @property area
         * @type {createjs.Rectangle}
        **/
        this.area = area;
    }
    var p = BoxSizer.prototype;
    
    /**
     * Adds a new object to the sizer.
     *
     * @method add
     * @param {Object} object The DisplayObject to be organized by this sizer.
     * @param {Number} proportion The expansion weight of this item, use 0 
     *                 (zero) to not expand. Default to 0.
     * @param {Number} border The spacing around this item. Default to 0.
     * @param {Constant} anchor The anchor of the object, only useful if 
     *                   proportion is greater than 0. Default to 
     *                   <code>creatine.TOP_LEFT</code>
    **/
    p.add = function(object, proportion, border, anchor) {
        anchor     = anchor     || creatine.TOP_LEFT;
        proportion = proportion || 0;
        border     = border     || 0;

        this.children.push([object, proportion, anchor, border]);
    }

    /**
     * Resize this sizer and its children.
     * 
     * For the root sizer, the parameter <code>area</code> does not to be 
     * specified, but it is automatically set in nested sizers.
     *
     * @method layout 
     * @param {createjs.Rectangle} area A rectangle containing the usable area
     *                             of the sizer. 
    **/
    p.layout = function(area) {
        if (area)
            this.area = area;

        var borders = 0;
        var proportions = 0;
        var fixed_widths = 0;
        var fixed_heights = 0;

        // Compute the available area
        for (var i=0; i<this.children.length; i++) {
            var item        = this.children[i][0];
            var proportion  = this.children[i][1];
            var anchor      = this.children[i][2];
            var border      = this.children[i][3];

            borders += border*2;
            if (proportion > 0) {
                proportions += proportion;
            } else {
                var bounds = item.getBounds();
                fixed_widths += bounds.width;
                fixed_heights += bounds.height;
            }
        }

        var avaliable_w = (this.area.width-borders-fixed_widths);
        var avaliable_h = (this.area.height-borders-fixed_heights);

        // Resize
        var step_x = this.area.x;
        var step_y = this.area.y;
        var x, y, w, h, weight = 0;
        for (var i=0; i<this.children.length; i++) {
            var item        = this.children[i][0];
            var proportion  = this.children[i][1];
            var anchor      = this.children[i][2];
            var border      = this.children[i][3];

            x = step_x + border;
            y = step_y + border;

            if (this.orientation == creatine.VERTICAL) {
                if (proportion == 0) {
                    var bounds = item.getBounds();
                    w = bounds.width;
                    h = bounds.height;
                } else {
                    weight = proportion/proportions;
                    w = this.area.width - border*2;
                    h = weight*avaliable_h;
                }

                step_y += h + border*2;
            }
            else if (this.orientation == creatine.HORIZONTAL) {
                if (proportion == 0) {
                    var bounds = item.getBounds();
                    w = bounds.width;
                    h = bounds.height;
                } else {
                    weight = proportion/proportions;
                    w = weight*avaliable_w;
                    h = this.area.height - border*2;
                }

                step_x += w + border*2;
            }

            this._resize_child(item, {x:x, y:y, width:w, height:h}, anchor);
        }
    }

    /**
     * Propagate the layout to a child and move it accordingly to its anchor.
     *
     * @method _resize_child 
     * @param {Object} item The DisplayObject to be organized by this sizer.
     * @param {createjs.Rectangle} area A rectangle containing the usable area
     *                             of the object. 
     * @param {Constant} anchor The anchor of the object, only useful if 
     *                   proportion is greater than 0. Default to 
     *                   <code>creatine.TOP_LEFT</code>
     * @private
    **/
    p._resize_child = function(item, area, anchor) {
        if (item.layout) {
            item.layout(area);
        }

        if (item.getBounds) {
            var bounds = item.getBounds();
        }

        if (bounds) {
            var w = bounds.width*item.scaleX;
            var h = bounds.height*item.scaleY;
        }
        else {
            var w = 0;
            var h = 0;
        }

        // Set y
        switch (anchor) {
            case creatine.TOP:
            case creatine.TOP_LEFT:
            case creatine.TOP_RIGHT:
                item.y = area.y;
                break;

            case creatine.LEFT:
            case creatine.CENTER:
            case creatine.RIGHT:
                item.y = (area.y+area.height/2)-h/2;
                break;
            
            case creatine.BOTTOM:
            case creatine.BOTTOM_LEFT:
            case creatine.BOTTOM_RIGHT:
                item.y = area.y+area.height-h;
                break;                
        }

        // Set x
        switch (anchor) {
            case creatine.LEFT:
            case creatine.TOP_LEFT:
            case creatine.BOTTOM_LEFT:
                item.x = area.x;
                break;

            case creatine.TOP:
            case creatine.CENTER:
            case creatine.BOTTOM:
                item.x = (area.x+area.width/2)-w/2;
                break;
            
            case creatine.RIGHT:
            case creatine.TOP_RIGHT:
            case creatine.BOTTOM_RIGHT:
                item.x = area.x+area.width-w;
                break;                
        }
        
        item.x += item.regX;
        item.y += item.regY;
    }

    creatine.BoxSizer = BoxSizer;
}());
/*
* GridSizer
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
    "use strict";

    /**
     * GridSizer is a layout manager that organizes its components in a regular
     * grid. 
     * 
     * Parameters <code>rows</code> and <code>cols</code> specify how many rows
     * and columns the grid will have, respectively. All cells in the grid have
     * the same size. However, each cell can have an individual border, by 
     * setting the border parameter when adding an object to the sizer.

     * The anchor parameter can be specified using the following constants: 
     * <code>LEFT, RIGHT, TOP, BOTTOM, TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, 
     * BOTTOM_RIGHT, CENTER</code>.
     * 
     * <h4>Example</h4>
     * 
     * A GridSizer which with 3 rows and 5 columns, and occupying all space of 
     * a canvas can be created as:
     * 
     *     var area = new createjs.Rectangle(0, 0, canvas.width, canvas.height);
     *     var hbox = new creatine.GridSizer(3, 5, area);
     * 
     * @class GridSizer
     * @constructor
     * @param {Number} rows The number of rows in the grid.
     * @param {Number} cols The number of columns in the grid.
     * @param {createjs.Rectangle} area A rectangle containing the usable area 
     *                             of the sizer.
    **/
    var GridSizer = function(rows, cols, area) {
        /**
         * The number of rows in the grid.
         * 
         * @property rows
         * @type {Number}
        **/
        this.rows = rows;

        /**
         * The number of columns in the grid.
         * 
         * @property cols
         * @type {Number}
        **/
        this.cols = cols;

        /**
         * The list within all items in this sizer together with their proportions,
         * border, and anchor.
         * 
         * @property children
         * @type {Array}
         * @private
        **/
        this.children = [];

        /**
         * A rectangle representing the area of which the sizer can use.
         *
         * @property area
         * @type {createjs.Rectangle}
        **/
        this.area = area;
    }
    var p = GridSizer.prototype;

    /**
     * Adds a new object to the sizer.
     *
     * @method add
     * @param {Object} object The DisplayObject to be organized by this sizer.
     * @param {Number} border The spacing around this item. Default to 0.
     * @param {Constant} anchor The anchor of the object. Default to 
     *                   <code>creatine.TOP_LEFT</code>
    **/
    p.add = function(object, border, anchor) {
        anchor = anchor || creatine.TOP_LEFT;
        border = border || 0;

        this.children.push([object, anchor, border]);
    }

    /**
     * Resize this sizer and its children.
     * 
     * For the root sizer, the parameter <code>area</code> does not to be 
     * specified, but it is automatically set in nested sizers.
     *
     * @method layout 
     * @param {createjs.Rectangle} area A rectangle containing the usable area
     *                             of the sizer. 
    **/
    p.layout = function(area) {
        if (area)
            this.area = area;

        var base_w = this.area.width/this.cols;
        var base_h = this.area.height/this.rows;

        for (var i=0; i<this.children.length; i++) {
            var item   = this.children[i][0];
            var anchor = this.children[i][1];
            var border = this.children[i][2];

            var x = this.area.x + base_w*Math.floor(i%this.cols) + border;
            var y = this.area.y + base_h*Math.floor(i/this.cols) + border;
            var w = base_w - border*2;
            var h = base_h - border*2;

            this._resize_child(item, {x:x, y:y, width:w, height:h}, anchor);
        }
    }

    /**
     * Propagate the layout to a child and move it accordingly to its anchor.
     *
     * @method _resize_child 
     * @param {Object} item The DisplayObject to be organized by this sizer.
     * @param {createjs.Rectangle} area A rectangle containing the usable area
     *                             of the object. 
     * @param {Constant} anchor The anchor of the object, only useful if 
     *                   proportion is greater than 0. Default to 
     *                   <code>creatine.TOP_LEFT</code>
     * @private
    **/
    p._resize_child = function(item, area, anchor) {
        if (item.layout)
            item.layout(area);

        if (item.getBounds)
            var bounds = item.getBounds();

        if (bounds) {
            var w = bounds.width*item.scaleX;
            var h = bounds.height*item.scaleY;
        }
        else {
            var w = 0;
            var h = 0;
        }

        // Set y
        switch (anchor) {
            case creatine.TOP:
            case creatine.TOP_LEFT:
            case creatine.TOP_RIGHT:
                item.y = area.y;
                break;

            case creatine.LEFT:
            case creatine.CENTER:
            case creatine.RIGHT:
                item.y = (area.y+area.height/2)-h/2;
                break;
            
            case creatine.BOTTOM:
            case creatine.BOTTOM_LEFT:
            case creatine.BOTTOM_RIGHT:
                item.y = area.y+area.height-h;
                break;                
        }

        // Set x
        switch (anchor) {
            case creatine.LEFT:
            case creatine.TOP_LEFT:
            case creatine.BOTTOM_LEFT:
                item.x = area.x;
                break;

            case creatine.TOP:
            case creatine.CENTER:
            case creatine.BOTTOM:
                item.x = (area.x+area.width/2)-w/2;
                break;
            
            case creatine.RIGHT:
            case creatine.TOP_RIGHT:
            case creatine.BOTTOM_RIGHT:
                item.x = area.x+area.width-w;
                break;                
        }

        item.x += item.regX;
        item.y += item.regY;
    }

    creatine.GridSizer = GridSizer;
}());
/*
* DiscreteBar
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
    "use strict";

    /**
     * DiscreteBar is a progress bar that only handle discrete values. This is  
     * a simple and specific implementation of a progress bar, for a more 
     * general version, consult the ProgressBar.
     * 
     * It can filled in 4 different directions, by using the parameter 
     * `direction`: <code>LEFT_TO_RIGHT, RIGHT_TO_LEFT, TOP_TO_BOTTOM, 
     * BOTTOM_TO_TOP</code>. 
     *
     * <h4>Example</h4>
     * 
     *     // Create the Director
     *     var progress = new creatine.DiscreteBar(
     *         image,                   // The image used to fill.
     *         5,                       // The space between one image and other.
     *         creatine.LEFT_TO_RIGHT   // The director.
     *     )
     * 
     * @class DiscreteBar
     * @constructor
     * @param {Bitmap|Image} image A bitmap or image that will be used to fill 
     *                       the progress bar.
     * @param {Number} spacing The space between one image and other. Default 
     *                 to 0.
     * @param {Constant} direction The filling direction. Default to 
     *                   `creatine.LEFT_TO_RIGHT`.
    **/
    var DiscreteBar = function(image, spacing, direction) {
        this.Container_constructor();

        /**
         * The bar filling direction (`LEFT_TO_RIGHT`, `RIGHT_TO_LEFT`, 
         * `TOP_TO_BOTTOM` or `BOTTOM_TO_TOP`).
         *
         * @property direction
         * @type {Constant}
        **/
        this.direction = direction || creatine.LEFT_TO_RIGHT;

        /**
         * The image which will be used to fill the bar.
         *
         * @property image
         * @type {Image}
        **/
        if (image.image) {
            this.image = image.image;
        } else {
            this.image = image;
        }

        /**
         * The space between one image and other.
         *
         * @property spacing
         * @type {Image}
        **/
        this.spacing = spacing || 0;

        /**
         * The current value of the progress bar.
         *
         * @property value
         * @type {Number}
        **/
        this.value = 0;

    }
    var p = createjs.extend(DiscreteBar, createjs.Container);

    /**
    * Returns true or false indicating whether the bar would be visible if 
    * drawn to a canvas. This does not account for whether it would be visible 
    * within the boundaries of the stage.
    * 
    * @method isVisible
    * @protected
    **/
    p.isVisible = function() {
        var hasContent = this.value > 0 || this.cacheCanvas;
        return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0 && hasContent);
    };

    /**
    * Draws the DiscreteBar into the specified context ignoring its visible, 
    * alpha, shadow, and transform. Returns true if the draw was handled 
    * (useful for overriding functionality).
    *
    * @method draw
    * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to 
    *                                   draw into.
    * @param {Boolean} [ignoreCache=false] Indicates whether the draw operation
    *                                      should ignore any current cache. For
    *                                      example, used for drawing the cache
    *                                      (to prevent it from simply drawing 
    *                                      an existing cache back into itself).
    * @protected
    **/
    p.draw = function(ctx, ignoreCache) {
        if (this.DisplayObject_draw(ctx, ignoreCache)) { return true; }

        var dir_x = 0;
        var dir_y = 0;
        var step_x = 0;
        var step_y = 0;
        var w = this.image.width;
        var h = this.image.height;


        if (this.direction === creatine.LEFT_TO_RIGHT) {dir_x = 1;}
        else if (this.direction === creatine.RIGHT_TO_LEFT) {dir_x = -1; step_x = -w;}
        else if (this.direction === creatine.TOP_TO_BOTTOM) {dir_y = 1;}
        else if (this.direction === creatine.BOTTOM_TO_TOP) {dir_y = -1; step_y = -h;}

        this.removeAllChildren();

        for (var i=0; i<this.value; i++) {
            var bitmap = new createjs.Bitmap(this.image);
            bitmap.x = step_x;
            bitmap.y = step_y;
            this.addChild(bitmap);

            step_x += this.spacing*dir_x + w*dir_x;
            step_y += this.spacing*dir_y + h*dir_y;
        }

        return this.Container_draw(ctx, ignoreCache);
    }

    creatine.DiscreteBar = createjs.promote(DiscreteBar, "Container");
}());
/*
* ProgressBar
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
    "use strict";
        
    /**
     * ProgressBar is a progress bar that handle continuous values. It is 
     * divided into three main types, which can be specified by `colorsOrImg` 
     * parameter:
     * 
     * - ColorBar: by passing a string representing a color (e.g., '#0f3' or 
     *   'red'), the progress bar will be filled using this color.
     * 
     * - GradientBar: by passing a list of colors (e.g., ['red', 'blue']), the 
     *   progress bar will be filled using a gradient passing through all 
     *   provided colors.
     *
     * - ImageBar: by passing a Bitmap or Image object, the progress bar will 
     *   be filled with using the provided image.
     *
     * A ProgressBar can filled in 4 different directions, by using the 
     * parameter `direction`: <code>LEFT_TO_RIGHT, RIGHT_TO_LEFT, 
     * TOP_TO_BOTTOM, BOTTOM_TO_TOP</code>. 
     *
     * <h4>Example</h4>
     * 
     *     // Create the Director
     *     var progress = new creatine.ProgressBar(
     *         'green',                     // The fill color
     *         'black',                     // The background color
     *         creatine.LEFT_TO_RIGHT       // The director
     *         100,                         // The bar width
     *         20,                          // The bar height
     *         0,                           // The minimum value
     *         100                          // The maximum value
     *     )
     * 
     * @class ProgressBar
     * @constructor
     * @param {String|Array|Bitmap|Image} colorsOrImg A color, list of colors 
     *                                    or bitmap that will be used to fill 
     *                                    the progress bar.
     * @param {String} backgroundColor A string with the color of the bar 
     *                 background. If `null`, the background will be 
     *                 transparent. Default to `null`.
     * @param {Constant} direction The filling direction. Default to 
     *                   `creatine.LEFT_TO_RIGHT`.
     * @param {Number} width The width of the bar. Default to 100.
     * @param {Number} height The height of the bar. Default to 10.
     * @param {Number} min The minimum value of the bar. Default to 0.
     * @param {Number} max The maximum value of the bar. Default to 100.
    **/
    var ProgressBar = function(colorsOrImg, backgroundColor, direction, width, 
                                 height, min, max) {
        /**
         * The bar type ('color', 'gradient' or 'image').
         *
         * @property type
         * @type {Sting}
        **/
        p.type = null;

        /**
         * The bar filling direction (`LEFT_TO_RIGHT`, `RIGHT_TO_LEFT`, 
         * `TOP_TO_BOTTOM` or `BOTTOM_TO_TOP`).
         *
         * @property direction
         * @type {Constant}
        **/
        p.direction = null;

        /**
         * The image which will be used to fill the bar (if type = 'image').
         *
         * @property image
         * @type {Image}
        **/
        p.image = null;

        /**
         * The array with colors of the gradient to fill the bar (if type = 
         * 'gradient').
         *
         * @property gradientColors
         * @type {Array}
        **/
        p.gradientColors = null;

        /**
         * The color to fill the bar (if type = 'color').
         *
         * @property fillColor
         * @type {String}
        **/
        p.fillColor = null;

        /**
         * The background color.
         *
         * @property backgroundColor
         * @type {String}
        **/
        p.backgroundColor = null;

        /**
         * The current value of the progress bar.
         *
         * @property value
         * @type {Number}
        **/
        p.value = null;

        /**
         * The minimum value of the progress bar.
         *
         * @property min
         * @type {Number}
        **/
        p.min = null;

        /**
         * The maximum value of the progress bar.
         *
         * @property max
         * @type {Number}
        **/
        p.max = null;

        /**
         * The width of the progress bar.
         *
         * @property width
         * @type {Number}
        **/
        p.width = null;

        /**
         * The height of the progress bar.
         *
         * @property height
         * @type {Number}
        **/
        p.height = null;

        if (colorsOrImg) {
            this._initialize(
                colorsOrImg,
                backgroundColor,
                direction,
                width,
                height,
                min,
                max
            );
        }
    }
    var p = createjs.extend(ProgressBar, createjs.Shape);

    /**
     * Initialization method.
     * 
     * @method initialize
     * @param {String|Array|Bitmap|Image} colorsOrImg A color, list of colors 
     *                                    or bitmap that will be used to fill 
     *                                    the progress bar.
     * @param {String} backgroundColor A string with the color of the bar 
     *                 background. If `null`, the background will be 
     *                 transparent. Default to `null`.
     * @param {Constant} direction The filling direction. Default to 
     *                   `creatine.LEFT_TO_RIGHT`.
     * @param {Number} width The width of the bar. Default to 100.
     * @param {Number} height The height of the bar. Default to 10.
     * @param {Number} min The minimum value of the bar. Default to 0.
     * @param {Number} max The maximum value of the bar. Default to 100.
     * @private
    **/
    p._initialize = function(colorsOrImg, backgroundColor, direction, width, 
                            height, min, max) {
        this.Shape_constructor();

        if (colorsOrImg instanceof Array) {
            this.type = 'gradient';
            this.gradientColors = colorsOrImg;
        } else if (typeof colorsOrImg === 'string') {
            this.type = 'color';
            this.fillColor = colorsOrImg;
        } else {
            this.type = 'image';
            this.image = colorsOrImg;
            if (this.image.image) {
                this.image = this.image.image;
            }
        }

        if (backgroundColor == null) backgroundColor = null;
        if (direction == null) direction = creatine.LEFT_TO_RIGHT;
        if (width == null) width = 100;
        if (height == null) height = 10;
        if (min == null) min = 0;
        if (max == null) max = 100;

        this.backgroundColor = backgroundColor;
        this.direction = direction;
        this.width = width;
        this.height = height;
        this.min = min;
        this.max = max;
        this.value = 0;
    }

    /**
    * Returns true or false indicating whether the bar would be visible if 
    * drawn to a canvas. This does not account for whether it would be visible 
    * within the boundaries of the stage.
    * 
    * @method isVisible
    * @protected
    **/
    p.isVisible = function() {
        return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0);
    };

    p.layout = function(area) {
        this.width = area.width;
        this.height = area.height;
    }

    /**
    * Draws the ProgressBar into the specified context ignoring its visible, 
    * alpha, shadow, and transform. Returns true if the draw was handled 
    * (useful for overriding functionality).
    *
    * @method draw
    * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to 
    *                                   draw into.
    * @param {Boolean} [ignoreCache=false] Indicates whether the draw operation
    *                                      should ignore any current cache. For
    *                                      example, used for drawing the cache
    *                                      (to prevent it from simply drawing 
    *                                      an existing cache back into itself).
    * @protected
    **/
    p.draw = function(ctx, ignoreCache) {
        if (this.DisplayObject_draw(ctx, ignoreCache)) { return true; }

        var x = 0;
        var y = 0;
        var w = this.width;
        var h = this.height;
        var value_w = creatine.clip(w*(this.value-this.min)/(this.max-this.min), 0, w);
        var value_h = h;
        var gline = [w, 0];

        if (this.direction === creatine.TOP_TO_BOTTOM) {
            var gline = [0, w];

            var w_ = w;
            w = h;
            h = w_;

            w_ = value_w;
            value_w = value_h;
            value_h = w_;
        } 
        else if (this.direction === creatine.BOTTOM_TO_TOP) {
            var gline = [0, -w];

            var w_ = w;
            w = h;
            h = -w_;

            w_ = value_w;
            value_w = value_h;
            value_h = -w_;
        }
        else if (this.direction === creatine.RIGHT_TO_LEFT) {
            var gline = [-w, 0];
            w = -w;
            value_w = -value_w;
        }

        this.graphics.clear();
        if (this.backgroundColor) {
            this.graphics.beginFill(this.backgroundColor);
            this.graphics.drawRect(x, y, w, h);
        }

        if (this.type === 'color') {
            this.graphics.beginFill(this.fillColor);
            this.graphics.drawRect(x, y, value_w, value_h);
        }
        else if (this.type === 'gradient') {
            var ratios = [];
            for (var i=0; i<this.gradientColors.length; i++) {
                ratios.push(i/(this.gradientColors.length-1));
            }

            this.graphics.beginLinearGradientFill(
                this.gradientColors,
                ratios,
                0, 0, gline[0], gline[1]
            );
            this.graphics.drawRect(x, y, value_w, value_h);
        }
        else if (this.type === 'image') {
            this.graphics.beginBitmapFill(this.image);
            this.graphics.drawRect(x, y, value_w, value_h);
        }


        this.graphics.draw(ctx);
        return true;
    }

    creatine.ProgressBar = createjs.promote(ProgressBar, "Shape");
}());
/*
* FlexBitmap
*
* Copyright (c) 2014 Renato de Pontes Pereira.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy 
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
* copies of the Software, and to permit persons to whom the Software is 
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/

/**
 * @module Creatine
 **/

// namespace:
this.creatine = this.creatine || {};

(function() {
    "use strict";

    /**
     * FlexBitmap extends the createjs.Bitmap and adds the layout function to 
     * it, thus, FlexBitmap can resize itself to best fit its position and area
     * in a layout manager, such as the BoxSizer and the GridSizer.
     *
     * @class FlexBitmap
     * @extends createjs.Bitmap
     * @constructor
     * @param {Image|HTMLCanvasElement|HTMLVideoElement|String} imageOrUri The 
     *        source object or URI to an image to display. This can be either 
     *        an Image, Canvas, or Video object, or a string URI to an image 
     *        file to load and use. If it is a URI, a new Image object will be 
     *        constructed and assigned to the .image property.
     * @param {boolean} scaleMode creatine.NOSCALE The scale mode.
    **/
    var FlexBitmap = function(imageOrUri, scaleMode) {
        this.Bitmap_constructor(imageOrUri);

        /**
         * Indicates the scaling mode of the image:
         * 
         * <ul>
         *     <li><code>creatine.STRETCH</code>: to fill the available area 
         *         ignoring the aspect ratio.</li>
         *     <li><code>creatine.FIT</code>: to fill the available area without 
         *         overflow and keeping the aspect ratio.</li>
         *     <li><code>creatine.FILL</code>: to fill the available area with 
         *         overflow and keeping the aspect ratio.</li>
         *     <li><code>creatine.NOSCALE</code>: to keep the original size.
         *     </li>
         * </ul>
         *
         * @property scaleMode
         * @type {constant}
        **/
        this.scaleMode = scaleMode || creatine.NOSCALE;
    }
    var p = createjs.extend(FlexBitmap, createjs.Bitmap);

    /**
     * Resize this this image to fit the area.
     * 
     * @method layout 
     * @param {createjs.Rectangle} area A rectangle containing the usable area
     *                             of the bitmap. 
    **/
    p.layout = function(area) {
        var width = this.image.width;
        var height = this.image.height;

        var scale_x = 1;
        var scale_y = 1;

        if (this.scaleMode === creatine.FIT) {
            scale_x = scale_y = Math.min(
                (area.height/height), 
                (area.width /width)
            );
        } else if (this.scaleMode === creatine.FILL) {
            scale_x = scale_y = Math.max(
                (area.height/height), 
                (area.width /width)
            );
        } else if (this.scaleMode === creatine.STRETCH) {
            scale_x = (area.width /width);
            scale_y = area.height/height;
        } 

        this.scaleX = scale_x;
        this.scaleY = scale_y;
    }

    /**
     * Returns a rectangle representing this object's bounds after the resize.
     *
     * @method getBounds
     * @protected
    **/
    p.getBounds = function() {
        var w = this.image.width*this.scaleX;
        var h = this.image.height*this.scaleY;
        return this._rectangle.setValues(0, 0, w, h);
    }

    creatine.FlexBitmap = createjs.promote(FlexBitmap, "Bitmap");
}());