Hide MP Battle Engine Melody IV

#===============================================================================
#
# Yanfly Engine Melody - Battle Engine Melody - Part IV - Visuals
# Last Date Updated: 2010.05.01
# Level: Phantasm
#
# This section contains most of the visual aspects of Battle Engine Melody.
# Therefore, this section will include mostly sprite information, window data,
# and minor Game_Battler info and data that is used for visuals. This section
# is excluded from the core coding to allow easier access.
#
#===============================================================================
# Updates
# -----------------------------------------------------------------------------
# o 2010.02.12 to 2010.05.01 - Started and Finished Script.
#===============================================================================

module YEM
  module DEFAULT_ACTIONS

    #===========================================================================
    # Default Attack Actions
    # -------------------------------------------------------------------------
    # These are the default attack actions for your enemies and weapons if they
    # don't have any tags to overwrite their programming.
    #===========================================================================
    ATTACK_SETUP =[
      ["MESSAGE", ["COMMAND ATTACK"]],
      ["MOVE USER", ["FORWARD", "WAIT"]],
      ["EFFECT", ["USER", "WHITE FLASH"]],
    ] # Do not remove this.
    ATTACK_WHOLE =[
      ["IMMORTAL", ["TARGETS", "TRUE"]],
    ] # Do not remove this.
    ATTACK_TARGET =[
      ["MOVE USER", ["TARGET", "MIDDLE", "WAIT"]],
      ["AUTOMELODY", ["SINGLE SWING"]],
      ["AUTOMELODY", ["ATTACK FULL"]],
    ] # Do not remove this.
    ATTACK_FOLLOW =[
      ["WAIT FOR MOVE"],
      ["IMMORTAL", ["TARGETS", "FALSE"]],
    ] # Do not remove this.
    ATTACK_FINISH =[
      ["ICON DELETE", ["USER", "WEAPON"]],
      ["AUTOMELODY", ["RETURN ORIGIN"]],
      ["WAIT", [45, "SKIP"]],
    ] # Do not remove this.

    #===========================================================================
    # Default Magical Skill Actions
    # -------------------------------------------------------------------------
    # The following is the default setup for magical skills. This is applied to
    # any skill that doesn't have Physical Attack checked in the database. If
    # Physical Attack is checked, it will use a different action list setup.
    #===========================================================================
    MAGIC_SETUP =[
      ["MESSAGE", ["COMMAND SKILL"]],
      ["MOVE USER", ["FORWARD", "WAIT"]],
      ["AUTOMELODY", ["CAST ANIMATION"]],
    ] # Do not remove this.
    MAGIC_WHOLE =[
      ["IMMORTAL", ["TARGETS", "TRUE"]],
      ["AUTOMELODY", ["SKILL FULL"]],
    ] # Do not remove this.
    MAGIC_TARGET =[
    ] # Do not remove this.
    MAGIC_FOLLOW =[
      ["WAIT FOR MOVE"],
      ["IMMORTAL", ["TARGETS", "FALSE"]],
    ] # Do not remove this.
    MAGIC_FINISH =[
      ["COMMON EVENT", ["SKILL"]],
      ["AUTOMELODY", ["RETURN ORIGIN"]],
      ["WAIT", [45, "SKIP"]],
    ] # Do not remove this.

    #===========================================================================
    # Default Physical Skill Actions
    # -------------------------------------------------------------------------
    # The following is the default setup for physical skills. This is applied
    # to any skill that has Physical Attack checked in the database. If Physical
    # Attack is not checked, it will use a different action list setup.
    #===========================================================================
    PHYSICAL_SETUP =[
      ["MESSAGE", ["COMMAND SKILL"]],
      ["MOVE USER", ["FORWARD", "WAIT"]],
      ["CAST ANIMATION", ["WAIT"]],
    ] # Do not remove this.
    PHYSICAL_WHOLE =[
    ] # Do not remove this.
    PHYSICAL_TARGET =[
      ["IMMORTAL", ["TARGETS", "TRUE"]],
      ["ICON DELETE", ["USER", "WEAPON"]],
      ["MOVE USER", ["TARGET", "BODY", "WAIT"]],
      ["AUTOMELODY", ["SINGLE SWING"]],
      ["AUTOMELODY", ["SKILL FULL"]],
      ["IMMORTAL", ["TARGETS", "FALSE"]],
    ] # Do not remove this.
    PHYSICAL_FOLLOW =[
      ["WAIT FOR MOVE"],
    ] # Do not remove this.
    PHYSICAL_FINISH =[
      ["COMMON EVENT", ["SKILL"]],
      ["ICON DELETE", ["USER", "WEAPON"]],
      ["AUTOMELODY", ["RETURN ORIGIN"]],
      ["WAIT", [45, "SKIP"]],
    ] # Do not remove this.

    #===========================================================================
    # Default Item Actions
    # -------------------------------------------------------------------------
    # The following is the default setup for using items. This is applied to
    # both physical and non-physical items.
    #===========================================================================
    ITEM_SETUP =[
      ["MESSAGE", ["COMMAND ITEM"]],
      ["MOVE USER", ["FORWARD", "WAIT"]],
      ["AUTOMELODY", ["ITEM FLOAT"]],
    ] # Do not remove this.
    ITEM_WHOLE =[
      ["IMMORTAL", ["TARGETS", "TRUE"]],
      ["AUTOMELODY", ["ITEM FULL"]],
    ] # Do not remove this.
    ITEM_TARGET =[
    ] # Do not remove this.
    ITEM_FOLLOW =[
      ["WAIT FOR MOVE"],
      ["IMMORTAL", ["TARGETS", "FALSE"]],
    ] # Do not remove this.
    ITEM_FINISH =[
      ["COMMON EVENT", ["ITEM"]],
      ["AUTOMELODY", ["RETURN ORIGIN"]],
      ["WAIT", [45, "SKIP"]],
    ] # Do not remove this.

    #===========================================================================
    # Guard Mini-Actions
    # -------------------------------------------------------------------------
    # This is the action command list for guarding. These are applied to every
    # enemy and every shield's selection.
    #===========================================================================
    GUARD_ACTIONS =[
      ["MESSAGE", ["COMMAND GUARD"]],
      ["POSE", ["GUARDING"]],
      ["EFFECT", ["USER", "WHITE FLASH"]],
      ["WAIT", [45, "SKIP"]],
    ] # Do not remove this.

    #===========================================================================
    # Wait Mini-Actions
    # -------------------------------------------------------------------------
    # This is the action command when for waiting battlers. These aren't unique
    # for each weapon or item or enemy. This is universal amongst all waits.
    #===========================================================================
    WAIT_ACTIONS =[
      ["MESSAGE", ["COMMAND WAIT"]],
      ["EFFECT", ["USER", "WHITE FLASH"]],
      ["WAIT", [45, "SKIP"]],
    ] # Do not remove this.

    #===========================================================================
    # Enemy Escape Mini-Actions
    # -------------------------------------------------------------------------
    # This is only applied to enemies who can escape. These aren't unique for
    # each enemy. All escaping enemies will draw from the same action list.
    #===========================================================================
    ENEMY_ESCAPE_ACTIONS =[
      ["MESSAGE", ["COMMAND ESCAPE"]],
      ["SE", ["PLAY ESCAPE"]],
      ["TURN USER", ["BACKWARD"]],
      ["STANCE", ["USER", "RETURN"]],
      ["MOVE USER", ["BACKWARD", 32, 30]],
      ["WAIT", [30, "SKIP"]],
      ["ESCAPE EFFECT", ["USER"]],
      ["WAIT", [60, "SKIP"]],
    ] # Do not remove this.

    #===========================================================================
    # Actor Escape Mini-Actions
    # -------------------------------------------------------------------------
    # This is only applied to the party when an escape is successful. This will
    # be applied to the whole party at once, but only non-dead members will
    # visually run away.
    #===========================================================================
    ACTOR_ESCAPE_ACTIONS =[
      ["TURN PARTY", ["BACKWARD"]],
      ["STANCE", ["PARTY", "RETURN"]],
      ["MOVE PARTY", ["BACKWARD", 256, 60, "WAIT"]],
    ] # Do not remove this.

    #===========================================================================
    # Critical Mini-Actions
    # -------------------------------------------------------------------------
    # This is what will occur when a critical hit occurs. These actions aren't
    # unique per character. All critical hits will play the same action.
    #===========================================================================
    CRITICAL_ACTIONS =[
    # ["POPUP", ["TARGET", "POP_CRITICAL"]],
      ["MESSAGE", ["COMMAND CRITICAL"]],
    ] # Do not remove this.

    #===========================================================================
    # Miss Mini-Actions
    # -------------------------------------------------------------------------
    # This is what will occur when a miss event occurs. These actions aren't
    # unique per character. All miss cases will play the same action.
    #===========================================================================
    MISS_ACTIONS =[
      ["STANCE", ["TARGET", "EVADE"]],
      ["POSE", ["TARGET", "EVADE"]],
      ["POPUP", ["TARGET", "POP_MISS"]],
      ["MESSAGE", ["COMMAND MISS"]],
      ["SE", ["PLAY MISS"]],
    ] # Do not remove this.

    #===========================================================================
    # Evade Mini-Actions
    # -------------------------------------------------------------------------
    # This is what will occur when a evasion occurs. These actions aren't
    # unique per character. All evasion cases will play the same action.
    #===========================================================================
    EVADE_ACTIONS =[
      ["STANCE", ["TARGET", "EVADE"]],
      ["POSE", ["TARGET", "EVADE"]],
      ["POPUP", ["TARGET", "POP_EVADE"]],
      ["MESSAGE", ["COMMAND EVADE"]],
      ["SE", ["PLAY EVADE"]],
    ] # Do not remove this.

    #===========================================================================
    # Fail Mini-Actions
    # -------------------------------------------------------------------------
    # When skills fail or items fail, the fail actions will be called upon to
    # produce a series of actions. All fail cases will play the same action.
    #===========================================================================
    FAIL_ACTIONS =[
      ["POPUP", ["TARGET", "POP_FAIL"]],
      ["MESSAGE", ["COMMAND FAIL"]],
    ] # Do not remove this.

    #===========================================================================
    # HP Damage Mini-Actions
    # -------------------------------------------------------------------------
    # The following sets the HP damage series. These are the actions played
    # when a target takes 0 HP damage, receives healing, or the takes damage.
    # Absorption is taken into consideration for healing and damage.
    #===========================================================================
    HP_DAMAGE_NONE =[
      ["POPUP", ["TARGET", "HP_NONE"]],
      ["MESSAGE", ["COMMAND HP DAMAGE", "NONE"]],
    ] # Do not remove this.
    HP_DAMAGE_HEAL =[
      ["POPUP", ["TARGET", "HP_HEAL"]],
      ["MESSAGE", ["COMMAND HP DAMAGE", "HEAL"]],
      ["SE", ["PLAY RECOVERY"]],
    ] # Do not remove this.
    HP_DAMAGE_DMG =[
      ["STANCE", ["TARGET", "DAMAGE"]],
      ["POSE", ["TARGET", "DAMAGE"]],
      ["POPUP", ["TARGET", "HP_DMG"]],
      ["MESSAGE", ["COMMAND HP DAMAGE", "DAMAGE"]],
      ["SE", ["PLAY ACTOR DAMAGE", "if target.actor?"]],
      ["SE", ["PLAY ENEMY DAMAGE", "if target.enemy?"]],
    ] # Do not remove this.

    #===========================================================================
    # MP Damage Mini-Actions
    # -------------------------------------------------------------------------
    # The following sets the MP damage series. These are the actions played
    # when a target takes 0 MP damage, receives healing, or the takes damage.
    # Absorption is taken into consideration for healing and damage.
    #===========================================================================
    MP_DAMAGE_HEAL =[
      ["POPUP", ["TARGET", "MP_HEAL"]],
      ["MESSAGE", ["COMMAND MP DAMAGE", "HEAL"]],
      ["SE", ["PLAY RECOVERY"]],
    ] # Do not remove this.
    MP_DAMAGE_DMG =[
      ["POPUP", ["TARGET", "MP_DMG"]],
      ["MESSAGE", ["COMMAND MP DAMAGE", "DAMAGE"]],
      ["SE", ["PLAY ACTOR DAMAGE", "if target.actor?"]],
      ["SE", ["PLAY ENEMY DAMAGE", "if target.enemy?"]],
    ] # Do not remove this.

    #===========================================================================
    # State Change Mini-Actions
    # -------------------------------------------------------------------------
    # The following sets the state change series. These actions are played
    # whenever a target receives a state change through an executed action.
    #===========================================================================
    ADD_STATE =[
      ["POPUP", ["TARGET", "POP_ADDSTATE"]],
      ["MESSAGE", ["COMMAND STATES", "ADDED"]],
    ] # Do not remove this.
    REM_STATE =[
      ["POPUP", ["TARGET", "POP_REMSTATE"]],
      ["MESSAGE", ["COMMAND STATES", "REMOVE"]],
    ] # Do not remove this.
    DUR_STATE =[
      ["POPUP", ["TARGET", "POP_DURSTATE"]],
      ["MESSAGE", ["COMMAND STATES", "REMAINED"]],
    ] # Do not remove this.

  end # DEFAULT_ACTIONS
end # YEM

#===============================================================================
# Editting anything past this point may potentially result in causing computer
# damage, incontinence, explosion of user's head, coma, death, and/or halitosis.
# Therefore, edit at your own risk.
#===============================================================================

#===============================================================================
# module Icon
#===============================================================================

module Icon

  #--------------------------------------------------------------------------
  # self.element
  #--------------------------------------------------------------------------
  def self.element(element_id)
    icon = YEM::BATTLE_ENGINE::ELEMENT_ICONS[element_id]
    return (icon == nil) ? 0 : icon
  end

  #--------------------------------------------------------------------------
  # self.stat
  #--------------------------------------------------------------------------
  def self.stat(actor, item)
    limit = actor.parameter_limit
    icon = 0
    case item
    when :atk
      if actor.atk > actor.base_atk
        icon = Icon.stat_up(item)
      elsif actor.atk < actor.base_atk and actor.atk != limit
        icon = Icon.stat_dn(item)
      end

    when :def
      if actor.def > actor.base_def
        icon = Icon.stat_up(item)
      elsif actor.def < actor.base_def and actor.def != limit
        icon = Icon.stat_dn(item)
      end

    when :spi
      if actor.spi > actor.base_spi
        icon = Icon.stat_up(item)
      elsif actor.spi < actor.base_spi and actor.spi != limit
        icon = Icon.stat_dn(item)
      end

    when :res
      return icon unless $imported["RES Stat"]
      if actor.res > actor.base_res
        icon = Icon.stat_up(item)
      elsif actor.res < actor.base_res and actor.res != limit
        icon = Icon.stat_dn(item)
      end

    when :dex
      return icon unless $imported["DEX Stat"]
      if actor.dex > actor.base_dex
        icon = Icon.stat_up(item)
      elsif actor.dex < actor.base_dex and actor.dex != limit
        icon = Icon.stat_dn(item)
      end

    when :agi
      if actor.agi > actor.base_agi
        icon = Icon.stat_up(item)
      elsif actor.agi < actor.base_agi and actor.agi != limit
        icon = Icon.stat_dn(item)
      end
    end
    return icon
  end

  #--------------------------------------------------------------------------
  # self.stat_up
  #--------------------------------------------------------------------------
  def self.stat_up(item = nil)
    return YEM::BATTLE_ENGINE::STAT_ICONS[:stat_up]
  end

  #--------------------------------------------------------------------------
  # self.stat_dn
  #--------------------------------------------------------------------------
  def self.stat_dn(item = nil)
    return YEM::BATTLE_ENGINE::STAT_ICONS[:stat_dn]
  end

  #--------------------------------------------------------------------------
  # self.normal_state
  #--------------------------------------------------------------------------
  def self.normal_state
    return YEM::BATTLE_ENGINE::STAT_ICONS[:normal]
  end

  #--------------------------------------------------------------------------
  # self.mp_cost
  #--------------------------------------------------------------------------
  def self.mp_cost
    return YEM::BATTLE_ENGINE::SKILL_SETTINGS[:mp_icon]
  end

  #--------------------------------------------------------------------------
  # self.hp_cost
  #--------------------------------------------------------------------------
  def self.hp_cost
    return YEM::BATTLE_ENGINE::SKILL_SETTINGS[:hp_icon]
  end

  #--------------------------------------------------------------------------
  # self.gold_cost
  #--------------------------------------------------------------------------
  def self.gold_cost
    return YEM::BATTLE_ENGINE::SKILL_SETTINGS[:gold_icon]
  end

  #--------------------------------------------------------------------------
  # self.rage_cost
  #--------------------------------------------------------------------------
  def self.rage_cost
    return YEM::BATTLE_ENGINE::SKILL_SETTINGS[:rage_icon]
  end

  #--------------------------------------------------------------------------
  # self.cooldown
  #--------------------------------------------------------------------------
  def self.cooldown
    return YEM::BATTLE_ENGINE::SKILL_SETTINGS[:cooldown_icon]
  end

  #--------------------------------------------------------------------------
  # self.limited_use
  #--------------------------------------------------------------------------
  def self.limited_use
    return YEM::BATTLE_ENGINE::SKILL_SETTINGS[:limited_icon]
  end

end # Icon

#===============================================================================
# Game_Battler
#===============================================================================

class Game_Battler

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :battler_animation_id
  attr_accessor :battler_icon
  attr_accessor :pseudo_ani_id
  attr_accessor :popup_array
  attr_accessor :sub_animation_id
  attr_accessor :vanish_case

  #--------------------------------------------------------------------------
  # alias method: clear_sprite_effects
  #--------------------------------------------------------------------------
  alias clear_sprite_effects_bem clear_sprite_effects unless $@
  def clear_sprite_effects
    clear_sprite_effects_bem
    @pseudo_ani_id = 0
  end

  #--------------------------------------------------------------------------
  # new method: state_animation_zoom
  #--------------------------------------------------------------------------
  def state_animation_zoom; return 100; end

  #--------------------------------------------------------------------------
  # new method: reload_state_animation
  #--------------------------------------------------------------------------
  def reload_state_animation
    return unless $scene.is_a?(Scene_Battle)
    @state_animation_id = 0
    for state in states
      next unless state.state_ani > 0
      @state_animation_id = state.state_ani
      break
    end
  end

  #--------------------------------------------------------------------------
  # new method: create_popup
  #--------------------------------------------------------------------------
  def create_popup(value, rules = "DEFAULT", flags = [])
    return unless $scene.is_a?(Scene_Battle)
    if flags.include?("critical") and $scene.ptb?
      bonus = YEM::BATTLE_ENGINE::PTB_RULES[:regain_critical]
      action.opponents_unit.gain_bonus($scene.active_battler, bonus)
    end
    array = [value, rules, flags]
    @popup_array = [] if @popup_array == nil
    @popup_array.push(array)
  end

  #--------------------------------------------------------------------------
  # new method: white_flash=
  #--------------------------------------------------------------------------
  def white_flash=(value)
    return unless exist?
    @white_flash = value
  end

  #--------------------------------------------------------------------------
  # new methods: bitmap_height and bitmap_width
  #--------------------------------------------------------------------------
  def bitmap_height; return Integer(spriteset.height * zoom); end
  def bitmap_width; return Integer(spriteset.width * zoom); end

  #--------------------------------------------------------------------------
  # new method: spriteset
  #--------------------------------------------------------------------------
  def spriteset
    return $scene.spriteset.enemy_sprites.reverse[self.index]
  end

  #--------------------------------------------------------------------------
  # new method: attack_icon
  #--------------------------------------------------------------------------
  def attack_icon
    return YEM::BATTLE_ENGINE::ICON_MESSAGE[:atk_icon]
  end

  #--------------------------------------------------------------------------
  # new method: guard_icon
  #--------------------------------------------------------------------------
  def guard_icon
    return YEM::BATTLE_ENGINE::ICON_MESSAGE[:grd_icon]
  end

  #--------------------------------------------------------------------------
  # new method: sprite_movable?
  #--------------------------------------------------------------------------
  def sprite_movable?
    return false if !exist?
    return true
  end

  #--------------------------------------------------------------------------
  # new method: mirror?
  #--------------------------------------------------------------------------
  def mirror?; return false; end

  #--------------------------------------------------------------------------
  # new method: zoom
  #--------------------------------------------------------------------------
  def zoom; return 1.0; end

  #--------------------------------------------------------------------------
  # use_battler_animations?
  #--------------------------------------------------------------------------
  def use_battler_animations?; return false; end

  #--------------------------------------------------------------------------
  # battler_animation_stance
  #--------------------------------------------------------------------------
  def battler_animation_stance(string); return; end

end # Game_Battler

#===============================================================================
# Game_Actor
#===============================================================================

class Game_Actor < Game_Battler

  #--------------------------------------------------------------------------
  # quick methods: use_sprite? screen_z battler_name battler_hue
  #--------------------------------------------------------------------------
  def use_sprite?; return true; end
  def battler_name; return ""; end
  def battler_hue; return 0; end

  #--------------------------------------------------------------------------
  # alias method: atk_animation_id
  #--------------------------------------------------------------------------
  alias atk_animation_id_bem atk_animation_id unless $@
  def atk_animation_id
    return @cache_atk_animation[1] if @cache_atk_animation[1] != nil
    @cache_atk_animation[1] = atk_animation_id_bem
    for state in states
      next unless state.attack_animation > 0
      @cache_atk_animation[1] = state.attack_animation
      break
    end
    return @cache_atk_animation[1]
  end

  #--------------------------------------------------------------------------
  # alias method: atk_animation_id2
  #--------------------------------------------------------------------------
  alias atk_animation_id2_bem atk_animation_id2 unless $@
  def atk_animation_id2
    return @cache_atk_animation[2] if @cache_atk_animation[2] != nil
    @cache_atk_animation[2] = atk_animation_id2_bem
    return @cache_atk_animation[2] if @cache_atk_animation[2] == 0
    for state in states
      next unless state.attack_animation > 0
      @cache_atk_animation[2] = state.attack_animation
      break
    end
    return @cache_atk_animation[2]
  end

  #--------------------------------------------------------------------------
  # new method: state_animation_zoom
  #--------------------------------------------------------------------------
  def state_animation_zoom
    return YEM::BATTLE_ENGINE::STATE_SETTINGS[:actor_ani_zoom]
  end

  #--------------------------------------------------------------------------
  # new method: screen_x
  #--------------------------------------------------------------------------
  def screen_x
    return 0 unless $scene.is_a?(Scene_Battle)
    if $scene.emptyview? or character == nil
      calc = Graphics.width - 128 - 32
      max_members = YEM::BATTLE_ENGINE::MAXIMUM_PARTY_MEMBERS
      maximum = [$game_party.members.size, max_members].max
      calc /= maximum
      width = calc
      n = index * width + width/2 + 16
      n += 128
      n -= $scene.info_viewport.ox if $scene.info_viewport != nil
      return n
    end
    return character.screen_x
  end

  #--------------------------------------------------------------------------
  # new method: screen_x=
  #--------------------------------------------------------------------------
  def screen_x=(value); character.screen_x = value; end

  #--------------------------------------------------------------------------
  # new method: origin_x
  #--------------------------------------------------------------------------
  def origin_x
    return 0 unless $scene.is_a?(Scene_Battle)
    return screen_x if $scene.emptyview?
    return character.origin_x
  end

  #--------------------------------------------------------------------------
  # new method: screen_y
  #--------------------------------------------------------------------------
  def screen_y
    return 0 unless $scene.is_a?(Scene_Battle)
    if $scene.emptyview? or character == nil
      n = Graphics.height - 128
      return n
    end
    return character.screen_y
  end

  #--------------------------------------------------------------------------
  # new method: screen_y=
  #--------------------------------------------------------------------------
  def screen_y=(value); character.screen_y = value; end

  #--------------------------------------------------------------------------
  # new method: origin_y
  #--------------------------------------------------------------------------
  def origin_y
    return 0 unless $scene.is_a?(Scene_Battle)
    return screen_y if $scene.emptyview?
    return character.origin_y
  end

  #--------------------------------------------------------------------------
  # new method: screen_z
  #--------------------------------------------------------------------------
  def screen_z
    return 100 unless $scene.is_a?(Scene_Battle)
    return 100 if $scene.emptyview? or character == nil
    return character.screen_z + character.screen_y
  end

  #--------------------------------------------------------------------------
  # new method: screen_z=
  #--------------------------------------------------------------------------
  def screen_z=(value); character.screen_z = value; end

  #--------------------------------------------------------------------------
  # new method: spriteset
  #--------------------------------------------------------------------------
  def spriteset
    return $scene.spriteset.actor_sprites[self.index]
  end

  #--------------------------------------------------------------------------
  # new method: character
  #--------------------------------------------------------------------------
  def character
    return nil unless $scene.is_a?(Scene_Battle)
    return $scene.characters[self.index]
  end

  #--------------------------------------------------------------------------
  # new method: attack_icon
  #--------------------------------------------------------------------------
  def attack_icon
    return super if weapons.compact == []
    return weapon1_icon
  end

  #--------------------------------------------------------------------------
  # new method: guard_icon
  #--------------------------------------------------------------------------
  def guard_icon
    for armor in armors.compact
      next unless armor.kind == 0
      return armor.icon_index
    end
    return super
  end

  #--------------------------------------------------------------------------
  # new method: battler_icon
  #--------------------------------------------------------------------------
  def battler_icon
    if YEM::BATTLE_ENGINE::BATTLER_ACTOR_ICONS.include?(@actor_id)
      return YEM::BATTLE_ENGINE::BATTLER_ACTOR_ICONS[@actor_id]
    elsif YEM::BATTLE_ENGINE::BATTLER_CLASS_ICONS.include?(@class_id)
      return YEM::BATTLE_ENGINE::BATTLER_CLASS_ICONS[@class_id]
    end
    return YEM::BATTLE_ENGINE::DEFAULT_ACTOR_ICON
  end

  #--------------------------------------------------------------------------
  # new method: weapon1_icon
  #--------------------------------------------------------------------------
  def weapon1_icon
    return @cache_weapon_icon[1] if @cache_weapon_icon[1] != nil
    icon = 0
    icon = weapons[0].icon_index if weapons.compact.size > 0
    for state in states
      next unless state.weapon_icon > 0
      icon = state.weapon_icon
      break
    end
    @cache_weapon_icon[1] = icon
    return @cache_weapon_icon[1]
  end

  #--------------------------------------------------------------------------
  # new method: weapon2_icon
  #--------------------------------------------------------------------------
  def weapon2_icon
    return @cache_weapon_icon[2] if @cache_weapon_icon[2] != nil
    icon = 0
    icon = weapons[1].icon_index if weapons.compact.size > 1
    for state in states
      next unless state.weapon_icon > 0
      icon = state.weapon_icon
      break
    end
    @cache_weapon_icon[2] = icon
    return @cache_weapon_icon[2]
  end

  #--------------------------------------------------------------------------
  # use_battler_animations?
  #--------------------------------------------------------------------------
  def use_battler_animations?
    array = [@character_name, @character_index]
    return YEM::BATTLE_ENGINE::ANIMATION_BATTLER_ACTORS.include?(array)
  end

  #--------------------------------------------------------------------------
  # battler_animation_stance
  #--------------------------------------------------------------------------
  def battler_animation_stance(string)
    array = [@character_name, @character_index]
    hash = YEM::BATTLE_ENGINE::ANIMATION_BATTLER_ACTORS[array]
    return unless hash.include?(string)
    @battler_animation_id = hash[string]
  end

end # Game_Actor

#===============================================================================
# Game_Enemy
#===============================================================================

