text: //=============================================================================
  // rpg_sprites.js v1.5.1
  //=============================================================================
  
  //-----------------------------------------------------------------------------
  // Sprite_Base
  //
  // The sprite class with a feature which displays animations.
  
  function Sprite_Base() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Base.prototype = Object.create(Sprite.prototype);
  Sprite_Base.prototype.constructor = Sprite_Base;
  
  Sprite_Base.prototype.initialize = function() {
      Sprite.prototype.initialize.call(this);
      this._animationSprites = [];
      this._effectTarget = this;
      this._hiding = false;
  };
  
  Sprite_Base.prototype.update = function() {
      Sprite.prototype.update.call(this);
      this.updateVisibility();
      this.updateAnimationSprites();
  };
  
  Sprite_Base.prototype.hide = function() {
      this._hiding = true;
      this.updateVisibility();
  };
  
  Sprite_Base.prototype.show = function() {
      this._hiding = false;
      this.updateVisibility();
  };
  
  Sprite_Base.prototype.updateVisibility = function() {
      this.visible = !this._hiding;
  };
  
  Sprite_Base.prototype.updateAnimationSprites = function() {
      if (this._animationSprites.length > 0) {
          var sprites = this._animationSprites.clone();
          this._animationSprites = [];
          for (var i = 0; i < sprites.length; i++) {
              var sprite = sprites[i];
              if (sprite.isPlaying()) {
                  this._animationSprites.push(sprite);
              } else {
                  sprite.remove();
              }
          }
      }
  };
  
  Sprite_Base.prototype.startAnimation = function(animation, mirror, delay) {
      var sprite = new Sprite_Animation();
      sprite.setup(this._effectTarget, animation, mirror, delay);
      this.parent.addChild(sprite);
      this._animationSprites.push(sprite);
  };
  
  Sprite_Base.prototype.isAnimationPlaying = function() {
      return this._animationSprites.length > 0;
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Button
  //
  // The sprite for displaying a button.
  
  function Sprite_Button() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Button.prototype = Object.create(Sprite.prototype);
  Sprite_Button.prototype.constructor = Sprite_Button;
  
  Sprite_Button.prototype.initialize = function() {
      Sprite.prototype.initialize.call(this);
      this._touching = false;
      this._coldFrame = null;
      this._hotFrame = null;
      this._clickHandler = null;
  };
  
  Sprite_Button.prototype.update = function() {
      Sprite.prototype.update.call(this);
      this.updateFrame();
      this.processTouch();
  };
  
  Sprite_Button.prototype.updateFrame = function() {
      var frame;
      if (this._touching) {
          frame = this._hotFrame;
      } else {
          frame = this._coldFrame;
      }
      if (frame) {
          this.setFrame(frame.x, frame.y, frame.width, frame.height);
      }
  };
  
  Sprite_Button.prototype.setColdFrame = function(x, y, width, height) {
      this._coldFrame = new Rectangle(x, y, width, height);
  };
  
  Sprite_Button.prototype.setHotFrame = function(x, y, width, height) {
      this._hotFrame = new Rectangle(x, y, width, height);
  };
  
  Sprite_Button.prototype.setClickHandler = function(method) {
      this._clickHandler = method;
  };
  
  Sprite_Button.prototype.callClickHandler = function() {
      if (this._clickHandler) {
          this._clickHandler();
      }
  };
  
  Sprite_Button.prototype.processTouch = function() {
      if (this.isActive()) {
          if (TouchInput.isTriggered() && this.isButtonTouched()) {
              this._touching = true;
          }
          if (this._touching) {
              if (TouchInput.isReleased() || !this.isButtonTouched()) {
                  this._touching = false;
                  if (TouchInput.isReleased()) {
                      this.callClickHandler();
                  }
              }
          }
      } else {
          this._touching = false;
      }
  };
  
  Sprite_Button.prototype.isActive = function() {
      var node = this;
      while (node) {
          if (!node.visible) {
              return false;
          }
          node = node.parent;
      }
      return true;
  };
  
  Sprite_Button.prototype.isButtonTouched = function() {
      var x = this.canvasToLocalX(TouchInput.x);
      var y = this.canvasToLocalY(TouchInput.y);
      return x >= 0 && y >= 0 && x < this.width && y < this.height;
  };
  
  Sprite_Button.prototype.canvasToLocalX = function(x) {
      var node = this;
      while (node) {
          x -= node.x;
          node = node.parent;
      }
      return x;
  };
  
  Sprite_Button.prototype.canvasToLocalY = function(y) {
      var node = this;
      while (node) {
          y -= node.y;
          node = node.parent;
      }
      return y;
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Character
  //
  // The sprite for displaying a character.
  
  function Sprite_Character() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Character.prototype = Object.create(Sprite_Base.prototype);
  Sprite_Character.prototype.constructor = Sprite_Character;
  
  Sprite_Character.prototype.initialize = function(character) {
      Sprite_Base.prototype.initialize.call(this);
      this.initMembers();
      this.setCharacter(character);
  };
  
  Sprite_Character.prototype.initMembers = function() {
      this.anchor.x = 0.5;
      this.anchor.y = 1;
      this._character = null;
      this._balloonDuration = 0;
      this._tilesetId = 0;
      this._upperBody = null;
      this._lowerBody = null;
  };
  
  Sprite_Character.prototype.setCharacter = function(character) {
      this._character = character;
  };
  
  Sprite_Character.prototype.update = function() {
      Sprite_Base.prototype.update.call(this);
      this.updateBitmap();
      this.updateFrame();
      this.updatePosition();
      this.updateAnimation();
      this.updateBalloon();
      this.updateOther();
  };
  
  Sprite_Character.prototype.updateVisibility = function() {
      Sprite_Base.prototype.updateVisibility.call(this);
      if (this._character.isTransparent()) {
          this.visible = false;
      }
  };
  
  Sprite_Character.prototype.isTile = function() {
      return this._character.tileId > 0;
  };
  
  Sprite_Character.prototype.tilesetBitmap = function(tileId) {
      var tileset = $gameMap.tileset();
      var setNumber = 5 + Math.floor(tileId / 256);
      return ImageManager.loadTileset(tileset.tilesetNames[setNumber]);
  };
  
  Sprite_Character.prototype.updateBitmap = function() {
      if (this.isImageChanged()) {
          this._tilesetId = $gameMap.tilesetId();
          this._tileId = this._character.tileId();
          this._characterName = this._character.characterName();
          this._characterIndex = this._character.characterIndex();
          if (this._tileId > 0) {
              this.setTileBitmap();
          } else {
              this.setCharacterBitmap();
          }
      }
  };
  
  Sprite_Character.prototype.isImageChanged = function() {
      return (this._tilesetId !== $gameMap.tilesetId() ||
              this._tileId !== this._character.tileId() ||
              this._characterName !== this._character.characterName() ||
              this._characterIndex !== this._character.characterIndex());
  };
  
  Sprite_Character.prototype.setTileBitmap = function() {
      this.bitmap = this.tilesetBitmap(this._tileId);
  };
  
  Sprite_Character.prototype.setCharacterBitmap = function() {
      this.bitmap = ImageManager.loadCharacter(this._characterName);
      this._isBigCharacter = ImageManager.isBigCharacter(this._characterName);
  };
  
  Sprite_Character.prototype.updateFrame = function() {
      if (this._tileId > 0) {
          this.updateTileFrame();
      } else {
          this.updateCharacterFrame();
      }
  };
  
  Sprite_Character.prototype.updateTileFrame = function() {
      var pw = this.patternWidth();
      var ph = this.patternHeight();
      var sx = (Math.floor(this._tileId / 128) % 2 * 8 + this._tileId % 8) * pw;
      var sy = Math.floor(this._tileId % 256 / 8) % 16 * ph;
      this.setFrame(sx, sy, pw, ph);
  };
  
  Sprite_Character.prototype.updateCharacterFrame = function() {
      var pw = this.patternWidth();
      var ph = this.patternHeight();
      var sx = (this.characterBlockX() + this.characterPatternX()) * pw;
      var sy = (this.characterBlockY() + this.characterPatternY()) * ph;
      this.updateHalfBodySprites();
      if (this._bushDepth > 0) {
          var d = this._bushDepth;
          this._upperBody.setFrame(sx, sy, pw, ph - d);
          this._lowerBody.setFrame(sx, sy + ph - d, pw, d);
          this.setFrame(sx, sy, 0, ph);
      } else {
          this.setFrame(sx, sy, pw, ph);
      }
  };
  
  Sprite_Character.prototype.characterBlockX = function() {
      if (this._isBigCharacter) {
          return 0;
      } else {
          var index = this._character.characterIndex();
          return index % 4 * 3;
      }
  };
  
  Sprite_Character.prototype.characterBlockY = function() {
      if (this._isBigCharacter) {
          return 0;
      } else {
          var index = this._character.characterIndex();
          return Math.floor(index / 4) * 4;
      }
  };
  
  Sprite_Character.prototype.characterPatternX = function() {
      return this._character.pattern();
  };
  
  Sprite_Character.prototype.characterPatternY = function() {
      return (this._character.direction() - 2) / 2;
  };
  
  Sprite_Character.prototype.patternWidth = function() {
      if (this._tileId > 0) {
          return $gameMap.tileWidth();
      } else if (this._isBigCharacter) {
          return this.bitmap.width / 3;
      } else {
          return this.bitmap.width / 12;
      }
  };
  
  Sprite_Character.prototype.patternHeight = function() {
      if (this._tileId > 0) {
          return $gameMap.tileHeight();
      } else if (this._isBigCharacter) {
          return this.bitmap.height / 4;
      } else {
          return this.bitmap.height / 8;
      }
  };
  
  Sprite_Character.prototype.updateHalfBodySprites = function() {
      if (this._bushDepth > 0) {
          this.createHalfBodySprites();
          this._upperBody.bitmap = this.bitmap;
          this._upperBody.visible = true;
          this._upperBody.y = - this._bushDepth;
          this._lowerBody.bitmap = this.bitmap;
          this._lowerBody.visible = true;
          this._upperBody.setBlendColor(this.getBlendColor());
          this._lowerBody.setBlendColor(this.getBlendColor());
          this._upperBody.setColorTone(this.getColorTone());
          this._lowerBody.setColorTone(this.getColorTone());
      } else if (this._upperBody) {
          this._upperBody.visible = false;
          this._lowerBody.visible = false;
      }
  };
  
  Sprite_Character.prototype.createHalfBodySprites = function() {
      if (!this._upperBody) {
          this._upperBody = new Sprite();
          this._upperBody.anchor.x = 0.5;
          this._upperBody.anchor.y = 1;
          this.addChild(this._upperBody);
      }
      if (!this._lowerBody) {
          this._lowerBody = new Sprite();
          this._lowerBody.anchor.x = 0.5;
          this._lowerBody.anchor.y = 1;
          this._lowerBody.opacity = 128;
          this.addChild(this._lowerBody);
      }
  };
  
  Sprite_Character.prototype.updatePosition = function() {
      this.x = this._character.screenX();
      this.y = this._character.screenY();
      this.z = this._character.screenZ();
  };
  
  Sprite_Character.prototype.updateAnimation = function() {
      this.setupAnimation();
      if (!this.isAnimationPlaying()) {
          this._character.endAnimation();
      }
      if (!this.isBalloonPlaying()) {
          this._character.endBalloon();
      }
  };
  
  Sprite_Character.prototype.updateOther = function() {
      this.opacity = this._character.opacity();
      this.blendMode = this._character.blendMode();
      this._bushDepth = this._character.bushDepth();
  };
  
  Sprite_Character.prototype.setupAnimation = function() {
      if (this._character.animationId() > 0) {
          var animation = $dataAnimations[this._character.animationId()];
          this.startAnimation(animation, false, 0);
          this._character.startAnimation();
      }
  };
  
  Sprite_Character.prototype.setupBalloon = function() {
      if (this._character.balloonId() > 0) {
          this.startBalloon();
          this._character.startBalloon();
      }
  };
  
  Sprite_Character.prototype.startBalloon = function() {
      if (!this._balloonSprite) {
          this._balloonSprite = new Sprite_Balloon();
      }
      this._balloonSprite.setup(this._character.balloonId());
      this.parent.addChild(this._balloonSprite);
  };
  
  Sprite_Character.prototype.updateBalloon = function() {
      this.setupBalloon();
      if (this._balloonSprite) {
          this._balloonSprite.x = this.x;
          this._balloonSprite.y = this.y - this.height;
          if (!this._balloonSprite.isPlaying()) {
              this.endBalloon();
          }
      }
  };
  
  Sprite_Character.prototype.endBalloon = function() {
      if (this._balloonSprite) {
          this.parent.removeChild(this._balloonSprite);
          this._balloonSprite = null;
      }
  };
  
  Sprite_Character.prototype.isBalloonPlaying = function() {
      return !!this._balloonSprite;
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Battler
  //
  // The superclass of Sprite_Actor and Sprite_Enemy.
  
  function Sprite_Battler() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Battler.prototype = Object.create(Sprite_Base.prototype);
  Sprite_Battler.prototype.constructor = Sprite_Battler;
  
  Sprite_Battler.prototype.initialize = function(battler) {
      Sprite_Base.prototype.initialize.call(this);
      this.initMembers();
      this.setBattler(battler);
  };
  
  Sprite_Battler.prototype.initMembers = function() {
      this.anchor.x = 0.5;
      this.anchor.y = 1;
      this._battler = null;
      this._damages = [];
      this._homeX = 0;
      this._homeY = 0;
      this._offsetX = 0;
      this._offsetY = 0;
      this._targetOffsetX = NaN;
      this._targetOffsetY = NaN;
      this._movementDuration = 0;
      this._selectionEffectCount = 0;
  };
  
  Sprite_Battler.prototype.setBattler = function(battler) {
      this._battler = battler;
  };
  
  Sprite_Battler.prototype.setHome = function(x, y) {
      this._homeX = x;
      this._homeY = y;
      this.updatePosition();
  };
  
  Sprite_Battler.prototype.update = function() {
      Sprite_Base.prototype.update.call(this);
      if (this._battler) {
          this.updateMain();
          this.updateAnimation();
          this.updateDamagePopup();
          this.updateSelectionEffect();
      } else {
          this.bitmap = null;
      }
  };
  
  Sprite_Battler.prototype.updateVisibility = function() {
      Sprite_Base.prototype.updateVisibility.call(this);
      if (!this._battler || !this._battler.isSpriteVisible()) {
          this.visible = false;
      }
  };
  
  Sprite_Battler.prototype.updateMain = function() {
      if (this._battler.isSpriteVisible()) {
          this.updateBitmap();
          this.updateFrame();
      }
      this.updateMove();
      this.updatePosition();
  };
  
  Sprite_Battler.prototype.updateBitmap = function() {
  };
  
  Sprite_Battler.prototype.updateFrame = function() {
  };
  
  Sprite_Battler.prototype.updateMove = function() {
      if (this._movementDuration > 0) {
          var d = this._movementDuration;
          this._offsetX = (this._offsetX * (d - 1) + this._targetOffsetX) / d;
          this._offsetY = (this._offsetY * (d - 1) + this._targetOffsetY) / d;
          this._movementDuration--;
          if (this._movementDuration === 0) {
              this.onMoveEnd();
          }
      }
  };
  
  Sprite_Battler.prototype.updatePosition = function() {
      this.x = this._homeX + this._offsetX;
      this.y = this._homeY + this._offsetY;
  };
  
  Sprite_Battler.prototype.updateAnimation = function() {
      this.setupAnimation();
  };
  
  Sprite_Battler.prototype.updateDamagePopup = function() {
      this.setupDamagePopup();
      if (this._damages.length > 0) {
          for (var i = 0; i < this._damages.length; i++) {
              this._damages[i].update();
          }
          if (!this._damages[0].isPlaying()) {
              this.parent.removeChild(this._damages[0]);
              this._damages.shift();
          }
      }
  };
  
  Sprite_Battler.prototype.updateSelectionEffect = function() {
      var target = this._effectTarget;
      if (this._battler.isSelected()) {
          this._selectionEffectCount++;
          if (this._selectionEffectCount % 30 < 15) {
              target.setBlendColor([255, 255, 255, 64]);
          } else {
              target.setBlendColor([0, 0, 0, 0]);
          }
      } else if (this._selectionEffectCount > 0) {
          this._selectionEffectCount = 0;
          target.setBlendColor([0, 0, 0, 0]);
      }
  };
  
  Sprite_Battler.prototype.setupAnimation = function() {
      while (this._battler.isAnimationRequested()) {
          var data = this._battler.shiftAnimation();
          var animation = $dataAnimations[data.animationId];
          var mirror = data.mirror;
          var delay = animation.position === 3 ? 0 : data.delay;
          this.startAnimation(animation, mirror, delay);
          for (var i = 0; i < this._animationSprites.length; i++) {
              var sprite = this._animationSprites[i];
              sprite.visible = this._battler.isSpriteVisible();
          }
      }
  };
  
  Sprite_Battler.prototype.setupDamagePopup = function() {
      if (this._battler.isDamagePopupRequested()) {
          if (this._battler.isSpriteVisible()) {
              var sprite = new Sprite_Damage();
              sprite.x = this.x + this.damageOffsetX();
              sprite.y = this.y + this.damageOffsetY();
              sprite.setup(this._battler);
              this._damages.push(sprite);
              this.parent.addChild(sprite);
          }
          this._battler.clearDamagePopup();
          this._battler.clearResult();
      }
  };
  
  Sprite_Battler.prototype.damageOffsetX = function() {
      return 0;
  };
  
  Sprite_Battler.prototype.damageOffsetY = function() {
      return 0;
  };
  
  Sprite_Battler.prototype.startMove = function(x, y, duration) {
      if (this._targetOffsetX !== x || this._targetOffsetY !== y) {
          this._targetOffsetX = x;
          this._targetOffsetY = y;
          this._movementDuration = duration;
          if (duration === 0) {
              this._offsetX = x;
              this._offsetY = y;
          }
      }
  };
  
  Sprite_Battler.prototype.onMoveEnd = function() {
  };
  
  Sprite_Battler.prototype.isEffecting = function() {
      return false;
  };
  
  Sprite_Battler.prototype.isMoving = function() {
      return this._movementDuration > 0;
  };
  
  Sprite_Battler.prototype.inHomePosition = function() {
      return this._offsetX === 0 && this._offsetY === 0;
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Actor
  //
  // The sprite for displaying an actor.
  
  function Sprite_Actor() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Actor.prototype = Object.create(Sprite_Battler.prototype);
  Sprite_Actor.prototype.constructor = Sprite_Actor;
  
  Sprite_Actor.MOTIONS = {
      walk:     { index: 0,  loop: true  },
      wait:     { index: 1,  loop: true  },
      chant:    { index: 2,  loop: true  },
      guard:    { index: 3,  loop: true  },
      damage:   { index: 4,  loop: false },
      evade:    { index: 5,  loop: false },
      thrust:   { index: 6,  loop: false },
      swing:    { index: 7,  loop: false },
      missile:  { index: 8,  loop: false },
      skill:    { index: 9,  loop: false },
      spell:    { index: 10, loop: false },
      item:     { index: 11, loop: false },
      escape:   { index: 12, loop: true  },
      victory:  { index: 13, loop: true  },
      dying:    { index: 14, loop: true  },
      abnormal: { index: 15, loop: true  },
      sleep:    { index: 16, loop: true  },
      dead:     { index: 17, loop: true  }
  };
  
  Sprite_Actor.prototype.initialize = function(battler) {
      Sprite_Battler.prototype.initialize.call(this, battler);
      this.moveToStartPosition();
  };
  
  Sprite_Actor.prototype.initMembers = function() {
      Sprite_Battler.prototype.initMembers.call(this);
      this._battlerName = '';
      this._motion = null;
      this._motionCount = 0;
      this._pattern = 0;
      this.createShadowSprite();
      this.createWeaponSprite();
      this.createMainSprite();
      this.createStateSprite();
  };
  
  Sprite_Actor.prototype.createMainSprite = function() {
      this._mainSprite = new Sprite_Base();
      this._mainSprite.anchor.x = 0.5;
      this._mainSprite.anchor.y = 1;
      this.addChild(this._mainSprite);
      this._effectTarget = this._mainSprite;
  };
  
  Sprite_Actor.prototype.createShadowSprite = function() {
      this._shadowSprite = new Sprite();
      this._shadowSprite.bitmap = ImageManager.loadSystem('Shadow2');
      this._shadowSprite.anchor.x = 0.5;
      this._shadowSprite.anchor.y = 0.5;
      this._shadowSprite.y = -2;
      this.addChild(this._shadowSprite);
  };
  
  Sprite_Actor.prototype.createWeaponSprite = function() {
      this._weaponSprite = new Sprite_Weapon();
      this.addChild(this._weaponSprite);
  };
  
  Sprite_Actor.prototype.createStateSprite = function() {
      this._stateSprite = new Sprite_StateOverlay();
      this.addChild(this._stateSprite);
  };
  
  Sprite_Actor.prototype.setBattler = function(battler) {
      Sprite_Battler.prototype.setBattler.call(this, battler);
      var changed = (battler !== this._actor);
      if (changed) {
          this._actor = battler;
          if (battler) {
              this.setActorHome(battler.index());
          }
          this.startEntryMotion();
          this._stateSprite.setup(battler);
      }
  };
  
  Sprite_Actor.prototype.moveToStartPosition = function() {
      this.startMove(300, 0, 0);
  };
  
  Sprite_Actor.prototype.setActorHome = function(index) {
      this.setHome(600 + index * 32, 280 + index * 48);
  };
  
  Sprite_Actor.prototype.update = function() {
      Sprite_Battler.prototype.update.call(this);
      this.updateShadow();
      if (this._actor) {
          this.updateMotion();
      }
  };
  
  Sprite_Actor.prototype.updateShadow = function() {
      this._shadowSprite.visible = !!this._actor;
  };
  
  Sprite_Actor.prototype.updateMain = function() {
      Sprite_Battler.prototype.updateMain.call(this);
      if (this._actor.isSpriteVisible() && !this.isMoving()) {
          this.updateTargetPosition();
      }
  };
  
  Sprite_Actor.prototype.setupMotion = function() {
      if (this._actor.isMotionRequested()) {
          this.startMotion(this._actor.motionType());
          this._actor.clearMotion();
      }
  };
  
  Sprite_Actor.prototype.setupWeaponAnimation = function() {
      if (this._actor.isWeaponAnimationRequested()) {
          this._weaponSprite.setup(this._actor.weaponImageId());
          this._actor.clearWeaponAnimation();
      }
  };
  
  Sprite_Actor.prototype.startMotion = function(motionType) {
      var newMotion = Sprite_Actor.MOTIONS[motionType];
      if (this._motion !== newMotion) {
          this._motion = newMotion;
          this._motionCount = 0;
          this._pattern = 0;
      }
  };
  
  Sprite_Actor.prototype.updateTargetPosition = function() {
      if (this._actor.isInputting() || this._actor.isActing()) {
          this.stepForward();
      } else if (this._actor.canMove() && BattleManager.isEscaped()) {
          this.retreat();
      } else if (!this.inHomePosition()) {
          this.stepBack();
      }
  };
  
  Sprite_Actor.prototype.updateBitmap = function() {
      Sprite_Battler.prototype.updateBitmap.call(this);
      var name = this._actor.battlerName();
      if (this._battlerName !== name) {
          this._battlerName = name;
          this._mainSprite.bitmap = ImageManager.loadSvActor(name);
      }
  };
  
  Sprite_Actor.prototype.updateFrame = function() {
      Sprite_Battler.prototype.updateFrame.call(this);
      var bitmap = this._mainSprite.bitmap;
      if (bitmap) {
          var motionIndex = this._motion ? this._motion.index : 0;
          var pattern = this._pattern < 3 ? this._pattern : 1;
          var cw = bitmap.width / 9;
          var ch = bitmap.height / 6;
          var cx = Math.floor(motionIndex / 6) * 3 + pattern;
          var cy = motionIndex % 6;
          this._mainSprite.setFrame(cx * cw, cy * ch, cw, ch);
      }
  };
  
  Sprite_Actor.prototype.updateMove = function() {
      var bitmap = this._mainSprite.bitmap;
      if (!bitmap || bitmap.isReady()) {
          Sprite_Battler.prototype.updateMove.call(this);
      }
  };
  
  Sprite_Actor.prototype.updateMotion = function() {
      this.setupMotion();
      this.setupWeaponAnimation();
      if (this._actor.isMotionRefreshRequested()) {
          this.refreshMotion();
          this._actor.clearMotion();
      }
      this.updateMotionCount();
  };
  
  Sprite_Actor.prototype.updateMotionCount = function() {
      if (this._motion && ++this._motionCount >= this.motionSpeed()) {
          if (this._motion.loop) {
              this._pattern = (this._pattern + 1) % 4;
          } else if (this._pattern < 2) {
              this._pattern++;
          } else {
              this.refreshMotion();
          }
          this._motionCount = 0;
      }
  };
  
  Sprite_Actor.prototype.motionSpeed = function() {
      return 12;
  };
  
  Sprite_Actor.prototype.refreshMotion = function() {
      var actor = this._actor;
      var motionGuard = Sprite_Actor.MOTIONS['guard'];
      if (actor) {
          if (this._motion === motionGuard && !BattleManager.isInputting()) {
                  return;
          }
          var stateMotion = actor.stateMotionIndex();
          if (actor.isInputting() || actor.isActing()) {
              this.startMotion('walk');
          } else if (stateMotion === 3) {
              this.startMotion('dead');
          } else if (stateMotion === 2) {
              this.startMotion('sleep');
          } else if (actor.isChanting()) {
              this.startMotion('chant');
          } else if (actor.isGuard() || actor.isGuardWaiting()) {
              this.startMotion('guard');
          } else if (stateMotion === 1) {
              this.startMotion('abnormal');
          } else if (actor.isDying()) {
              this.startMotion('dying');
          } else if (actor.isUndecided()) {
              this.startMotion('walk');
          } else {
              this.startMotion('wait');
          }
      }
  };
  
  Sprite_Actor.prototype.startEntryMotion = function() {
      if (this._actor && this._actor.canMove()) {
          this.startMotion('walk');
          this.startMove(0, 0, 30);
      } else if (!this.isMoving()) {
          this.refreshMotion();
          this.startMove(0, 0, 0);
      }
  };
  
  Sprite_Actor.prototype.stepForward = function() {
      this.startMove(-48, 0, 12);
  };
  
  Sprite_Actor.prototype.stepBack = function() {
      this.startMove(0, 0, 12);
  };
  
  Sprite_Actor.prototype.retreat = function() {
      this.startMove(300, 0, 30);
  };
  
  Sprite_Actor.prototype.onMoveEnd = function() {
      Sprite_Battler.prototype.onMoveEnd.call(this);
      if (!BattleManager.isBattleEnd()) {
          this.refreshMotion();
      }
  };
  
  Sprite_Actor.prototype.damageOffsetX = function() {
      return -32;
  };
  
  Sprite_Actor.prototype.damageOffsetY = function() {
      return 0;
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Enemy
  //
  // The sprite for displaying an enemy.
  
  function Sprite_Enemy() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Enemy.prototype = Object.create(Sprite_Battler.prototype);
  Sprite_Enemy.prototype.constructor = Sprite_Enemy;
  
  Sprite_Enemy.prototype.initialize = function(battler) {
      Sprite_Battler.prototype.initialize.call(this, battler);
  };
  
  Sprite_Enemy.prototype.initMembers = function() {
      Sprite_Battler.prototype.initMembers.call(this);
      this._enemy = null;
      this._appeared = false;
      this._battlerName = '';
      this._battlerHue = 0;
      this._effectType = null;
      this._effectDuration = 0;
      this._shake = 0;
      this.createStateIconSprite();
  };
  
  Sprite_Enemy.prototype.createStateIconSprite = function() {
      this._stateIconSprite = new Sprite_StateIcon();
      this.addChild(this._stateIconSprite);
  };
  
  Sprite_Enemy.prototype.setBattler = function(battler) {
      Sprite_Battler.prototype.setBattler.call(this, battler);
      this._enemy = battler;
      this.setHome(battler.screenX(), battler.screenY());
      this._stateIconSprite.setup(battler);
  };
  
  Sprite_Enemy.prototype.update = function() {
      Sprite_Battler.prototype.update.call(this);
      if (this._enemy) {
          this.updateEffect();
          this.updateStateSprite();
      }
  };
  
  Sprite_Enemy.prototype.updateBitmap = function() {
      Sprite_Battler.prototype.updateBitmap.call(this);
      var name = this._enemy.battlerName();
      var hue = this._enemy.battlerHue();
      if (this._battlerName !== name || this._battlerHue !== hue) {
          this._battlerName = name;
          this._battlerHue = hue;
          this.loadBitmap(name, hue);
          this.initVisibility();
      }
  };
  
  Sprite_Enemy.prototype.loadBitmap = function(name, hue) {
      if ($gameSystem.isSideView()) {
          this.bitmap = ImageManager.loadSvEnemy(name, hue);
      } else {
          this.bitmap = ImageManager.loadEnemy(name, hue);
      }
  };
  
  Sprite_Enemy.prototype.updateFrame = function() {
      Sprite_Battler.prototype.updateFrame.call(this);
      var frameHeight = this.bitmap.height;
      if (this._effectType === 'bossCollapse') {
          frameHeight = this._effectDuration;
      }
      this.setFrame(0, 0, this.bitmap.width, frameHeight);
  };
  
  Sprite_Enemy.prototype.updatePosition = function() {
      Sprite_Battler.prototype.updatePosition.call(this);
      this.x += this._shake;
  };
  
  Sprite_Enemy.prototype.updateStateSprite = function() {
      this._stateIconSprite.y = -Math.round((this.bitmap.height + 40) * 0.9);
      if (this._stateIconSprite.y < 20 - this.y) {
          this._stateIconSprite.y = 20 - this.y;
      }
  };
  
  Sprite_Enemy.prototype.initVisibility = function() {
      this._appeared = this._enemy.isAlive();
      if (!this._appeared) {
          this.opacity = 0;
      }
  };
  
  Sprite_Enemy.prototype.setupEffect = function() {
      if (this._appeared && this._enemy.isEffectRequested()) {
          this.startEffect(this._enemy.effectType());
          this._enemy.clearEffect();
      }
      if (!this._appeared && this._enemy.isAlive()) {
          this.startEffect('appear');
      } else if (this._appeared && this._enemy.isHidden()) {
          this.startEffect('disappear');
      }
  };
  
  Sprite_Enemy.prototype.startEffect = function(effectType) {
      this._effectType = effectType;
      switch (this._effectType) {
      case 'appear':
          this.startAppear();
          break;
      case 'disappear':
          this.startDisappear();
          break;
      case 'whiten':
          this.startWhiten();
          break;
      case 'blink':
          this.startBlink();
          break;
      case 'collapse':
          this.startCollapse();
          break;
      case 'bossCollapse':
          this.startBossCollapse();
          break;
      case 'instantCollapse':
          this.startInstantCollapse();
          break;
      }
      this.revertToNormal();
  };
  
  Sprite_Enemy.prototype.startAppear = function() {
      this._effectDuration = 16;
      this._appeared = true;
  };
  
  Sprite_Enemy.prototype.startDisappear = function() {
      this._effectDuration = 32;
      this._appeared = false;
  };
  
  Sprite_Enemy.prototype.startWhiten = function() {
      this._effectDuration = 16;
  };
  
  Sprite_Enemy.prototype.startBlink = function() {
      this._effectDuration = 20;
  };
  
  Sprite_Enemy.prototype.startCollapse = function() {
      this._effectDuration = 32;
      this._appeared = false;
  };
  
  Sprite_Enemy.prototype.startBossCollapse = function() {
      this._effectDuration = this.bitmap.height;
      this._appeared = false;
  };
  
  Sprite_Enemy.prototype.startInstantCollapse = function() {
      this._effectDuration = 16;
      this._appeared = false;
  };
  
  Sprite_Enemy.prototype.updateEffect = function() {
      this.setupEffect();
      if (this._effectDuration > 0) {
          this._effectDuration--;
          switch (this._effectType) {
          case 'whiten':
              this.updateWhiten();
              break;
          case 'blink':
              this.updateBlink();
              break;
          case 'appear':
              this.updateAppear();
              break;
          case 'disappear':
              this.updateDisappear();
              break;
          case 'collapse':
              this.updateCollapse();
              break;
          case 'bossCollapse':
              this.updateBossCollapse();
              break;
          case 'instantCollapse':
              this.updateInstantCollapse();
              break;
          }
          if (this._effectDuration === 0) {
              this._effectType = null;
          }
      }
  };
  
  Sprite_Enemy.prototype.isEffecting = function() {
      return this._effectType !== null;
  };
  
  Sprite_Enemy.prototype.revertToNormal = function() {
      this._shake = 0;
      this.blendMode = 0;
      this.opacity = 255;
      this.setBlendColor([0, 0, 0, 0]);
  };
  
  Sprite_Enemy.prototype.updateWhiten = function() {
      var alpha = 128 - (16 - this._effectDuration) * 10;
      this.setBlendColor([255, 255, 255, alpha]);
  };
  
  Sprite_Enemy.prototype.updateBlink = function() {
      this.opacity = (this._effectDuration % 10 < 5) ? 255 : 0;
  };
  
  Sprite_Enemy.prototype.updateAppear = function() {
      this.opacity = (16 - this._effectDuration) * 16;
  };
  
  Sprite_Enemy.prototype.updateDisappear = function() {
      this.opacity = 256 - (32 - this._effectDuration) * 10;
  };
  
  Sprite_Enemy.prototype.updateCollapse = function() {
      this.blendMode = Graphics.BLEND_ADD;
      this.setBlendColor([255, 128, 128, 128]);
      this.opacity *= this._effectDuration / (this._effectDuration + 1);
  };
  
  Sprite_Enemy.prototype.updateBossCollapse = function() {
      this._shake = this._effectDuration % 2 * 4 - 2;
      this.blendMode = Graphics.BLEND_ADD;
      this.opacity *= this._effectDuration / (this._effectDuration + 1);
      this.setBlendColor([255, 255, 255, 255 - this.opacity]);
      if (this._effectDuration % 20 === 19) {
          SoundManager.playBossCollapse2();
      }
  };
  
  Sprite_Enemy.prototype.updateInstantCollapse = function() {
      this.opacity = 0;
  };
  
  Sprite_Enemy.prototype.damageOffsetX = function() {
      return 0;
  };
  
  Sprite_Enemy.prototype.damageOffsetY = function() {
      return -8;
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Animation
  //
  // The sprite for displaying an animation.
  
  function Sprite_Animation() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Animation.prototype = Object.create(Sprite.prototype);
  Sprite_Animation.prototype.constructor = Sprite_Animation;
  
  Sprite_Animation._checker1 = {};
  Sprite_Animation._checker2 = {};
  
  Sprite_Animation.prototype.initialize = function() {
      Sprite.prototype.initialize.call(this);
      this._reduceArtifacts = true;
      this.initMembers();
  };
  
  Sprite_Animation.prototype.initMembers = function() {
      this._target = null;
      this._animation = null;
      this._mirror = false;
      this._delay = 0;
      this._rate = 4;
      this._duration = 0;
      this._flashColor = [0, 0, 0, 0];
      this._flashDuration = 0;
      this._screenFlashDuration = 0;
      this._hidingDuration = 0;
      this._bitmap1 = null;
      this._bitmap2 = null;
      this._cellSprites = [];
      this._screenFlashSprite = null;
      this._duplicated = false;
      this.z = 8;
  };
  
  Sprite_Animation.prototype.setup = function(target, animation, mirror, delay) {
      this._target = target;
      this._animation = animation;
      this._mirror = mirror;
      this._delay = delay;
      if (this._animation) {
          this.remove();
          this.setupRate();
          this.setupDuration();
          this.loadBitmaps();
          this.createSprites();
      }
  };
  
  Sprite_Animation.prototype.remove = function() {
      if (this.parent && this.parent.removeChild(this)) {
          this._target.setBlendColor([0, 0, 0, 0]);
          this._target.show();
      }
  };
  
  Sprite_Animation.prototype.setupRate = function() {
      this._rate = 4;
  };
  
  Sprite_Animation.prototype.setupDuration = function() {
      this._duration = this._animation.frames.length * this._rate + 1;
  };
  
  Sprite_Animation.prototype.update = function() {
      Sprite.prototype.update.call(this);
      this.updateMain();
      this.updateFlash();
      this.updateScreenFlash();
      this.updateHiding();
      Sprite_Animation._checker1 = {};
      Sprite_Animation._checker2 = {};
  };
  
  Sprite_Animation.prototype.updateFlash = function() {
      if (this._flashDuration > 0) {
          var d = this._flashDuration--;
          this._flashColor[3] *= (d - 1) / d;
          this._target.setBlendColor(this._flashColor);
      }
  };
  
  Sprite_Animation.prototype.updateScreenFlash = function() {
      if (this._screenFlashDuration > 0) {
          var d = this._screenFlashDuration--;
          if (this._screenFlashSprite) {
              this._screenFlashSprite.x = -this.absoluteX();
              this._screenFlashSprite.y = -this.absoluteY();
              this._screenFlashSprite.opacity *= (d - 1) / d;
              this._screenFlashSprite.visible = (this._screenFlashDuration > 0);
          }
      }
  };
  
  Sprite_Animation.prototype.absoluteX = function() {
      var x = 0;
      var object = this;
      while (object) {
          x += object.x;
          object = object.parent;
      }
      return x;
  };
  
  Sprite_Animation.prototype.absoluteY = function() {
      var y = 0;
      var object = this;
      while (object) {
          y += object.y;
          object = object.parent;
      }
      return y;
  };
  
  Sprite_Animation.prototype.updateHiding = function() {
      if (this._hidingDuration > 0) {
          this._hidingDuration--;
          if (this._hidingDuration === 0) {
              this._target.show();
          }
      }
  };
  
  Sprite_Animation.prototype.isPlaying = function() {
      return this._duration > 0;
  };
  
  Sprite_Animation.prototype.loadBitmaps = function() {
      var name1 = this._animation.animation1Name;
      var name2 = this._animation.animation2Name;
      var hue1 = this._animation.animation1Hue;
      var hue2 = this._animation.animation2Hue;
      this._bitmap1 = ImageManager.loadAnimation(name1, hue1);
      this._bitmap2 = ImageManager.loadAnimation(name2, hue2);
  };
  
  Sprite_Animation.prototype.isReady = function() {
      return this._bitmap1 && this._bitmap1.isReady() && this._bitmap2 && this._bitmap2.isReady();
  };
  
  Sprite_Animation.prototype.createSprites = function() {
      if (!Sprite_Animation._checker2[this._animation]) {
          this.createCellSprites();
          if (this._animation.position === 3) {
              Sprite_Animation._checker2[this._animation] = true;
          }
          this.createScreenFlashSprite();
      }
      if (Sprite_Animation._checker1[this._animation]) {
          this._duplicated = true;
      } else {
          this._duplicated = false;
          if (this._animation.position === 3) {
              Sprite_Animation._checker1[this._animation] = true;
          }
      }
  };
  
  Sprite_Animation.prototype.createCellSprites = function() {
      this._cellSprites = [];
      for (var i = 0; i < 16; i++) {
          var sprite = new Sprite();
          sprite.anchor.x = 0.5;
          sprite.anchor.y = 0.5;
          this._cellSprites.push(sprite);
          this.addChild(sprite);
      }
  };
  
  Sprite_Animation.prototype.createScreenFlashSprite = function() {
      this._screenFlashSprite = new ScreenSprite();
      this.addChild(this._screenFlashSprite);
  };
  
  Sprite_Animation.prototype.updateMain = function() {
      if (this.isPlaying() && this.isReady()) {
          if (this._delay > 0) {
              this._delay--;
          } else {
              this._duration--;
              this.updatePosition();
              if (this._duration % this._rate === 0) {
                  this.updateFrame();
              }
          }
      }
  };
  
  Sprite_Animation.prototype.updatePosition = function() {
      if (this._animation.position === 3) {
          this.x = this.parent.width / 2;
          this.y = this.parent.height / 2;
      } else {
          var parent = this._target.parent;
          var grandparent = parent ? parent.parent : null;
          this.x = this._target.x;
          this.y = this._target.y;
          if (this.parent === grandparent) {
              this.x += parent.x;
              this.y += parent.y;
          }
          if (this._animation.position === 0) {
              this.y -= this._target.height;
          } else if (this._animation.position === 1) {
              this.y -= this._target.height / 2;
          }
      }
  };
  
  Sprite_Animation.prototype.updateFrame = function() {
      if (this._duration > 0) {
          var frameIndex = this.currentFrameIndex();
          this.updateAllCellSprites(this._animation.frames[frameIndex]);
          this._animation.timings.forEach(function(timing) {
              if (timing.frame === frameIndex) {
                  this.processTimingData(timing);
              }
          }, this);
      }
  };
  
  Sprite_Animation.prototype.currentFrameIndex = function() {
      return (this._animation.frames.length -
              Math.floor((this._duration + this._rate - 1) / this._rate));
  };
  
  Sprite_Animation.prototype.updateAllCellSprites = function(frame) {
      for (var i = 0; i < this._cellSprites.length; i++) {
          var sprite = this._cellSprites[i];
          if (i < frame.length) {
              this.updateCellSprite(sprite, frame[i]);
          } else {
              sprite.visible = false;
          }
      }
  };
  
  Sprite_Animation.prototype.updateCellSprite = function(sprite, cell) {
      var pattern = cell[0];
      if (pattern >= 0) {
          var sx = pattern % 5 * 192;
          var sy = Math.floor(pattern % 100 / 5) * 192;
          var mirror = this._mirror;
          sprite.bitmap = pattern < 100 ? this._bitmap1 : this._bitmap2;
          sprite.setFrame(sx, sy, 192, 192);
          sprite.x = cell[1];
          sprite.y = cell[2];
          sprite.rotation = cell[4] * Math.PI / 180;
          sprite.scale.x = cell[3] / 100;
  
          if(cell[5]){
              sprite.scale.x *= -1;
          }
          if(mirror){
              sprite.x *= -1;
              sprite.rotation *= -1;
              sprite.scale.x *= -1;
          }
  
          sprite.scale.y = cell[3] / 100;
          sprite.opacity = cell[6];
          sprite.blendMode = cell[7];
          sprite.visible = true;
      } else {
          sprite.visible = false;
      }
  };
  
  Sprite_Animation.prototype.processTimingData = function(timing) {
      var duration = timing.flashDuration * this._rate;
      switch (timing.flashScope) {
      case 1:
          this.startFlash(timing.flashColor, duration);
          break;
      case 2:
          this.startScreenFlash(timing.flashColor, duration);
          break;
      case 3:
          this.startHiding(duration);
          break;
      }
      if (!this._duplicated && timing.se) {
          AudioManager.playSe(timing.se);
      }
  };
  
  Sprite_Animation.prototype.startFlash = function(color, duration) {
      this._flashColor = color.clone();
      this._flashDuration = duration;
  };
  
  Sprite_Animation.prototype.startScreenFlash = function(color, duration) {
      this._screenFlashDuration = duration;
      if (this._screenFlashSprite) {
          this._screenFlashSprite.setColor(color[0], color[1], color[2]);
          this._screenFlashSprite.opacity = color[3];
      }
  };
  
  Sprite_Animation.prototype.startHiding = function(duration) {
      this._hidingDuration = duration;
      this._target.hide();
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Damage
  //
  // The sprite for displaying a popup damage.
  
  function Sprite_Damage() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Damage.prototype = Object.create(Sprite.prototype);
  Sprite_Damage.prototype.constructor = Sprite_Damage;
  
  Sprite_Damage.prototype.initialize = function() {
      Sprite.prototype.initialize.call(this);
      this._duration = 90;
      this._flashColor = [0, 0, 0, 0];
      this._flashDuration = 0;
      this._damageBitmap = ImageManager.loadSystem('Damage');
  };
  
  Sprite_Damage.prototype.setup = function(target) {
      var result = target.result();
      if (result.missed || result.evaded) {
          this.createMiss();
      } else if (result.hpAffected) {
          this.createDigits(0, result.hpDamage);
      } else if (target.isAlive() && result.mpDamage !== 0) {
          this.createDigits(2, result.mpDamage);
      }
      if (result.critical) {
          this.setupCriticalEffect();
      }
  };
  
  Sprite_Damage.prototype.setupCriticalEffect = function() {
      this._flashColor = [255, 0, 0, 160];
      this._flashDuration = 60;
  };
  
  Sprite_Damage.prototype.digitWidth = function() {
      return this._damageBitmap ? this._damageBitmap.width / 10 : 0;
  };
  
  Sprite_Damage.prototype.digitHeight = function() {
      return this._damageBitmap ? this._damageBitmap.height / 5 : 0;
  };
  
  Sprite_Damage.prototype.createMiss = function() {
      var w = this.digitWidth();
      var h = this.digitHeight();
      var sprite = this.createChildSprite();
      sprite.setFrame(0, 4 * h, 4 * w, h);
      sprite.dy = 0;
  };
  
  Sprite_Damage.prototype.createDigits = function(baseRow, value) {
      var string = Math.abs(value).toString();
      var row = baseRow + (value < 0 ? 1 : 0);
      var w = this.digitWidth();
      var h = this.digitHeight();
      for (var i = 0; i < string.length; i++) {
          var sprite = this.createChildSprite();
          var n = Number(string[i]);
          sprite.setFrame(n * w, row * h, w, h);
          sprite.x = (i - (string.length - 1) / 2) * w;
          sprite.dy = -i;
      }
  };
  
  Sprite_Damage.prototype.createChildSprite = function() {
      var sprite = new Sprite();
      sprite.bitmap = this._damageBitmap;
      sprite.anchor.x = 0.5;
      sprite.anchor.y = 1;
      sprite.y = -40;
      sprite.ry = sprite.y;
      this.addChild(sprite);
      return sprite;
  };
  
  Sprite_Damage.prototype.update = function() {
      Sprite.prototype.update.call(this);
      if (this._duration > 0) {
          this._duration--;
          for (var i = 0; i < this.children.length; i++) {
              this.updateChild(this.children[i]);
          }
      }
      this.updateFlash();
      this.updateOpacity();
  };
  
  Sprite_Damage.prototype.updateChild = function(sprite) {
      sprite.dy += 0.5;
      sprite.ry += sprite.dy;
      if (sprite.ry >= 0) {
          sprite.ry = 0;
          sprite.dy *= -0.6;
      }
      sprite.y = Math.round(sprite.ry);
      sprite.setBlendColor(this._flashColor);
  };
  
  Sprite_Damage.prototype.updateFlash = function() {
      if (this._flashDuration > 0) {
          var d = this._flashDuration--;
          this._flashColor[3] *= (d - 1) / d;
      }
  };
  
  Sprite_Damage.prototype.updateOpacity = function() {
      if (this._duration < 10) {
          this.opacity = 255 * this._duration / 10;
      }
  };
  
  Sprite_Damage.prototype.isPlaying = function() {
      return this._duration > 0;
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_StateIcon
  //
  // The sprite for displaying state icons.
  
  function Sprite_StateIcon() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_StateIcon.prototype = Object.create(Sprite.prototype);
  Sprite_StateIcon.prototype.constructor = Sprite_StateIcon;
  
  Sprite_StateIcon.prototype.initialize = function() {
      Sprite.prototype.initialize.call(this);
      this.initMembers();
      this.loadBitmap();
  };
  
  Sprite_StateIcon._iconWidth  = 32;
  Sprite_StateIcon._iconHeight = 32;
  
  Sprite_StateIcon.prototype.initMembers = function() {
      this._battler = null;
      this._iconIndex = 0;
      this._animationCount = 0;
      this._animationIndex = 0;
      this.anchor.x = 0.5;
      this.anchor.y = 0.5;
  };
  
  Sprite_StateIcon.prototype.loadBitmap = function() {
      this.bitmap = ImageManager.loadSystem('IconSet');
      this.setFrame(0, 0, 0, 0);
  };
  
  Sprite_StateIcon.prototype.setup = function(battler) {
      this._battler = battler;
  };
  
  Sprite_StateIcon.prototype.update = function() {
      Sprite.prototype.update.call(this);
      this._animationCount++;
      if (this._animationCount >= this.animationWait()) {
          this.updateIcon();
          this.updateFrame();
          this._animationCount = 0;
      }
  };
  
  Sprite_StateIcon.prototype.animationWait = function() {
      return 40;
  };
  
  Sprite_StateIcon.prototype.updateIcon = function() {
      var icons = [];
      if (this._battler && this._battler.isAlive()) {
          icons = this._battler.allIcons();
      }
      if (icons.length > 0) {
          this._animationIndex++;
          if (this._animationIndex >= icons.length) {
              this._animationIndex = 0;
          }
          this._iconIndex = icons[this._animationIndex];
      } else {
          this._animationIndex = 0;
          this._iconIndex = 0;
      }
  };
  
  Sprite_StateIcon.prototype.updateFrame = function() {
      var pw = Sprite_StateIcon._iconWidth;
      var ph = Sprite_StateIcon._iconHeight;
      var sx = this._iconIndex % 16 * pw;
      var sy = Math.floor(this._iconIndex / 16) * ph;
      this.setFrame(sx, sy, pw, ph);
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_StateOverlay
  //
  // The sprite for displaying an overlay image for a state.
  
  function Sprite_StateOverlay() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_StateOverlay.prototype = Object.create(Sprite_Base.prototype);
  Sprite_StateOverlay.prototype.constructor = Sprite_StateOverlay;
  
  Sprite_StateOverlay.prototype.initialize = function() {
      Sprite_Base.prototype.initialize.call(this);
      this.initMembers();
      this.loadBitmap();
  };
  
  Sprite_StateOverlay.prototype.initMembers = function() {
      this._battler = null;
      this._overlayIndex = 0;
      this._animationCount = 0;
      this._pattern = 0;
      this.anchor.x = 0.5;
      this.anchor.y = 1;
  };
  
  Sprite_StateOverlay.prototype.loadBitmap = function() {
      this.bitmap = ImageManager.loadSystem('States');
      this.setFrame(0, 0, 0, 0);
  };
  
  Sprite_StateOverlay.prototype.setup = function(battler) {
      this._battler = battler;
  };
  
  Sprite_StateOverlay.prototype.update = function() {
      Sprite_Base.prototype.update.call(this);
      this._animationCount++;
      if (this._animationCount >= this.animationWait()) {
          this.updatePattern();
          this.updateFrame();
          this._animationCount = 0;
      }
  };
  
  Sprite_StateOverlay.prototype.animationWait = function() {
      return 8;
  };
  
  Sprite_StateOverlay.prototype.updatePattern = function() {
      this._pattern++;
      this._pattern %= 8;
      if (this._battler) {
          this._overlayIndex = this._battler.stateOverlayIndex();
      }
  };
  
  Sprite_StateOverlay.prototype.updateFrame = function() {
      if (this._overlayIndex > 0) {
          var w = 96;
          var h = 96;
          var sx = this._pattern * w;
          var sy = (this._overlayIndex - 1) * h;
          this.setFrame(sx, sy, w, h);
      } else {
          this.setFrame(0, 0, 0, 0);
      }
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Weapon
  //
  // The sprite for displaying a weapon image for attacking.
  
  function Sprite_Weapon() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Weapon.prototype = Object.create(Sprite_Base.prototype);
  Sprite_Weapon.prototype.constructor = Sprite_Weapon;
  
  Sprite_Weapon.prototype.initialize = function() {
      Sprite_Base.prototype.initialize.call(this);
      this.initMembers();
  };
  
  Sprite_Weapon.prototype.initMembers = function() {
      this._weaponImageId = 0;
      this._animationCount = 0;
      this._pattern = 0;
      this.anchor.x = 0.5;
      this.anchor.y = 1;
      this.x = -16;
  };
  
  Sprite_Weapon.prototype.setup = function(weaponImageId) {
      this._weaponImageId = weaponImageId;
      this._animationCount = 0;
      this._pattern = 0;
      this.loadBitmap();
      this.updateFrame();
  };
  
  Sprite_Weapon.prototype.update = function() {
      Sprite_Base.prototype.update.call(this);
      this._animationCount++;
      if (this._animationCount >= this.animationWait()) {
          this.updatePattern();
          this.updateFrame();
          this._animationCount = 0;
      }
  };
  
  Sprite_Weapon.prototype.animationWait = function() {
      return 12;
  };
  
  Sprite_Weapon.prototype.updatePattern = function() {
      this._pattern++;
      if (this._pattern >= 3) {
          this._weaponImageId = 0;
      }
  };
  
  Sprite_Weapon.prototype.loadBitmap = function() {
      var pageId = Math.floor((this._weaponImageId - 1) / 12) + 1;
      if (pageId >= 1) {
          this.bitmap = ImageManager.loadSystem('Weapons' + pageId);
      } else {
          this.bitmap = ImageManager.loadSystem('');
      }
  };
  
  Sprite_Weapon.prototype.updateFrame = function() {
      if (this._weaponImageId > 0) {
          var index = (this._weaponImageId - 1) % 12;
          var w = 96;
          var h = 64;
          var sx = (Math.floor(index / 6) * 3 + this._pattern) * w;
          var sy = Math.floor(index % 6) * h;
          this.setFrame(sx, sy, w, h);
      } else {
          this.setFrame(0, 0, 0, 0);
      }
  };
  
  Sprite_Weapon.prototype.isPlaying = function() {
      return this._weaponImageId > 0;
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Balloon
  //
  // The sprite for displaying a balloon icon.
  
  function Sprite_Balloon() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Balloon.prototype = Object.create(Sprite_Base.prototype);
  Sprite_Balloon.prototype.constructor = Sprite_Balloon;
  
  Sprite_Balloon.prototype.initialize = function() {
      Sprite_Base.prototype.initialize.call(this);
      this.initMembers();
      this.loadBitmap();
  };
  
  Sprite_Balloon.prototype.initMembers = function() {
      this._balloonId = 0;
      this._duration = 0;
      this.anchor.x = 0.5;
      this.anchor.y = 1;
      this.z = 7;
  };
  
  Sprite_Balloon.prototype.loadBitmap = function() {
      this.bitmap = ImageManager.loadSystem('Balloon');
      this.setFrame(0, 0, 0, 0);
  };
  
  Sprite_Balloon.prototype.setup = function(balloonId) {
      this._balloonId = balloonId;
      this._duration = 8 * this.speed() + this.waitTime();
  };
  
  Sprite_Balloon.prototype.update = function() {
      Sprite_Base.prototype.update.call(this);
      if (this._duration > 0) {
          this._duration--;
          if (this._duration > 0) {
              this.updateFrame();
          }
      }
  };
  
  Sprite_Balloon.prototype.updateFrame = function() {
      var w = 48;
      var h = 48;
      var sx = this.frameIndex() * w;
      var sy = (this._balloonId - 1) * h;
      this.setFrame(sx, sy, w, h);
  };
  
  Sprite_Balloon.prototype.speed = function() {
      return 8;
  };
  
  Sprite_Balloon.prototype.waitTime = function() {
      return 12;
  };
  
  Sprite_Balloon.prototype.frameIndex = function() {
      var index = (this._duration - this.waitTime()) / this.speed();
      return 7 - Math.max(Math.floor(index), 0);
  };
  
  Sprite_Balloon.prototype.isPlaying = function() {
      return this._duration > 0;
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Picture
  //
  // The sprite for displaying a picture.
  
  function Sprite_Picture() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Picture.prototype = Object.create(Sprite.prototype);
  Sprite_Picture.prototype.constructor = Sprite_Picture;
  
  Sprite_Picture.prototype.initialize = function(pictureId) {
      Sprite.prototype.initialize.call(this);
      this._pictureId = pictureId;
      this._pictureName = '';
      this._isPicture = true;
      this.update();
  };
  
  Sprite_Picture.prototype.picture = function() {
      return $gameScreen.picture(this._pictureId);
  };
  
  Sprite_Picture.prototype.update = function() {
      Sprite.prototype.update.call(this);
      this.updateBitmap();
      if (this.visible) {
          this.updateOrigin();
          this.updatePosition();
          this.updateScale();
          this.updateTone();
          this.updateOther();
      }
  };
  
  Sprite_Picture.prototype.updateBitmap = function() {
      var picture = this.picture();
      if (picture) {
          var pictureName = picture.name();
          if (this._pictureName !== pictureName) {
              this._pictureName = pictureName;
              this.loadBitmap();
          }
          this.visible = true;
      } else {
          this._pictureName = '';
          this.bitmap = null;
          this.visible = false;
      }
  };
  
  Sprite_Picture.prototype.updateOrigin = function() {
      var picture = this.picture();
      if (picture.origin() === 0) {
          this.anchor.x = 0;
          this.anchor.y = 0;
      } else {
          this.anchor.x = 0.5;
          this.anchor.y = 0.5;
      }
  };
  
  Sprite_Picture.prototype.updatePosition = function() {
      var picture = this.picture();
      this.x = Math.floor(picture.x());
      this.y = Math.floor(picture.y());
  };
  
  Sprite_Picture.prototype.updateScale = function() {
      var picture = this.picture();
      this.scale.x = picture.scaleX() / 100;
      this.scale.y = picture.scaleY() / 100;
  };
  
  Sprite_Picture.prototype.updateTone = function() {
      var picture = this.picture();
      if (picture.tone()) {
          this.setColorTone(picture.tone());
      } else {
          this.setColorTone([0, 0, 0, 0]);
      }
  };
  
  Sprite_Picture.prototype.updateOther = function() {
      var picture = this.picture();
      this.opacity = picture.opacity();
      this.blendMode = picture.blendMode();
      this.rotation = picture.angle() * Math.PI / 180;
  };
  
  Sprite_Picture.prototype.loadBitmap = function() {
      this.bitmap = ImageManager.loadPicture(this._pictureName);
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Timer
  //
  // The sprite for displaying the timer.
  
  function Sprite_Timer() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Timer.prototype = Object.create(Sprite.prototype);
  Sprite_Timer.prototype.constructor = Sprite_Timer;
  
  Sprite_Timer.prototype.initialize = function() {
      Sprite.prototype.initialize.call(this);
      this._seconds = 0;
      this.createBitmap();
      this.update();
  };
  
  Sprite_Timer.prototype.createBitmap = function() {
      this.bitmap = new Bitmap(96, 48);
      this.bitmap.fontSize = 32;
  };
  
  Sprite_Timer.prototype.update = function() {
      Sprite.prototype.update.call(this);
      this.updateBitmap();
      this.updatePosition();
      this.updateVisibility();
  };
  
  Sprite_Timer.prototype.updateBitmap = function() {
      if (this._seconds !== $gameTimer.seconds()) {
          this._seconds = $gameTimer.seconds();
          this.redraw();
      }
  };
  
  Sprite_Timer.prototype.redraw = function() {
      var text = this.timerText();
      var width = this.bitmap.width;
      var height = this.bitmap.height;
      this.bitmap.clear();
      this.bitmap.drawText(text, 0, 0, width, height, 'center');
  };
  
  Sprite_Timer.prototype.timerText = function() {
      var min = Math.floor(this._seconds / 60) % 60;
      var sec = this._seconds % 60;
      return min.padZero(2) + ':' + sec.padZero(2);
  };
  
  Sprite_Timer.prototype.updatePosition = function() {
      this.x = Graphics.width - this.bitmap.width;
      this.y = 0;
  };
  
  Sprite_Timer.prototype.updateVisibility = function() {
      this.visible = $gameTimer.isWorking();
  };
  
  //-----------------------------------------------------------------------------
  // Sprite_Destination
  //
  // The sprite for displaying the destination place of the touch input.
  
  function Sprite_Destination() {
      this.initialize.apply(this, arguments);
  }
  
  Sprite_Destination.prototype = Object.create(Sprite.prototype);
  Sprite_Destination.prototype.constructor = Sprite_Destination;
  
  Sprite_Destination.prototype.initialize = function() {
      Sprite.prototype.initialize.call(this);
      this.createBitmap();
      this._frameCount = 0;
  };
  
  Sprite_Destination.prototype.update = function() {
      Sprite.prototype.update.call(this);
      if ($gameTemp.isDestinationValid()){
          this.updatePosition();
          this.updateAnimation();
          this.visible = true;
      } else {
          this._frameCount = 0;
          this.visible = false;
      }
  };
  
  Sprite_Destination.prototype.createBitmap = function() {
      var tileWidth = $gameMap.tileWidth();
      var tileHeight = $gameMap.tileHeight();
      this.bitmap = new Bitmap(tileWidth, tileHeight);
      this.bitmap.fillAll('white');
      this.anchor.x = 0.5;
      this.anchor.y = 0.5;
      this.blendMode = Graphics.BLEND_ADD;
  };
  
  Sprite_Destination.prototype.updatePosition = function() {
      var tileWidth = $gameMap.tileWidth();
      var tileHeight = $gameMap.tileHeight();
      var x = $gameTemp.destinationX();
      var y = $gameTemp.destinationY();
      this.x = ($gameMap.adjustX(x) + 0.5) * tileWidth;
      this.y = ($gameMap.adjustY(y) + 0.5) * tileHeight;
  };
  
  Sprite_Destination.prototype.updateAnimation = function() {
      this._frameCount++;
      this._frameCount %= 20;
      this.opacity = (20 - this._frameCount) * 6;
      this.scale.x = 1 + this._frameCount / 20;
      this.scale.y = this.scale.x;
  };
  
  //-----------------------------------------------------------------------------
  // Spriteset_Base
  //
  // The superclass of Spriteset_Map and Spriteset_Battle.
  
  function Spriteset_Base() {
      this.initialize.apply(this, arguments);
  }
  
  Spriteset_Base.prototype = Object.create(Sprite.prototype);
  Spriteset_Base.prototype.constructor = Spriteset_Base;
  
  Spriteset_Base.prototype.initialize = function() {
      Sprite.prototype.initialize.call(this);
      this.setFrame(0, 0, Graphics.width, Graphics.height);
      this._tone = [0, 0, 0, 0];
      this.opaque = true;
      this.createLowerLayer();
      this.createToneChanger();
      this.createUpperLayer();
      this.update();
  };
  
  Spriteset_Base.prototype.createLowerLayer = function() {
      this.createBaseSprite();
  };
  
  Spriteset_Base.prototype.createUpperLayer = function() {
      this.createPictures();
      this.createTimer();
      this.createScreenSprites();
  };
  
  Spriteset_Base.prototype.update = function() {
      Sprite.prototype.update.call(this);
      this.updateScreenSprites();
      this.updateToneChanger();
      this.updatePosition();
  };
  
  Spriteset_Base.prototype.createBaseSprite = function() {
      this._baseSprite = new Sprite();
      this._baseSprite.setFrame(0, 0, this.width, this.height);
      this._blackScreen = new ScreenSprite();
      this._blackScreen.opacity = 255;
      this.addChild(this._baseSprite);
      this._baseSprite.addChild(this._blackScreen);
  };
  
  Spriteset_Base.prototype.createToneChanger = function() {
      if (Graphics.isWebGL()) {
          this.createWebGLToneChanger();
      } else {
          this.createCanvasToneChanger();
      }
  };
  
  Spriteset_Base.prototype.createWebGLToneChanger = function() {
      var margin = 48;
      var width = Graphics.width + margin * 2;
      var height = Graphics.height + margin * 2;
      this._toneFilter = new ToneFilter();
      this._baseSprite.filters = [this._toneFilter];
      this._baseSprite.filterArea = new Rectangle(-margin, -margin, width, height);
  };
  
  Spriteset_Base.prototype.createCanvasToneChanger = function() {
      this._toneSprite = new ToneSprite();
      this.addChild(this._toneSprite);
  };
  
  Spriteset_Base.prototype.createPictures = function() {
      var width = Graphics.boxWidth;
      var height = Graphics.boxHeight;
      var x = (Graphics.width - width) / 2;
      var y = (Graphics.height - height) / 2;
      this._pictureContainer = new Sprite();
      this._pictureContainer.setFrame(x, y, width, height);
      for (var i = 1; i <= $gameScreen.maxPictures(); i++) {
          this._pictureContainer.addChild(new Sprite_Picture(i));
      }
      this.addChild(this._pictureContainer);
  };
  
  Spriteset_Base.prototype.createTimer = function() {
      this._timerSprite = new Sprite_Timer();
      this.addChild(this._timerSprite);
  };
  
  Spriteset_Base.prototype.createScreenSprites = function() {
      this._flashSprite = new ScreenSprite();
      this._fadeSprite = new ScreenSprite();
      this.addChild(this._flashSprite);
      this.addChild(this._fadeSprite);
  };
  
  Spriteset_Base.prototype.updateScreenSprites = function() {
      var color = $gameScreen.flashColor();
      this._flashSprite.setColor(color[0], color[1], color[2]);
      this._flashSprite.opacity = color[3];
      this._fadeSprite.opacity = 255 - $gameScreen.brightness();
  };
  
  Spriteset_Base.prototype.updateToneChanger = function() {
      var tone = $gameScreen.tone();
      if (!this._tone.equals(tone)) {
          this._tone = tone.clone();
          if (Graphics.isWebGL()) {
              this.updateWebGLToneChanger();
          } else {
              this.updateCanvasToneChanger();
          }
      }
  };
  
  Spriteset_Base.prototype.updateWebGLToneChanger = function() {
      var tone = this._tone;
      this._toneFilter.reset();
      this._toneFilter.adjustTone(tone[0], tone[1], tone[2]);
      this._toneFilter.adjustSaturation(-tone[3]);
  };
  
  Spriteset_Base.prototype.updateCanvasToneChanger = function() {
      var tone = this._tone;
      this._toneSprite.setTone(tone[0], tone[1], tone[2], tone[3]);
  };
  
  Spriteset_Base.prototype.updatePosition = function() {
      var screen = $gameScreen;
      var scale = screen.zoomScale();
      this.scale.x = scale;
      this.scale.y = scale;
      this.x = Math.round(-screen.zoomX() * (scale - 1));
      this.y = Math.round(-screen.zoomY() * (scale - 1));
      this.x += Math.round(screen.shake());
  };
  
  //-----------------------------------------------------------------------------
  // Spriteset_Map
  //
  // The set of sprites on the map screen.
  
  function Spriteset_Map() {
      this.initialize.apply(this, arguments);
  }
  
  Spriteset_Map.prototype = Object.create(Spriteset_Base.prototype);
  Spriteset_Map.prototype.constructor = Spriteset_Map;
  
  Spriteset_Map.prototype.initialize = function() {
      Spriteset_Base.prototype.initialize.call(this);
  };
  
  Spriteset_Map.prototype.createLowerLayer = function() {
      Spriteset_Base.prototype.createLowerLayer.call(this);
      this.createParallax();
      this.createTilemap();
      this.createCharacters();
      this.createShadow();
      this.createDestination();
      this.createWeather();
  };
  
  Spriteset_Map.prototype.update = function() {
      Spriteset_Base.prototype.update.call(this);
      this.updateTileset();
      this.updateParallax();
      this.updateTilemap();
      this.updateShadow();
      this.updateWeather();
  };
  
  Spriteset_Map.prototype.hideCharacters = function() {
      for (var i = 0; i < this._characterSprites.length; i++) {
          var sprite = this._characterSprites[i];
          if (!sprite.isTile()) {
              sprite.hide();
          }
      }
  };
  
  Spriteset_Map.prototype.createParallax = function() {
      this._parallax = new TilingSprite();
      this._parallax.move(0, 0, Graphics.width, Graphics.height);
      this._baseSprite.addChild(this._parallax);
  };
  
  Spriteset_Map.prototype.createTilemap = function() {
      if (Graphics.isWebGL()) {
          this._tilemap = new ShaderTilemap();
      } else {
          this._tilemap = new Tilemap();
      }
      this._tilemap.tileWidth = $gameMap.tileWidth();
      this._tilemap.tileHeight = $gameMap.tileHeight();
      this._tilemap.setData($gameMap.width(), $gameMap.height(), $gameMap.data());
      this._tilemap.horizontalWrap = $gameMap.isLoopHorizontal();
      this._tilemap.verticalWrap = $gameMap.isLoopVertical();
      this.loadTileset();
      this._baseSprite.addChild(this._tilemap);
  };
  
  Spriteset_Map.prototype.loadTileset = function() {
      this._tileset = $gameMap.tileset();
      if (this._tileset) {
          var tilesetNames = this._tileset.tilesetNames;
          for (var i = 0; i < tilesetNames.length; i++) {
              this._tilemap.bitmaps[i] = ImageManager.loadTileset(tilesetNames[i]);
          }
          var newTilesetFlags = $gameMap.tilesetFlags();
          this._tilemap.refreshTileset();
          if (!this._tilemap.flags.equals(newTilesetFlags)) {
              this._tilemap.refresh();
          }
          this._tilemap.flags = newTilesetFlags;
      }
  };
  
  Spriteset_Map.prototype.createCharacters = function() {
      this._characterSprites = [];
      $gameMap.events().forEach(function(event) {
          this._characterSprites.push(new Sprite_Character(event));
      }, this);
      $gameMap.vehicles().forEach(function(vehicle) {
          this._characterSprites.push(new Sprite_Character(vehicle));
      }, this);
      $gamePlayer.followers().reverseEach(function(follower) {
          this._characterSprites.push(new Sprite_Character(follower));
      }, this);
      this._characterSprites.push(new Sprite_Character($gamePlayer));
      for (var i = 0; i < this._characterSprites.length; i++) {
          this._tilemap.addChild(this._characterSprites[i]);
      }
  };
  
  Spriteset_Map.prototype.createShadow = function() {
      this._shadowSprite = new Sprite();
      this._shadowSprite.bitmap = ImageManager.loadSystem('Shadow1');
      this._shadowSprite.anchor.x = 0.5;
      this._shadowSprite.anchor.y = 1;
      this._shadowSprite.z = 6;
      this._tilemap.addChild(this._shadowSprite);
  };
  
  Spriteset_Map.prototype.createDestination = function() {
      this._destinationSprite = new Sprite_Destination();
      this._destinationSprite.z = 9;
      this._tilemap.addChild(this._destinationSprite);
  };
  
  Spriteset_Map.prototype.createWeather = function() {
      this._weather = new Weather();
      this.addChild(this._weather);
  };
  
  Spriteset_Map.prototype.updateTileset = function() {
      if (this._tileset !== $gameMap.tileset()) {
          this.loadTileset();
      }
  };
  
  /*
   * Simple fix for canvas parallax issue, destroy old parallax and readd to  the tree.
   */
  Spriteset_Map.prototype._canvasReAddParallax = function() {
      var index = this._baseSprite.children.indexOf(this._parallax);
      this._baseSprite.removeChild(this._parallax);
      this._parallax = new TilingSprite();
      this._parallax.move(0, 0, Graphics.width, Graphics.height);
      this._parallax.bitmap = ImageManager.loadParallax(this._parallaxName);
      this._baseSprite.addChildAt(this._parallax,index);
  };
  
  Spriteset_Map.prototype.updateParallax = function() {
      if (this._parallaxName !== $gameMap.parallaxName()) {
          this._parallaxName = $gameMap.parallaxName();
  
          if (this._parallax.bitmap && Graphics.isWebGL() != true) {
              this._canvasReAddParallax();
          } else {
              this._parallax.bitmap = ImageManager.loadParallax(this._parallaxName);
          }
      }
      if (this._parallax.bitmap) {
          this._parallax.origin.x = $gameMap.parallaxOx();
          this._parallax.origin.y = $gameMap.parallaxOy();
      }
  };
  
  Spriteset_Map.prototype.updateTilemap = function() {
      this._tilemap.origin.x = $gameMap.displayX() * $gameMap.tileWidth();
      this._tilemap.origin.y = $gameMap.displayY() * $gameMap.tileHeight();
  };
  
  Spriteset_Map.prototype.updateShadow = function() {
      var airship = $gameMap.airship();
      this._shadowSprite.x = airship.shadowX();
      this._shadowSprite.y = airship.shadowY();
      this._shadowSprite.opacity = airship.shadowOpacity();
  };
  
  Spriteset_Map.prototype.updateWeather = function() {
      this._weather.type = $gameScreen.weatherType();
      this._weather.power = $gameScreen.weatherPower();
      this._weather.origin.x = $gameMap.displayX() * $gameMap.tileWidth();
      this._weather.origin.y = $gameMap.displayY() * $gameMap.tileHeight();
  };
  
  //-----------------------------------------------------------------------------
  // Spriteset_Battle
  //
  // The set of sprites on the battle screen.
  
  function Spriteset_Battle() {
      this.initialize.apply(this, arguments);
  }
  
  Spriteset_Battle.prototype = Object.create(Spriteset_Base.prototype);
  Spriteset_Battle.prototype.constructor = Spriteset_Battle;
  
  Spriteset_Battle.prototype.initialize = function() {
      Spriteset_Base.prototype.initialize.call(this);
      this._battlebackLocated = false;
  };
  
  Spriteset_Battle.prototype.createLowerLayer = function() {
      Spriteset_Base.prototype.createLowerLayer.call(this);
      this.createBackground();
      this.createBattleField();
      this.createBattleback();
      this.createEnemies();
      this.createActors();
  };
  
  Spriteset_Battle.prototype.createBackground = function() {
      this._backgroundSprite = new Sprite();
      this._backgroundSprite.bitmap = SceneManager.backgroundBitmap();
      this._baseSprite.addChild(this._backgroundSprite);
  };
  
  Spriteset_Battle.prototype.update = function() {
      Spriteset_Base.prototype.update.call(this);
      this.updateActors();
      this.updateBattleback();
  };
  
  Spriteset_Battle.prototype.createBattleField = function() {
      var width = Graphics.boxWidth;
      var height = Graphics.boxHeight;
      var x = (Graphics.width - width) / 2;
      var y = (Graphics.height - height) / 2;
      this._battleField = new Sprite();
      this._battleField.setFrame(x, y, width, height);
      this._battleField.x = x;
      this._battleField.y = y;
      this._baseSprite.addChild(this._battleField);
  };
  
  Spriteset_Battle.prototype.createBattleback = function() {
      var margin = 32;
      var x = -this._battleField.x - margin;
      var y = -this._battleField.y - margin;
      var width = Graphics.width + margin * 2;
      var height = Graphics.height + margin * 2;
      this._back1Sprite = new TilingSprite();
      this._back2Sprite = new TilingSprite();
      this._back1Sprite.bitmap = this.battleback1Bitmap();
      this._back2Sprite.bitmap = this.battleback2Bitmap();
      this._back1Sprite.move(x, y, width, height);
      this._back2Sprite.move(x, y, width, height);
      this._battleField.addChild(this._back1Sprite);
      this._battleField.addChild(this._back2Sprite);
  };
  
  Spriteset_Battle.prototype.updateBattleback = function() {
      if (!this._battlebackLocated) {
          this.locateBattleback();
          this._battlebackLocated = true;
      }
  };
  
  Spriteset_Battle.prototype.locateBattleback = function() {
      var width = this._battleField.width;
      var height = this._battleField.height;
      var sprite1 = this._back1Sprite;
      var sprite2 = this._back2Sprite;
      sprite1.origin.x = sprite1.x + (sprite1.bitmap.width - width) / 2;
      sprite2.origin.x = sprite1.y + (sprite2.bitmap.width - width) / 2;
      if ($gameSystem.isSideView()) {
          sprite1.origin.y = sprite1.x + sprite1.bitmap.height - height;
          sprite2.origin.y = sprite1.y + sprite2.bitmap.height - height;
      }
  };
  
  Spriteset_Battle.prototype.battleback1Bitmap = function() {
      return ImageManager.loadBattleback1(this.battleback1Name());
  };
  
  Spriteset_Battle.prototype.battleback2Bitmap = function() {
      return ImageManager.loadBattleback2(this.battleback2Name());
  };
  
  Spriteset_Battle.prototype.battleback1Name = function() {
      if (BattleManager.isBattleTest()) {
          return $dataSystem.battleback1Name;
      } else if ($gameMap.battleback1Name()) {
          return $gameMap.battleback1Name();
      } else if ($gameMap.isOverworld()) {
          return this.overworldBattleback1Name();
      } else {
          return '';
      }
  };
  
  Spriteset_Battle.prototype.battleback2Name = function() {
      if (BattleManager.isBattleTest()) {
          return $dataSystem.battleback2Name;
      } else if ($gameMap.battleback2Name()) {
          return $gameMap.battleback2Name();
      } else if ($gameMap.isOverworld()) {
          return this.overworldBattleback2Name();
      } else {
          return '';
      }
  };
  
  Spriteset_Battle.prototype.overworldBattleback1Name = function() {
      if ($gamePlayer.isInVehicle()) {
          return this.shipBattleback1Name();
      } else {
          return this.normalBattleback1Name();
      }
  };
  
  Spriteset_Battle.prototype.overworldBattleback2Name = function() {
      if ($gamePlayer.isInVehicle()) {
          return this.shipBattleback2Name();
      } else {
          return this.normalBattleback2Name();
      }
  };
  
  Spriteset_Battle.prototype.normalBattleback1Name = function() {
      return (this.terrainBattleback1Name(this.autotileType(1)) ||
              this.terrainBattleback1Name(this.autotileType(0)) ||
              this.defaultBattleback1Name());
  };
  
  Spriteset_Battle.prototype.normalBattleback2Name = function() {
      return (this.terrainBattleback2Name(this.autotileType(1)) ||
              this.terrainBattleback2Name(this.autotileType(0)) ||
              this.defaultBattleback2Name());
  };
  
  Spriteset_Battle.prototype.terrainBattleback1Name = function(type) {
      switch (type) {
      case 24: case 25:
          return 'Wasteland';
      case 26: case 27:
          return 'DirtField';
      case 32: case 33:
          return 'Desert';
      case 34:
          return 'Lava1';
      case 35:
          return 'Lava2';
      case 40: case 41:
          return 'Snowfield';
      case 42:
          return 'Clouds';
      case 4: case 5:
          return 'PoisonSwamp';
      default:
          return null;
      }
  };
  
  Spriteset_Battle.prototype.terrainBattleback2Name = function(type) {
      switch (type) {
      case 20: case 21:
          return 'Forest';
      case 22: case 30: case 38:
          return 'Cliff';
      case 24: case 25: case 26: case 27:
          return 'Wasteland';
      case 32: case 33:
          return 'Desert';
      case 34: case 35:
          return 'Lava';
      case 40: case 41:
          return 'Snowfield';
      case 42:
          return 'Clouds';
      case 4: case 5:
          return 'PoisonSwamp';
      }
  };
  
  Spriteset_Battle.prototype.defaultBattleback1Name = function() {
      return 'Grassland';
  };
  
  Spriteset_Battle.prototype.defaultBattleback2Name = function() {
      return 'Grassland';
  };
  
  Spriteset_Battle.prototype.shipBattleback1Name = function() {
      return 'Ship';
  };
  
  Spriteset_Battle.prototype.shipBattleback2Name = function() {
      return 'Ship';
  };
  
  Spriteset_Battle.prototype.autotileType = function(z) {
      return $gameMap.autotileType($gamePlayer.x, $gamePlayer.y, z);
  };
  
  Spriteset_Battle.prototype.createEnemies = function() {
      var enemies = $gameTroop.members();
      var sprites = [];
      for (var i = 0; i < enemies.length; i++) {
          sprites[i] = new Sprite_Enemy(enemies[i]);
      }
      sprites.sort(this.compareEnemySprite.bind(this));
      for (var j = 0; j < sprites.length; j++) {
          this._battleField.addChild(sprites[j]);
      }
      this._enemySprites = sprites;
  };
  
  Spriteset_Battle.prototype.compareEnemySprite = function(a, b) {
      if (a.y !== b.y) {
          return a.y - b.y;
      } else {
          return b.spriteId - a.spriteId;
      }
  };
  
  Spriteset_Battle.prototype.createActors = function() {
      this._actorSprites = [];
      for (var i = 0; i < $gameParty.maxBattleMembers(); i++) {
          this._actorSprites[i] = new Sprite_Actor();
          this._battleField.addChild(this._actorSprites[i]);
      }
  };
  
  Spriteset_Battle.prototype.updateActors = function() {
      var members = $gameParty.battleMembers();
      for (var i = 0; i < this._actorSprites.length; i++) {
          this._actorSprites[i].setBattler(members[i]);
      }
  };
  
  Spriteset_Battle.prototype.battlerSprites = function() {
      return this._enemySprites.concat(this._actorSprites);
  };
  
  Spriteset_Battle.prototype.isAnimationPlaying = function() {
      return this.battlerSprites().some(function(sprite) {
          return sprite.isAnimationPlaying();
      });
  };
  
  Spriteset_Battle.prototype.isEffecting = function() {
      return this.battlerSprites().some(function(sprite) {
          return sprite.isEffecting();
      });
  };
  
  Spriteset_Battle.prototype.isAnyoneMoving = function() {
      return this.battlerSprites().some(function(sprite) {
          return sprite.isMoving();
      });
  };
  
  Spriteset_Battle.prototype.isBusy = function() {
      return this.isAnimationPlaying() || this.isAnyoneMoving();
  };
  