class Game_Enemy < Game_Battler

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :direction
  attr_accessor :origin_x
  attr_accessor :origin_y

  #--------------------------------------------------------------------------
  # new method: screen_x
  #--------------------------------------------------------------------------
  def screen_x
    return character == nil ? @screen_x : character.screen_x
  end

  #--------------------------------------------------------------------------
  # new method: screen_x=
  #--------------------------------------------------------------------------
  def screen_x=(value)
    @screen_x = value if character == nil
    character.screen_x = value if character != nil
  end

  #--------------------------------------------------------------------------
  # new method: screen_y
  #--------------------------------------------------------------------------
  def screen_y
    return character == nil ? @screen_y : character.screen_y
  end

  #--------------------------------------------------------------------------
  # new method: screen_y=
  #--------------------------------------------------------------------------
  def screen_y=(value)
    @screen_y = value if character == nil
    character.screen_y = value if character != nil
  end

  #--------------------------------------------------------------------------
  # alias method: screen_z
  #--------------------------------------------------------------------------
  alias screen_z_enemy screen_z unless $@
  def screen_z
    return @battle_screen_z if @battle_screen_z != nil
    return screen_z_enemy + self.screen_y
  end

  #--------------------------------------------------------------------------
  # new method: screen_z=
  #--------------------------------------------------------------------------
  def screen_z=(value)
    @battle_screen_z = value if character == nil
    character.screen_z = value if character != nil
  end

  #--------------------------------------------------------------------------
  # new method: character
  #--------------------------------------------------------------------------
  def character
    if enemy.character_name == "" or !$scene.is_a?(Scene_Battle)
      return nil
    else
      return $scene.enemychars[self]
    end
  end

  #--------------------------------------------------------------------------
  # new method: character_name
  #--------------------------------------------------------------------------
  def character_name; return enemy.character_name; end

  #--------------------------------------------------------------------------
  # new method: character_index
  #--------------------------------------------------------------------------
  def character_index; return enemy.character_index; end

  #--------------------------------------------------------------------------
  # new method: screen_z=
  #--------------------------------------------------------------------------
  def screen_z=(value); @battle_screen_z = value; end

  #--------------------------------------------------------------------------
  # new method: state_animation_zoom
  #--------------------------------------------------------------------------
  def state_animation_zoom; return enemy.state_zoom; end

  #--------------------------------------------------------------------------
  # new method: atk_animation_id
  #--------------------------------------------------------------------------
  def atk_animation_id
    return @cache_atk_animation[1] if @cache_atk_animation[1] != nil
    @cache_atk_animation[1] = enemy.attack_animation
    for state in states
      next unless state.attack_animation > 0
      @cache_atk_animation[1] = state.attack_animation
      break
    end
    return @cache_atk_animation[1]
  end

  #--------------------------------------------------------------------------
  # new method: attack_icon
  #--------------------------------------------------------------------------
  def attack_icon
    return enemy.weapons[0].icon_index if enemy.weapons.compact.size > 0
    return super
  end

  #--------------------------------------------------------------------------
  # new method: weapon1_icon
  #--------------------------------------------------------------------------
  def weapon1_icon
    return enemy.weapons[0].icon_index if enemy.weapons.compact.size > 0
    return 0
  end

  #--------------------------------------------------------------------------
  # new method: weapon2_icon
  #--------------------------------------------------------------------------
  def weapon2_icon
    return enemy.weapons[1].icon_index if enemy.weapons.compact.size > 1
    return 0
  end

  #--------------------------------------------------------------------------
  # new method: guard_icon
  #--------------------------------------------------------------------------
  def guard_icon
    return enemy.shield.icon_index if enemy.shield.icon_index != 0
    return super
  end

  #--------------------------------------------------------------------------
  # new method: battler_icon
  #--------------------------------------------------------------------------
  def battler_icon; return enemy.enemy_icon; end

  #--------------------------------------------------------------------------
  # new method: mirror?
  #--------------------------------------------------------------------------
  def mirror?
    return false unless $scene.is_a?(Scene_Battle)
    case $scene.view_type
    when 0; return enemy.view_mirror[:empty]
    when 1; return enemy.view_mirror[:front]
    when 2; return enemy.view_mirror[:side]
    when 3; return enemy.view_mirror[:angle]
    end
    return false
  end

  #--------------------------------------------------------------------------
  # new method: zoom
  #--------------------------------------------------------------------------
  def zoom
    return false unless $scene.is_a?(Scene_Battle)
    case $scene.view_type
    when 0; return enemy.view_zoom[:empty]
    when 1; return enemy.view_zoom[:front]
    when 2; return enemy.view_zoom[:side]
    when 3; return enemy.view_zoom[:angle]
    end
    return false
  end

  #--------------------------------------------------------------------------
  # use_battler_animations?
  #--------------------------------------------------------------------------
  def use_battler_animations?
    return enemy.animation_stance.include?("IDLE")
  end

  #--------------------------------------------------------------------------
  # battler_animation_stance
  #--------------------------------------------------------------------------
  def battler_animation_stance(string)
    return unless enemy.animation_stance.include?(string)
    @battler_animation_id = enemy.animation_stance[string]
  end

  #--------------------------------------------------------------------------
  # new method: sprite_movable?
  #--------------------------------------------------------------------------
  def sprite_movable?
    return false if enemy.unmoving
    return super
  end

  #--------------------------------------------------------------------------
  # new method: weapons
  #--------------------------------------------------------------------------
  def weapons; return enemy.weapons; end

  #--------------------------------------------------------------------------
  # new method: armor1_id
  #--------------------------------------------------------------------------
  def armor1_id; return enemy.shield == nil ? 0 : enemy.shield.id; end

end # Game_Enemy

#===============================================================================
# Game_Troop
#===============================================================================

class Game_Troop < Game_Unit

  #--------------------------------------------------------------------------
  # overwrite method: setup
  #--------------------------------------------------------------------------
  def setup(troop_id)
    clear
    @troop_id = troop_id
    @enemies = []
    case $game_variables[YEM::BATTLE_ENGINE::VIEW_TYPE_VARIABLE]
    when 1; type = :front
    when 2; type = :side
    when 3; type = :angle
    else    type = :empty
    end
    offsets = YEM::BATTLE_ENGINE::AUTO_POSITION_ADJUSTMENTS[type]
    offsets = [0,0,1.0,0.0,0.0,1.0] if !YEM::BATTLE_ENGINE::AUTO_ENEMY_POSITIONS
    for member in troop.members
      next if $data_enemies[member.enemy_id] == nil
      enemy = Game_Enemy.new(@enemies.size, member.enemy_id)
      enemy.hidden = member.hidden
      enemy.immortal = member.immortal
      #---
      result_x = (member.x * offsets[2]) + (member.y * offsets[4])
      result_x += offsets[0] # Offset X
      #---
      result_y = (member.x * offsets[3]) + (member.y * offsets[5])
      result_y += offsets[1] # Offset Y
      #---
      enemy.screen_x = Integer(result_x)
      enemy.screen_y = Integer(result_y)
      enemy.origin_x = enemy.screen_x
      enemy.origin_y = enemy.screen_y
      @enemies.push(enemy)
    end
    make_unique_names
  end

end # Game_Troop

#===============================================================================
# Game_Map
#===============================================================================

class Game_Map

  #--------------------------------------------------------------------------
  # alias method: loop_horizontal?
  #--------------------------------------------------------------------------
  alias loop_horizontal_bem loop_horizontal? unless $@
  def loop_horizontal?
    return false if $game_temp.in_battle
    return loop_horizontal_bem
  end

  #--------------------------------------------------------------------------
  # alias method: loop_vertical?
  #--------------------------------------------------------------------------
  alias loop_vertical_bem loop_vertical? unless $@
  def loop_vertical?
    return false if $game_temp.in_battle
    return loop_vertical_bem
  end

end # Game_Map

#===============================================================================
# Game_Character
#===============================================================================

class Game_Character

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :mirror
  attr_accessor :opacity
  attr_accessor :origin_x
  attr_accessor :origin_y
  attr_accessor :step_anime

  #--------------------------------------------------------------------------
  # alias method: screen_x
  #--------------------------------------------------------------------------
  alias screen_x_character_bem screen_x unless $@
  def screen_x
    return @battle_screen_x if @battle_screen_x != nil
    return screen_x_character_bem
  end

  #--------------------------------------------------------------------------
  # new method: screen_x=
  #--------------------------------------------------------------------------
  def screen_x=(value); @battle_screen_x = value; end

  #--------------------------------------------------------------------------
  # alias method: screen_y
  #--------------------------------------------------------------------------
  alias screen_y_character_bem screen_y unless $@
  def screen_y
    return @battle_screen_y if @battle_screen_y != nil
    return screen_y_character_bem
  end

  #--------------------------------------------------------------------------
  # new method: screen_y=
  #--------------------------------------------------------------------------
  def screen_y=(value); @battle_screen_y = value; end

  #--------------------------------------------------------------------------
  # alias method: screen_z
  #--------------------------------------------------------------------------
  alias screen_z_character_bem screen_z unless $@
  def screen_z
    return @battle_screen_z if @battle_screen_z != nil
    return screen_z_character_bem
  end

  #--------------------------------------------------------------------------
  # new method: screen_z=
  #--------------------------------------------------------------------------
  def screen_z=(value); @battle_screen_z = value; end

end # Game_Character

#===============================================================================
# Sprite_Base
#===============================================================================

class Sprite_Base < Sprite

  #--------------------------------------------------------------------------
  # constants
  #--------------------------------------------------------------------------
  RATE = $imported["CoreFixesUpgradesMelody"] ? YEM::FIXES::ANIMATION_RATE : 4
  @@sub_animations = []

  #--------------------------------------------------------------------------
  # alias method: initialize
  #--------------------------------------------------------------------------
  alias initialize_sprite_base_bem initialize unless $@
  def initialize(viewport = nil)
    initialize_sprite_base_bem(viewport)
    @no_effect = false
    @banimation_duration = 0
    @sub_animation_duration = 0
  end

  #--------------------------------------------------------------------------
  # alias method: dispose
  #--------------------------------------------------------------------------
  alias dispose_sprite_base_bem dispose unless $@
  def dispose
    dispose_sprite_base_bem
    dispose_sub_animation
  end

  #--------------------------------------------------------------------------
  # alias method: update
  #--------------------------------------------------------------------------
  alias update_sprite_base_bem update unless $@
  def update
    update_sprite_base_bem
    update_sub_animation if @sub_animation != nil
    @@sub_animations.clear
  end

  #--------------------------------------------------------------------------
  # alias method: start_animation
  #--------------------------------------------------------------------------
  alias start_animation_bem start_animation unless $@
  def start_animation(animation, mirror = false)
    @no_effect = false
    start_animation_bem(animation, mirror)
  end

  #--------------------------------------------------------------------------
  # new method: start_pseudo_ani
  #--------------------------------------------------------------------------
  def start_pseudo_ani(animation, mirror = false)
    dispose_animation
    @animation = animation
    return if @animation == nil
    @no_effect = true
    @animation_mirror = mirror
    @animation_duration = @animation.frame_max * RATE + 1
    @animation_sprites = []
  end

  #--------------------------------------------------------------------------
  # overwrite method: animation_process_timing
  #--------------------------------------------------------------------------
  def animation_process_timing(timing)
    timing.se.play unless @no_effect
    case timing.flash_scope
    when 1
      if @battler_animation == nil
        self.flash(timing.flash_color, timing.flash_duration * RATE)
      end
      battler_animation_flash(timing) if @battler_animation != nil
    when 2
      return if @no_effect
      if viewport != nil
        viewport.flash(timing.flash_color, timing.flash_duration * RATE)
      end
    when 3
      self.flash(nil, timing.flash_duration * RATE)
      battler_animation_flash(timing) if @battler_animation != nil
    end
  end

  #--------------------------------------------------------------------------
  # new method: start_sub_animation
  #--------------------------------------------------------------------------
  def start_sub_animation(animation, mirror = false)
    dispose_sub_animation
    @sub_animation = animation
    return if @sub_animation == nil
    @sub_animation_mirror = mirror
    @sub_animation_duration = @sub_animation.frame_max * RATE + 1
    load_sub_animation_bitmap
    @sub_animation_sprites = []
    if @sub_animation.position != 3 or not @@sub_animations.include?(animation)
      if @use_sprite
        for i in 0..15
          sprite = ::Sprite.new(self.viewport)
          sprite.visible = false
          @sub_animation_sprites.push(sprite)
        end
        unless @@sub_animations.include?(animation)
          @@sub_animations.push(animation)
        end
      end
    end
    if @sub_animation.position == 3
      if viewport == nil
        @sub_animation_ox = Graphics.width / 2
        @sub_animation_oy = Graphics.height / 2
      else
        @sub_animation_ox = viewport.rect.width / 2
        @sub_animation_oy = viewport.rect.height / 2
      end
    else
      @sub_animation_ox = x - ox + width / 2
      @sub_animation_oy = y - oy + height / 2
      if @sub_animation.position == 0
        @sub_animation_oy -= height / 2
      elsif @sub_animation.position == 2
        @sub_animation_oy += height / 2
      end
    end
  end

  #--------------------------------------------------------------------------
  # new method: load_sub_animation_bitmap
  #--------------------------------------------------------------------------
  def load_sub_animation_bitmap
    animation1_name = @sub_animation.animation1_name
    animation1_hue = @sub_animation.animation1_hue
    animation2_name = @sub_animation.animation2_name
    animation2_hue = @sub_animation.animation2_hue
    @sub_animation_bitmap1 = Cache.animation(animation1_name, animation1_hue)
    @sub_animation_bitmap2 = Cache.animation(animation2_name, animation2_hue)
    if @@_reference_count.include?(@sub_animation_bitmap1)
      @@_reference_count[@sub_animation_bitmap1] += 1
    else
      @@_reference_count[@sub_animation_bitmap1] = 1
    end
    if @@_reference_count.include?(@sub_animation_bitmap2)
      @@_reference_count[@sub_animation_bitmap2] += 1
    else
      @@_reference_count[@sub_animation_bitmap2] = 1
    end
    Graphics.frame_reset
  end

  #--------------------------------------------------------------------------
  # new method: dispose_sub_animation
  #--------------------------------------------------------------------------
  def dispose_sub_animation
    if @sub_animation_bitmap1 != nil
      @@_reference_count[@sub_animation_bitmap1] -= 1
      if @@_reference_count[@sub_animation_bitmap1] == 0
        @sub_animation_bitmap1.dispose
      end
    end
    if @sub_animation_bitmap2 != nil
      @@_reference_count[@sub_animation_bitmap2] -= 1
      if @@_reference_count[@sub_animation_bitmap2] == 0
        @sub_animation_bitmap2.dispose
      end
    end
    if @sub_animation_sprites != nil
      for sprite in @sub_animation_sprites
        sprite.dispose
      end
      @sub_animation_sprites = nil
      @sub_animation = nil
    end
    @sub_animation_bitmap1 = nil
    @sub_animation_bitmap2 = nil
  end

  #--------------------------------------------------------------------------
  # new method: update_sub_animation
  #--------------------------------------------------------------------------
  def update_sub_animation
    @sub_animation_duration -= 1
    return unless @sub_animation_duration % RATE == 0
    if @sub_animation_duration > 0
      frame_index = @sub_animation.frame_max
      frame_index -= (@sub_animation_duration+RATE-1)/RATE
      sub_animation_set_sprites(@sub_animation.frames[frame_index])
      for timing in @sub_animation.timings
        next unless timing.frame == frame_index
        animation_process_timing(timing)
      end
      return
    end
    dispose_sub_animation
  end

  #--------------------------------------------------------------------------
  # new method: sub_animation_set_sprites
  #--------------------------------------------------------------------------
  def sub_animation_set_sprites(frame)
    cell_data = frame.cell_data
    for i in 0..15
      sprite = @sub_animation_sprites[i]
      next if sprite == nil
      pattern = cell_data[i, 0]
      if pattern == nil or pattern == -1
        sprite.visible = false
        next
      end
      if pattern < 100
        sprite.bitmap = @sub_animation_bitmap1
      else
        sprite.bitmap = @sub_animation_bitmap2
      end
      sprite.visible = true
      sprite.src_rect.set(pattern % 5 * 192,
        pattern % 100 / 5 * 192, 192, 192)
      if @sub_animation_mirror
        sprite.x = @sub_animation_ox - cell_data[i, 1]
        sprite.y = @sub_animation_oy + cell_data[i, 2]
        sprite.angle = (360 - cell_data[i, 4])
        sprite.mirror = (cell_data[i, 5] == 0)
      else
        sprite.x = @sub_animation_ox + cell_data[i, 1]
        sprite.y = @sub_animation_oy + cell_data[i, 2]
        sprite.angle = cell_data[i, 4]
        sprite.mirror = (cell_data[i, 5] == 1)
      end
      sprite.z = self.z + 250 + i
      sprite.ox = 96
      sprite.oy = 96
      sprite.zoom_x = cell_data[i, 3] / 100.0
      sprite.zoom_y = cell_data[i, 3] / 100.0
      sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
      sprite.blend_type = cell_data[i, 7]
    end
  end

end # Sprite_Base

#===============================================================================
# Sprite_Battler
#===============================================================================

class Sprite_Battler < Sprite_Base

  #--------------------------------------------------------------------------
  # constants
  #--------------------------------------------------------------------------
  RATE = $imported["CoreFixesUpgradesMelody"] ? YEM::FIXES::ANIMATION_RATE : 4
  @@battler_animations = []
  @@state_animations = []

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :character_death_duration
  attr_accessor :character_sprite
  attr_accessor :icon_weapon1
  attr_accessor :icon_weapon2
  attr_accessor :icon_sprites
  attr_accessor :icon_shield
  attr_accessor :icon_item
  attr_accessor :icon_last
  attr_accessor :jump_duration
  attr_accessor :move_to_x
  attr_accessor :move_to_y
  attr_accessor :popups

  #--------------------------------------------------------------------------
  # alias method: initialize
  #--------------------------------------------------------------------------
  alias initialize_sprite_battler_bem initialize unless $@
  def initialize(viewport, battler = nil)
    initialize_sprite_battler_bem(viewport, battler)
    @popups = []
    @popup_flags = []
    @state_animation_duration = 0
    return if @battler == nil
    self.mirror = @battler.mirror?
    self.zoom_x = @battler.zoom
    self.zoom_y = @battler.zoom
  end

  #--------------------------------------------------------------------------
  # alias method: dispose
  #--------------------------------------------------------------------------
  alias dispose_sprite_battler_bem dispose
  def dispose
    @character_sprite.dispose if @character_sprite != nil
    dispose_popups
    dispose_sprite_battler_bem
    dispose_state_animation
    dispose_battler_animation
    return if @icon_sprites == nil
    for icon_sprite in @icon_sprites; icon_sprite.dispose; end
  end

  #--------------------------------------------------------------------------
  # alias method: update
  #--------------------------------------------------------------------------
  alias update_sprite_battler_bem update unless $@
  def update
    update_sprite_battler_bem
    update_battler_animation
    update_state_animation
    return if @battler == nil
    update_popups
    update_jump
    update_move_to
    update_character_sprite
    update_character_death
    update_icon_sprites
  end

  #--------------------------------------------------------------------------
  # alias method: setup_new_effect
  #--------------------------------------------------------------------------
  alias setup_new_effect_bem setup_new_effect unless $@
  def setup_new_effect
    start_character_death if @battler.collapse
    setup_new_effect_bem unless anti_whiten
    #---
    if @battler.vanish_case == 1
      @battler.vanish_case = nil
      @effect_type = DISAPPEAR
      @effect_duration = 32
    elsif @battler.vanish_case == 2
      @battler.vanish_case = nil
      @effect_type = APPEAR
      @effect_duration = 16
    elsif @battler.vanish_case == 3
      @battler.vanish_case = nil
      self.opacity = 0
      @battler.character.opacity = 0 if @character_sprite != nil
    elsif @battler.vanish_case == 4
      @battler.vanish_case = nil
      self.opacity = 255
      @battler.character.opacity = 255 if @character_sprite != nil
    end
    #---
    if @battler.popup_array != [] and @battler.popup_array != nil
      array = @battler.popup_array.shift
      create_popup(array[0], array[1], array[2])
    end
    #---
    if @battler.pseudo_ani_id != 0 and @battler.pseudo_ani_id != nil
      animation = $data_animations[@battler.pseudo_ani_id]
      start_pseudo_ani(animation)
      @battler.pseudo_ani_id = 0
    end
    #---
    if @battler.state_animation_id != nil
      if @battler.state_animation_id == 0
        dispose_state_animation
      else
        start_state_animation($data_animations[@battler.state_animation_id])
      end
    end
    #---
    if @battler.battler_animation_id != nil
      start_battler_animation($data_animations[@battler.battler_animation_id])
    end
    #---
    if @battler.sub_animation_id != nil
      start_sub_animation($data_animations[@battler.sub_animation_id])
      @battler.sub_animation_id = nil
    end
  end

  #--------------------------------------------------------------------------
  # alias method: update_appear
  #--------------------------------------------------------------------------
  alias update_appear_bem update_appear unless $@
  def update_appear
    update_appear_bem
    return if @character_sprite == nil
    @battler.character.opacity = (16 - @effect_duration) * 16
  end

  #--------------------------------------------------------------------------
  # alias method: update_disappear
  #--------------------------------------------------------------------------
  alias update_disappear_bem update_disappear unless $@
  def update_disappear
    update_disappear_bem
    return if @character_sprite == nil
    @battler.character.opacity = 256 - (32 - @effect_duration) * 10
  end

  #--------------------------------------------------------------------------
  # alias method: update_collapse
  #--------------------------------------------------------------------------
  alias update_collapse_bem update_collapse unless $@
  def update_collapse
    if @battler.actor?
      @effect_duration = 0
      return
    end
    update_collapse_bem
  end

  #--------------------------------------------------------------------------
  # new method: anti_whiten
  #--------------------------------------------------------------------------
  def anti_whiten
    if @battler.white_flash and @battler.state?(1)
      if @battler.collapse
        @effect_type = COLLAPSE
        @effect_duration = 48
        @battler.collapse = false
        @battler_visible = false
      end
      return true
    end
    return false
  end

  #--------------------------------------------------------------------------
  # new method: start_animation
  #--------------------------------------------------------------------------
  def start_animation(animation, mirror = false)
    if @character_sprite != nil
      @character_sprite.start_animation(animation, mirror)
      return
    end
    super(animation, mirror)
  end

  #--------------------------------------------------------------------------
  # new method: start_pseudo_ani
  #--------------------------------------------------------------------------
  def start_pseudo_ani(animation, mirror = false)
    if @character_sprite != nil
      @character_sprite.start_pseudo_ani(animation, mirror)
      return
    end
    super(animation, mirror)
  end

  #--------------------------------------------------------------------------
  # new method: start_state_animation
  #--------------------------------------------------------------------------
  def start_state_animation(animation)
    return if @state_animation != nil and @state_animation.id == animation.id
    dispose_state_animation
    @state_animation = animation
    return if @state_animation == nil
    @state_frame_index = 0
    @state_animation_mirror = false
    @state_animation_duration = @state_animation.frame_max * RATE + 1
    load_state_animation_bitmap
    @state_animation_sprites = []
    if @state_animation.position != 3 or !@@state_animations.include?(animation)
      if @use_sprite
        for i in 0..15
          sprite = ::Sprite.new(self.viewport)
          sprite.visible = false
          @state_animation_sprites.push(sprite)
        end
        unless @@state_animations.include?(animation)
          @@state_animations.push(animation)
        end
      end
    end
    if @state_animation.position == 3
      if viewport == nil
        @state_animation_ox = Graphics.width / 2
        @state_animation_oy = Graphics.width / 2
      else
        @state_animation_ox = viewport.rect.width / 2
        @state_animation_oy = viewport.rect.height / 2
      end
    else
      @state_animation_ox = x - ox + width / 2
      @state_animation_oy = y - oy + height / 2
      if @state_animation.position == 0
        @state_animation_oy -= height / 2
      elsif @state_animation.position == 2
        @state_animation_oy += height / 2
      end
    end
  end

  #--------------------------------------------------------------------------
  # new method: load_state_animation_bitmap
  #--------------------------------------------------------------------------
  def load_state_animation_bitmap
    animation1_name = @state_animation.animation1_name
    animation1_hue = @state_animation.animation1_hue
    animation2_name = @state_animation.animation2_name
    animation2_hue = @state_animation.animation2_hue
    @state_animation_bitmap1 = Cache.animation(animation1_name, animation1_hue)
    @state_animation_bitmap2 = Cache.animation(animation2_name, animation2_hue)
    if @@_reference_count.include?(@state_animation_bitmap1)
      @@_reference_count[@state_animation_bitmap1] += 1
    else
      @@_reference_count[@state_animation_bitmap1] = 1
    end
    if @@_reference_count.include?(@state_animation_bitmap2)
      @@_reference_count[@state_animation_bitmap2] += 1
    else
      @@_reference_count[@state_animation_bitmap2] = 1
    end
    Graphics.frame_reset
  end

  #--------------------------------------------------------------------------
  # new method: dispose_state_animation
  #--------------------------------------------------------------------------
  def dispose_state_animation
    if @state_animation_bitmap1 != nil
      @@_reference_count[@state_animation_bitmap1] -= 1
      if @@_reference_count[@state_animation_bitmap1] == 0
        @state_animation_bitmap1.dispose
      end
    end
    if @state_animation_bitmap2 != nil
      @@_reference_count[@state_animation_bitmap2] -= 1
      if @@_reference_count[@state_animation_bitmap2] == 0
        @state_animation_bitmap2.dispose
      end
    end
    if @state_animation_sprites != nil
      for sprite in @state_animation_sprites
        sprite.dispose
      end
      @state_animation_sprites = nil
      @state_animation = nil
    end
    @state_animation_bitmap1 = nil
    @state_animation_bitmap2 = nil
  end

  #--------------------------------------------------------------------------
  # new method: update_state_animation
  #--------------------------------------------------------------------------
  def update_state_animation
    return if @state_animation == nil
    update_state_animation_position
    @state_animation_duration -= 1
    unless @state_animation_duration % RATE == 0
      if @state_animation_duration >= 0
        @state_frame_index = @state_animation.frame_max
        @state_frame_index -= (@state_animation_duration + RATE - 1) / RATE
        for timing in @state_animation.timings
          next unless timing.frame == @state_frame_index
          state_animation_process_timing(timing)
        end
      else
        @state_frame_index = 0
        @state_animation_duration = @state_animation.frame_max * RATE
      end
    end
    return if @state_frame_index == nil
    state_animation_set_sprites(@state_animation.frames[@state_frame_index])
  end

  #--------------------------------------------------------------------------
  # new method: update_state_animation_position
  #--------------------------------------------------------------------------
  def update_state_animation_position
    if @state_animation.position == 3
      if viewport == nil
        @state_animation_ox = Graphics.width / 2
        @state_animation_oy = Graphics.width / 2
      else
        @state_animation_ox = viewport.rect.width / 2
        @state_animation_oy = viewport.rect.height / 2
      end
    else
      @state_animation_ox = x - ox + width / 2
      @state_animation_oy = y - oy + height / 2
      if @state_animation.position == 0
        @state_animation_oy -= height / 2
      elsif @state_animation.position == 2
        @state_animation_oy += height / 2
      end
    end
  end

  #--------------------------------------------------------------------------
  # new method: state_animation_set_sprites
  #--------------------------------------------------------------------------
  def state_animation_set_sprites(frame)
    return if @state_animation == nil
    return if frame == nil
    cell_data = frame.cell_data
    for i in 0..15
      sprite = @state_animation_sprites[i]
      next if sprite == nil
      pattern = cell_data[i, 0]
      if pattern == nil or pattern == -1
        sprite.visible = false
        next
      end
      if pattern < 100
        sprite.bitmap = @state_animation_bitmap1
      else
        sprite.bitmap = @state_animation_bitmap2
      end
      sprite.visible = true
      sprite.src_rect.set(pattern % 5 * 192,
      #---
      pattern % 100 / 5 * 192, 192, 192)
      sprite.x = @state_animation_ox + cell_data[i, 1]
      sprite.y = @state_animation_oy + cell_data[i, 2]
      sprite.angle = cell_data[i, 4]
      sprite.mirror = (cell_data[i, 5] == 1)
      #---
      sprite.z = self.z + 200 + i
      sprite.ox = 96
      sprite.oy = 96
      sprite.zoom_x = cell_data[i, 3] / 100.0
      sprite.zoom_y = cell_data[i, 3] / 100.0
      sprite.zoom_x *= @battler.state_animation_zoom
      sprite.zoom_x /= 100
      sprite.zoom_y *= @battler.state_animation_zoom
      sprite.zoom_y /= 100
      sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
      sprite.blend_type = cell_data[i, 7]
    end
  end

  #--------------------------------------------------------------------------
  # new method: state_animation_process_timing
  #--------------------------------------------------------------------------
  def state_animation_process_timing(timing)
    timing.se.play
    case timing.flash_scope
    when 1
      if @battler_animation == nil
        self.flash(timing.flash_color, timing.flash_duration * RATE)
      end
      return if @character_sprite == nil
      @character_sprite.flash(timing.flash_color, timing.flash_duration*RATE)
    when 2
      return if viewport == nil
      viewport.flash(timing.flash_color, timing.flash_duration * RATE)
    when 3
      self.flash(nil, timing.flash_duration * RATE)
      return if @character_sprite == nil
      @character_sprite.flash(nil, timing.flash_duration * RATE)
    end
  end

  #--------------------------------------------------------------------------
  # new method: start_battler_animation
  #--------------------------------------------------------------------------
  def start_battler_animation(animation)
    if $scene.is_a?(Scene_Battle) and $scene.emptyview? and @battler.actor?
      dispose_battler_animation
      return
    end
    return if @battler_animation != nil and
      @battler_animation.id == animation.id
    dispose_battler_animation
    @battler_animation = animation
    return if @battler_animation == nil
    @battler_ani_hash = YEM::BATTLE_ENGINE::ANIMATION_BATTLER_SETTINGS
    @battler_ani_max_cell = YEM::BATTLE_ENGINE::ANIMATION_BATTLER_MAX_CELLS
    #---
    if @battler.actor?
      @battler_animation_mirror = @battler_ani_hash[:mirror_actor]
    else
      @battler_animation_mirror = @battler_ani_hash[:mirror_enemy]
    end
    #---
    @battler_animation_duration = @battler_animation.frame_max * RATE + 1
    load_battler_animation_bitmap
    @battler_animation_sprites = []
    if @battler_animation.position != 3 or
    !@@battler_animations.include?(animation)
      if @use_sprite
        for i in 0..@battler_ani_max_cell
          sprite = ::Sprite.new(self.viewport)
          sprite.visible = false
          @battler_animation_sprites.push(sprite)
        end
        unless @@battler_animations.include?(animation)
          @@battler_animations.push(animation)
        end
      end
    end
    if @battler_animation.position == 3
      if viewport == nil
        @battler_animation_ox = Graphics.width / 2
        @battler_animation_oy = Graphics.height / 2
      else
        @battler_animation_ox = viewport.rect.width / 2
        @battler_animation_oy = viewport.rect.height / 2
      end
    else
      @battler_animation_ox = x - ox + width/2
      @battler_animation_oy = y - oy + height/2
      if @battler_animation.position == 0
        @battler_animation_oy -= height / 2
      elsif @battler_animation.position == 2
        @battler_animation_oy += height / 2
      end
    end
    @battler_frame_index = 0
  end

  #--------------------------------------------------------------------------
  # new method: load_battler_animation_bitmap
  #--------------------------------------------------------------------------
  def load_battler_animation_bitmap
    animation1_name = @battler_animation.animation1_name
    animation1_hue = @battler_animation.animation1_hue
    animation1_hue += @battler.enemy.animation_hue if @battler.enemy?
    animation2_name = @battler_animation.animation2_name
    animation2_hue = @battler_animation.animation2_hue
    animation2_hue += @battler.enemy.animation_hue if @battler.enemy?
    @battler_animation_bitmap1 = Cache.animation(animation1_name,animation1_hue)
    @battler_animation_bitmap2 = Cache.animation(animation2_name,animation2_hue)
    if @@_reference_count.include?(@battler_animation_bitmap1)
      @@_reference_count[@battler_animation_bitmap1] += 1
    else
      @@_reference_count[@battler_animation_bitmap1] = 1
    end
    if @@_reference_count.include?(@battler_animation_bitmap2)
      @@_reference_count[@battler_animation_bitmap2] += 1
    else
      @@_reference_count[@battler_animation_bitmap2] = 1
    end
    Graphics.frame_reset
  end

  #--------------------------------------------------------------------------
  # new method: dispose_battler_animation
  #--------------------------------------------------------------------------
  def dispose_battler_animation
    if @battler_animation_bitmap1 != nil
      @@_reference_count[@battler_animation_bitmap1] -= 1
      if @@_reference_count[@battler_animation_bitmap1] == 0
        @battler_animation_bitmap1.dispose
      end
    end
    if @battler_animation_bitmap2 != nil
      @@_reference_count[@battler_animation_bitmap2] -= 1
      if @@_reference_count[@battler_animation_bitmap2] == 0
        @battler_animation_bitmap2.dispose
      end
    end
    if @battler_animation_sprites != nil
      for sprite in @battler_animation_sprites
        sprite.dispose
      end
      @battler_animation_sprites = nil
      @battler_animation = nil
    end
    @battler_animation_bitmap1 = nil
    @battler_animation_bitmap2 = nil
  end

  #--------------------------------------------------------------------------
  # new method: update_battler_animation
  #--------------------------------------------------------------------------
  def update_battler_animation
    return if @battler_animation == nil
    update_battler_animation_position
    @battler_animation_duration -= 1
    unless @battler_animation_duration % RATE == 0
      if @battler_animation_duration >= 0
        @battler_frame_index = @battler_animation.frame_max
        @battler_frame_index -= (@battler_animation_duration + RATE - 1) / RATE
        for timing in @battler_animation.timings
          next unless timing.frame == @battler_frame_index
          battler_animation_process_timing(timing)
        end
      elsif @battler_animation.battler_looping
        @battler_frame_index = 0
        @battler_animation_duration = @battler_animation.frame_max * RATE
      end
    end
    return if @battler_frame_index == nil
    frame = @battler_animation.frames[@battler_frame_index]
    battler_animation_set_sprites(frame)
  end

  #--------------------------------------------------------------------------
  # new method: update_battler_animation_position
  #--------------------------------------------------------------------------
  def update_battler_animation_position
    if @battler_animation.position == 3
      if viewport == nil
        @battler_animation_ox = Graphics.width / 2
        @battler_animation_oy = Graphics.width / 2
      else
        @battler_animation_ox = viewport.rect.width / 2
        @battler_animation_oy = viewport.rect.height / 2
      end
    else
      @battler_animation_ox = x - ox + width/2
      @battler_animation_oy = y - oy + height/2
      if @battler_animation.position == 0
        @battler_animation_oy -= height / 2
      elsif @battler_animation.position == 2
        @battler_animation_oy += height / 2
      end
    end
  end

  #--------------------------------------------------------------------------
  # new method: battler_animation_set_sprites
  #--------------------------------------------------------------------------
  def battler_animation_set_sprites(frame)
    return if @battler_animation == nil
    return if frame == nil
    cell_data = frame.cell_data
    for i in 0..@battler_ani_max_cell
      sprite = @battler_animation_sprites[i]
      next if sprite == nil
      pattern = cell_data[i, 0]
      if pattern == nil or pattern == -1
        sprite.visible = false
        next
      end
      if pattern < 100
        sprite.bitmap = @battler_animation_bitmap1
      else
        sprite.bitmap = @battler_animation_bitmap2
      end
      sprite.visible = true
      sprite.src_rect.set(pattern % 5 * 192,
        pattern % 100 / 5 * 192, 192, 192)
      if @battler_animation_mirror
        sprite.x = @battler_animation_ox - cell_data[i, 1]
        sprite.y = @battler_animation_oy + cell_data[i, 2]
        sprite.angle = (360 - cell_data[i, 4])
        sprite.mirror = (cell_data[i, 5] == 0)
      else
        sprite.x = @battler_animation_ox + cell_data[i, 1]
        sprite.y = @battler_animation_oy + cell_data[i, 2]
        sprite.angle = cell_data[i, 4]
        sprite.mirror = (cell_data[i, 5] == 1)
      end
      sprite.z = self.z + 50 + i
      sprite.ox = 96
      sprite.oy = 96
      sprite.zoom_x = cell_data[i, 3] / 100.0
      sprite.zoom_y = cell_data[i, 3] / 100.0
      sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
      sprite.blend_type = cell_data[i, 7]
      #---
      sprite.color = self.color
      sprite.visible = self.visible
      sprite.update
    end
    self.flash(nil, 60 * RATE)
    return if @character_sprite == nil
    @character_sprite.flash(nil, 60 * RATE)
  end

  #--------------------------------------------------------------------------
  # new method: battler_animation_process_timing
  #--------------------------------------------------------------------------
  def battler_animation_process_timing(timing)
    timing.se.play if @battler_ani_hash[:allow_sound]
    case timing.flash_scope
    when 1
      if @battler_animation == nil
        self.flash(timing.flash_color, timing.flash_duration * RATE)
      end
      battler_animation_flash(timing)
    when 2
      return if viewport == nil
      return unless @battler_ani_hash[:allow_flash]
      viewport.flash(timing.flash_color, timing.flash_duration * RATE)
    end
  end

  #--------------------------------------------------------------------------
  # new method: battler_animation_flash
  #--------------------------------------------------------------------------
  def battler_animation_flash(timing)
    frame = @battler_animation.frames[@battler_frame_index]
    return if @battler_animation == nil
    return if frame == nil
    cell_data = frame.cell_data
    colour = (timing.flash_scope == 1) ? timing.flash_color : nil
    for i in 0..@battler_ani_max_cell
      sprite = @battler_animation_sprites[i]
      next if sprite == nil
      sprite.flash(colour, timing.flash_duration * RATE)
    end
  end

  #--------------------------------------------------------------------------
  # new method: create_popup
  #--------------------------------------------------------------------------
  def create_popup(value, rules, flags)
    return if @battler == nil
    return if flags & @popup_flags != []
    array = YEM::BATTLE_ENGINE::POPUP_RULES[rules]
    for popup in @popups
      popup.y -= array[2]*9/11
    end
    #---
    view = $scene.spriteset.viewportB
    new_popup = Sprite_Popup.new(view, @battler, value, rules, flags)
    @popups.push(new_popup)
    @popup_flags.push("weakness") if flags.include?("weakness")
    @popup_flags.push("resistant") if flags.include?("resistant")
    @popup_flags.push("immune") if flags.include?("immune")
    @popup_flags.push("absorbed") if flags.include?("absorbed")
  end

  #--------------------------------------------------------------------------
  # new method: dispose_popups
  #--------------------------------------------------------------------------
  def dispose_popups
    for popup in @popups
      @popups.delete(popup)
      popup.dispose
      popup = nil
    end
  end

  #--------------------------------------------------------------------------
  # new method: update_popups
  #--------------------------------------------------------------------------
  def update_popups
    @popups = [] if @popups == nil
    for popup in @popups
      popup.update
      next unless popup.opacity <= 0
      popup.bitmap.dispose
      popup.dispose
      @popups.delete(popup)
      popup = nil
    end
    @popup_flags = [] if @popups == [] and @popup_flags != []
    return unless $scene.is_a?(Scene_Battle)
    if @current_active_battler != $scene.active_battler
      @current_active_battler = $scene.active_battler
      @popup_flags = []
    end
  end

  #--------------------------------------------------------------------------
  # new method: create_character_dimensions
  #--------------------------------------------------------------------------
  def create_character_dimensions
    return if @character_sprite == nil
    @width  = YEM::BATTLE_ENGINE::ACTOR_ASPECTS[:width]
    @height = YEM::BATTLE_ENGINE::ACTOR_ASPECTS[:height]
    self.ox = @width/2
    self.oy = @height
  end

  #--------------------------------------------------------------------------
  # new method: update_character_sprite
  #--------------------------------------------------------------------------
  def update_character_sprite
    return if @character_sprite == nil
    if @battler.character.character_name != @battler.character_name or
    @battler.character.character_index != @battler.character_index
      char_name = @battler.character_name
      char_index = @battler.character_index
      @battler.character.set_graphic(char_name, char_index)
    end
    @character_sprite.update
    @character_sprite.z = self.z
  end

  #--------------------------------------------------------------------------
  # new method: create_move_to
  #--------------------------------------------------------------------------
  def create_move_to(destination_x, destination_y, total_frames = 60)
    return unless @battler.sprite_movable?
    den = [total_frames, 1].max
    if destination_x != nil
      @move_to_x = Integer(destination_x)
      @move_rate_x = [(@battler.screen_x - @move_to_x).abs/den, 2].max
    end
    if destination_y != nil
      @move_to_y = Integer(destination_y)
      @move_rate_y = [(@battler.screen_y - @move_to_y).abs/den, 2].max
    end
    return if @character_sprite == nil
  end

  #--------------------------------------------------------------------------
  # new method: update_move_to
  #--------------------------------------------------------------------------
  def update_move_to
    if @move_to_x != nil
      value = [(@battler.screen_x - @move_to_x).abs, @move_rate_x].min
      @battler.screen_x += (@move_to_x > @battler.screen_x) ? value : -value
      @move_to_x = nil if @battler.screen_x == @move_to_x
    end
    if @move_to_y != nil
      value = [(@battler.screen_y - @move_to_y).abs, @move_rate_y].min
      @battler.screen_y += (@move_to_y > @battler.screen_y) ? value : -value
      @move_to_y = nil if @battler.screen_y == @move_to_y
    end
  end

  #--------------------------------------------------------------------------
  # new method: face_coordinate
  #--------------------------------------------------------------------------
  def face_coordinate(destination_x, destination_y)
    if @character_sprite != nil
      @battler.character.break_pose if $imported["ExtendedMovement"]
      @battler.character.step_anime = true
      @battler.character.mirror = false
    end
    x1 = Integer(@battler.screen_x)
    x2 = Integer(destination_x)
    y1 = Graphics.height - Integer(@battler.screen_y)
    y2 = Graphics.height - Integer(destination_y)
    return if x1 == x2 and y1 == y2
    #---
    angle = Integer(Math.atan2((y2-y1),(x2-x1)) * 1800 / Math::PI)
    if (0..225) === angle or (-225..0) === angle
      direction = 6
    elsif (226..675) === angle
      direction = 9
    elsif (676..1125) === angle
      direction = 8
    elsif (1126..1575) === angle
      direction = 7
    elsif (1576..1800) === angle or (-1800..-1576) === angle
      direction = 4
    elsif (-1575..-1126) === angle
      direction = 1
    elsif (-1125..-676) === angle
      direction = 2
    elsif (-675..-226) === angle
      direction = 3
    end
    #---
    @battler.direction = direction if @battler.enemy?
    if @character_sprite != nil
      direction = $scene.spriteset.correct_direction(direction)
      @battler.character.set_direction(direction)
    end
  end

  #--------------------------------------------------------------------------
  # new method: turn_direction
  #--------------------------------------------------------------------------
  def turn_direction(direction, backward = false)
    return if @character_sprite == nil
    return unless [1,2,3,4,6,7,8,9].include?(direction)
    back_hash = {1=>9,2=>8,3=>7,4=>6,6=>4,7=>3,8=>2,9=>1}
    direction = back_hash[direction] if backward
    direction = back_hash[direction] if @battler.enemy?
    direction = $scene.spriteset.correct_direction(direction)
    @battler.character.break_pose if $imported["ExtendedMovement"]
    @battler.character.set_direction(direction)
  end

  #--------------------------------------------------------------------------
  # new method: start_character_death
  #--------------------------------------------------------------------------
  def start_character_death
    return if @character_sprite == nil
    return if @character_death_duration != nil
    @character_death_duration = 9
    @battler.character.step_anime = false
    @battler.character.mirror = false
    @battler.character.set_direction(4)
    if @battler.use_battler_animations?
      @battler.battler_animation_stance("DEAD")
      return
    end
    if $imported["ExtendedMovement"]
      @battler.character.pose = "fallen"
      @character_sprite.ox *= 2
      @character_sprite.angle = -90
      @character_sprite.update
    end
  end

  #--------------------------------------------------------------------------
  # new method: update_character_death
  #--------------------------------------------------------------------------
  def update_character_death
    return if @character_death_duration == nil
    return if @character_sprite == nil
    return if @character_death_duration == 0
    @character_sprite.angle += 10
    @character_death_duration -= 1
    return unless @character_death_duration == 0
    if $imported["ExtendedMovement"]
      @character_sprite.angle = 0
    else
      @battler.character.set_direction(8)
      @character_sprite.angle = 90
    end
  end

  #--------------------------------------------------------------------------
  # new method: revive_character_death
  #--------------------------------------------------------------------------
  def revive_character_death
    return if @character_sprite == nil
    @character_death_duration = nil
    @character_sprite.angle = 0
    @character_sprite.ox = @character_sprite.width/2
    @battler.character.break_pose if $imported["ExtendedMovement"]
    @battler.character.step_anime = true
    case $scene.view_type
    when 1; type = :front
    when 2; type = :side
    when 3; type = :angle
    else; return
    end
    direction = YEM::BATTLE_ENGINE::ACTOR_OFFSETS[type][0]
    turn_direction(direction)
    create_move_to(@battler.origin_x, @battler.origin_y, 20)
    $scene.update_battler_poses
  end

  #--------------------------------------------------------------------------
  # new method: create_icon
  #--------------------------------------------------------------------------
  def create_icon(icon, attachment)
    return if @character_sprite == nil
    @icon_sprites = [] if @icon_sprites == nil
    #---
    case icon
    when :weapon1
      return if @battler.weapons.compact.size <= 0
      dispose_icon(@icon_weapon1, icon)
      icon_index = @battler.weapon1_icon
    when :weapon2
      return if @battler.weapons.compact.size <= 1
      dispose_icon(@icon_weapon2, icon)
      icon_index = @battler.weapon2_icon
    when :shield
      return if @battler.armor1_id == 0
      dispose_icon(@icon_shield, icon)
      icon_index = @battler.guard_icon
    when :item
      return unless @battler.action.item?
      dispose_icon(@icon_item, icon)
      icon_index = @battler.action.item.icon_index
    else
      return if icon.to_i == 0
      icon_index = icon.to_i
      icon = :last
    end
    #---
    icon_sprite = Sprite_Icon.new(viewport, icon_index, @battler)
    @icon_sprites.push(icon_sprite)
    icon_sprite.set_origin(attachment)
    #---
    case icon
    when :weapon1
      @icon_weapon1 = icon_sprite
    when :weapon2
      @icon_weapon2 = icon_sprite
    when :shield
      @icon_shield = icon_sprite
    when :item
      @icon_item = icon_sprite
    end
    @icon_last = @icon_sprites[-1]
  end

  #--------------------------------------------------------------------------
  # new method: dispose_icon
  #--------------------------------------------------------------------------
  def dispose_icon(icon_sprite, type = nil)
    return if icon_sprite == nil
    icon_sprite.dispose
    case type
    when :weapon1; @icon_weapon1 = nil
    when :weapon2; @icon_weapon2 = nil
    when :shield; @icon_armour = nil
    when :item; @icon_item = nil
    end
    @icon_sprites.delete(icon_sprite)
    icon_sprite = nil
    @icon_last = @icon_sprites[-1]
  end

  #--------------------------------------------------------------------------
  # new method: update_icon_sprites
  #--------------------------------------------------------------------------
  def update_icon_sprites
    return if @icon_sprites == nil
    return unless @icon_sprites != []
    for icon_sprite in @icon_sprites; icon_sprite.update; end
  end

  #--------------------------------------------------------------------------
  # new method: clear_jump
  #--------------------------------------------------------------------------
  def clear_jump
    @jump_count = nil
    @jump_duration = nil
    @jump_peak = nil
    @jump_height = nil
  end

  #--------------------------------------------------------------------------
  # new method: create_jump
  #--------------------------------------------------------------------------
  def create_jump(height, duration)
    @jump_count = duration
    @jump_duration = duration
    @jump_peak = height
    @jump_height = 0
  end

  #--------------------------------------------------------------------------
  # new method: update_jump
  #--------------------------------------------------------------------------
  def update_jump
    return if @jump_count == nil
    @jump_duration -= 1
    if @jump_duration < 0
      clear_jump
      return
    end
    #---
    @battler.screen_y += @jump_height
    if @move_to_y != nil
      value = [(@battler.screen_y - @move_to_y).abs, @move_rate_y].min
      difference = (@move_to_y > @battler.screen_y) ? value : -value
      @battler.screen_y += difference
    end
    #---
    if @jump_duration > @jump_count*7/8
      n = @jump_height + [@jump_peak/@jump_count, 1].max * 1.50
    elsif @jump_duration > @jump_count*6/8
      n = @jump_height + [@jump_peak/@jump_count, 1].max * 1.45
    elsif @jump_duration > @jump_count*5/8
      n = @jump_height + [@jump_peak/@jump_count, 1].max * 1.30
    elsif @jump_duration > @jump_count*4/8
      n = @jump_height + [@jump_peak/@jump_count, 1].max * 1.00
    elsif @jump_duration > @jump_count*3/8
      n = @jump_height - [@jump_peak/@jump_count, 1].max * 1.00
    elsif @jump_duration > @jump_count*2/8
      n = @jump_height - [@jump_peak/@jump_count, 1].max * 1.30
    elsif @jump_duration > @jump_count*1/8
      n = @jump_height - [@jump_peak/@jump_count, 1].max * 1.45
    else
      n = @jump_height - [@jump_peak/@jump_count, 1].max * 1.50
    end
    @jump_height = [Integer(n), 0].max
    @battler.screen_y = @battler.screen_y - @jump_height
  end

end # Sprite_Battler

#===============================================================================
# Sprite_Popup
#===============================================================================

class Sprite_Popup < Sprite_Base

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :flags

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(viewport, battler, value, rules, flags)
    super(viewport)
    @value = value
    @rules = rules
    @rules = "DEFAULT" unless YEM::BATTLE_ENGINE::POPUP_RULES.include?(@rules)
    @fade = YEM::BATTLE_ENGINE::POPUP_SETTINGS[:fade]
    @full = YEM::BATTLE_ENGINE::POPUP_SETTINGS[:full]
    @flags = flags
    @battler = battler
    create_popup_bitmap
  end

  #--------------------------------------------------------------------------
  # create_popup_bitmap
  #--------------------------------------------------------------------------
  def create_popup_bitmap
    array = YEM::BATTLE_ENGINE::POPUP_RULES[@rules]
    bw = YEM::BATTLE_ENGINE::POPUP_SETTINGS[:width]
    bw += 48 if @flags.include?("state")
    size = array[2]
    size = Integer(size * 1.2) if @flags.include?("critical")
    bh = size * 2
    bitmap = Bitmap.new(bw, bh)
    bitmap.font.name = array[8]
    bitmap.font.size = size
    bitmap.font.bold = array[3]
    bitmap.font.italic = array[4]
    bitmap.font.shadow = false
    if flags.include?("critical")
      crit_rules = YEM::BATTLE_ENGINE::POPUP_RULES["CRITICAL"]
      bitmap.font.color.set(crit_rules[5], crit_rules[6], crit_rules[7])
    else
      bitmap.font.color.set(0, 0, 0)
    end
    self.bitmap = bitmap
    dx = 0; dy = 0; dw = 0
    dx += 24 if @flags.include?("state")
    dw += 24 if @flags.include?("state")
    bitmap.draw_text(dx+1, dy+1, bw-dw, bh, @value, 1)
    bitmap.draw_text(dx+1, dy-1, bw-dw, bh, @value, 1)
    bitmap.draw_text(dx-1, dy+1, bw-dw, bh, @value, 1)
    bitmap.draw_text(dx-1, dy-1, bw-dw, bh, @value, 1)
    bitmap.font.color.set(array[5], array[6], array[7])
    bitmap.draw_text(dx, dy, bw-dw, bh, @value, 1)
    if @flags.include?("state")
      c_width = bitmap.text_size(@value).width
      icon_bitmap = $game_temp.iconset
      icon_index = flag_state_icon
      rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      bitmap.blt(dx+(bw-c_width)/2-36, (bh/2-dy)/2-2, icon_bitmap, rect, 255)
    end
    self.bitmap = bitmap
    self.x = @battler.screen_x
    self.x += rand(4) - rand(4) if @battler.spriteset.popups.size >= 1
    self.x -= $scene.spriteset.viewport1.ox
    self.y = @battler.screen_y - @battler.spriteset.oy/2
    self.y += YEM::BATTLE_ENGINE::POPUP_SETTINGS[:offset] if !$scene.emptyview?
    self.y -= $scene.spriteset.viewport1.oy
    self.ox = bw/2; self.oy = bh/2
    self.zoom_x = self.zoom_y = array[0]
    if @flags.include?("no zoom")
      self.zoom_x = self.zoom_y = array[1]
    end
    @target_zoom = array[1]
    @zoom_direction = (self.zoom_x > @target_zoom) ? "down" : "up"
    self.z = 500
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    #---
    if @flags.include?("critical") and
    YEM::BATTLE_ENGINE::POPUP_SETTINGS[:flash]
      @hue_duration = 2 if @hue_duration == nil or @hue_duration == 0
      @hue_duration -= 1
      self.bitmap.hue_change(15) if @hue_duration <= 0
    end
    #---
    if @zoom_direction == "up"
      self.zoom_x = [self.zoom_x + 0.075, @target_zoom].min
      self.zoom_y = [self.zoom_y + 0.075, @target_zoom].min
    else
      self.zoom_x = [self.zoom_x - 0.075, @target_zoom].max
      self.zoom_y = [self.zoom_y - 0.075, @target_zoom].max
    end
    #---
    @full -= 1
    return if @full > 0
    self.y -= 1
    self.opacity -= @fade
  end

  #--------------------------------------------------------------------------
  # flag_state_icon
  #--------------------------------------------------------------------------
  def flag_state_icon
    for item in @flags; return item if item.is_a?(Integer); end
    return 0
  end

end # Sprite_Popup

#===============================================================================
# Sprite_OrderBattler
#===============================================================================

class Sprite_OrderBattler < Sprite_Base

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :first_time

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(viewport, battler, battle_type = 0)
    super(viewport)
    @battler = battler
    @battle_type = battle_type
    @destination = 24
    @move_rate_x = 1
    @move_rate_y = 1
    @update_wait = 0
    @hash = YEM::BATTLE_ENGINE::BATTLER_ICON_BORDERS
    @show_dead = YEM::BATTLE_ENGINE::TURNS_DEAD_BATTLERS
    @charge_icon_id = YEM::BATTLE_ENGINE::CTB_RULES[:chargeicon]
    @charge_size = Integer(YEM::BATTLE_ENGINE::CTB_RULES[:chargesize] * 24)
    create_battler_bitmap
  end

  #--------------------------------------------------------------------------
  # dispose
  #--------------------------------------------------------------------------
  def dispose
    self.bitmap.dispose if self.bitmap != nil
    super
  end

  #--------------------------------------------------------------------------
  # create_battler_bitmap
  #--------------------------------------------------------------------------
  def create_battler_bitmap
    case @battle_type
    when 0 # Default Turn Battle
      create_dtb_style
    when 1 # Press Turn Battle
      # Unused
    when 2 # Active Turn Battle
      create_atb_style
    when 3 # Press Turn Battle
      create_dtb_style
    end
  end

  #--------------------------------------------------------------------------
  # create_dtb_style
  #--------------------------------------------------------------------------
  def create_dtb_style
    bitmap = Bitmap.new(24, 24)
    icon_bitmap = Cache.system("Iconset")
    #--- Create Battler Background ---
    icon_index = @battler.actor? ? @hash[:actor][0] : @hash[:enemy][0]
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    bitmap.blt(0, 0, icon_bitmap, rect)
    #--- Create Battler Icon ---
    icon_index = @battler.battler_icon
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    temp_bitmap = Bitmap.new(24, 24)
    temp_bitmap.blt(0, 0, icon_bitmap, rect)
    temp_bitmap.hue_change(@battler.enemy.enemy_icon_hue) if @battler.enemy?
    bitmap.blt(0, 0, temp_bitmap, Rect.new(0, 0, 24, 24))
    temp_bitmap.dispose
    #--- Create Battler Border ---
    icon_index = @battler.actor? ? @hash[:actor][1] : @hash[:enemy][1]
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    bitmap.blt(0, 0, icon_bitmap, rect)
    #--- Create Battler Letter ---
    @draw_letter = draw_letter?
    @charge_icon = charge_icon?
    if @draw_letter
      bitmap.font.name = ["UmePlus Gothic", "Courier New"]
      bitmap.font.color.set(255, 255, 255)
      bitmap.font.size = 12
      bitmap.draw_text(-3, 10, 12, 12, @battler.letter.to_s, 0)
    end
    if @charge_icon
      icon_index = @charge_icon_id
      rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      dest_rect = Rect.new(0, 0, @charge_size, @charge_size)
      bitmap.stretch_blt(dest_rect, icon_bitmap, rect)
    end
    #---
    self.bitmap.dispose if self.bitmap != nil
    self.bitmap = bitmap
    return if @created_icon
    @created_icon = true
    self.ox = 12; self.oy = 12
    self.x = 24
    self.y = 24
    self.z = 8000
  end

  #--------------------------------------------------------------------------
  # create_atb_style
  #--------------------------------------------------------------------------
  def create_atb_style
    bitmap = Bitmap.new(24, 48)
    icon_bitmap = Cache.system("Iconset")
    #--- Create Battler Background ---
    icon_index = @battler.actor? ? @hash[:actor][0] : @hash[:enemy][0]
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    bitmap.blt(0, 24, icon_bitmap, rect)
    #--- Create Battler Icon ---
    icon_index = @battler.battler_icon
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    temp_bitmap = Bitmap.new(24, 24)
    temp_bitmap.blt(0, 0, icon_bitmap, rect)
    temp_bitmap.hue_change(@battler.enemy.enemy_icon_hue) if @battler.enemy?
    bitmap.blt(0, 24, temp_bitmap, Rect.new(0, 0, 24, 24))
    temp_bitmap.dispose
    #--- Create Battler Border ---
    icon_index = @battler.actor? ? @hash[:actor][1] : @hash[:enemy][1]
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    bitmap.blt(0, 24, icon_bitmap, rect)
    #--- Create Battler Letter ---
    @draw_letter = draw_letter?
    @charge_icon = charge_icon?
    if @draw_letter
      bitmap.font.name = ["UmePlus Gothic", "Courier New"]
      bitmap.font.color.set(255, 255, 255)
      bitmap.font.size = 12
      bitmap.draw_text(-3, 34, 12, 12, @battler.letter.to_s, 0)
    end
    #--- Create Battler Arrow ---
    icon_index = @battler.actor? ? @hash[:actor][5] : @hash[:enemy][5]
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    bitmap.blt(0, 0, icon_bitmap, rect)
    #---
    self.bitmap.dispose if self.bitmap != nil
    self.bitmap = bitmap
    return if @created_icon
    @created_icon = true
    self.ox = 12; self.oy = 18
    self.x = 6
    self.y = 12
    self.z = 8000 + self.x
  end

  #--------------------------------------------------------------------------
  # draw_letter?
  #--------------------------------------------------------------------------
  def draw_letter?
    return false unless @battler.enemy?
    return @battler.plural
  end

  #--------------------------------------------------------------------------
  # charge_icon?
  #--------------------------------------------------------------------------
  def charge_icon?
    return false unless $scene.is_a?(Scene_Battle)
    return false unless $scene.ctb?
    return @battler.ctb_speed_bonus < 0
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    return unless $scene.is_a?(Scene_Battle)
    if (@draw_letter != draw_letter?) or (@charge_icon != charge_icon?)
      create_battler_bitmap
    end
    #---
    case @battle_type
    when 0 # Default Turn Battle
      update_dtb_style
    when 1 # Press Turn Battle
      # No update
    when 2 # Active Turn Battle
      update_atb_style
    when 3 # Charge Turn Battle
      update_dtb_style
    end
  end

  #--------------------------------------------------------------------------
  # update_dtb_style
  #--------------------------------------------------------------------------
  def update_dtb_style
    return if @move_to_x == nil
    if @battler.hidden or (!@show_dead and @battler.dead? and
    self.opacity <= 64)
      @move_to_x = -48
      self.x = -48
      return
    end
    self.z = (@battler.dead?) ? 6000 : 8000
    @move_to_y = 24
    if self.x != @move_to_x
      self.z = (@move_to_x < self.x) ? 7500 : 8500
      @move_to_y = (@move_to_x < self.x) ? 18 : 30 if @first_time
      value = [[(@move_to_x-self.x).abs, @move_rate_x].min, 1].max
      self.x += (@move_to_x > self.x) ? value : -value
      @first_time = true if self.x == @move_to_x
    end
    #---
    if $scene.target_actor_window != nil
      @move_to_y = 12 if $scene.highlighted_targets.include?(@battler)
      @move_to_y = 12 if $scene.target_actor_window.actor == @battler
    end
    if $scene.target_enemy_window != nil
      @move_to_y = 12 if $scene.highlighted_targets.include?(@battler)
      @move_to_y = 12 if $scene.target_enemy_window.enemy == @battler
    end
    #---
    if self.y != @move_to_y
      @update_wait -= 1
      if @update_wait <= 0
        value = [[(@move_to_y-self.y).abs, @move_rate_y].min, 1].max
        self.y += (@move_to_y > self.y) ? value : -value
      end
    end
    if self.y == @move_to_y and $scene.target_enemy_window != nil
      @update_wait = 4
    end
    self.opacity += (@battler.exist?) ? 8 : -4
    self.opacity = [[self.opacity, 255].min, 0].max
  end

  #--------------------------------------------------------------------------
  # make_dtb_destination
  #--------------------------------------------------------------------------
  def make_dtb_destination
    if @battler.hidden
      self.opacity = 0
      return
    end
    array = $scene.performed_actors.reverse
    action = $scene.action_battlers.reverse - $scene.performed_actors.reverse
    array += action
    result = []
    #---
    if @show_dead
      for member in array
        next if member.hidden
        result.push(member) if member.dead?
      end
    end
    for member in array
      next if member.hidden
      result.push(member) unless member.dead?
      action.delete(member) if member.dead? and !@show_dead
    end
    #---
    index = result.index(@battler).to_i
    @move_to_x = 24 + index * 24
    if dtb_spacing?
      @move_to_x += 6 if action.include?(@battler)
      @move_to_x += 6 if (index + 1 == result.size) and action.size > 1
    end
    den = @first_time ? 12 : 24
    @move_rate_x = [(self.x - @move_to_x).abs/den, 1].max
  end

  #--------------------------------------------------------------------------
  # dtb_spacing?
  #--------------------------------------------------------------------------
  def dtb_spacing?
    return false if $scene.party_input_flag
    return true
  end

  #--------------------------------------------------------------------------
  # update_atb_style
  #--------------------------------------------------------------------------
  def update_atb_style
    if self.x >= 6 + @battler.atb_position
      self.x = [self.x-16, 6 + @battler.atb_position].max
    else
      difference = (6 + @battler.atb_position) - self.x
      value = [difference / $scene.atb_speed, 1].max
      self.x = [self.x+value, 6 + @battler.atb_position].min
    end
    self.z = 8000 + self.x
    self.opacity += @battler.exist? ? 8 : -8
  end

  #--------------------------------------------------------------------------
  # new method: make_ctb_destination
  #--------------------------------------------------------------------------
  def make_ctb_destination
    if @battler.hidden
      self.opacity = 0
      return
    end
    array = $scene.action_battlers.reverse
    result = []
    #---
    if @show_dead
      for member in array
        next if member.hidden
        next unless member.dead?
        result.push(member)
      end
    end
    for member in array
      next if member.hidden
      next if member.dead?
      next if member.movable?
      result.push(member)
    end
    for member in array
      next if member.hidden
      next if member.dead?
      next unless member.movable?
      result.push(member)
    end
    #---
    index = result.index(@battler).to_i
    @move_to_x = 24 + index * 24
    den = @first_time ? 12 : 24
    @move_rate_x = [(self.x - @move_to_x).abs/den, 1].max
  end

end # Sprite_OrderBattler

#===============================================================================
# Sprite_Icon
#===============================================================================

class Sprite_Icon < Sprite_Base

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :battler
  attr_accessor :icon
  attr_accessor :offset_x
  attr_accessor :offset_y
  attr_accessor :offset_z

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(viewport, icon, battler = nil)
    super(viewport)
    @battler = battler
    @icon = icon
    @attach_x = 0
    @attach_y = 0
    @offset_x = 0
    @offset_y = 0
    @offset_z = 0
    create_icon_bitmap
  end

  #--------------------------------------------------------------------------
  # dispose
  #--------------------------------------------------------------------------
  def dispose
    self.bitmap.dispose if self.bitmap != nil
    super
  end

  #--------------------------------------------------------------------------
  # create_icon_bitmap
  #--------------------------------------------------------------------------
  def create_icon_bitmap
    return if @icon == nil
    self.bitmap = Cache.system("Iconset")
    self.src_rect.set(@icon % 16 * 24, @icon / 16 * 24, 24, 24)
  end

  #--------------------------------------------------------------------------
  # set_origin
  #--------------------------------------------------------------------------
  def set_origin(type)
    @offset_z = 2
    @attachment = type
    case type
    when :item
      self.ox = 12
      self.oy = 12
      @offset_y = -@battler.bitmap_height
      @offset_x = -@battler.bitmap_width / 2
    when :hand1
      self.ox = 24
      self.oy = 24
      @attach_y = -@battler.bitmap_height/3
      @attach_x = -@battler.bitmap_width/5
    when :hand2
      self.ox = 24
      self.oy = 24
      @attach_y = -@battler.bitmap_height/3
      @attach_x = @battler.bitmap_width/5
    when :middle
      self.ox = 12
      self.oy = 12
      @offset_y = -@battler.bitmap_height/2
    when :top
      self.ox = 12
      self.oy = 24
      @offset_y = -@battler.bitmap_height
    when :base
      self.ox = 12
      self.oy = 24
    end
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    update_rotate
    update_opacity
    update_move
    update_position
  end

  #--------------------------------------------------------------------------
  # update_position
  #--------------------------------------------------------------------------
  def update_position
    if @battler != nil
      self.mirror = mirror_battler?
      update_attachment(self.mirror)
      attach_x = self.mirror ? -@attach_x : @attach_x
      self.x = @battler.screen_x + attach_x + @offset_x
      self.y = @battler.screen_y + @attach_y + @offset_y
      self.z = @battler.screen_z + @offset_z - 1
    else
      self.x = @offset_x
      self.y = @offset_y
      self.z = @offset_z
    end
  end

  #--------------------------------------------------------------------------
  # update_attachment
  #--------------------------------------------------------------------------
  def update_attachment(mirror = false)
    case @attachment
    when :hand1
      self.ox = mirror ? 0 : 24
      self.oy = 24
      @attach_y = -@battler.bitmap_height/3
      @attach_x = -@battler.bitmap_width/5
    when :hand2
      self.ox = mirror ? 0 : 24
      self.oy = 24
      @attach_y = -@battler.bitmap_height/3
      @attach_x = @battler.bitmap_width/5
    else
      @attach_x = 0
      @attach_y = 0
    end
  end

  #--------------------------------------------------------------------------
  # mirror_battler?
  #--------------------------------------------------------------------------
  def mirror_battler?
    return false if @battler.spriteset.character_sprite == nil
    return true if @battler.character.direction == 8
    return @battler.character.mirror
  end

  #--------------------------------------------------------------------------
  # change_angle
  #--------------------------------------------------------------------------
  def change_angle(value); self.angle = value; end

  #--------------------------------------------------------------------------
  # rotate
  #--------------------------------------------------------------------------
  def rotate(set_angle, set_speed, clockwise = false)
    @rotate_angle = set_angle
    @turn_angle = 0
    @rotate_speed = set_speed
    @clockwise = clockwise
  end

  #--------------------------------------------------------------------------
  # update_rotate
  #--------------------------------------------------------------------------
  def update_rotate
    return if @rotate_angle == nil
    clockwise = @clockwise
    clockwise = !clockwise if self.mirror
    self.angle += clockwise ? -@rotate_speed : @rotate_speed
    @turn_angle += @rotate_speed
    if @rotate_angle.is_a?(Integer) and @turn_angle >= @rotate_angle
      @rotate_angle = nil
    end
  end

  #--------------------------------------------------------------------------
  # opacity_rate
  #--------------------------------------------------------------------------
  def opacity_rate(rate); @opacity_rate = rate; end

  #--------------------------------------------------------------------------
  # update_opacity
  #--------------------------------------------------------------------------
  def update_opacity
    return if @opacity_rate == nil or @opacity_rate == 0
    self.opacity += @opacity_rate
  end

  #--------------------------------------------------------------------------
  # move_direction
  #--------------------------------------------------------------------------
  def move_direction(direction, speed, frames)
    case direction
    when 1 # Down Left
      @move_2 = @move_4 = speed
      @move_2_count  = @move_4_count  = 0
      @move_2_frames = @move_4_frames = frames
    when 2 # Down
      @move_2 = speed
      @move_2_count  = 0
      @move_2_frames = frames
    when 3 # Down Right
      @move_2 = @move_6 = speed
      @move_2_count  = @move_6_count  = 0
      @move_2_frames = @move_6_frames = frames
    when 4 # Left
      @move_4 = speed
      @move_4_count  = 0
      @move_4_frames = frames
    when 6 # Right
      @move_6 = speed
      @move_6_count  = 0
      @move_6_frames = frames
    when 7 # Up Left
      @move_8 = @move_4 = speed
      @move_8_count  = @move_4_count  = 0
      @move_8_frames = @move_4_frames = frames
    when 8 # Up
      @move_8 = speed
      @move_8_count  = 0
      @move_8_frames = frames
    when 9 # Up Right
      @move_8 = @move_6 = speed
      @move_8_count  = @move_6_count  = 0
      @move_8_frames = @move_6_frames = frames
    else; return
    end
  end

  #--------------------------------------------------------------------------
  # update_move
  #--------------------------------------------------------------------------
  def update_move
    if @move_2 != nil # Down Move
      @offset_y += @move_2
      @move_2_count += 1
      if @move_2_count >= @move_2_frames
        @move_2 = @move_2_count = @move_2_frames = nil
      end
    end
    if @move_4 != nil # Left Move
      @offset_x -= @move_4
      @move_4_count += 1
      if @move_4_count >= @move_4_frames
        @move_4 = @move_4_count = @move_4_frames = nil
      end
    end
    if @move_6 != nil # Right Move
      @offset_x += @move_6
      @move_6_count += 1
      if @move_6_count >= @move_6_frames
        @move_6 = @move_6_count = @move_6_frames = nil
      end
    end
    if @move_8 != nil # Up Move
      @offset_y -= @move_8
      @move_8_count += 1
      if @move_8_count >= @move_8_frames
        @move_8 = @move_8_count = @move_8_frames = nil
      end
    end
  end

end # Sprite_Icon

#===============================================================================
# Sprite_PTB
#===============================================================================

class Sprite_PTB < Sprite_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(viewport, dx, dy, group, index)
    super(viewport)
    self.x = dx
    self.y = dy
    self.z = 100
    @group = group
    @index = index
    create_bitmap
  end

  #--------------------------------------------------------------------------
  # create_bitmap
  #--------------------------------------------------------------------------
  def create_bitmap
    return unless @index > @group.ptb_total_turns - @group.ptb_bonus_turns
    return unless @index <= @group.ptb_total_turns
    hash = YEM::BATTLE_ENGINE::BATTLER_ICON_BORDERS
    icon_index = (@group == $game_party) ? hash[:actor][4] : hash[:enemy][4]
    bitmap = Bitmap.new(24, 24)
    icon_bitmap = Cache.system("Iconset")
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    bitmap.blt(0, 0, icon_bitmap, rect)
    self.bitmap = bitmap
    self.blend_type = 1
    self.ox = 12; self.oy = 12
    self.x += 12; self.y += 12
    @allow_update = true
    @up_glow = false
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    return unless @allow_update
    self.opacity += @up_glow ? 8 : -8
    if self.opacity <= 0
      @up_glow = true
    elsif self.opacity >= 255
      @up_glow = false
    end
  end

end # Sprite_PTB

#===============================================================================
# Sprite_BattleCursor
#===============================================================================

class Sprite_BattleCursor < Sprite

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(viewport)
    super(viewport)
    create_cursor
    self.x = Graphics.width/2
    self.y = Graphics.height/2
    self.z = 200
    self.opacity = 0
  end

  #--------------------------------------------------------------------------
  # create_cursor
  #--------------------------------------------------------------------------
  def create_cursor
    self.bitmap = Cache.system(YEM::BATTLE_ENGINE::BATTLE_CURSOR[:filename])
    self.ox = self.width / 2
    self.ox += YEM::BATTLE_ENGINE::BATTLE_CURSOR[:x_offset]
    self.oy = self.height
    self.oy += YEM::BATTLE_ENGINE::BATTLE_CURSOR[:y_offset]
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    #---
    return unless $scene.is_a?(Scene_Battle)
    update_opacity
    update_move_to
    update_follow
  end

  #--------------------------------------------------------------------------
  # update_opacity
  #--------------------------------------------------------------------------
  def update_opacity
    value = opaque? ? 16 : -16
    self.opacity += value
  end

  #--------------------------------------------------------------------------
  # opaque?
  #--------------------------------------------------------------------------
  def opaque?
    return false unless $scene.is_a?(Scene_Battle)
    return false if $scene.hide_battlecursor
    return false if @battler != nil and @battler.actor? and $scene.emptyview?
    if $scene.actor_command_window != nil
      return true if $scene.actor_command_window.active
    end
    return true if $scene.target_actor_window != nil
    return true if $scene.target_enemy_window != nil
    return false
  end

  #--------------------------------------------------------------------------
  # create_move_to
  #--------------------------------------------------------------------------
  def create_move_to
    return unless $scene.is_a?(Scene_Battle)
    if $scene.target_actor_window != nil
      @battler = $scene.target_actor_window.actor
    elsif $scene.target_enemy_window != nil
      @battler = $scene.target_enemy_window.enemy
    elsif $scene.actor_command_window.active
      @battler = $scene.actor_command_window.actor
    else
      return
    end
    return if @battler == nil
    return if @battler.actor? and $scene.emptyview?
    @move_to_x = @battler.screen_x
    @move_to_x += YEM::BATTLE_ENGINE::BATTLE_CURSOR[:actor_x] if @battler.actor?
    @move_to_x -= $scene.spriteset.viewport1.ox
    @move_to_y = @battler.screen_y - @battler.bitmap_height
    @move_to_y -= YEM::BATTLE_ENGINE::BATTLE_CURSOR[:actor_y] if @battler.actor?
    @move_to_y -= $scene.spriteset.viewport1.oy
    #---
    if @first_time
      distance_x = (@move_to_x - self.x).abs
      distance_y = (@move_to_y - self.y).abs
      @move_rate_x = [distance_x/10, 1].max
      @move_rate_y = [distance_y/10, 1].max
    else
      @first_time = true
      self.x = @move_to_x
      self.y = @move_to_y
    end
  end

  #--------------------------------------------------------------------------
  # update_move_to
  #--------------------------------------------------------------------------
  def update_move_to
    return unless $scene.is_a?(Scene_Battle)
    return if @battler == nil
    if @move_to_x != nil and @move_rate_x != nil
      value = [(self.x - @move_to_x).abs, @move_rate_x].min
      self.x += (@move_to_x > self.x) ? value : -value
      @move_to_x = nil if self.x == @move_to_x
    end
    if @move_to_y != nil and @move_rate_y != nil
      value = [(self.y - @move_to_y).abs, @move_rate_y].min
      self.y += (@move_to_y > self.y) ? value : -value
      @move_to_y = nil if self.y == @move_to_y
    end
  end

  #--------------------------------------------------------------------------
  # update_follow
  #--------------------------------------------------------------------------
  def update_follow
    return unless $scene.is_a?(Scene_Battle)
    return unless $scene.atb?
    return if @battler == nil
    require_update = false
    if @battler_x != @battler.screen_x - $scene.spriteset.viewport1.ox
      require_update = true
    elsif @battler_y != @battler.screen_y - $scene.spriteset.viewport1.oy
      require_update = true
    end
    if require_update
      @battler_x = @battler.screen_x - $scene.spriteset.viewport1.ox
      @battler_y = @battler.screen_y - $scene.spriteset.viewport1.oy
      create_move_to
    end
  end

end # Sprite_BattleCursor

#===============================================================================
# Spriteset_Battle
#===============================================================================

class Spriteset_Battle

  #--------------------------------------------------------------------------
  # public instance variable
  #--------------------------------------------------------------------------
  attr_accessor :actor_sprites
  attr_accessor :enemy_sprites
  attr_accessor :battle_cursor
  attr_accessor :battleback_sprite
  attr_accessor :camera_x
  attr_accessor :camera_y
  attr_accessor :order_sprites
  attr_accessor :ptb_update
  attr_accessor :viewport1
  attr_accessor :viewportA
  attr_accessor :viewportB
  attr_accessor :viewportC

  #--------------------------------------------------------------------------
  # overwrite method: create_viewports
  #--------------------------------------------------------------------------
  def create_viewports
    create_camera
    #---
    @viewport1 = Viewport.new(0, 0, Graphics.width, Graphics.height)
    @viewport2 = Viewport.new(0, 0, Graphics.width, Graphics.height)
    @viewport3 = Viewport.new(0, 0, Graphics.width, Graphics.height)
    @viewportA = Viewport.new(0, 0, Graphics.width, Graphics.height)
    @viewportB = Viewport.new(0, 0, Graphics.width, Graphics.height)
    @viewportC = Viewport.new(0, 0, Graphics.width, Graphics.height)
    @viewport2.z = 50
    @viewport3.z = 100
    @viewportA.z = 250
    @viewportB.z = 200
    @viewportC.z = 500
    #---
    create_order_sprites
    create_battle_cursor
  end

  #--------------------------------------------------------------------------
  # alias method: dispose_viewports
  #--------------------------------------------------------------------------
  alias dispose_viewports_spriteset_battle_bem dispose_viewports unless $@
  def dispose_viewports
    dispose_viewports_spriteset_battle_bem
    dispose_order_sprites
    dispose_battle_cursor
    @viewportA.dispose
    @viewportB.dispose
  end

  #--------------------------------------------------------------------------
  # overwrite method: update_viewports
  #--------------------------------------------------------------------------
  def update_viewports
    update_camera
    update_order_sprites
    update_ptb_call
    #---
    @viewport1.tone = $game_troop.screen.tone
    @viewport1.ox = @camera_x + $game_troop.screen.shake
    @viewport1.oy = @camera_y
    @viewport2.color = $game_troop.screen.flash_color
    @viewport3.color.set(0, 0, 0, 255 - $game_troop.screen.brightness)
    @viewport1.update
    @viewport2.update
    @viewport3.update
    #---
    if $scene.is_a?(Scene_Battle) and $scene.target_help_window != nil
      if $scene.target_help_window.active and !$scene.win_loss_flag
        @viewportA.rect.y = [@viewportA.rect.y+4, 56].min
      else
        @viewportA.rect.y = [@viewportA.rect.y-4, 0].max
      end
    end
    @viewportA.update
    @viewportB.update
    #---
    update_battle_cursor
    update_magic_circle
    update_magic_square
    update_battleback_lighting
  end

  #--------------------------------------------------------------------------
  # overwrite method: create_enemies
  #--------------------------------------------------------------------------
  def create_enemies
    dispose_enemies if @enemy_sprites != nil
    $scene.enemychars = {}
    @enemy_sprites = []
    for enemy in $game_troop.members.reverse
      if $scene.view_type == 0 or enemy.character_name == ""
        @enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy))
      else
        character = Game_Character.new
        character.set_graphic(enemy.character_name, enemy.character_index)
        character.step_anime = true
        character_sprite = Sprite_Character.new(@viewport1, character)
        create_enemy_coordinates(character, enemy)
        battler_sprite = Sprite_Battler.new(@viewport1, enemy)
        battler_sprite.character_sprite = character_sprite
        @enemy_sprites.push(battler_sprite)
        @enemy_sprites[@enemy_sprites.size-1].create_character_dimensions
        $scene.enemychars[enemy] = character
        if enemy.dead?
          battler_sprite.start_character_death
          battler_sprite.character_death_duration = 1
          battler_sprite.update_character_death
        end
      end
    end
  end

  #--------------------------------------------------------------------------
  # new method: create_enemy_coordinates
  #--------------------------------------------------------------------------
  def create_enemy_coordinates(character, enemy)
    character.origin_x = enemy.origin_x
    character.origin_y = enemy.origin_y
    case $scene.view_type
    when 1; array = YEM::BATTLE_ENGINE::ACTOR_OFFSETS[:front]
    when 2; array = YEM::BATTLE_ENGINE::ACTOR_OFFSETS[:side]
    when 3; array = YEM::BATTLE_ENGINE::ACTOR_OFFSETS[:angle]
    end
    back_hash = {1=>9,2=>8,3=>7,4=>6,6=>4,7=>3,8=>2,9=>1}
    backdir = back_hash[array[0]]
    direction = correct_direction(backdir)
    character.set_direction(direction)
    character.screen_x = character.origin_x
    character.screen_y = character.origin_y
    character.screen_z = 200
  end

  #--------------------------------------------------------------------------
  # overwrite method: create_actors
  #--------------------------------------------------------------------------
  def create_actors
    dispose_actors if @actor_sprites != nil
    $scene.characters = {}
    @actor_sprites = []
    unless [1, 2, 3].include?($scene.view_type)
      for member in $game_party.members
        @actor_sprites.push(Sprite_Battler.new(@viewport1, member))
      end
      return
    end
    for actor in $game_party.members
      character = Game_Character.new
      character.set_graphic(actor.character_name, actor.character_index)
      character.step_anime = true
      character_sprite = Sprite_Character.new(@viewport1, character)
      create_actor_coordinates(character, actor)
      battler_sprite = Sprite_Battler.new(@viewport1, actor)
      battler_sprite.character_sprite = character_sprite
      @actor_sprites.push(battler_sprite)
      @actor_sprites[@actor_sprites.size-1].create_character_dimensions
      $scene.characters[actor.index] = character
      if actor.dead?
        battler_sprite.start_character_death
        battler_sprite.character_death_duration = 1
        battler_sprite.update_character_death
      end
    end
  end

  #--------------------------------------------------------------------------
  # new method: create_actor_coordinates
  #--------------------------------------------------------------------------
  def create_actor_coordinates(character, actor)
    index = actor.index
    index = 0 unless YEM::BATTLE_ENGINE::ACTOR_COORDINATES.include?(index)
    array = YEM::BATTLE_ENGINE::ACTOR_COORDINATES[index][$scene.view_type]
    character.origin_x = array[0]
    character.origin_y = array[1]
    case $scene.view_type
    when 1; array = YEM::BATTLE_ENGINE::ACTOR_OFFSETS[:front]
    when 2; array = YEM::BATTLE_ENGINE::ACTOR_OFFSETS[:side]
    when 3; array = YEM::BATTLE_ENGINE::ACTOR_OFFSETS[:angle]
    end
    direction = correct_direction(array[0])
    character.set_direction(direction)
    case actor.class.position
    when 0
      character.origin_x += array[1]
      character.origin_y += array[2]
    when 1
      character.origin_x += array[3]
      character.origin_y += array[4]
    when 2
      character.origin_x += array[5]
      character.origin_y += array[6]
    end
    character.screen_x = character.origin_x
    character.screen_y = character.origin_y
    character.screen_z = 200
  end

  #--------------------------------------------------------------------------
  # new method: correct_direction
  #--------------------------------------------------------------------------
  def correct_direction(direction)
    return direction if $imported["ExtendedMovement"]
    correction ={ 1=>2, 2=>2, 3=>6, 4=>4, 6=>6, 7=>4, 8=>8, 9=>8 }
    return correction[direction]
  end

  #--------------------------------------------------------------------------
  # alias method: update_enemies
  #--------------------------------------------------------------------------
  alias update_enemies_bem update_enemies unless $@
  def update_enemies
    return unless $scene.is_a?(Scene_Battle)
    update_enemies_bem
    for key in $scene.enemychars
      character = key[1]
      character.update
    end
  end

  #--------------------------------------------------------------------------
  # overwrite method: update_actors
  #--------------------------------------------------------------------------
  def update_actors
    return unless $scene.is_a?(Scene_Battle)
    for sprite in @actor_sprites
      sprite.update
    end
    for key in $scene.characters
      character = key[1]
      character.update
    end
  end

  #--------------------------------------------------------------------------
  # overwrite method: animation?
  #--------------------------------------------------------------------------
  def animation?
    for sprite in @enemy_sprites + @actor_sprites
      return true if sprite.animation?
      next if sprite.character_sprite == nil
      return true if sprite.character_sprite.animation?
    end
    return false
  end

  #--------------------------------------------------------------------------
  # new method: create_camera
  #--------------------------------------------------------------------------
  def create_camera
    @camera_x = 0
    @camera_y = 0
    @camera_to_x = 0
    @camera_to_y = 0
    @camera_to_x_rate = 4
    @camera_to_y_rate = 4
  end

  #--------------------------------------------------------------------------
  # new method: update_camera
  #--------------------------------------------------------------------------
  def update_camera
    if @camera_x != @camera_to_x
      value = [[(@camera_to_x-@camera_x).abs, @camera_to_x_rate].min, 1].max
      @camera_x += (@camera_to_x > @camera_x) ? value : -value
    end
    if @camera_y != @camera_to_y
      value = [[(@camera_to_y-@camera_y).abs, @camera_to_y_rate].min, 1].max
      @camera_y += (@camera_to_y > @camera_y) ? value : -value
    end
  end

  #--------------------------------------------------------------------------
  # new method: set_camera_desintation
  #--------------------------------------------------------------------------
  def set_camera_destination(to_x, to_y, frames = 60)
    @camera_to_x = to_x
    @camera_to_y = to_y
    @camera_to_x_rate = [(@camera_to_x-@camera_x).abs/[frames, 1].max, 1].max
    @camera_to_y_rate = [(@camera_to_y-@camera_y).abs/[frames, 1].max, 1].max
  end

  #--------------------------------------------------------------------------
  # new method: scroll_camera
  #--------------------------------------------------------------------------
  def scroll_camera(direction, distance, frames = 60)
    to_x = @camera_to_x
    to_y = @camera_to_y
    case direction
    when 1 # Down Left
      to_x += distance
      to_y -= distance
    when 2 # Down
      to_y -= distance
    when 3 # Down Right
      to_x -= distance
      to_y -= distance
    when 4 # Left
      to_x -= distance
    when 6 # Right
      to_x += distance
    when 7 # Up Left
      to_x -= distance
      to_y += distance
    when 8 # Up
      to_y += distance
    when 9 # Up Right
      to_x += distance
      to_y += distance
    end
    set_camera_destination(to_x, to_y, frames)
  end

  #--------------------------------------------------------------------------
  # new method: create_order_sprites
  #--------------------------------------------------------------------------
  def create_order_sprites
    case $scene.battle_type
    when 0 # Default Turn Battle
      create_dtb_sprites
    when 1 # Press Turn Battle
      # none, reset in battle
    when 2 # Active Turn Battle
      create_atb_sprites
    when 3 # Charge Turn Battle
      create_ctb_sprites
    end
  end

  #--------------------------------------------------------------------------
  # new method: update_order_sprites
  #--------------------------------------------------------------------------
  def update_order_sprites
    return if @order_sprites == nil
    for sprite in @order_sprites
      sprite.update
    end
  end

  #--------------------------------------------------------------------------
  # new method: dispose_order_sprites
  #--------------------------------------------------------------------------
  def dispose_order_sprites
    return if @order_sprites == nil
    for sprite in @order_sprites
      sprite.dispose
      sprite = nil
    end
    @order_sprites = nil
  end

  #--------------------------------------------------------------------------
  # new method: create_dtb_sprites
  #--------------------------------------------------------------------------
  def create_dtb_sprites
    dispose_order_sprites
    @order_sprites = []
    array = $game_party.members + $game_troop.members
    for member in array.reverse
      sprite = Sprite_OrderBattler.new(@viewportA, member, 0)
      @order_sprites.push(sprite)
    end
  end

  #--------------------------------------------------------------------------
  # new method: update_dtb_order
  #--------------------------------------------------------------------------
  def update_dtb_order
    return unless $scene.dtb?
    return if @order_sprites == nil
    for sprite in @order_sprites
      sprite.make_dtb_destination
    end
  end

  #--------------------------------------------------------------------------
  # new method: update_ptb_call
  #--------------------------------------------------------------------------
  def update_ptb_call
    return if @ptb_update == nil
    refresh_ptb_counters(@ptb_update)
  end

  #--------------------------------------------------------------------------
  # new method: refresh_ptb_counters
  #--------------------------------------------------------------------------
  def refresh_ptb_counters(group)
    @ptb_update = nil
    dispose_order_sprites
    @order_sprites = []
    amount = group.ptb_total_turns
    index = 1; dx = 12; dy = 6
    amount.times do
      sprite = Sprite_PTB.new(@viewportA, dx, dy, group, index)
      @order_sprites.push(sprite)
      index += 1
      dx += 24
      dy = (dy == 6) ? 18 : 6
    end
  end

  #--------------------------------------------------------------------------
  # create_atb_sprites
  #--------------------------------------------------------------------------
  def create_atb_sprites
    dispose_order_sprites
    @order_sprites = []
    create_atb_gauge
    array = $game_party.members + $game_troop.members
    for member in array.reverse
      sprite = Sprite_OrderBattler.new(@viewportA, member, 2)
      @order_sprites.push(sprite)
    end
  end

  #--------------------------------------------------------------------------
  # create_atb_gauge
  #--------------------------------------------------------------------------
  def create_atb_gauge
    sprite = Sprite_Base.new(@viewportA)
    bitmap = Cache.system(YEM::BATTLE_ENGINE::ATB_GAUGE)
    sprite.bitmap = bitmap
    sprite.x = 5
    sprite.y = 5
    @order_sprites.push(sprite)
  end

  #--------------------------------------------------------------------------
  # new method: create_ctb_sprites
  #--------------------------------------------------------------------------
  def create_ctb_sprites
    dispose_order_sprites
    @order_sprites = []
    array = $game_party.members + $game_troop.members
    for member in array.reverse
      sprite = Sprite_OrderBattler.new(@viewportA, member, 3)
      @order_sprites.push(sprite)
    end
  end

  #--------------------------------------------------------------------------
  # new method: update_ctb_order
  #--------------------------------------------------------------------------
  def update_ctb_order
    return unless $scene.is_a?(Scene_Battle)
    return unless $scene.ctb?
    return if @order_sprites == nil
    for sprite in @order_sprites
      sprite.make_ctb_destination
    end
  end

  #--------------------------------------------------------------------------
  # new method: mark_first_time_order
  #--------------------------------------------------------------------------
  def mark_first_time_order
    return unless $scene.is_a?(Scene_Battle)
    return if @marked_first_time
    @marked_first_time = true
    return if $scene.ptb?
    return if @order_sprites == nil
    for sprite in @order_sprites
      sprite.first_time = true
    end
  end

  #--------------------------------------------------------------------------
  # new method: create_battle_cursor
  #--------------------------------------------------------------------------
  def create_battle_cursor
    return unless YEM::BATTLE_ENGINE::BATTLE_CURSOR[:enable]
    @battle_cursor = Sprite_BattleCursor.new(@viewportB)
  end

  #--------------------------------------------------------------------------
  # new method: update_battle_cursor
  #--------------------------------------------------------------------------
  def update_battle_cursor
    return if @battle_cursor == nil
    @battle_cursor.update
  end

  #--------------------------------------------------------------------------
  # new method: dispose_battle_cursor
  #--------------------------------------------------------------------------
  def dispose_battle_cursor
    return if @battle_cursor == nil
    @battle_cursor.dispose
  end

  #--------------------------------------------------------------------------
  # new method: create_magic_circle
  #--------------------------------------------------------------------------
  def create_magic_circle(window, obj)
    if obj.is_a?(RPG::Skill) or obj.is_a?(RPG::Item)
      return if obj.aoe_radius <= 0
    else; return
    end
    #---
    @aoe_window = window
    @magic_circle_sprite = Sprite.new(@viewport1)
    @magic_circle_sprite.bitmap = Cache.picture(obj.aoe_image)
    diameter = obj.aoe_radius * 2 + 1
    @magic_circle_sprite.blend_type = obj.aoe_blend
    @magic_circle_sprite.zoom_x = diameter * 1.125 /
      @magic_circle_sprite.width
    @magic_circle_sprite.zoom_y = @magic_circle_sprite.zoom_x *
      (obj.aoe_height + 0.01)
    @magic_circle_sprite.ox = @magic_circle_sprite.width/2
    @magic_circle_sprite.oy = @magic_circle_sprite.height/2
    @magic_circle_sprite.z = 2
  end

  #--------------------------------------------------------------------------
  # new method: dispose_magic_circle
  #--------------------------------------------------------------------------
  def dispose_magic_circle
    @magic_circle_sprite.dispose if @magic_circle_sprite != nil
    @magic_circle_sprite = nil
    @aoe_window = nil
  end

  #--------------------------------------------------------------------------
  # new method: update_magic_circle
  #--------------------------------------------------------------------------
  def update_magic_circle
    return if @magic_circle_sprite == nil
    if @aoe_window != nil
      if @aoe_window.is_a?(Window_TargetEnemy)
        target = @aoe_window.enemy
        group = $game_troop
        value_x = target.screen_x + target.enemy.target_offset_x
        value_y = target.screen_y + target.enemy.target_offset_y
      elsif @aoe_window.is_a?(Window_BattleStatus)
        target = @aoe_window.actor
        group = $game_party
        value_x = target.screen_x
        value_y = target.screen_y
      end
      #---
      update_highlight = false
      if @magic_circle_sprite.x != value_x
        update_highlight = true
        @magic_circle_sprite.x = value_x
      end
      if @magic_circle_sprite.y != value_y
        update_highlight = true
        @magic_circle_sprite.y = value_y
      end
      $scene.create_highlighted_targets(group) if update_highlight
      #---
    end
    @magic_circle_sprite.opacity += @magic_circle_sprite_upward ? 8 : -8
    if @magic_circle_sprite.opacity <= 0
      @magic_circle_sprite_upward = true
    elsif @magic_circle_sprite.opacity >= 255
      @magic_circle_sprite_upward = false
    end
  end

  #--------------------------------------------------------------------------
  # new method: create_magic_square
  #--------------------------------------------------------------------------
  def create_magic_square(window, obj)
    if obj.is_a?(RPG::Skill) or obj.is_a?(RPG::Item)
      return if obj.rect_type <= 0
    else; return
    end
    @aoe_window = window
    @magic_square_sprite = Sprite.new(@viewport1)
    @magic_square_sprite.bitmap = Cache.picture(obj.rect_image)
    @magic_square_sprite.blend_type = obj.rect_blend
    @magic_square_type = obj.rect_type
    rect_value = obj.rect_value * 2 + 1
    case @magic_square_type
    when 1 # Column
      @magic_square_sprite.zoom_x = rect_value * 1.0 /
        @magic_square_sprite.width
      @magic_square_sprite.zoom_y = Graphics.height * 1.0 /
        @magic_square_sprite.height
      @magic_square_sprite.ox = @magic_square_sprite.width/2
    when 2 # Row
      @magic_square_sprite.zoom_x = Graphics.width * 1.0 /
        @magic_square_sprite.width
      @magic_square_sprite.zoom_y = rect_value * 1.0 /
        @magic_square_sprite.height
      @magic_square_sprite.oy = @magic_square_sprite.height/2
    when 3 # Map
      @magic_square_sprite.zoom_x = Graphics.width * 1.0 /
        @magic_square_sprite.width
      @magic_square_sprite.zoom_y = Graphics.height * 1.0 /
        @magic_square_sprite.height
    end
    @magic_square_sprite.z = 3
  end

  #--------------------------------------------------------------------------
  # new method: dispose_magic_square
  #--------------------------------------------------------------------------
  def dispose_magic_square
    @magic_square_sprite.dispose if @magic_square_sprite != nil
    @magic_square_sprite = nil
    @aoe_window = nil
  end

  #--------------------------------------------------------------------------
  # new method: update_magic_square
  #--------------------------------------------------------------------------
  def update_magic_square
    return if @magic_square_sprite == nil
    if @aoe_window != nil
      if @aoe_window.is_a?(Window_TargetEnemy)
        group = $game_troop
        target = @aoe_window.enemy
        case @magic_square_type
        when 1 # Column
          value_x = target.screen_x
          value_x += target.enemy.target_offset_x
          value_y = 0
        when 2 # Row
          value_x = 0
          value_y = target.screen_y
          value_y += target.enemy.target_offset_y
        when 3 # Map
          value_x = 0
          value_y = 0
        end
      elsif @aoe_window.is_a?(Window_BattleStatus)
        group = $game_party
        target = @aoe_window.actor
        case @magic_square_type
        when 1 # Column
          value_x = target.screen_x
          value_y = 0
        when 2 # Row
          value_x = 0
          value_y = target.screen_y
        when 3 # Map
          value_x = 0
          value_y = 0
        end
      end
      #---
      update_highlight = false
      if @magic_square_sprite.x != value_x
        update_highlight = true
        @magic_square_sprite.x = value_x
      end
      if @magic_square_sprite.y != value_y
        update_highlight = true
        @magic_square_sprite.y = value_y
      end
      $scene.create_highlighted_targets(group) if update_highlight
      #---
    end
    @magic_square_sprite.opacity += @magic_square_sprite_upward ? 8 : -8
    if @magic_square_sprite.opacity <= 0
      @magic_square_sprite_upward = true
    elsif @magic_square_sprite.opacity >= 255
      @magic_square_sprite_upward = false
    end
  end

  #--------------------------------------------------------------------------
  # new method: start_battleback_darken
  #--------------------------------------------------------------------------
  def start_battleback_darken
    @battleback_darken_duration = 32
    @battleback_sprite.color.set(0,0,0,0)
  end

  #--------------------------------------------------------------------------
  # new method: start_battleback_lighten
  #--------------------------------------------------------------------------
  def start_battleback_lighten
    @battleback_lighten_duration = 16
    @battleback_sprite.color.set(0,0,0,128)
  end

  #--------------------------------------------------------------------------
  # new method: update_battleback_lighting
  #--------------------------------------------------------------------------
  def update_battleback_lighting
    if @battleback_darken_duration != nil
      @battleback_darken_duration -= 1
      duration = @battleback_darken_duration
      @battleback_sprite.color.alpha += 4
      @battleback_darken_duration = nil if @battleback_darken_duration <= 0
      return
    end
    if @battleback_lighten_duration != nil
      @battleback_lighten_duration -= 1
      @battleback_sprite.color.alpha -= 8
      @battleback_lighten_duration = nil if @battleback_lighten_duration <= 0
    end
  end

end # Spriteset_Battle

#==============================================================================
# Window_Base
#==============================================================================

class Window_Base < Window

  #--------------------------------------------------------------------------
  # alias method: initialize
  #--------------------------------------------------------------------------
  alias initialize_window_base_bem initialize unless $@
  def initialize(x, y, width, height)
    initialize_window_base_bem(x, y, width, height)
    if $game_temp.in_battle
      $disposable_melody_windows = [] if $disposable_melody_windows == nil
      $disposable_melody_windows.push(self)
    end
  end

  #--------------------------------------------------------------------------
  # alias method: dispose
  #--------------------------------------------------------------------------
  alias dispose_window_base_bem dispose unless $@
  def dispose
    if $game_temp.in_battle
      $disposable_melody_windows = [] if $disposable_melody_windows == nil
      $disposable_melody_windows.delete(self)
    end
    dispose_window_base_bem
  end

  #--------------------------------------------------------------------------
  # rage_gauge_color1
  #--------------------------------------------------------------------------
  def rage_gauge_color1
    return text_color(YEM::BATTLE_ENGINE::SKILL_SETTINGS[:rage_gauge1])
  end

  #--------------------------------------------------------------------------
  # rage_gauge_color2
  #--------------------------------------------------------------------------
  def rage_gauge_color2
    return text_color(YEM::BATTLE_ENGINE::SKILL_SETTINGS[:rage_gauge2])
  end

  #--------------------------------------------------------------------------
  # new method: draw_actor_rage_gauge
  #--------------------------------------------------------------------------
  unless $imported["CoreFixesUpgradesMelody"]
  def draw_actor_rage_gauge(actor, x, y, width = 120, height = nil)
    gc0 = gauge_back_color
    gc1 = text_color(YEM::BATTLE_ENGINE::RAGE[:rage_gauge1])
    gc2 = text_color(YEM::BATTLE_ENGINE::RAGE[:rage_gauge2])
    gh = 6
    gy = y + WLH - 8 - (gh - 6)
    gb = width
    self.contents.fill_rect(x, gy, gb, gh, gc0)
    gw = [[gb * actor.rage / actor.max_rage, width].min, 0].max
    self.contents.gradient_fill_rect(x, gy, gw, gh, gc1, gc2)
  end
  end

  #--------------------------------------------------------------------------
  # new method: draw_enemy_hp_gauge
  #--------------------------------------------------------------------------
  def draw_enemy_hp_gauge(battler, x, y, width = 120)
    battler.hp = [battler.hp, battler.maxhp].min
    gc0 = gauge_back_color
    gc1 = text_color(battler.enemy.quick_gauge[:hp_gauge1])
    gc2 = text_color(battler.enemy.quick_gauge[:hp_gauge2])
    gh = 6
    gy = y + WLH - 8 - (gh - 6)
    if battler.maxhp < battler.base_maxhp and battler.base_maxhp > 0 and
    !(battler.base_maxhp > battler.maxhp_limit)
      gb = width * battler.maxhp / battler.base_maxhp
      self.contents.fill_rect(x, gy, width, gh, text_color(7))
    else
      gb = width
    end
    self.contents.fill_rect(x, gy, gb, gh, gc0)
    gw = gb * battler.hp / battler.maxhp
    self.contents.gradient_fill_rect(x, gy, gw, gh, gc1, gc2)
  end

  #--------------------------------------------------------------------------
  # new method: draw_enemy_mp_gauge
  #--------------------------------------------------------------------------
  def draw_enemy_mp_gauge(battler, x, y, width = 120, height = nil)
    battler.mp = [battler.mp, battler.maxmp].min
    gc0 = gauge_back_color
    gc1 = text_color(battler.enemy.quick_gauge[:mp_gauge1])
    gc2 = text_color(battler.enemy.quick_gauge[:mp_gauge2])
    gh = 6
    gy = y + WLH - 8 - (gh - 6)
    if battler.maxmp < battler.base_maxmp and battler.base_maxmp > 0 and
    !(battler.base_maxmp > battler.maxmp_limit)
      gb = width * battler.maxmp / battler.base_maxmp
      self.contents.fill_rect(x, gy, width, gh, text_color(7))
    else
      gb = width
    end
    self.contents.fill_rect(x, gy, gb, gh, gc0)
    if battler.maxmp <= 0
      if battler.base_maxmp <= 0
        gw = width
      else
        gw = 0
      end
    else
      gw = gb * battler.mp / battler.maxmp
    end
    self.contents.gradient_fill_rect(x, gy, gw, gh, gc1, gc2)
  end

  #--------------------------------------------------------------------------
  # new method: draw_enemy_rage_gauge
  #--------------------------------------------------------------------------
  def draw_enemy_rage_gauge(actor, x, y, width = 120, height = nil)
    gc0 = gauge_back_color
    gc1 = text_color(YEM::BATTLE_ENGINE::SKILL_SETTINGS[:rage_gauge1])
    gc2 = text_color(YEM::BATTLE_ENGINE::SKILL_SETTINGS[:rage_gauge2])
    gh = $imported["CoreFixesUpgradesMelody"] ? YEM::UPGRADE::GAUGE_HEIGHT : 6
    gy = y + WLH - 8 - (gh - 6)
    gb = width
    self.contents.fill_rect(x, gy, gb, gh, gc0)
    gw = [[gb * actor.rage / actor.max_rage, width].min, 0].max
    self.contents.gradient_fill_rect(x, gy, gw, gh, gc1, gc2)
  end

end # Window_Base

#==============================================================================
# Window_Command_Centered
#==============================================================================

class Window_Command_Centered < Window_Command

  #--------------------------------------------------------------------------
  # new method: draw_item
  #--------------------------------------------------------------------------
  def draw_item(index, enabled = true)
    rect = item_rect(index)
    rect.x += 4
    rect.width -= 8
    self.contents.clear_rect(rect)
    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(rect, @commands[index],1)
  end

end # Window_Command_Centered

#===============================================================================
# Window_BattleDebug
#===============================================================================

class Window_BattleDebug < Window_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    super(0, 16, Graphics.width, 56)
    self.back_opacity = 0
    self.opacity = 0
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    call_enable
    return unless @enabled
    return unless $scene.is_a?(Scene_Battle)
    refresh if @current_selected != $scene.selected_battler
    refresh if @current_active != $scene.active_battler
    refresh if @current_turn != $game_troop.turn_count
  end

  #--------------------------------------------------------------------------
  # call_enable
  #--------------------------------------------------------------------------
  def call_enable
    return if @enabled
    if Input.press?(Input::CTRL) and Input.press?(Input::ALT)
      @enabled = true
      Sound.play_decision
    end
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.font.size = 16
    dw = contents.width/4
    @current_selected = $scene.selected_battler
    @current_active = $scene.active_battler
    @current_turn = $game_troop.turn_count
    if @current_turn != nil
      turn = @current_turn
      text = sprintf("Turn: %s", turn)
      self.contents.draw_text(dw*0, 0, dw, WLH, text, 0)
    end
    if @current_selected != nil
      name = @current_selected.name
      text = sprintf("Sel: %s", name)
      self.contents.draw_text(dw*2, 0, dw, WLH, text, 0)
    end
    if @current_active != nil
      name = @current_active.name
      text = sprintf("Act: %s", name)
      self.contents.draw_text(dw*3, 0, dw, WLH, text, 0)
    end
  end

end # Window_BattleDebug

#==============================================================================
# Window_TargetEnemy
#==============================================================================

class Window_TargetEnemy < Window_Command

  #--------------------------------------------------------------------------
  # overwrite method: initialize
  #--------------------------------------------------------------------------
  def initialize
    commands = []
    super(416, commands, 8, 1)
  end

  #--------------------------------------------------------------------------
  # overwrite method: refresh
  #--------------------------------------------------------------------------
  def refresh
    @commands = []
    @enemies = []
    for enemy in $game_troop.members
      next unless enemy.exist?
      @commands.push(enemy.name)
      @enemies.push(enemy)
    end
    @enemies.sort! { |a,b| a.screen_x <=> b.screen_x }
    self.contents.clear
    @item_max = @commands.size
    for i in 0...@item_max; draw_item(i); end
  end

end # Window_TargetEnemy

#===============================================================================
# Window_TargetHelp
#===============================================================================

class Window_TargetHelp < Window_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, Graphics.width, 56)
    refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh(target = nil, battler = nil)
    self.contents.clear
    return if target == nil
    if draw_unique_name?(battler)
      draw_obj_selection(battler)
      return
    end
    name = target.name
    if $imported["EnemyLevels"] and target.enemy?
      name = sprintf(YEZ::ENEMY_LEVEL::LEVEL_TEXT, target.level, name) #edit
    end
    self.contents.draw_text(0, 0, contents.width, WLH, name, 1)
  end

  #--------------------------------------------------------------------------
  # draw_unique_name?
  #--------------------------------------------------------------------------
  def draw_unique_name?(battler)
    return false if battler == nil
    return false if battler.action == nil
    return false if battler.action.attack?
    obj = battler.action.skill if battler.action.skill?
    obj = battler.action.item if battler.action.item?
    if $scene.atb?
      case battler.action.atb_queue_kind
      when 0; return false
      when 1; obj = $data_skills[battler.action.atb_queue_basic]
      when 2; obj = $data_items[battler.action.atb_queue_basic]
      end
    end
    return false if obj == nil
    return true if obj.target_text != nil
    return true if !obj.need_selection?
    return false
  end

  #--------------------------------------------------------------------------
  # draw_obj_selection
  #--------------------------------------------------------------------------
  def draw_obj_selection(battler)
    obj = battler.action.skill if battler.action.skill?
    obj = battler.action.item if battler.action.item?
    if $scene.atb?
      case battler.action.atb_queue_kind
      when 1; obj = $data_skills[battler.action.atb_queue_basic]
      when 2; obj = $data_items[battler.action.atb_queue_basic]
      end
    end
    if obj.for_user?
      text = YEM::BATTLE_ENGINE::TARGET_WINDOW[:user]
    elsif obj.for_friend?
      if obj.for_one?
        text = YEM::BATTLE_ENGINE::TARGET_WINDOW[:actor]
      else
        text = YEM::BATTLE_ENGINE::TARGET_WINDOW[:actors]
      end
      if obj.for_dead_friend?
        text = sprintf(YEM::BATTLE_ENGINE::TARGET_WINDOW[:dead], text)
      end
    elsif obj.for_opponent?
      if obj.for_one?
        text = YEM::BATTLE_ENGINE::TARGET_WINDOW[:enemy]
      else
        text = YEM::BATTLE_ENGINE::TARGET_WINDOW[:enemies]
      end
    else
      text = YEM::BATTLE_ENGINE::TARGET_WINDOW[:none]
      self.contents.draw_text(0, 0, contents.width, WLH, text, 1)
      return
    end
    if obj.for_random?
      n = obj.random_targets
      text = sprintf(YEM::BATTLE_ENGINE::TARGET_WINDOW[:random], n, text)
    end
    if obj.for_all?
      text = sprintf(YEM::BATTLE_ENGINE::TARGET_WINDOW[:all], text)
    end
    if obj.target_text != nil
      name = ""
      if $scene.target_enemy_window != nil
        name = $scene.target_enemy_window.enemy.name
        if $imported["EnemyLevels"] and $scene.target_enemy_window.enemy.enemy?
          level = $scene.target_enemy_window.enemy.level
          name = sprintf(YEZ::ENEMY_LEVEL::LEVEL_TEXT, level, name) #edit
        end
      elsif $scene.target_actor_window != nil
        name = $scene.target_enemy_window.actor.name
      end
      text = sprintf(obj.target_text, name)
    end
    self.contents.draw_text(0, 0, contents.width, WLH, text, 1)
  end

end # Window_TargetHelp

#===============================================================================
# Window_BattleMessageMelody
#===============================================================================

class Window_BattleMessageMelody < Window_BattleMessage

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :align
  attr_accessor :icon

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    super
    self.x = 0
    self.y = 32
    self.z = 300
    self.back_opacity = 0
    self.opacity = 0
    self.windowskin = Cache.system("Window")
    @align = YEM::BATTLE_ENGINE::MESSAGE_SETTINGS[:alignment]
    create_background_sprite
    change_viewport($scene.spriteset.viewportB)
  end

  #--------------------------------------------------------------------------
  # dispose
  #--------------------------------------------------------------------------
  def dispose
    super
    @leftsprite.bitmap.dispose
    @leftsprite.dispose
    @centersprite.bitmap.dispose
    @centersprite.dispose
    @rightsprite.bitmap.dispose
    @rightsprite.dispose
  end

  #--------------------------------------------------------------------------
  # create_background_sprite
  #--------------------------------------------------------------------------
  def create_background_sprite
    gw = Graphics.width
    g1 = YEM::BATTLE_ENGINE::MESSAGE_SETTINGS[:gradient1]
    g2 = YEM::BATTLE_ENGINE::MESSAGE_SETTINGS[:gradient2]
    #--- Create Left Aligned Sprite ---
    bitmap = Bitmap.new(gw, 112)
    bitmap.gradient_fill_rect(0, 16, gw, 96, g1, g2)
    @leftsprite = Sprite.new(self.viewport)
    @leftsprite.bitmap = bitmap
    @leftsprite.x = self.x
    @leftsprite.y = self.y
    @leftsprite.z = self.z - 1
    @leftsprite.src_rect.height = 16
    #--- Create Center Aligned Sprite ---
    bitmap = Bitmap.new(gw, 112)
    bitmap.gradient_fill_rect(0, 16, gw/2, 96, g2, g1)
    bitmap.gradient_fill_rect(gw/2, 16, gw/2, 96, g1, g2)
    @centersprite = Sprite.new(self.viewport)
    @centersprite.bitmap = bitmap
    @centersprite.x = self.x
    @centersprite.y = self.y
    @centersprite.z = self.z - 1
    @centersprite.src_rect.height = 16
    #--- Create Right Aligned Sprite ---
    bitmap = Bitmap.new(gw, 112)
    bitmap.gradient_fill_rect(0, 16, gw, 96, g2, g1)
    @rightsprite = Sprite.new(self.viewport)
    @rightsprite.bitmap = bitmap
    @rightsprite.x = self.x
    @rightsprite.y = self.y
    @rightsprite.z = self.z - 1
    @rightsprite.src_rect.height = 16
    #--- Hide Sprites ---
    @leftsprite.opacity = 0
    @centersprite.opacity = 0
    @rightsprite.opacity = 0
  end

  #--------------------------------------------------------------------------
  # change_viewport
  #--------------------------------------------------------------------------
  def change_viewport(viewport)
    return if self.viewport == viewport
    self.viewport = viewport
    @leftsprite.viewport = self.viewport
    @centersprite.viewport = self.viewport
    @rightsprite.viewport = self.viewport
  end

  #--------------------------------------------------------------------------
  # new_page
  #--------------------------------------------------------------------------
  def new_page
    super
    self.windowskin = Cache.system("Window")
    self.contents.font.shadow = true
    self.contents.font.color = normal_color
  end

  #--------------------------------------------------------------------------
  # clear
  #--------------------------------------------------------------------------
  def clear
    super
    @icon = nil
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    update
    super
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    return if @anti_update
    if self.viewport != nil
      #---
      self.x = self.viewport.ox
      @leftsprite.x = @centersprite.x = @rightsprite.x = self.x
      #---
      self.y = self.viewport.oy + 32
      @leftsprite.y = @centersprite.y = @rightsprite.y = self.y
      #---
    end
    if self.visible and (@lines.size > 0) or
    (@text != nil or self.pause or @index > -1)
      if @text != nil
        lines = 4
      else
        lines = (!self.pause or @index > -1) ? @lines.size : 4
      end
      case @align
      when 1
        @centersprite.opacity += YEM::BATTLE_ENGINE::MESSAGE_SETTINGS[:opacity]
        @centersprite.src_rect.height = 16 + (lines * 24)
      when 2
        @rightsprite.opacity += YEM::BATTLE_ENGINE::MESSAGE_SETTINGS[:opacity]
        @rightsprite.src_rect.height = 16 + (lines * 24)
      else
        @leftsprite.opacity += YEM::BATTLE_ENGINE::MESSAGE_SETTINGS[:opacity]
        @leftsprite.src_rect.height = 16 + (lines * 24)
      end
      @countdown = 8
    elsif @countdown != nil and @countdown > 0
      @countdown -= 1
    elsif @countdown != nil
      @centersprite.opacity -= YEM::BATTLE_ENGINE::MESSAGE_SETTINGS[:opacity]
      @leftsprite.opacity -= YEM::BATTLE_ENGINE::MESSAGE_SETTINGS[:opacity]
      @rightsprite.opacity -= YEM::BATTLE_ENGINE::MESSAGE_SETTINGS[:opacity]
    end
    super
  end

  #--------------------------------------------------------------------------
  # draw_line
  #--------------------------------------------------------------------------
  def draw_line(index)
    rect = Rect.new(0, 0, 0, 0)
    rect.x += 4
    rect.y += index * WLH
    rect.width = contents.width - 8
    rect.height = WLH
    dx = rect.x; dy = rect.y; dw = rect.width; dh = rect.height
    self.contents.clear_rect(rect)
    if $imported["CustomMessageMelody"] and $game_message.busy
      self.contents.font.name = YEM::MESSAGE::MESSAGE_WINDOW_FONT
    else
      self.contents.font.name = Font.default_name
    end
    self.contents.font.color = normal_color
    if index == 0 and (@icon != nil and @icon != 0)
      fx = contents.text_size(@lines[index]).width
      case @align
      when 0 # Left Aligned
        draw_icon(@icon, dx, dy)
        dx += 24
      when 1 # Center Aligned
        draw_icon(@icon, (dw-fx)/2-12, dy)
        dx += 12
      when 2 # Right Aligned
        draw_icon(@icon, dw-fx-24, dy)
      end
    end
    self.contents.draw_text(dx, dy, dw, dh, @lines[index], @align)
  end

end # Window_BattleMessageMelody

#===============================================================================
# Window_BattleStatus
#===============================================================================

class Window_BattleStatus < Window_Selectable

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :battle_refresh_call
  attr_accessor :frozen_cursor
  attr_accessor :highlight_all
  attr_accessor :highlight_user
  attr_accessor :highlight_none
  attr_accessor :highlight_dead
  attr_accessor :target_highlight

  #--------------------------------------------------------------------------
  # overwrite method: initialize
  #--------------------------------------------------------------------------
  def initialize(minimum = false)
    super(0, 0, Graphics.width - 128, 128)
    max_members = YEM::BATTLE_ENGINE::MAXIMUM_PARTY_MEMBERS
    @item_max = [$game_party.members.size, max_members].max
    @column_max = @item_max
    @minimum = minimum
    @current_party = $game_party.members
    recreate unless @miniature
    self.active = false
  end

  #--------------------------------------------------------------------------
  # actor
  #--------------------------------------------------------------------------
  def actor; return $game_party.members[self.index]; end

  #--------------------------------------------------------------------------
  # recreate
  #--------------------------------------------------------------------------
  def recreate
    max_members = YEM::BATTLE_ENGINE::MAXIMUM_PARTY_MEMBERS
    @item_max = [$game_party.members.size, max_members].max
    @item_max = 1 if @minitature
    @updating = -1
    @current_party = $game_party.members
    @current_hp = {}; @current_hp_gauge = {}; @maxhp = {}
    @current_mp = {}; @current_mp_gauge = {}; @maxmp = {}
    @current_rage = {}; @current_rage_gauge = {}; @max_rage = {}
    temp_rect = item_rect(0)
    @hp_gauge_width = temp_rect.width-4
    @mp_gauge_width = temp_rect.width-4
    @rg_gauge_width = temp_rect.width-4
    for i in 0...@current_party.size
      actor = $game_party.members[i]
      #--
      @current_hp[i] = actor.hp
      maxhp = [[actor.maxhp, actor.base_maxhp, 1].max, actor.maxhp_limit].min
      @current_hp_gauge[i] = (actor.hp * @hp_gauge_width / maxhp)
      @maxhp[i] = maxhp
      #--
      maxmp = [[actor.maxmp, actor.base_maxmp, 1].max, actor.maxmp_limit].min
      @current_mp[i] = actor.mp
      @current_mp_gauge[i] = (actor.mp * @mp_gauge_width / [actor.maxmp,1].max)
      @maxmp[i] = maxmp
      #---
      actor.rage = 0 if actor.rage == nil
      @current_rage[i] = actor.rage
      @current_rage_gauge[i] = actor.rage * @rg_gauge_width / actor.max_rage
      @max_rage[i] = actor.max_rage
    end
    refresh
  end

  #--------------------------------------------------------------------------
  # new method: update
  #--------------------------------------------------------------------------
  def update
    super unless prevent_left_right?
    redraw if @last_index != self.index
    redraw if @battle_refresh_call
    return unless @minimum
    recreate if @current_party != $game_party.members
    return unless $scene.is_a?(Scene_Battle)
    for member in $game_party.members; redraw if member.update_states; end
    redraw if @last_active_battler != $scene.active_battler
  end

  #--------------------------------------------------------------------------
  # new method: prevent_left_right
  #--------------------------------------------------------------------------
  def prevent_left_right?
    return true if (@frozen_cursor and (Input.repeat?(Input::LEFT) or
      Input.repeat?(Input::RIGHT)))
    if Input.repeat?(Input::LEFT) and $game_party.members[self.index-1] == nil
      return true
    end
    if Input.repeat?(Input::RIGHT) and $game_party.members[self.index+1] == nil
      return true
    end
    return false
  end

  #--------------------------------------------------------------------------
  # new method: redraw
  #--------------------------------------------------------------------------
  def redraw
    return unless $scene.is_a?(Scene_Battle)
    @last_index = self.index
    @last_active_battler = $scene.active_battler
    @battle_refresh_call = false
    refresh
  end

  #--------------------------------------------------------------------------
  # overwrite method: refresh
  #--------------------------------------------------------------------------
  def refresh
    return if @miniature
    max_members = YEM::BATTLE_ENGINE::MAXIMUM_PARTY_MEMBERS
    @item_max = [$game_party.members.size, max_members].max
    @column_max = @item_max
    for i in 0...@item_max; draw_item(i); end
  end

  #--------------------------------------------------------------------------
  # overwrite method: draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    actor = $game_party.members[index]
    return if actor == nil
    draw_member_face(actor, rect.clone)
    draw_member_action(actor, rect.clone)
    return if @minimum
    draw_member_name(actor, rect.clone)
    draw_member_states(actor, rect.clone)
    draw_member_hp(actor, rect.clone)
    draw_member_mp(actor, rect.clone)
    draw_member_rage(actor, rect.clone)
  end

  #--------------------------------------------------------------------------
  # new method: item_rect
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = Rect.new(0, 0, 0, 0)
    rect.width = contents.width / @item_max
    rect.height = contents.height
    rect.x = index * rect.width
    rect.y = 0
    return rect
  end

  #--------------------------------------------------------------------------
  # new method: draw_member_face
  #--------------------------------------------------------------------------
  def draw_member_face(actor, content_rect)
    lower_opacity = YEM::BATTLE_ENGINE::PARTY_WINDOW[:face_opacity]
    opacity = opacity?(actor) ? 255 : lower_opacity
    face_name = actor.face_name
    face_index = actor.face_index
    bitmap = Cache.face(face_name)
    rect = Rect.new(0, 0, 0, 0)
    rect.width = [content_rect.width-4, 92].min
    rect.height = [contents.height-4, 92].min
    rect.x = face_index % 4 * 96 + (96-rect.width) / 2
    rect.y = face_index / 4 * 96 + (96-rect.height) / 2
    self.contents.blt(content_rect.x+2, content_rect.y+2, bitmap, rect, opacity)
  end

  #--------------------------------------------------------------------------
  # new method: draw_member_action
  #--------------------------------------------------------------------------
  def draw_member_action(actor, rect)
    return unless YEM::BATTLE_ENGINE::PARTY_WINDOW[:action_icons]
    icon = YEM::BATTLE_ENGINE::ICON_MESSAGE[:wait_icon]
    case actor.action.kind
    when 0 # Basic
      case actor.action.basic
      when 0 # Attack
        icon = actor.attack_icon
      when 1 # Guard
        icon = actor.guard_icon
      when 2 # Escape
        icon = YEM::BATTLE_ENGINE::ICON_MESSAGE[:flee_icon]
      end
    when 1 # Skill
      icon = actor.action.skill.icon_index
    when 2 # Item
      icon = actor.action.item.icon_index
    end
    enabled = actor.action.valid?
    enabled = false if actor.action.kind == 0 and actor.action.basic == 3
    if $scene.is_a?(Scene_Battle) and $scene.ctb? and actor.action.guard?
      icon = actor.guard_icon
      enabled = true
    end
    draw_icon(icon, rect.x, rect.y, enabled)
  end

  #--------------------------------------------------------------------------
  # new method: opacity?
  #--------------------------------------------------------------------------
  def opacity?(actor)
    return false if actor == nil
    if $scene.is_a?(Scene_Battle) and $scene.ctb?
      return true if actor.ctb_active? and !@minimum
    end
    return true if self.is_a?(Window_BattleStatus_Mini)
    return false if actor == nil
    return false if @highlight_none
    return true if @highlight_all
    if @highlight_dead
      return true if self.index == actor.index and actor.dead?
      return false
    end
    return false if actor.dead?
    if !@target_highlight and $scene.is_a?(Scene_Battle)
      return true if actor.active_battler?
    end
    if @highlight_user and $scene.is_a?(Scene_Battle)
      return true if actor == $scene.selected_battler
    end
    return false if @highlight_user
    return true if self.index == actor.index
    return false if !@minimum
    return false
  end

  #--------------------------------------------------------------------------
  # new method: draw_member_name
  #--------------------------------------------------------------------------
  def draw_member_name(actor, rect)
    name = actor.name
    self.contents.font.size = YEM::BATTLE_ENGINE::PARTY_WINDOW[:name_size]
    dy = rect.y
    if YEM::BATTLE_ENGINE::PARTY_WINDOW[:action_icons]
      dx = rect.x+24
      dw = rect.width-28
    else
      dx = rect.x+4
      dw = rect.width-8
    end
    self.contents.font.color = hp_color(actor)
    self.contents.draw_text(dx, dy, dw, WLH, name)
  end

  #--------------------------------------------------------------------------
  # new method: draw_member_states
  #--------------------------------------------------------------------------
  def draw_member_states(actor, rect)
    dw = [YEM::BATTLE_ENGINE::PARTY_WINDOW[:max_states] * 24, rect.width].min
    draw_actor_state(actor, rect.x, rect.y + WLH, dw)
    actor.update_states = false
  end

  #--------------------------------------------------------------------------
  # new method: draw_member_hp
  #--------------------------------------------------------------------------
  def draw_member_hp(actor, rect)
    @updating = -1
    i = actor.index
    maxhp = @maxhp[i]
    dy = WLH * 3 - YEM::BATTLE_ENGINE::PARTY_WINDOW[:stat_size]
    dx = rect.x + 2
    self.contents.fill_rect(dx, dy+WLH-8, @hp_gauge_width, 8, gauge_back_color)
    #---
    target_gauge = (actor.hp * @hp_gauge_width / maxhp)
    if @current_hp_gauge[i] > target_gauge
      @updating = i
      @current_hp_gauge[i] -= [2, (@current_hp_gauge[i]-target_gauge).abs].min
      @current_hp_gauge[i] = [@current_hp_gauge[i], 0].max
      gw = @current_hp_gauge[i]
      gw = [gw, 3].max if actor.hp > 0
      gc1 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:hp_dmg_gauge])
      gc2 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:hp_dmg_gauge])
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
      gw = @hp_gauge_width * actor.hp / maxhp
      gw = [gw, 3].max if actor.hp > 0
      gc1 = hp_gauge_color1
      gc2 = hp_gauge_color2
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
    elsif @current_hp_gauge[i] < target_gauge
      @updating = i
      @current_hp_gauge[i] += [2, (@current_hp_gauge[i]-target_gauge).abs].min
      @current_hp_gauge[i] = [@current_hp_gauge[i], @hp_gauge_width].min
      gw = @hp_gauge_width * actor.hp / maxhp
      gw = [gw, 3].max if actor.hp > 0
      gc1 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:hp_heal_gauge])
      gc2 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:hp_heal_gauge])
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
      gw = @current_hp_gauge[i]
      gw = [gw, 3].max if actor.hp > 0
      gc1 = hp_gauge_color1
      gc2 = hp_gauge_color2
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
    else
      gw = @current_hp_gauge[i]
      gw = [gw, 3].max if actor.hp > 0
      gc1 = hp_gauge_color1
      gc2 = hp_gauge_color2
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
    end
    #---
    if maxhp > actor.maxhp
      gce = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:exhaust_gauge])
      gbw = @hp_gauge_width * (actor.base_maxhp - actor.maxhp) / maxhp + 1
      gbc = gauge_back_color
      self.contents.fill_rect(dx+@hp_gauge_width-gbw-2, dy+WLH-8, gbw, 8, gbc)
      self.contents.fill_rect(dx+@hp_gauge_width-gbw-1, dy+WLH-7, gbw, 6, gce)
    end
    #---
    if @current_hp[i] != actor.hp
      @updating = i
      den = [@hp_gauge_width/3 + rand(@hp_gauge_width/2), 1].max
      value = [[maxhp/den, (@current_hp[i]-actor.hp).abs].min, 1].max
      @current_hp[i] += (@current_hp[i] > actor.hp) ? -value : value
      @current_hp[i] = actor.hp if @current_hp_gauge[i] == target_gauge
    end
    #---
    dy += 4
    self.contents.font.size = YEM::BATTLE_ENGINE::PARTY_WINDOW[:stat_size]
    self.contents.font.color = system_color
    self.contents.draw_text(dx, dy, rect.width-4, WLH, Vocab::hp_a, 0)
    self.contents.font.color = hp_color(actor)
    text = @current_hp[i]
    self.contents.draw_text(dx, dy, rect.width-4, WLH, text, 2)
    #---
  end

  #--------------------------------------------------------------------------
  # new method: draw_member_mp
  #--------------------------------------------------------------------------
  def draw_member_mp(actor, rect)
    return unless actor.maxmp > 0
    @updating = -1
    i = actor.index
    maxmp = @maxmp[i]
    dy = WLH * 3 - 2
    dx = rect.x + 2
    mp_gw = @mp_gauge_width
    if actor.use_rage?
      dx += rect.width/2
      dx -= 3
      mp_gw = mp_gw/2+1
    end
    self.contents.fill_rect(dx, dy+WLH-8, mp_gw, 8, gauge_back_color)
    #---
    target_gauge = (actor.mp * @mp_gauge_width / maxmp)
    if @current_mp_gauge[i] > target_gauge and !@miniature
      @updating = i
      @current_mp_gauge[i] -= [2, (@current_mp_gauge[i]-target_gauge).abs].min
      @current_mp_gauge[i] = [@current_mp_gauge[i], 0].max
      gw = @current_mp_gauge[i]
      gw = gw/2+1 if actor.use_rage?
      gw = [gw, 3].max if actor.mp > 0
      gc1 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:mp_dmg_gauge])
      gc2 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:mp_dmg_gauge])
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
      gw = mp_gw * actor.mp / maxmp
      gw = [gw, 3].max if actor.mp > 0
      gc1 = mp_gauge_color1
      gc2 = mp_gauge_color2
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
    elsif @current_mp_gauge[i] < target_gauge and !@miniature
      @updating = i
      @current_mp_gauge[i] += [2, (@current_mp_gauge[i]-target_gauge).abs].min
      @current_mp_gauge[i] = [@current_mp_gauge[i], @mp_gauge_width].min
      gw = mp_gw * actor.mp / maxmp
      gw = [gw, 3].max if actor.mp > 0
      gc1 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:mp_heal_gauge])
      gc2 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:mp_heal_gauge])
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
      gw = @current_mp_gauge[i]
      gw = gw/2+1 if actor.use_rage?
      gw = [gw, 3].max if actor.mp > 0
      gc1 = mp_gauge_color1
      gc2 = mp_gauge_color2
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
    else
      gw = mp_gw * actor.mp / maxmp
      gw = [gw, 3].max if actor.mp > 0
      gc1 = mp_gauge_color1
      gc2 = mp_gauge_color2
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
    end
    #---
    if actor.base_maxmp > actor.maxmp
      gce = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:exhaust_gauge])
      gbw = mp_gw
      gbw *= (actor.base_maxmp - actor.maxmp) / [actor.base_maxmp, 1].max + 1
      gbc = gauge_back_color
      self.contents.fill_rect(dx+mp_gw-gbw-2, dy+WLH-8, gbw, 8, gbc)
      self.contents.fill_rect(dx+mp_gw-gbw-1, dy+WLH-7, gbw, 6, gce)
    end
    #---
    if @current_mp[i] != actor.mp
      @updating = i
      den = [mp_gw/3 + rand(mp_gw/2), 1].max
      value = [[maxmp/den, (@current_mp[i]-actor.mp).abs].min, 1].max
      @current_mp[i] += (@current_mp[i] > actor.mp) ? -value : value
      @current_mp[i] = actor.mp if @current_mp_gauge[i] == target_gauge
    end
    #---
    dy += 4
    self.contents.font.size = YEM::BATTLE_ENGINE::PARTY_WINDOW[:stat_size]
    self.contents.font.color = system_color
    self.contents.draw_text(dx, dy, rect.width-4, WLH, Vocab::mp_a, 0)
    self.contents.font.color = mp_color(actor)
    text = @current_mp[i]
    dw = rect.width-4
    dw /= 2 if actor.use_rage?
    self.contents.draw_text(dx, dy, dw, WLH, text, 2)
    #---
  end

  #--------------------------------------------------------------------------
  # new method: draw_member_rage
  #--------------------------------------------------------------------------
  def draw_member_rage(actor, rect)
    return unless actor.use_rage?
    @updating = -1
    i = actor.index
    max_rage = @max_rage[i]
    dy = WLH * 3 - 2
    dx = rect.x + 2
    rg_gw = @rg_gauge_width
    rg_gw /= 2 if actor.maxmp > 0
    self.contents.fill_rect(dx, dy+WLH-8, rg_gw, 8, gauge_back_color)
    #---
    target_gauge = (actor.rage * @rg_gauge_width / max_rage)
    target_gauge += 2 if actor.rage > 0
    if @current_rage_gauge[i] > target_gauge
      @updating = i
      value = [2,(@current_rage_gauge[i]-target_gauge).abs].min
      @current_rage_gauge[i] -= value
      @current_rage_gauge[i] = [@current_rage_gauge[i], 0].max
      gw = @current_rage_gauge[i]
      gw /= 2 if actor.maxmp > 0
      gw = [gw, 3].max if actor.rage > 0
      gc1 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:rg_dmg_gauge])
      gc2 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:rg_dmg_gauge])
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
      gw = rg_gw * actor.rage / max_rage
      gw = [gw, 3].max if actor.rage > 0
      gc1 = rage_gauge_color1
      gc2 = rage_gauge_color2
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
    elsif @current_rage_gauge[i] < target_gauge
      @updating = i
      value = [2,(@current_rage_gauge[i]-target_gauge).abs].min
      @current_rage_gauge[i] += value
      @current_rage_gauge[i] = [@current_rage_gauge[i], rg_gw*2].min
      gw = rg_gw * actor.rage / max_rage
      gw = [gw, 3].max if actor.rage > 0
      gc1 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:rg_heal_gauge])
      gc2 = text_color(YEM::BATTLE_ENGINE::PARTY_WINDOW[:rg_heal_gauge])
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
      gw = @current_rage_gauge[i]
      gw /= 2 if actor.maxmp > 0
      gw = [gw, 3].max if actor.rage > 0
      gc1 = rage_gauge_color1
      gc2 = rage_gauge_color2
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
    else
      gw = @current_rage_gauge[i]
      gw /= 2 if actor.maxmp > 0
      gw = [gw, 3].max if actor.rage > 0
      gc1 = rage_gauge_color1
      gc2 = rage_gauge_color2
      self.contents.gradient_fill_rect(dx+1, dy+WLH-7, gw-2, 6, gc1, gc2)
    end
    #---
    if @current_rage[i] != actor.rage
      @updating = i
      @current_rage[i] += (@current_rage[i] > actor.rage) ? -1 : 1
      @current_rage[i] = actor.rage if @current_rage_gauge[i] == target_gauge
    end
    #---
    dy += 4
    self.contents.font.size = YEM::BATTLE_ENGINE::PARTY_WINDOW[:stat_size]
    self.contents.font.color = system_color
    self.contents.draw_text(dx, dy, rect.width/2-2, WLH, Vocab::rage_a, 0)
    self.contents.font.color = normal_color
    text = @current_rage[i]
    dw = rect.width-4
    dw /= 2 if actor.maxmp > 0
    self.contents.draw_text(dx, dy, dw, WLH, text, 2)
    #---
  end

end # Window_BattleStatus

#===============================================================================
# Window_BattleStatus_Mini
#===============================================================================

class Window_BattleStatus_Mini < Window_BattleStatus

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    @miniature = true
    super
    self.x = Graphics.width - 128
    self.y = Graphics.height - 128
    self.width = 128
    self.height = 128
    create_contents
    recreate
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_item($scene.selected_battler.index)
  end

  #--------------------------------------------------------------------------
  # new method: item_rect
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = Rect.new(0, 0, 96, 96)
    return rect
  end

end # Window_BattleStatus_Mini

#===============================================================================
# Window_BattleStatusHP
#===============================================================================

class Window_BattleStatusHP < Window_BattleStatus

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    super
    self.active = false
    self.back_opacity = 0
    self.opacity = 0
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    recreate if @current_party != $game_party.members
    if @updating >= 0
      draw_item(@updating)
      return
    end
    for member in $game_party.members
      draw_item(member.index) if redraw?(member)
      break if redraw?(member)
    end
  end

  #--------------------------------------------------------------------------
  # redraw?
  #--------------------------------------------------------------------------
  def redraw?(member)
    i = member.index
    if member.update_maxhp
      value = [[member.maxhp, member.base_maxhp, 1].max, member.maxhp_limit].min
      @maxhp[i] = value
      member.update_maxhp = nil
      return true
    end
    return true if @current_hp_gauge[i] != (member.hp*@hp_gauge_width/@maxhp[i])
    return true if @current_hp[i] != member.hp
    return false
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    max_members = YEM::BATTLE_ENGINE::MAXIMUM_PARTY_MEMBERS
    @item_max = [$game_party.members.size, max_members].max
    for i in 0...@item_max; draw_item(i); end
  end

  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    actor = $game_party.members[index]
    return if actor == nil
    draw_member_name(actor, rect.clone)
    draw_member_hp(actor, rect.clone)
  end

end # Window_BattleStatusHP

#===============================================================================
# Window_BattleStatusMP
#===============================================================================

class Window_BattleStatusMP < Window_BattleStatus

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    super
    self.active = false
    self.back_opacity = 0
    self.opacity = 0
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    recreate if @current_party != $game_party.members
    if @updating >= 0
      draw_item(@updating)
      return
    end
    for member in $game_party.members
      draw_item(member.index) if redraw?(member)
      break if redraw?(member)
    end
  end

  #--------------------------------------------------------------------------
  # redraw?
  #--------------------------------------------------------------------------
  def redraw?(member)
    i = member.index
    if member.update_maxmp
      value = [[member.maxmp, member.base_maxmp, 1].max, member.maxmp_limit].min
      @maxmp[i] = value
      member.update_maxmp = nil
      @first_test = false
      return true
    end
    return true if @current_mp_gauge[i] != (member.mp*@mp_gauge_width/@maxmp[i])
    return true if @current_mp[i] != member.mp
    return false
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    max_members = YEM::BATTLE_ENGINE::MAXIMUM_PARTY_MEMBERS
    @item_max = [$game_party.members.size, max_members].max
    for i in 0...@item_max; draw_item(i); end
  end

  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    actor = $game_party.members[index]
    return if actor == nil
    draw_member_mp(actor, rect.clone)
  end

end # Window_BattleStatusMP

#===============================================================================
# Window_BattleStatusRage
#===============================================================================

class Window_BattleStatusRage < Window_BattleStatus

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    super
    self.active = false
    self.back_opacity = 0
    self.opacity = 0
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    recreate if @current_party != $game_party.members
    if @updating >= 0
      draw_item(@updating)
      return
    end
    for member in $game_party.members
      draw_item(member.index) if redraw?(member)
      break if redraw?(member)
    end
  end

  #--------------------------------------------------------------------------
  # redraw?
  #--------------------------------------------------------------------------
  def redraw?(member)
    return false unless member.use_rage?
    return true if @current_rage[member.index] != member.rage
    return false
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    max_members = YEM::BATTLE_ENGINE::MAXIMUM_PARTY_MEMBERS
    @item_max = [$game_party.members.size, max_members].max
    for i in 0...@item_max; draw_item(i); end
  end

  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    actor = $game_party.members[index]
    return if actor == nil
    draw_member_rage(actor, rect.clone)
  end

end # Window_BattleStatusRage

#===============================================================================
# Window_BattleStatusStates
#===============================================================================

class Window_BattleStatusStates < Window_BattleStatus

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    super
    self.active = false
    self.back_opacity = 0
    self.opacity = 0
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    recreate if @current_party != $game_party.members
    for member in $game_party.members
      draw_item(member.index) if redraw?(member)
      break if redraw?(member)
    end
  end

  #--------------------------------------------------------------------------
  # redraw?
  #--------------------------------------------------------------------------
  def redraw?(member)
    return true if member.update_states
    return false
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    max_members = YEM::BATTLE_ENGINE::MAXIMUM_PARTY_MEMBERS
    @item_max = [$game_party.members.size, max_members].max
    for i in 0...@item_max; draw_item(i); end
  end

  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    actor = $game_party.members[index]
    return if actor == nil
    draw_member_states(actor, rect.clone)
  end

end # Window_BattleStatusStates

#===============================================================================
# Window_ComboCounter
#===============================================================================

class Window_ComboCounter < Window_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    super(0, -64, Graphics.width, 80)
    self.back_opacity = 0
    self.opacity = 0
    @current = 0
    @current_active_battler = nil
    @close_counter = 0
    @req = YEM::BATTLE_ENGINE::COMBO_WINDOW[:requirehit] - 1
    @fade_frames  = YEM::BATTLE_ENGINE::COMBO_WINDOW[:fadeframes]
    @total_sprint = YEM::BATTLE_ENGINE::COMBO_WINDOW[:total_text]
    @heal_sprint  = YEM::BATTLE_ENGINE::COMBO_WINDOW[:total_heal]
    @dmg_sprint   = YEM::BATTLE_ENGINE::COMBO_WINDOW[:total_dmg]
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    return unless $scene.is_a?(Scene_Battle)
    return if $scene.combo_hits == nil
    update_combo_damage if $scene.combo_update
    self.y = [self.y + 4, -14].min if $scene.combo_hits > @req and self.y < -14
    refresh if @combo_damage != @current
    return if $scene.combo_hits > @req
    return if @close_flag
    @close_counter -= 1
    return if @close_counter > 0
    self.y = [self.y - 1, -64].max
    return unless self.y <= -64
    self.contents.clear
    @current = 0
    @close_flag = true
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    if @current_active_battler != $scene.active_battler# and !@updating
      @current_active_battler = $scene.active_battler
      @combo = $scene.combo_hits
      @current = 0
    end
    return unless $scene.combo_hits > @req# or @updating
    #---
    if @combo_damage != @current
      #maxdmg = @combo_damage
      #value = [maxdmg/32 + rand(maxdmg/32), 1].max
      #value = [[value, (@combo_damage-@current).abs].min, 1].max
      #@current = [@current + value, @combo_damage].min
      @current = @combo_damage
    end
    #@updating = @combo_damage != @current
    self.contents.clear
    self.contents.font.color = normal_color
    self.contents.font.bold = true
    @combo = [@combo, $scene.combo_hits].max
    text = sprintf(YEM::BATTLE_ENGINE::COMBO_WINDOW[:combo_text], @combo)
    self.contents.draw_text(4,WLH*0, contents.width-8, WLH, text, 2)
    #---
    update_combo_damage if @combo_direction == nil
    text = sprintf(@dmg_sprint, @current) if @combo_direction > 0
    text = sprintf(@heal_sprint, @current) if @combo_direction < 0
    text = sprintf(@total_sprint, @current) if @combo_direction == 0
    self.contents.draw_text(4,WLH*1-4, contents.width-8, WLH, text, 2)
    #---
    #return unless @updating
    @close_flag = false
    @close_counter = @fade_frames
  end

  #--------------------------------------------------------------------------
  # update_combo_damage
  #--------------------------------------------------------------------------
  def update_combo_damage
    $scene.combo_update = false
    @combo_direction = -1 if $scene.combo_damage < 0
    @combo_direction = 0 if $scene.combo_damage == 0
    @combo_direction = 1 if $scene.combo_damage > 0
    @combo_damage = $scene.combo_damage.abs
  end

end # Window_ComboCounter

#===============================================================================
# Window_Skill
#===============================================================================

class Window_Skill < Window_Selectable

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :battle_refresh_call

  #--------------------------------------------------------------------------
  # new method: update
  #--------------------------------------------------------------------------
  def update
    if @battle_refresh_call
      $game_temp.less_spacing = true
      refresh
      @battle_refresh_call = false
      $game_temp.less_spacing = nil
    end
    super
  end

  #--------------------------------------------------------------------------
  # overwrite method: refresh
  #--------------------------------------------------------------------------
  def refresh
    @spacing = 4 if $game_temp.less_spacing
    @data = []
    for skill in @actor.skills
      next unless include?(skill) and skill != nil #casha
      @data.push(skill)
      if skill.id == @actor.last_skill_id
        self.index = @data.size - 1 unless @first_time
      end
    end
    @item_max = @data.size
    self.index = [self.index, @data.size - 1].min
    create_contents
    @first_time = true
    for i in 0...@item_max; draw_item(i); end
  end

  #--------------------------------------------------------------------------
  # new method: include?
  #--------------------------------------------------------------------------
  def include?(skill)
    if skill != nil
      return false if skill.name == ""
      return false if $game_temp.in_battle and skill.hide_in_battle
    end
    return true
  end

  #--------------------------------------------------------------------------
  # overwrite method: draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    skill = @data[index]
    return if skill == nil
    enabled = @actor.skill_can_use?(skill)
    draw_obj_name(skill, rect.clone, enabled)
    draw_obj_cost(skill, rect.clone, enabled)
  end

  #--------------------------------------------------------------------------
  # new method: draw_obj_name
  #--------------------------------------------------------------------------
  def draw_obj_name(obj, rect, enabled)
    draw_icon(obj.icon_index, rect.x, rect.y, enabled)
    self.contents.font.size = Font.default_size
    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    rect.width -= 48
    self.contents.draw_text(rect.x+24, rect.y, rect.width-24, WLH, obj.name)
  end

  #--------------------------------------------------------------------------
  # new method: draw_obj_cost
  #--------------------------------------------------------------------------
  def draw_obj_cost(obj, rect, enabled)
    return unless obj.is_a?(RPG::Skill)
    return draw_obj_cooldown(obj, rect) if @actor.cooldown(obj) > 0
    return draw_obj_limited(obj, rect) if @actor.skill_limited?(obj)
    return if @actor.custom_skill_costs(obj, :calc_cost) <= 0
    dx = rect.x + rect.width - 48; dy = rect.y
    if @actor.custom_skill_costs(obj, :use_icon) != 0
      icon = @actor.custom_skill_costs(obj, :use_icon)
      draw_icon(icon, rect.x+rect.width-24, rect.y, enabled)
      text = @actor.custom_skill_costs(obj, :text_cost)
      dw = 24
    else
      cost = @actor.custom_skill_costs(obj, :text_cost)
      text = @actor.custom_skill_costs(obj, :suffix)
      text = sprintf(text, cost)
      dw = 44
    end
    self.contents.font.size = @actor.custom_skill_costs(obj, :font_size)
    colour_id = @actor.custom_skill_costs(obj, :colour)
    self.contents.font.color = text_color(colour_id)
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(dx, dy, dw, WLH, text, 2)
  end

  #--------------------------------------------------------------------------
  # new method: draw_obj_cooldown
  #--------------------------------------------------------------------------
  def draw_obj_cooldown(obj, rect, enabled = false)
    hash = YEM::BATTLE_ENGINE::SKILL_SETTINGS
    dx = rect.x + rect.width - 48; dy = rect.y
    if Icon.cooldown != 0
      draw_icon(Icon.cooldown, rect.x+rect.width-24, rect.y, enabled)
      text = @actor.cooldown(obj)
      dw = 24
    else
      cost = @actor.cooldown(obj)
      text = hash[:cooldown_suffix]
      text = sprintf(text, cost)
      dw = 44
    end
    self.contents.font.size = hash[:cooldown_size]
    colour_id = hash[:cooldown_colour]
    self.contents.font.color = text_color(colour_id)
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(dx, dy, dw, WLH, text, 2)
  end

  #--------------------------------------------------------------------------
  # new method: draw_obj_limited
  #--------------------------------------------------------------------------
  def draw_obj_limited(obj, rect, enabled = false)
    hash = YEM::BATTLE_ENGINE::SKILL_SETTINGS
    dx = rect.x + rect.width - 48; dy = rect.y
    text = hash[:limited_text]
    if Icon.cooldown != 0
      draw_icon(Icon.limited_use, rect.x+rect.width-24, rect.y, enabled)
      dw = 24
    else
      dw = 24
    end
    self.contents.font.size = hash[:limited_size]
    colour_id = hash[:limited_colour]
    self.contents.font.color = text_color(colour_id)
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(dx, dy, dw, WLH, text, 2)
  end

end # Window_Skill

#===============================================================================
# Window_Item
#===============================================================================

class Window_Item < Window_Selectable

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :battle_refresh_call

  #--------------------------------------------------------------------------
  # new method: update
  #--------------------------------------------------------------------------
  def update
    if @battle_refresh_call
      $game_temp.less_spacing = true
      refresh
      @battle_refresh_call = false
      $game_temp.less_spacing = nil
    end
    super
  end

  #--------------------------------------------------------------------------
  # overwrite method: include
  #--------------------------------------------------------------------------
  def include?(item)
    return false if item == nil
    return false if $game_temp.in_battle and !$game_party.item_can_use?(item)
    return false if item.name == ""
    return true
  end

  #--------------------------------------------------------------------------
  # overwrite method: refresh
  #--------------------------------------------------------------------------
  def refresh
    @spacing = 4 if $game_temp.less_spacing
    @data = []
    for item in $game_party.items
      next unless include?(item)
      @data.push(item)
      if item.is_a?(RPG::Item) and item.id == $game_party.last_item_id
        self.index = @data.size - 1 unless @first_time
      end
    end
    @data.push(nil) if include?(nil)
    @item_max = @data.size
    create_contents
    @first_time = true
    for i in 0...@item_max; draw_item(i); end
  end

  #--------------------------------------------------------------------------
  # alias method: enable?
  #--------------------------------------------------------------------------
  alias enable_window_item_bem enable? unless $@
  def enable?(item)
    if $scene.is_a?(Scene_Battle) and $scene.selected_battler != nil
      return $scene.selected_battler.item_can_use?(item)
    end
    return enable_window_item_bem(item)
  end

  #--------------------------------------------------------------------------
  # overwrite method: draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    return if item == nil
    enabled = enable?(item)
    draw_obj_name(item, rect.clone, enabled)
    draw_obj_charges(item, rect.clone, enabled)
    draw_obj_total(item, rect.clone, enabled)
  end

  #--------------------------------------------------------------------------
  # new method: draw_obj_name
  #--------------------------------------------------------------------------
  def draw_obj_name(obj, rect, enabled)
    draw_icon(obj.icon_index, rect.x, rect.y, enabled)
    self.contents.font.size = Font.default_size
    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    rect.width -= 48
    self.contents.draw_text(rect.x+24, rect.y, rect.width-24, WLH, obj.name)
  end

  #--------------------------------------------------------------------------
  # new method: draw_obj_charges
  #--------------------------------------------------------------------------
  def draw_obj_charges(obj, rect, enabled)
    return unless obj.is_a?(RPG::Item)
    return unless obj.consumable
    return if obj.charges <= 1
    $game_party.item_charges = {} if $game_party.item_charges == nil
    $game_party.item_charges[obj.id] = obj.charges if
      $game_party.item_charges[obj.id] == nil
    charges = $game_party.item_charges[obj.id]
    dx = rect.x; dy = rect.y + WLH/3
    self.contents.font.size = YEM::BATTLE_ENGINE::ITEM_SETTINGS[:charge]
    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(dx, dy, 24, WLH * 2/3, charges, 2)
    self.contents.font.size = Font.default_size
  end

  #--------------------------------------------------------------------------
  # new method: draw_obj_total
  #--------------------------------------------------------------------------
  def draw_obj_total(obj, rect, enabled)
    hash = YEM::BATTLE_ENGINE::ITEM_SETTINGS
    number = $game_party.item_number(obj)
    dx = rect.x + rect.width - 36; dy = rect.y; dw = 32
    text = sprintf(hash[:text], number)
    self.contents.font.size = hash[:size]
    self.contents.font.color = text_color(hash[:colour])
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(dx, dy, dw, WLH, text, 2)
  end

end # Window_Item

#===============================================================================
# Window_PartyCommand
#===============================================================================

class Window_PartyCommand < Window_Command

  #--------------------------------------------------------------------------
  # overwrite method: initialize
  #--------------------------------------------------------------------------
  def initialize
    array = create_command_list
    super(128, array)
    self.height = 128
    self.active = false
  end

  #--------------------------------------------------------------------------
  # item
  #--------------------------------------------------------------------------
  def item; return @data[self.index]; end

  #--------------------------------------------------------------------------
  # new method: create_command_list
  #--------------------------------------------------------------------------
  def create_command_list
    @data = []; array = []
    for command in YEM::BATTLE_ENGINE::PARTY_COMMANDS
      case command
      when :fight
        array.push(Vocab.fight)
      when :execute
        next unless $scene.dtb?
        vocab = YEM::BATTLE_ENGINE::PARTY_VOCAB[command]
        array.push(vocab)
      when :status, :option
        vocab = YEM::BATTLE_ENGINE::PARTY_VOCAB[command]
        array.push(vocab)
      when :escape
        next unless $scene.dtb? or $scene.ptb?
        array.push(Vocab.escape)
      when :turnskip
        next unless $scene.ptb?
        vocab = YEM::BATTLE_ENGINE::PARTY_VOCAB[command]
        array.push(vocab)
      when :atb_type
        next unless $scene.atb?
        array.push("ATB_COMMAND_TYPE")
      when :atb_speed
        next unless $scene.atb?
        array.push("ATB_COMMAND_SPEED")
      else; next
      end
      @data.push(command)
    end
    return array
  end

  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index, enabled = true)
    rect = item_rect(index)
    rect.x += 4
    rect.width -= 8
    enabled = enabled?(@data[index])
    self.contents.clear_rect(rect)
    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    text = @commands[index]
    #---
    case text
    when "ATB_COMMAND_TYPE"
      case $game_variables[YEM::BATTLE_ENGINE::OPTIONS[:atb_avariable]]
      when 0; key = :atb_t0
      when 1; key = :atb_t1
      when 2; key = :atb_t2
      when 3; key = :atb_t3
      else; return
      end
      text = YEM::BATTLE_ENGINE::PARTY_VOCAB[key]
    when "ATB_COMMAND_SPEED"
      text = YEM::BATTLE_ENGINE::PARTY_VOCAB[:atb_spd]
      variable = YEM::BATTLE_ENGINE::OPTIONS[:atb_svariable]
      text = sprintf(text, $game_variables[variable])
    end
    #---
    self.contents.draw_text(rect, text, 1)
  end

  #--------------------------------------------------------------------------
  # enabled?
  #--------------------------------------------------------------------------
  def enabled?(obj)
    return $game_troop.can_escape if obj == :escape
    return true
  end

end # Window_PartyCommand

#===============================================================================
# Window_ActorCommand
#===============================================================================

class Window_ActorCommand < Window_Command

  #--------------------------------------------------------------------------
  # public instance variable
  #--------------------------------------------------------------------------
  attr_accessor :actor

  #--------------------------------------------------------------------------
  # alias method: initialize
  #--------------------------------------------------------------------------
  alias initialize_window_actorcommand_bem initialize unless $@
  def initialize
    @disable_empty_commands = YEM::BATTLE_ENGINE::DISABLE_EMPTY_COMMANDS
    initialize_window_actorcommand_bem
  end

  #--------------------------------------------------------------------------
  # new method: item
  #--------------------------------------------------------------------------
  def item; return @data[self.index]; end

  #--------------------------------------------------------------------------
  # new method: skill
  #--------------------------------------------------------------------------
  def skill; return $data_skills[@skills[item]]; end

  #--------------------------------------------------------------------------
  # overwrite method: setup
  #--------------------------------------------------------------------------
  def setup(actor)
    @actor = actor
    @data = []; @commands = []; @skills = {}
    data_set = actor.class.id
    data_set = 0 if !YEM::BATTLE_ENGINE::CLASS_COMMANDS.include?(actor.class.id)
    #---
    for item in YEM::BATTLE_ENGINE::CLASS_COMMANDS[data_set]
      case item
      when :attack; @commands.push(actor.attack_vocab)
      when :skill;  @commands.push(actor.skill_vocab)
      when :guard;  @commands.push(actor.guard_vocab)
      when :item;   @commands.push(Vocab.item)
      when :equip;  @commands.push(YEM::BATTLE_ENGINE::EQUIP_VOCAB)
      when :escape
        next unless $game_troop.can_escape
        @commands.push(Vocab.escape)
      else
        valid = false
        if YEM::BATTLE_ENGINE::SKILL_COMMANDS.include?(item)
          @skills[item] = YEM::BATTLE_ENGINE::SKILL_COMMANDS[item][0]
          @commands.push(YEM::BATTLE_ENGINE::SKILL_COMMANDS[item][1])
          valid = true
        end
        next unless valid
      end
      @data.push(item)
    end
    #---
    @item_max = @commands.size
    refresh
    self.index = 0
  end

  #--------------------------------------------------------------------------
  # new method: update
  #--------------------------------------------------------------------------
  def update
    return unless $scene.is_a?(Scene_Battle)
    super unless Input.trigger?(Input::L) or Input.trigger?(Input::R)
    return unless @actor == $scene.status_window.actor
    refresh if @actor != nil and @actor.update_commands
  end

  #--------------------------------------------------------------------------
  # new method: refresh
  #--------------------------------------------------------------------------
  def refresh
    create_contents
    @actor.update_commands = false if @actor != nil
    for i in 0...@item_max
      draw_item(i)
    end
  end

  #--------------------------------------------------------------------------
  # new method: draw_item
  #--------------------------------------------------------------------------
  def draw_item(index, enabled = true)
    rect = item_rect(index)
    rect.x += 4
    rect.width -= 8
    obj = @data[index]
    enabled = enabled?(obj)
    self.contents.clear_rect(rect)
    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(rect, @commands[index], 1)
  end

  #--------------------------------------------------------------------------
  # new method: enabled?
  #--------------------------------------------------------------------------
  def enabled?(obj = nil)
    return false unless @actor.actor?
    if @actor.auto_battle
      return true if obj == :equip and @actor.equip_cooldown.to_i <= 0
      return true if obj == :escape and $game_troop.can_escape
      return false
    end
    return false unless @actor.inputable?
    return false if obj == nil
    return false if obj == :equip and @actor.equip_cooldown.to_i > 0
    if @disable_empty_commands
      return false if obj == :skill and @actor.skills.size <= 0
      return false if obj == :item and $game_party.battle_item_size <= 0
    end
    if @skills.include?(obj)
      skill = $data_skills[@skills[obj]]
      return @actor.skill_can_use?(skill)
    end
    return true
  end

end # Window_ActorCommand

#===============================================================================
# Window_ConfirmCommand
#===============================================================================

class Window_ConfirmCommand < Window_Command

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    array = create_command_list
    super(128, array)
    self.openness = 0
    self.height = 128
    self.active = false
  end

  #--------------------------------------------------------------------------
  # item
  #--------------------------------------------------------------------------
  def item; return @data[self.index]; end

  #--------------------------------------------------------------------------
  # create_command_list
  #--------------------------------------------------------------------------
  def create_command_list
    @data = []; array = []
    for command in YEM::BATTLE_ENGINE::CONFIRM_COMMANDS
      case command
      when :confirm
        next unless $scene.dtb?
        vocab = YEM::BATTLE_ENGINE::CONFIRM_VOCAB[command]
        array.push(vocab)
      when :status, :option
        vocab = YEM::BATTLE_ENGINE::CONFIRM_VOCAB[command]
        array.push(vocab)
      when :escape
        next unless $scene.dtb? or $scene.ptb?
        array.push(Vocab.escape)
      when :turnskip
        next unless $scene.ptb?
        vocab = YEM::BATTLE_ENGINE::CONFIRM_VOCAB[command]
        array.push(vocab)
      when :atb_type
        next unless $scene.atb?
        array.push("ATB_COMMAND_TYPE")
      when :atb_speed
        next unless $scene.atb?
        array.push("ATB_COMMAND_SPEED")
      else; next
      end
      @data.push(command)
    end
    return array
  end

  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index, enabled = true)
    rect = item_rect(index)
    rect.x += 4
    rect.width -= 8
    enabled = enabled?(@data[index])
    self.contents.clear_rect(rect)
    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    text = @commands[index]
    #---
    case text
    when "ATB_COMMAND_TYPE"
      case $game_variables[YEM::BATTLE_ENGINE::OPTIONS[:atb_avariable]]
      when 0; key = :atb_t0
      when 1; key = :atb_t1
      when 2; key = :atb_t2
      when 3; key = :atb_t3
      else; return
      end
      text = YEM::BATTLE_ENGINE::CONFIRM_VOCAB[key]
    when "ATB_COMMAND_SPEED"
      text = YEM::BATTLE_ENGINE::CONFIRM_VOCAB[:atb_spd]
      variable = YEM::BATTLE_ENGINE::OPTIONS[:atb_svariable]
      text = sprintf(text, $game_variables[variable])
    end
    #---
    self.contents.draw_text(rect, text, 1)
  end

  #--------------------------------------------------------------------------
  # enabled?
  #--------------------------------------------------------------------------
  def enabled?(obj)
    return $game_troop.can_escape if obj == :escape
    return true
  end

end # Window_ConfirmCommand

#===============================================================================
# Window_BattleActor
#===============================================================================

class Window_BattleActor < Window_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, Graphics.width, Graphics.height - 128)
    @letter_ranks = YEM::BATTLE_ENGINE::TEXT_RANKS[:enable]
    refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh(index = 0)
    self.contents.clear
    @actor = $game_party.members[index]
    return if @actor == nil
    self.contents.font.size = Font.default_size
    self.contents.font.color = normal_color
    dx = 8; dy = 0
    #--- Left Half ---
    draw_actor_face(@actor, dx, dy)
    draw_actor_name(@actor, dx+112, dy); dy += WLH
    draw_actor_class(@actor, dx+112, dy); dy += WLH
    draw_actor_level(@actor, dx+112, dy); dy += WLH*2
    dw = contents.width/2 - dx - 24
    draw_actor_hp(@actor, dx, dy, dw); dy += WLH
    draw_actor_mp(@actor, dx, dy, dw); dy += WLH
    #--- Right Half ---
    dx = contents.width/2; dy = WLH/2
    draw_actor_elements(@actor, dx, dy); dy += WLH*3
    draw_actor_states(@actor, dx, dy); dy = WLH*6 + 8
    draw_actor_parameters(@actor, dx, dy)
  end

  #--------------------------------------------------------------------------
  # draw_actor_elements
  #--------------------------------------------------------------------------
  def draw_actor_elements(actor, dx, dy)
    self.contents.font.size = YEM::BATTLE_ENGINE::TEXT_RANK_SIZE
    dw = contents.width - dx
    spacing = YEM::BATTLE_ENGINE::ELEMENT_SPACING
    array = YEM::BATTLE_ENGINE::ALLY_ELEMENTS
    dx = dx + dw - (array.size*(spacing+24)) - spacing*3/2
    for element_id in array
      next if element_id > $data_system.elements.size
      icon = Icon.element(element_id)
      draw_icon(icon, dx, dy)
      rate = actor.element_rate(element_id)
      text = sprintf("%d%%", rate)
      if rate > 200;    colour = :rank_s
      elsif rate > 150; colour = :rank_a
      elsif rate > 100; colour = :rank_b
      elsif rate > 50;  colour = :rank_c
      elsif rate > 0;   colour = :rank_d
      elsif rate == 0;  colour = :rank_e
      else;             colour = :rank_f
      end
      text = YEM::BATTLE_ENGINE::TEXT_RANKS[colour] if @letter_ranks
      colour = YEM::BATTLE_ENGINE::RANK_COLOURS[colour]
      self.contents.font.color = text_color(colour)
      self.contents.draw_text(dx-spacing/2, dy+WLH, spacing+24, WLH, text, 1)
      dx += spacing+24
    end
  end

  #--------------------------------------------------------------------------
  # draw_actor_states
  #--------------------------------------------------------------------------
  def draw_actor_states(actor, dx, dy)
    self.contents.font.size = YEM::BATTLE_ENGINE::TEXT_RANK_SIZE
    dw = contents.width - dx
    spacing = YEM::BATTLE_ENGINE::STATE_SPACING
    array = YEM::BATTLE_ENGINE::ALLY_STATES
    dx = dx + dw - (array.size*(spacing+24)) - spacing*3/2
    for state_id in array
      state = $data_states[state_id]
      next if state == nil
      icon = state.icon_index
      draw_icon(icon, dx, dy)
      rate = actor.state_probability(state_id)
      text = sprintf("%d%%", rate)
      if rate > 100;   colour = :rank_s
      elsif rate > 80; colour = :rank_a
      elsif rate > 60; colour = :rank_b
      elsif rate > 40; colour = :rank_c
      elsif rate > 20; colour = :rank_d
      elsif rate > 0;  colour = :rank_e
      else;            colour = :rank_f
      end
      text = YEM::BATTLE_ENGINE::TEXT_RANKS[colour] if @letter_ranks
      colour = YEM::BATTLE_ENGINE::RANK_COLOURS[colour]
      self.contents.font.color = text_color(colour)
      self.contents.draw_text(dx-spacing/2, dy+WLH, spacing+24, WLH, text, 1)
      dx += spacing+24
    end
  end

  #--------------------------------------------------------------------------
  # draw_actor_parameters
  #--------------------------------------------------------------------------
  def draw_actor_parameters(actor, dx, dy)
    self.contents.font.size = YEM::BATTLE_ENGINE::TEXT_STAT_SIZE
    fx = dx; fy = dy
    dw = (contents.width - dx)/2 - 4
    for stat in YEM::BATTLE_ENGINE::ALLY_STATS
      case stat
      when :atk
        name = Vocab.atk
        value = actor.atk
      when :def
        name = Vocab.def
        value = actor.def
      when :spi
        name = Vocab.spi
        value = actor.spi
      when :res
        next unless $imported["RES Stat"]
        name = Vocab.res
        value = actor.res
      when :dex
        next unless $imported["DEX Stat"]
        name = Vocab.dex
        value = actor.dex
      when :agi
        name = Vocab.agi
        value = actor.agi
      when :hit
        name = Vocab.hit
        value = sprintf("%d%%", [[actor.hit, 1].max, 99].min)
      when :eva
        name = Vocab.eva
        value = sprintf("%d%%", [[actor.eva, 1].max, 99].min)
      when :cri
        name = Vocab.cri
        value = sprintf("%d%%", [[actor.cri, 1].max, 99].min)
      when :odds
        name = Vocab.odds
        value = actor.odds * 100 / total_party_odds
        value = sprintf("%d%%", [[value, 1].max, 99].min)
      else; next
      end
      draw_icon(Icon.stat(actor, stat), dx, dy)
      self.contents.font.color = system_color
      self.contents.draw_text(dx+24, dy, 40, WLH, name)
      self.contents.font.color = normal_color
      self.contents.draw_text(dx+64, dy, dw-72, WLH, value, 2)
      dx += dw + 4
      if dx + dw + 4 > contents.width
        dx = fx
        dy += WLH
        break if dy + WLH > contents.height
      end
    end
  end

  #--------------------------------------------------------------------------
  # total_party_odds
  #--------------------------------------------------------------------------
  def total_party_odds
    return @total_odds if @total_odds != nil
    @total_odds = 0
    for member in $game_party.members
      @total_odds += member.odds
    end
    return @total_odds
  end

end # Window_BattleActor

#===============================================================================
# Window_BattleActorStates
#===============================================================================

class Window_BattleActorStates < Window_Selectable

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    dx = 8; dy = WLH*7 - 16
    super(dx, dy, Graphics.width/2 - dx*2, Graphics.height - 128 - dy)
    @draw_state_turns = $imported["CoreFixesUpgradesMelody"]
    self.back_opacity = 0
    self.opacity = 0
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh(actor = nil)
    @data = []
    @actor = actor
    if @actor == nil
      self.index = -1
      @item_max = 0
      create_contents
      return
    end
    for state in actor.states
      next if state == nil
      @data.push(state)
    end
    @data = [:normal] if @data == []
    @item_max = @data.size
    create_contents
    self.index = (@item_max > 0) ? 0 : -1
    for i in 0...@item_max; draw_item(i); end
  end

  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    state = @data[index]
    return if state == nil
    if state == :normal
      draw_icon(Icon.normal_state, rect.x, rect.y)
      text = YEM::BATTLE_ENGINE::TEXT_NORMAL_STATE
    else
      draw_icon(state.icon_index, rect.x, rect.y)
      draw_state_turns(rect.x, rect.y, state, @actor) if @draw_state_turns
      text = state.name
      if @actor.stack(state) > 1
        display = YEM::BATTLE_ENGINE::STATE_SETTINGS[:stack_display]
        text = sprintf(display, text, @actor.stack(state).to_s)
      end
    end
    self.contents.font.color = normal_color
    self.contents.font.bold = Font.default_bold
    self.contents.font.size = Font.default_size
    self.contents.draw_text(rect.x+24, rect.y, rect.width-28, WLH, text)
  end

end # Window_BattleActorStates

#===============================================================================
# Window_BattleOptions
#===============================================================================

class Window_BattleOptions < Window_Selectable

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(dx, dy)
    super(dx, dy, Graphics.width-dx, Graphics.height-dy-128)
    self.index = 0
    refresh
  end

  #--------------------------------------------------------------------------
  # item
  #--------------------------------------------------------------------------
  def item; return @data[self.index]; end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    for command in YEM::BATTLE_ENGINE::OPTION_COMMANDS
      case command
      when :bgm_volume, :bgs_volume, :sfx_volume
      when :animations, :autocursor, :next_actor, :skill_help
      when :atb_active, :atb_speeds; next unless $scene.atb?
      when :cinematics; next
      else; next
      end
      @data.push(command)
    end
    @item_max = @data.size
    create_contents
    for i in 0...@item_max; draw_item(i); end
  end

  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    obj = @data[index]
    return if obj == nil
    case obj
    when :bgm_volume, :bgs_volume, :sfx_volume
      draw_volume_item(obj, rect.clone)
    when :animations, :autocursor, :next_actor, :skill_help, :cinematics
      draw_switch_item(obj, rect.clone)
    when :atb_active, :atb_speeds
      draw_atb_item(obj, rect.clone)
    end
  end

  #--------------------------------------------------------------------------
  # draw_volume_item
  #--------------------------------------------------------------------------
  def draw_volume_item(obj, rect)
    options = YEM::BATTLE_ENGINE::OPTIONS
    case obj
    when :bgm_volume
      title = options[:bgm_volume]
      value = $game_variables[options[:bgm_variable]]
      mute  = $game_switches[options[:bgm_mute_sw]]
    when :bgs_volume
      title = options[:bgs_volume]
      value = $game_variables[options[:bgs_variable]]
      mute  = $game_switches[options[:bgs_mute_sw]]
    when :sfx_volume
      title = options[:sfx_volume]
      value = $game_variables[options[:sfx_variable]]
      mute  = $game_switches[options[:sfx_mute_sw]]
    else; return
    end
    value = sprintf(options[:audio], value)
    self.contents.font.color = normal_color
    self.contents.draw_text(rect.x, rect.y, rect.width/2, WLH, title, 1)
    self.contents.font.color.alpha = mute ? 128 : 255
    dx = rect.x + rect.width/2
    self.contents.draw_text(dx, rect.y, rect.width/4, WLH, value, 1)
    self.contents.font.color.alpha = mute ? 255 : 128
    dx = rect.x + rect.width*3/4
    self.contents.draw_text(dx, rect.y, rect.width/4, WLH, options[:mute], 1)
  end

  #--------------------------------------------------------------------------
  # draw_switch_item
  #--------------------------------------------------------------------------
  def draw_switch_item(obj, rect)
    options = YEM::BATTLE_ENGINE::OPTIONS
    title = options[obj]
    case obj
    when :animations
      name1 = options[:ani_show]
      name2 = options[:ani_hide]
      toggle = $game_switches[options[:animation_sw]]
    when :autocursor
      name1 = options[:curmem_on]
      name2 = options[:curmem_off]
      toggle = $game_switches[options[:autocursor_sw]]
    when :next_actor
      name1 = options[:next_on]
      name2 = options[:next_off]
      toggle = $game_switches[options[:next_actor_sw]]
    when :skill_help
      name1 = options[:help_on]
      name2 = options[:help_off]
      toggle = $game_switches[options[:skill_help_sw]]
    when :cinematics
      name1 = options[:cinem_on]
      name2 = options[:cinem_off]
      toggle = $game_switches[options[:cinematics_sw]]
    else; return
    end
    self.contents.font.color = normal_color
    self.contents.draw_text(rect.x, rect.y, rect.width/2, WLH, title, 1)
    self.contents.font.color.alpha = toggle ? 255 : 128
    dx = rect.x + rect.width/2
    self.contents.draw_text(dx, rect.y, rect.width/4, WLH, name1, 1)
    self.contents.font.color.alpha = toggle ? 128 : 255
    dx = rect.x + rect.width*3/4
    self.contents.draw_text(dx, rect.y, rect.width/4, WLH, name2, 1)
  end

  #--------------------------------------------------------------------------
  # draw_atb_item
  #--------------------------------------------------------------------------
  def draw_atb_item(obj, rect)
    options = YEM::BATTLE_ENGINE::OPTIONS
    case obj
    when :atb_active
      title = options[:atb_aname]
      value = $game_variables[options[:atb_avariable]]
      #---
      self.contents.font.color = normal_color
      name1 = options[:wait_0]
      dx = rect.x + rect.width/2
      self.contents.font.color.alpha = (value == 0) ? 255 : 128
      self.contents.draw_text(dx, rect.y, rect.width/8, WLH, name1, 1)
      name2 = options[:wait_1]
      dx = rect.x + rect.width*5/8
      self.contents.font.color.alpha = (value == 1) ? 255 : 128
      self.contents.draw_text(dx, rect.y, rect.width/8, WLH, name2, 1)
      name3 = options[:wait_2]
      dx = rect.x + rect.width*6/8
      self.contents.font.color.alpha = (value == 2) ? 255 : 128
      self.contents.draw_text(dx, rect.y, rect.width/8, WLH, name3, 1)
      name4 = options[:wait_3]
      dx = rect.x + rect.width*7/8
      self.contents.font.color.alpha = (value == 3) ? 255 : 128
      self.contents.draw_text(dx, rect.y, rect.width/8, WLH, name4, 1)
      #---
    when :atb_speeds
      title = options[:atb_sname]
      value = $game_variables[options[:atb_svariable]] - 1
      #---
      for i in 0...10
        self.contents.font.color = normal_color
        name = (i + 1).to_s
        dx = rect.x + rect.width * (10 + i)/20
        self.contents.font.color.alpha = (value == i) ? 255 : 128
        self.contents.draw_text(dx, rect.y, rect.width/20, WLH, name, 1)
      end
      #---
    else; return
    end
    self.contents.font.color = normal_color
    self.contents.draw_text(rect.x, rect.y, rect.width/2, WLH, title, 1)
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    if Input.trigger?(Input::C)
      input_case_c
    elsif Input.repeat?(Input::LEFT)
      input_case_left
    elsif Input.repeat?(Input::RIGHT)
      input_case_right
    end
  end

  #--------------------------------------------------------------------------
  # input_case_c
  #--------------------------------------------------------------------------
  def input_case_c
    options = YEM::BATTLE_ENGINE::OPTIONS
    case item
    when :bgm_volume; switch = options[:bgm_mute_sw]
    when :bgs_volume; switch = options[:bgs_mute_sw]
    when :sfx_volume; switch = options[:sfx_mute_sw]
    when :animations; switch = options[:animation_sw]
    when :autocursor; switch = options[:autocursor_sw]
    when :next_actor; switch = options[:next_actor_sw]
    when :skill_help; switch = options[:skill_help_sw]
    when :cinematics; switch = options[:cinematics_sw]
    else; return
    end
    $game_switches[switch] = !$game_switches[switch]
    Sound.play_decision
    RPG::BGM::last.play if item == :bgm_volume
    RPG::BGS::last.play if item == :bgs_volume
    draw_item(self.index)
  end

  #--------------------------------------------------------------------------
  # input_case_left
  #--------------------------------------------------------------------------
  def input_case_left
    options = YEM::BATTLE_ENGINE::OPTIONS
    ignore = false
    case item
    when :bgm_volume, :bgs_volume, :sfx_volume
      value = Input.press?(Input::SHIFT) ? 10 : 1
      case item
      when :bgm_volume; variable = options[:bgm_variable]
      when :bgs_volume; variable = options[:bgs_variable]
      when :sfx_volume; variable = options[:sfx_variable]
      end
      return if $game_variables[variable] == 0
      $game_variables[variable] -= value
      $game_variables[variable] = [$game_variables[variable], 0].max
      ignore = true
    when :atb_active
      variable = options[:atb_avariable]
      return if $game_variables[variable] == 0
      $game_variables[variable] -= 1
      $game_variables[variable] = [$game_variables[variable], 0].max
      ignore = true
      if $scene.is_a?(Scene_Battle) and $scene.atb?
        $scene.party_command_window.refresh
        $scene.confirm_command_window.refresh
      end
    when :atb_speeds
      variable = options[:atb_svariable]
      return if $game_variables[variable] == 1
      $game_variables[variable] -= 1
      $game_variables[variable] = [$game_variables[variable], 1].max
      ignore = true
      if $scene.is_a?(Scene_Battle) and $scene.atb?
        $scene.party_command_window.refresh
        $scene.confirm_command_window.refresh
      end
    when :animations; switch = options[:animation_sw]
    when :autocursor; switch = options[:autocursor_sw]
    when :next_actor; switch = options[:next_actor_sw]
    when :skill_help; switch = options[:skill_help_sw]
    when :cinematics; switch = options[:cinematics_sw]
    else; return
    end
    unless ignore
      return if $game_switches[switch]
      $game_switches[switch] = true
    end
    Sound.play_cursor
    RPG::BGM::last.play if item == :bgm_volume
    RPG::BGS::last.play if item == :bgs_volume
    draw_item(self.index)
  end

  #--------------------------------------------------------------------------
  # input_case_right
  #--------------------------------------------------------------------------
  def input_case_right
    options = YEM::BATTLE_ENGINE::OPTIONS
    ignore = false
    case item
    when :bgm_volume, :bgs_volume, :sfx_volume
      value = Input.press?(Input::SHIFT) ? 10 : 1
      case item
      when :bgm_volume; variable = options[:bgm_variable]
      when :bgs_volume; variable = options[:bgs_variable]
      when :sfx_volume; variable = options[:sfx_variable]
      end
      return if $game_variables[variable] == 100
      $game_variables[variable] += value
      $game_variables[variable] = [$game_variables[variable], 100].min
      ignore = true
    when :atb_active
      variable = options[:atb_avariable]
      return if $game_variables[variable] == 3
      $game_variables[variable] += 1
      $game_variables[variable] = [$game_variables[variable], 3].min
      ignore = true
      if $scene.is_a?(Scene_Battle) and $scene.atb?
        $scene.party_command_window.refresh
        $scene.confirm_command_window.refresh
      end
    when :atb_speeds
      variable = options[:atb_svariable]
      return if $game_variables[variable] == 10
      $game_variables[variable] += 1
      $game_variables[variable] = [$game_variables[variable], 10].min
      ignore = true
      if $scene.is_a?(Scene_Battle) and $scene.atb?
        $scene.party_command_window.refresh
        $scene.confirm_command_window.refresh
      end
    when :animations; switch = options[:animation_sw]
    when :autocursor; switch = options[:autocursor_sw]
    when :next_actor; switch = options[:next_actor_sw]
    when :skill_help; switch = options[:skill_help_sw]
    when :cinematics; switch = options[:cinematics_sw]
    else; return
    end
    unless ignore
      return if !$game_switches[switch]
      $game_switches[switch] = false
    end
    Sound.play_cursor
    RPG::BGM::last.play if item == :bgm_volume
    RPG::BGS::last.play if item == :bgs_volume
    draw_item(self.index)
  end

  #--------------------------------------------------------------------------
  # update_help
  #--------------------------------------------------------------------------
  def update_help
    case item
    when :bgm_volume; type = :bgm_des
    when :bgs_volume; type = :bgs_des
    when :sfx_volume; type = :sfx_des
    when :animations; type = :ani_des
    when :autocursor; type = :curmem_des
    when :next_actor; type = :next_des
    when :skill_help; type = :help_des
    when :cinematics; type = :cinem_des
    when :atb_active
      case $game_variables[YEM::BATTLE_ENGINE::OPTIONS[:atb_avariable]]
      when 0; type = :wait_0_des
      when 1; type = :wait_1_des
      when 2; type = :wait_2_des
      when 3: type = :wait_3_des
      end
    when :atb_speeds; type = :atb_s_des
    else; type = nil
    end
    text = YEM::BATTLE_ENGINE::OPTIONS[type].to_s
    @help_window.set_text(text, 1)
  end

end # Window_BattleOptions

#===============================================================================
# Window_PressTurns
#===============================================================================

class Window_PressTurns < Window_Base

  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :update_call

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(group)
    @group = group
    super(-16, -64, Graphics.width + 16, 80)
    self.z = 10
    self.back_opacity = 0
    self.opacity = 0
    set_icons
    @appear = false
    @disappear = false
  end

  #--------------------------------------------------------------------------
  # set_icons
  #--------------------------------------------------------------------------
  def set_icons
    if @group.is_a?(Game_Party)
      @turn_icon = YEM::BATTLE_ENGINE::BATTLER_ICON_BORDERS[:actor][2]
      @used_icon = YEM::BATTLE_ENGINE::BATTLER_ICON_BORDERS[:actor][3]
      @bonus_icon = YEM::BATTLE_ENGINE::BATTLER_ICON_BORDERS[:actor][4]
    else
      @turn_icon = YEM::BATTLE_ENGINE::BATTLER_ICON_BORDERS[:enemy][2]
      @used_icon = YEM::BATTLE_ENGINE::BATTLER_ICON_BORDERS[:enemy][3]
      @bonus_icon = YEM::BATTLE_ENGINE::BATTLER_ICON_BORDERS[:enemy][4]
    end
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    if @appear
      self.y = [self.y + 4, -16].min
      @appear = false if self.y >= -16
    elsif @disappear
      self.y = [self.y - 4, -64].max
      @disappear = false if self.y <= -64
    end
    refresh if @update_call
  end

  #--------------------------------------------------------------------------
  # appear
  #--------------------------------------------------------------------------
  def appear
    @appear = true
    @disappear = false
    self.z = 11
    refresh
  end

  #--------------------------------------------------------------------------
  # disappear
  #--------------------------------------------------------------------------
  def disappear
    @disappear = true
    @appear = false
    self.z = 10
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @update_call = false
    dx = draw_turn_icons
    dx = draw_bonus_icons(dx)
    draw_used_icons(dx)
  end

  #--------------------------------------------------------------------------
  # draw_turn_icons
  #--------------------------------------------------------------------------
  def draw_turn_icons(dx = 12)
    @dy = 6
    amount = @group.ptb_total_turns
    amount -= @group.ptb_bonus_turns
    amount.times do
      draw_icon(@turn_icon, dx, @dy)
      @dy = (@dy == 6) ? 18 : 6
      dx += 24
    end
    return dx
  end

  #--------------------------------------------------------------------------
  # draw_bonus_icons
  #--------------------------------------------------------------------------
  def draw_bonus_icons(dx)
    return dx if @group.ptb_total_turns <= 0
    amount = @group.ptb_bonus_turns
    amount.times do
      draw_icon(@turn_icon, dx, @dy)
      @dy = (@dy == 6) ? 18 : 6
      dx += 24
    end
    return dx
  end

  #--------------------------------------------------------------------------
  # draw_used_icons
  #--------------------------------------------------------------------------
  def draw_used_icons(dx)
    amount = @group.ptb_member_turns
    amount -= @group.ptb_total_turns
    return if amount <= 0
    amount.times do
      draw_icon(@used_icon, dx, @dy)
      @dy = (@dy == 6) ? 18 : 6
      dx += 24
    end
  end

end # Window_PressTurns

#===============================================================================
# Window_EnemyGauge
#===============================================================================

class Window_EnemyGauge < Window_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 120, WLH*3+32)
    self.visible = false
    self.opacity = 0
    self.back_opacity = 0
    self.z = 16000
  end

  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    return unless $scene.is_a?(Scene_Battle)
    return unless $scene.atb?
    if @battler == nil
      self.visible = false
      return
    end
    refresh_call = false
    #---
    refresh_call = true if @current_hp != @battler.hp
    refresh_call = true if @current_maxhp != @battler.maxhp
    refresh_call = true if @current_mp != @battler.mp
    refresh_call = true if @current_maxmp != @battler.maxmp
    refresh_call = true if @current_states != @battler.states
    #---
    if @current_x != @battler.screen_x or @current_y != @battler.screen_y
      @current_x = @battler.screen_x
      @current_y = @battler.screen_y
      self.x = @battler.screen_x - self.width/2
      self.x -= $scene.spriteset.viewport1.ox
      self.y = @battler.screen_y - self.height/2 - WLH + 12
      self.y -= $scene.spriteset.viewport1.oy
    end
    #---
    refresh if refresh_call
  end

  #--------------------------------------------------------------------------
  # battler=
  #--------------------------------------------------------------------------
  def battler=(battler)
    @battler = battler
    if @battler == nil
      self.visible = false
      return
    end
    self.visible = true
    self.width = @battler.enemy.quick_gauge[:width]
    @current_x = @battler.screen_x
    @current_y = @battler.screen_y
    self.x = @battler.screen_x - self.width/2
    self.x -= $scene.spriteset.viewport1.ox
    self.y = @battler.screen_y - self.height/2 - WLH + 12
    self.y -= $scene.spriteset.viewport1.oy
    create_contents
    refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    dy = 0
    sw = contents.width
    #---
    if $scene.atb?
      @current_hp = @battler.hp
      @current_maxhp = @battler.maxhp
      @current_mp = @battler.mp
      @current_maxmp = @battler.maxmp
      @current_states = @battler.states.clone
    end
    #---
    draw_actor_state(@battler,0,WLH,sw) if @battler.enemy.quick_gauge[:states]
    dy += WLH+8
    if @battler.enemy.quick_gauge[:show_hp]
      draw_back_gauge(0, dy, sw)
      draw_enemy_hp_gauge(@battler,1,dy+1,sw-2)
      dy += 7
    end
    if @battler.enemy.quick_gauge[:show_mp]
      draw_back_gauge(0, dy, contents.width)
      if @battler.use_rage?
        draw_enemy_rage_gauge(@battler,1,dy+1,sw/2-1)
        draw_enemy_mp_gauge(@battler,sw/2+1,dy+1,sw/2-2)
      else
        draw_enemy_mp_gauge(@battler,1,dy+1,sw-2)
      end
      dy += 7
    end
  end

  #--------------------------------------------------------------------------
  # new method: draw_back_gauge
  #--------------------------------------------------------------------------
  def draw_back_gauge(x, y, width = 120)
    self.contents.fill_rect(x, y + WLH - 8, width, 8, gauge_back_color)
  end

end # Window_EnemyGauge

#===============================================================================
# Scene_Battle
#===============================================================================

class Scene_Battle < Scene_Base

  #--------------------------------------------------------------------------
  # overwrite method: wait_for_animation
  #--------------------------------------------------------------------------
  def wait_for_animation
    update_basic
    update_basic while @spriteset.animation?
  end

  #--------------------------------------------------------------------------
  # overwrite method: display_attack_animation
  #--------------------------------------------------------------------------
  def display_attack_animation(targets)
    if @active_battler.is_a?(Game_Enemy)
      aid1 = @active_battler.atk_animation_id
      display_normal_animation(targets, aid1)
    else
      aid1 = @active_battler.atk_animation_id
      aid2 = @active_battler.atk_animation_id2
      display_normal_animation(targets, aid1, false)
      wait_for_animation if aid2 != 0
      display_normal_animation(targets, aid2, true)
    end
  end

  #--------------------------------------------------------------------------
  # overwrite method: display_animation
  #--------------------------------------------------------------------------
  def display_animation(targets, animation_id)
    if animation_id < 0
      display_attack_animation(targets)
    else
      display_normal_animation(targets, animation_id)
    end
  end

  #--------------------------------------------------------------------------
  # overwrite method: display_normal_animation
  #--------------------------------------------------------------------------
  def display_normal_animation(targets, animation_id, mirror = false)
    return unless show_animation?
    animation = $data_animations[animation_id]
    return if animation == nil
    mirror = !mirror if @action_values.include?("MIRROR")
    to_screen = (animation.position == 3)
    ani_check = false
    for target in targets.uniq
      if ani_check
        target.pseudo_ani_id = animation_id
      else
        target.animation_id = animation_id
        target.animation_mirror = target_mirror?(mirror, target)
        target.animation_mirror = false if animation.anti_mirror
      end
      ani_check = true if to_screen
    end
  end

  #--------------------------------------------------------------------------
  # overwrite method: display_pseudo_animation
  #--------------------------------------------------------------------------
  def display_pseudo_animation(targets, animation_id)
    return unless show_animation?
    animation = $data_animations[animation_id]
    return if animation == nil
    for target in targets.uniq
      target.pseudo_ani_id = animation_id
    end
  end

  #--------------------------------------------------------------------------
  # new method: wait_for_movement
  #--------------------------------------------------------------------------
  def wait_for_movement
    return if emptyview?
    members = $game_party.members + $game_troop.members
    movers = []; requirement = 0
    for member in members
      next unless member.sprite_movable?
      movers.push(member)
      requirement += 1
    end
    return if requirement == 0
    loop do
      check = 0
      for mover in movers
        next unless mover.sprite_movable?
        next if mover.spriteset.move_to_x != nil
        next if mover.spriteset.move_to_y != nil
        check += 1
      end
      break if check == requirement
      update_basic
    end
  end

  #--------------------------------------------------------------------------
  # new method: wait_for_jump
  #--------------------------------------------------------------------------
  def wait_for_jump
    return if emptyview?
    members = $game_party.members + $game_troop.members
    movers = []; requirement = 0
    for member in members
      next unless member.sprite_movable?
      movers.push(member)
      requirement += 1
    end
    return if requirement == 0
    loop do
      check = 0
      for mover in movers
        next unless mover.sprite_movable?
        next if mover.spriteset.jump_duration != nil
        check += 1
      end
      break if check == requirement
      update_basic
    end
  end

  #--------------------------------------------------------------------------
  # new method: start_victory_poses
  #--------------------------------------------------------------------------
  def start_victory_poses
    for member in $game_party.existing_members
      next unless member.use_battler_animations?
      member.battler_animation_stance("VICTORY")
    end
    return unless $imported["ExtendedMovement"]
    return unless YEM::BATTLE_ENGINE::AUTO_POSES[:victory]
    for member in $game_party.existing_members
      next if member.character == nil
      member.character.break_pose
      member.character.mirror = false
      member.character.pose = "VICTORY"
    end
  end

  #--------------------------------------------------------------------------
  # new method: update_battler_poses
  #--------------------------------------------------------------------------
  def update_battler_poses
    return unless $scene.is_a?(Scene_Battle)
    return if @action_occuring
    for member in @all_members
      update_stances_individual(member)
    end
    #---
    return unless $imported["ExtendedMovement"]
    for member in $game_party.existing_members
      update_pose_individual(member)
    end
    for member in $game_troop.existing_members
      update_pose_individual(member)
    end
  end

  #--------------------------------------------------------------------------
  # new method: update_stances_individual
  #--------------------------------------------------------------------------
  def update_stances_individual(member, ignore_active_battler = false)
    return unless member.use_battler_animations?
    return if member == @active_battler and !ignore_active_battler
    stance = ""
    if member.dead?
      stance = "DEAD"
    elsif member.guarding?
      stance = "GUARDING"
    elsif !member.movable?
      stance = "STASIS"
    elsif member.hp < member.maxhp / 4
      stance = "PIYORI"
    else
      stance = "IDLE"
    end
    return if stance == ""
    member.battler_animation_stance(stance)
  end

  #--------------------------------------------------------------------------
  # new method: update_pose_individual
  #--------------------------------------------------------------------------
  def update_pose_individual(member, ignore_active_battler = false)
    return unless $scene.is_a?(Scene_Battle)
    return unless $imported["ExtendedMovement"]
    return if member == @active_battler and !ignore_active_battler
    return if member.dead?
    return if member.character == nil
    return if member.use_battler_animations?
    auto_poses = YEM::BATTLE_ENGINE::AUTO_POSES
    settings = YEM::BATTLE_ENGINE::POSE_SETTINGS
    if member.hp < member.maxhp / 4
      pose = :piyori
      name = "PIYORI"
      stance = "PIYORI"
    elsif member.guarding?
      pose = :guard
      name = "GUARDING"
      stance = "GUARDING"
    else
      pose = :ready
      name = "READY"
      stance = "IDLE"
    end
    return if member.character.pose == name.upcase
    member.character.break_pose
    member.character.step_anime = true
    return unless auto_poses[pose]
    direction = member.character.direction
    member.character.step_anime = false unless member.movable?
    return if settings[pose][1].include?(direction)
    member.character.mirror = settings[pose][0].include?(direction)
    member.character.pose = name
    member.character.step_anime = false unless member.movable?
  end

  #--------------------------------------------------------------------------
  # new method: refresh_ptb_windows
  #--------------------------------------------------------------------------
  def refresh_battle_windows
    @skill_window.battle_refresh_call = true if @skill_window != nil
    @item_window.battle_refresh_call = true if @item_window != nil
    @mini_window.battle_refresh_call = true if @mini_window != nil
  end

  #--------------------------------------------------------------------------
  # new method: refresh_ptb_windows
  #--------------------------------------------------------------------------
  def refresh_ptb_windows
    return unless ptb?
    return if @active_battler == nil
    if @active_battler.actor?
      @ptb_party_window.update_call = true
      @spriteset.ptb_update = $game_party
    else
      @ptb_troop_window.update_call = true
      @spriteset.ptb_update = $game_troop
    end
  end

  #--------------------------------------------------------------------------
  # new method: update_battle_cursor
  #--------------------------------------------------------------------------
  def update_battle_cursor
    return unless $scene.is_a?(Scene_Battle)
    return if @spriteset.battle_cursor == nil
    @spriteset.battle_cursor.create_move_to
  end

  #--------------------------------------------------------------------------
  # new method: create_aoe_indicator
  #--------------------------------------------------------------------------
  def create_aoe_indicator(window)
    if atb?
      case @selected_battler.action.atb_queue_kind
      when 1 # Skill
        obj = $data_skills[@selected_battler.action.atb_queue_basic]
      when 2 # Item
        obj = $data_items[@selected_battler.action.atb_queue_basic]
      else; return
      end
    else
      if @selected_battler.action.skill?
        obj = @selected_battler.action.skill
      elsif @selected_battler.action.item?
        obj = @selected_battler.action.item
      else; return
      end
    end
    #---
    @spriteset.create_magic_circle(window, obj)
    @spriteset.create_magic_square(window, obj)
  end

  #--------------------------------------------------------------------------
  # new method: dispose_aoe_indicator
  #--------------------------------------------------------------------------
  def dispose_aoe_indicator
    @spriteset.dispose_magic_circle
    @spriteset.dispose_magic_square
  end

end # Scene_Battle

#===============================================================================
#
# END OF FILE
#
#===============================================================================