怎么在这个脚本里添加武器攻击动作？

陈大帅帅帅哥

#==============================================================================
#
# ▼ Yami Engine Symphony - Battle Symphony
# -- Version: 1.15 (2013.03.04)
# -- Level: Easy, Normal, Hard, Very Hard
# -- Requires: n/a
#
#==============================================================================

$imported = {} if $imported.nil?
$imported["YES-BattleSymphony"] = true

#==============================================================================
# ▼ Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2013.03.04 - Release Build 1.15.
# 2013.02.07 - Release Build 1.14.
# 2013.02.01 - Release Build 1.13.
# 2013.01.12 - Release Build 1.12.
# 2013.01.09 - Release Build 1.11.
# 2013.01.03 - Release Build 1.10.
# 2012.11.29 - Release Build 1.09.
# 2012.11.29 - Release Build 1.08.
# 2012.11.28 - Release Build 1.07.
# 2012.11.25 - Release Build 1.06.
# 2012.11.24 - Release Build 1.05.
# 2012.11.16 - Release Build 1.04.
# 2012.11.15 - Release Build 1.03.
# 2012.11.12 - Release Build 1.02.
# 2012.11.08 - Release Build 1.01.
# 2012.10.20 - Finished Script.
# 2012.07.01 - Started Script.
#
#==============================================================================
# ▼ Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# Core Engine of Symphony. This script provides a complicated visual battle
# which can be customized and many add-on awaited in the future.
# -----------------------------------------------------------------------------
# There are 8 Sections of Script:
#
# Section I. Basic Settings (S-01)
# Section II. Default Actions (S-02)
# Section III. AutoSymphony (S-03)
# Section IV. Default Symphony Tags (S-04)
# Section V. Imports Symphony Tags (S-05)
# Section VI. Sprites Initialization (S-06)
# Section VII. Icons Sprites Initialization (S-07)
# Section VIII. Core Script (S-08)
#
# You can search these sections by the code next to them (S-xx).
#
#==============================================================================
# ▼ Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
# To make this script work correctly with YEA - Battle Engine Ace, you have to
# put this script under YEA - Battle Engine Ace.
#
#==============================================================================
# ▼ Credits
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# Symphony Tags: Yanfly (From his Melody Tags).
# Inspired: Yanfly, Nessiah, EvilEagles.
# Testers: Many Guys in RPG Maker Community.
# Many Descriptions: Yanfly (From his Yanfly Engine Melody)
#
#==============================================================================

#==============================================================================
# Section I. Basic Settings (S-01)
# -----------------------------------------------------------------------------
# These are all basic requirements for running Battle Engine Symphony.
# Please pay attention to those settings before you touch and read next
# sections and add-ons.
#==============================================================================
module SYMPHONY
  module View
    # Set this to false to set Battle View to Empty.
    # All Sprites of actors as well as Icon (Weapon, Item...) will be hide.
    # All other Symphony Tags are still available.   
    EMPTY_VIEW = false
   
    # Set Party default Direction. For Number of Direction, check NumPad on the
    # Keyboard. Troop Direction will be opposited with Party Direction.
    PARTY_DIRECTION = 4
   
    # Set Party default Location. If You have more than 4 Actors in Battle, You
    # have to add more index in the hash below.
    # For example: If you have 5 Actors, You will have to add default Location
    # for 5th Actor by adding: 4 => [Location X, Location Y],
    # (Don't forget the comma at the end of each line)
    ACTORS_POSITION = { # Begin.
      0 =>  [480, 224],
      1 =>  [428, 244],
      2 =>  [472, 264],
      3 =>  [422, 284],
      3 =>  [452, 304],
    } # End.
  end # View
  module Visual
    # Set this to false to disable Weapon Icon creating for non-charset Battlers.
    # Recommend not to enable this, unless You use a Battler which doesn't show
    # its own weapon in the Battler-set.
    WEAPON_ICON_NON_CHARSET = false
   
    # Set this to true to disable auto Move Posing. When set this to false,
    # You can let the actor to change to any pose while moving.
    DISABLE_AUTO_MOVE_POSE = true
   
    # Set this to true to enable shadow beneath battler.
    BATTLER_SHADOW = true
   
    # Enemies default attack animation ID.
    # First Attack Animation and Second Attack Animation can be defined by
    # notetags <atk ani 1: x> and <atk ani 2: x> respectively.
    ENEMY_ATTACK_ANIMATION = 1
  end # Visual
  module Fixes
    # Set this to false to disable auto turn-off the immortal flag. Many people
    # forgot to turn-off immortal flag in an actions sequence, so the targets
    # remain alive even their HP reach zero.
    # Auto Turn-off Immortal will be push to Finish Actions.
    AUTO_IMMORTAL_OFF = true
  end # Fixes
end # SYMPHONY

#==============================================================================
# Section II. Default Actions (S-02)
# -----------------------------------------------------------------------------
# These are all Default Actions of Symphony. There are Magic Action,
# Physical Action, Item Action and some Misc Actions. If You are really
# good at Symphony Tags and want to customize all of these actions, please
# pay attention here.
# Note: You can use Symphony Tags in each skills so You don't have to check
# this if these actions settings are good for You.
#==============================================================================
module SYMPHONY
  module DEFAULT_ACTIONS
      
    #==========================================================================
    # Default Magic Actions
    # -------------------------------------------------------------------------
    # These are the default magic actions for all Magic Skills as well as Certain
    # hit Skills. Battlers will play these actions when use a Magic/Certain Hit
    # Skill unless You customize it with Symphony Tags.
    #==========================================================================
    MAGIC_SETUP =[
      ["MESSAGE"],
      ["MOVE USER", ["FORWARD", "WAIT"]],
      ["POSE", ["USER", "CAST"]],
      ["STANCE", ["USER", "CAST"]],
    ] # Do not remove this.
    MAGIC_WHOLE =[
      ["IMMORTAL", ["TARGETS", "TRUE"]],
      ["AUTO SYMPHONY", ["SKILL FULL"]],
    ] # Do not remove this.
    MAGIC_TARGET =[
    ] # Do not remove this.
    MAGIC_FOLLOW =[
      ["WAIT FOR MOVE"],
    ] # Do not remove this.
    MAGIC_FINISH =[
      ["IMMORTAL", ["TARGETS", "FALSE"]],
      ["AUTO SYMPHONY", ["RETURN ORIGIN"]],
      ["WAIT FOR MOVE"],
      ["WAIT", ["12", "SKIP"]],
    ] # Do not remove this.
      
    #==========================================================================
    # Default Physical Actions
    # -------------------------------------------------------------------------
    # These are the default physical actions for all Physical Skills as well as
    # Normal Attack. Battlers will play these actions when use a Physical
    # Skill unless You customize it with Symphony Tags.
    #==========================================================================
    PHYSICAL_SETUP =[
      ["MESSAGE"],
      ["MOVE USER", ["FORWARD", "WAIT"]],
    ] # Do not remove this.
    PHYSICAL_WHOLE =[
    ] # Do not remove this.
    PHYSICAL_TARGET =[
      ["IMMORTAL", ["TARGETS", "TRUE"]],
      ["POSE", ["USER", "FORWARD"]],
      ["STANCE", ["USER", "FORWARD"]],
      ["MOVE USER", ["TARGET", "BODY", "WAIT"]],
      ["AUTO SYMPHONY", ["SINGLE SWING"]],
      ["AUTO SYMPHONY", ["SKILL FULL", "unless attack"]],
      ["AUTO SYMPHONY", ["ATTACK FULL", "if attack"]],
    ] # Do not remove this.
    PHYSICAL_FOLLOW =[
      ["WAIT FOR MOVE"],
    ] # Do not remove this.
    PHYSICAL_FINISH =[
      ["IMMORTAL", ["TARGETS", "FALSE"]],
      ["ICON DELETE", ["USER", "WEAPON"]],
      ["AUTO SYMPHONY", ["RETURN ORIGIN"]],
      ["WAIT FOR MOVE"],
      ["WAIT", ["12", "SKIP"]],
    ] # Do not remove this.
   
    #==========================================================================
    # Default Item Actions
    # -------------------------------------------------------------------------
    # These are the default item actions for all Items. Battlers will play these
    # actions when use an Item unless You customize it with Symphony Tags.
    #==========================================================================
    ITEM_SETUP =[
      ["MESSAGE"],
      ["MOVE USER", ["FORWARD", "WAIT"]],
      ["AUTO SYMPHONY", ["ITEM FLOAT"]],
    ] # Do not remove this.
    ITEM_WHOLE =[
      ["IMMORTAL", ["TARGETS", "TRUE"]],
      ["AUTO SYMPHONY", ["ITEM FULL"]],
    ] # Do not remove this.
    ITEM_TARGET =[
    ] # Do not remove this.
    ITEM_FOLLOW =[
      ["WAIT FOR MOVE"],
    ] # Do not remove this.
    ITEM_FINISH =[
      ["IMMORTAL", ["TARGETS", "FALSE"]],
      ["AUTO SYMPHONY", ["RETURN ORIGIN"]],
      ["WAIT FOR MOVE"],
      ["WAIT", ["12", "SKIP"]],
    ] # Do not remove this.
    #==========================================================================
    # Critical Action
    # -------------------------------------------------------------------------
    # This is the critical action. This action will be played when a battler
    # scores a critical hit.
    #==========================================================================
    CRITICAL_ACTIONS =[
      ["SCREEN", ["FLASH", "30", "255", "255", "255"]],
    ] # Do not remove this.
   
    #==========================================================================
    # Miss Action
    # -------------------------------------------------------------------------
    # This is the miss action. This action will be played when a battler attacks
    # miss.
    #==========================================================================
    MISS_ACTIONS =[
      ["POSE", ["TARGET", "EVADE"]],
    ] # Do not remove this.
   
    #==========================================================================
    # Evade Action
    # -------------------------------------------------------------------------
    # This is the evade action. This action will be played when a battler evades.
    #==========================================================================
    EVADE_ACTIONS =[
      ["POSE", ["TARGET", "EVADE"]],
    ] # Do not remove this.

    #==========================================================================
    # Fail Action
    # -------------------------------------------------------------------------
    # This is the fail action. This action will be played when a battler fails
    # on casting skill.
    #==========================================================================
    FAIL_ACTIONS =[
   
    ] # Do not remove this.
      
    #==========================================================================
    # Damaged Action
    # -------------------------------------------------------------------------
    # This is the damaged action. This action will be played when a battler is
    # damaged.
    #==========================================================================
    DAMAGED_ACTION = [
      ["POSE", ["TARGET", "DAMAGE"]],
      ["STANCE", ["TARGET", "STRUCK"]],
    ] # Do not remove this.
      
    #==========================================================================
    # Counter Action
    # -------------------------------------------------------------------------
    # This is the counter action. This action will be played when a battler
    # counters an attack.
    #==========================================================================
    COUNTER_ACTION = [
      ["MOVE COUNTER SUBJECT", ["FORWARD", "WAIT"]],
      ["AUTO SYMPHONY", ["SINGLE SWING COUNTER"]],
      ["AUTO SYMPHONY", ["SKILL FULL COUNTER"]],
      ["ICON DELETE", ["COUNTER SUBJECT", "WEAPON"]],
      ["POSE", ["COUNTER SUBJECT", "BREAK"]],
      ["STANCE", ["COUNTER SUBJECT", "BREAK"]],
    ] # Do not remove this.
      
    #==========================================================================
    # Reflect Action
    # -------------------------------------------------------------------------
    # This is the reflect action. This action will be played when a battler
    # reflects a magic.
    #==========================================================================
    REFLECT_ACTION = [
      ["MOVE REFLECT SUBJECT", ["FORWARD", "WAIT"]],
      ["POSE", ["REFLECT SUBJECT", "CAST"]],
      ["STANCE", ["REFLECT SUBJECT", "CAST"]],
      ["AUTO SYMPHONY", ["SKILL FULL COUNTER"]],
      ["POSE", ["REFLECT SUBJECT", "BREAK"]],
      ["STANCE", ["REFLECT SUBJECT", "BREAK"]],
    ] # Do not remove this.
   
  end # DEFAULT_ACTIONS
end # SYMPHONY

#==============================================================================
# Section III. AutoSymphony (S-03)
# -----------------------------------------------------------------------------
# These are all Settings of AutoSymphony. You can make a sequence of Actions
# and Symphony Tags and reuse it with a single tag: AutoSymphony.
#==============================================================================
module SYMPHONY
  AUTO_SYMPHONY = { # Start
    # "Key" => [Symphony Sequence],
   
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # autosymphony: return origin
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This AutoSymphony returns the active battler and all of its targets back
    # to their original locations. Used often at the end of a skill, item,
    # or any other action sequence.
    # --- WARNING --- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This is a default-used AutoSymphony. Do not remove this.
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    "RETURN ORIGIN" => [
      ["STANCE", ["USER", "ORIGIN"]],
      ["MOVE USER", ["ORIGIN", "WAIT"]],
      ["POSE", ["USER", "BREAK"]],
      ["MOVE EVERYTHING", ["ORIGIN"]],
    ], # end RETURN ORIGIN
     
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # autosymphony: single swing
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This causes the active battler to perform a single-handed weapon swing
    # downwards.
    # --- WARNING --- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This is a default-used AutoSymphony. Do not remove this.
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    "SINGLE SWING" => [
      ["ICON CREATE", ["USER", "WEAPON"]],
      ["ICON", ["USER", "WEAPON", "SWING"]],
      ["POSE", ["USER", "2H SWING"]],
      ["STANCE", ["USER", "ATTACK"]],
    ], # end SINGLE SWING
      
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # autosymphony: single swing counter
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This causes the countering battler to perform a single-handed weapon
    # swing downwards.
    # --- WARNING --- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This is a default-used AutoSymphony. Do not remove this.
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    "SINGLE SWING COUNTER" => [
      ["ICON CREATE", ["COUNTER SUBJECT", "WEAPON"]],
      ["ICON", ["COUNTER SUBJECT", "WEAPON", "SWING"]],
      ["POSE", ["COUNTER SUBJECT", "2H SWING"]],
      ["STANCE", ["USER", "ATTACK"]],
    ], # end SINGLE SWING COUNTER
            
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # autosymphony: item float
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This causes the active battler to enter a "Cast" stance to make the
    # active battler appear to throw the item upward. The icon of the item
    # is then created and floats upward.
    # --- WARNING --- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This is a default-used AutoSymphony. Do not remove this.
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    "ITEM FLOAT" => [
      ["POSE", ["USER", "CAST"]],
      ["STANCE", ["USER", "ITEM"]],
      ["ICON CREATE", ["USER", "ITEM"]],
      ["ICON", ["USER", "ITEM", "FLOAT", "WAIT"]],
    ], # end ITEM FLOAT
      
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # autosymphony: attack full
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This triggers the full course for an attack effect. Attack's animation
    # plays and waits until it ends. The damage, status changes, and anything
    # else the attack may do to the target. Once the attack effect is over,
    # the target is sent sliding backwards a little bit.
    # --- WARNING --- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This is a default-used AutoSymphony. Do not remove this.
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    "ATTACK FULL" => [
      ["ATTACK EFFECT", ["COUNTER CHECK"]],
      ["ATTACK ANIMATION", ["WAIT"]],
      ["ATTACK EFFECT", ["WHOLE"]],
      ["MOVE TARGETS", ["BACKWARD"]],
    ], # end ATTACK FULL
      
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # autosymphony: skill full
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This trigger the full course for a skill's effect. The skill animation
    # plays and waits to the end. The damage, status changes, and anything
    # else the skill may do to the target. Once the skill effect is over, the
    # target is sent sliding backwards a little bit.
    # --- WARNING --- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This is a default-used AutoSymphony. Do not remove this.
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    "SKILL FULL" => [
      ["SKILL EFFECT", ["COUNTER CHECK"]],
      ["SKILL EFFECT", ["REFLECT CHECK"]],
      ["SKILL ANIMATION", ["WAIT"]],
      ["SKILL EFFECT", ["WHOLE"]],
      ["MOVE TARGETS", ["BACKWARD", "unless skill.for_friend?"]],
    ], # end SKILL FULL
      
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # autosymphony: skill full counter
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This trigger the full course for a skill's effect. The skill animation
    # plays and waits to the end. The damage, status changes, and anything
    # else the skill may do to the target. Once the skill effect is over, the
    # target is sent sliding backwards a little bit.
    # This trigger is used in countering/reflecting skill.
    # --- WARNING --- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This is a default-used AutoSymphony. Do not remove this.
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    "SKILL FULL COUNTER" => [
      ["ATTACK ANIMATION", ["TARGETS", "WAIT", "if attack"]],
      ["SKILL ANIMATION", ["TARGETS", "WAIT", "unless attack"]],
      ["SKILL EFFECT", ["WHOLE"]],
      ["MOVE TARGETS", ["BACKWARD", "unless skill.for_friend?"]],
    ], # end SKILL FULL COUNTER
   
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    # autosymphony: item full
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This triggers the full course for an item's effect. The item animation
    # plays and waits to the end. The damage, status changes, and anything
    # else the item may do to the target. Once the skill effect is over, the
    # target is sent sliding backwards a little bit.
    # --- WARNING --- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # This is a default-used AutoSymphony. Do not remove this.
    #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    "ITEM FULL" => [
      ["SKILL EFFECT", ["COUNTER CHECK"]],
      ["SKILL EFFECT", ["REFLECT CHECK", "unless skill.for_all?"]],
      ["SKILL ANIMATION", ["WAIT"]],
      ["ICON", ["USER", "ITEM", "FADE OUT", "WAIT"]],
      ["ICON DELETE", ["USER", "ITEM"]],
      ["SKILL EFFECT", ["WHOLE"]],
      ["MOVE TARGETS", ["BACKWARD", "unless item.for_friend?"]],
    ], # end ITEM FULL
   
  } # Do not remove this.
end # SYMPHONY

#==============================================================================
# Section IV. Default Symphony Tags (S-04)
# -----------------------------------------------------------------------------
# These are all Default Symphony Tags. They define actions that will be played
# when the tags are called. All these tags are optimized for the best
# performance through testings.
# -----------------------------------------------------------------------------
# Do not edit anything below here unless You have read carefully the Tutorial
# at Creating and Editing Symphony Tags.
#==============================================================================
#==============================================================================
# ■ Scene_Battle - Defines Tags Names
#==============================================================================
class Scene_Battle < Scene_Base
  
  #--------------------------------------------------------------------------
  # new method: perform_actions_list
  #--------------------------------------------------------------------------
  def perform_actions_list(actions, targets)
    #--- Create Formers ---
    former_action = @action
    former_values = (@action_values != nil) ? @action_values.clone : nil
    former_targets = (@action_targets != nil) ? @action_targets.clone : nil
    former_item = (@scene_item != nil) ? @scene_item.clone : nil
    #--- Create Current ---
    @action_targets = targets
    actions.each { |action|
      @action = action[0].upcase; @action_values = action[1]
      @action_values.each { |s| s.upcase! if s.is_a?(String) } if @action_values
      break unless SceneManager.scene_is?(Scene_Battle)
      break if @subject && @subject.dead?
      next unless action_condition_met
      case @action.upcase
      
        when /ANIMATION[ ](\d+)|SKILL ANIMATION|ATTACK ANIMATION|ANIMATION/i
          action_animation
      
        when /ATTACK EFFECT|SKILL EFFECT/i
          action_skill_effect
         
        when /AUTO SYMPHONY|AUTOSYMPHONY/i
          action_autosymphony
         
        when /ICON CREATE|CREATE ICON/i
          action_create_icon
         
        when /ICON DELETE|DELETE ICON/i
          action_delete_icon
         
        when "ICON", "ICON EFFECT"
          action_icon_effect
         
        when /ICON THROW[ ](.*)/i
          action_icon_throw
         
        when /IF[ ](.+)/i
          action_condition
         
        when /JUMP[ ](.*)/i
          action_move
                    
        when /MESSAGE/i
          action_message
         
        when /MOVE[ ](.*)/i
          action_move
         
        when /IMMORTAL/i
          action_immortal
         
        when /POSE/i
          action_pose
         
        when /STANCE/i
          action_stance
         
        when /UNLESS[ ](.+)/i
          action_condition
         
        when /TELEPORT[ ](.*)/i
          action_move
         
        when "WAIT", "WAIT SKIP", "WAIT FOR ANIMATION", "WAIT FOR MOVE",
          "WAIT FOR MOVEMENT", "ANI WAIT"
          action_wait
         
        else
          imported_symphony
      end
    }
    #--- Release Formers ---
    @action = former_action
    @action_values = former_values
    @action_targets = former_targets
    @scene_item = former_item
  end
  
end # Scene_Battle
#==============================================================================
# ■ Scene_Battle - Defines Tags Actions
#==============================================================================
class Scene_Battle < Scene_Base
  
  #--------------------------------------------------------------------------
  # new method: action_condition_met
  #--------------------------------------------------------------------------
  def action_condition_met
    target = @action_targets[0]
    targets = @action_targets
    user = @subject
    skill = item = @scene_item
    attack = false
    if @counter_subject || (user.current_action && user.current_action.attack?)
      attack = true
    end
    weapons = user.weapons if user.actor?
    @action_condition ||= []
    @action_condition.pop if @action.upcase == "END"
    if @action_condition.size > 0
      @action_condition.each { |action_condition|
        action_condition =~ /(IF|UNLESS)[ ](.+)/i
        condition_type = $1.upcase
        condition_value = $2.downcase
        #---
        if condition_type == "IF"
          return false unless eval(condition_value)
        elsif condition_type == "UNLESS"
          return false if eval(condition_value)
        end
      }
    end
    if @action_values
      @action_values.each { |value|
        case value
        when /IF[ ](.*)/i
          eval("return false unless " + $1.to_s.downcase)
        when /UNLESS[ ](.*)/i
          eval("return false if " + $1.to_s.downcase)
        end
      }
    end
    return true
  end
  
  #--------------------------------------------------------------------------
  # new method: get_action_mains
  #--------------------------------------------------------------------------
  def get_action_mains
    result = []
    case @action.upcase
    when /(?:USER)/i
      result.push(@subject) if @subject
    when /(?:TARGET|TARGETS)/i
      result = @action_targets
    when /(?:COUNTER SUBJECT)/i
      result = [@counter_subject]
    when /(?:REFLECT SUBJECT)/i
      result = [@reflect_subject]
    when /(?:ACTORS|PARTY|ACTORS LIVING)/i
      result = $game_party.alive_members
    when /(?:ALL ACTORS|ACTORS ALL)/i
      result = $game_party.battle_members
    when /(?:ACTORS NOT USER|PARTY NOT USER)/i
      result = $game_party.alive_members
      result.delete(@subject) if @subject
    when /(?:ENEMIES|TROOP|ENEMIES LIVING)/i
      result = $game_troop.alive_members
    when /(?:ALL ENEMIES|ENEMIES ALL)/i
      result = $game_troop.battle_members
    when /(?:ENEMIES NOT USER|ENEMIES NOT USER)/i
      result = $game_troop.alive_members
      result.delete(@subject) if @subject
    when /ACTOR[ ](\d+)/i
      result.push($game_party.battle_members[$1.to_i])
    when /ENEMY[ ](\d+)/i
      result.push($game_troop.battle_members[$1.to_i])
    when /(?:EVERYTHING|EVERYBODY)/i
      result = $game_party.alive_members + $game_troop.alive_members
    when /(?:EVERYTHING NOT USER|EVERYBODY NOT USER)/i
      result = $game_party.alive_members + $game_troop.alive_members
      result.delete(@subject) if @subject
    when /(?:ALLIES|FRIENDS)/i
      result = @subject.friends_unit.alive_members if @subject
    when /(?:OPPONENTS|RIVALS)/i
      result = @subject.opponents_unit.alive_members if @subject
    when /(?:FRIENDS NOT USER)/i
      if @subject
        result = @subject.friends_unit.alive_members
        result.delete(@subject)
      end
    when /(?:FOCUS)/i
      result = @action_targets
      result.push(@subject) if @subject
    when /(?:NOT FOCUS|NON FOCUS)/i
      result = $game_party.alive_members + $game_troop.alive_members
      result -= @action_targets
      result.delete(@subject) if @subject
    else;
    end
    return result.compact
  end
  
  #--------------------------------------------------------------------------
  # new method: get_action_targets
  #--------------------------------------------------------------------------
  def get_action_targets
    result = []
    @action_values.reverse.each { |value|
      next if value.nil?
      case value.upcase
      when /(?:USER)/i
        result.push(@subject) if @subject
      when /(?:TARGET|TARGETS)/i
        result = @action_targets
      when /(?:COUNTER SUBJECT)/i
        result = [@counter_subject]
      when /(?:REFLECT SUBJECT)/i
        result = [@reflect_subject]
      when /(?:ACTORS|PARTY|ACTORS LIVING)/i
        result = $game_party.alive_members
      when /(?:ALL ACTORS|ACTORS ALL)/i
        result = $game_party.battle_members
      when /(?:ACTORS NOT USER|PARTY NOT USER)/i
        result = $game_party.alive_members
        result.delete(@subject) if @subject
      when /(?:ENEMIES|TROOP|ENEMIES LIVING)/i
        result = $game_troop.alive_members
      when /(?:ALL ENEMIES|ENEMIES ALL)/i
        result = $game_troop.battle_members
      when /(?:ENEMIES NOT USER|ENEMIES NOT USER)/i
        result = $game_troop.alive_members
        result.delete(@subject) if @subject
      when /ACTOR[ ](\d+)/i
        result.push($game_party.battle_members[$1.to_i])
      when /ENEMY[ ](\d+)/i
        result.push($game_troop.battle_members[$1.to_i])
      when /(?:EVERYTHING|EVERYBODY)/i
        result = $game_party.alive_members + $game_troop.alive_members
      when /(?:EVERYTHING NOT USER|EVERYBODY NOT USER)/i
        result = $game_party.alive_members + $game_troop.alive_members
        result.delete(@subject) if @subject
      when /(?:ALLIES|FRIENDS)/i
        result = @subject.friends_unit.alive_members if @subject
      when /(?:OPPONENTS|RIVALS)/i
        result = @subject.opponents_unit.alive_members if @subject
      when /(?:FRIENDS NOT USER)/i
        if @subject
          result = @subject.friends_unit.alive_members
          result.delete(@subject)
        end
      when /(?:NOT FOCUS|NON FOCUS)/i
        result = $game_party.alive_members + $game_troop.alive_members
        result -= @action_targets
        result.delete(@subject)
      when /(?:FOCUS)/i
        result = @action_targets
        result.push(@subject) if @subject
      else;
      end
    }
    return result.compact
  end
  
  #--------------------------------------------------------------------------
  # new method: action_animation
  #--------------------------------------------------------------------------
  def action_animation
    targets = get_action_targets
    targets = @action_targets if ["SKILL ANIMATION", "ATTACK ANIMATION"].include?(@action.upcase)
    return if targets.size == 0
    #---
    case @action.upcase
    when /ANIMATION[ ](\d+)/i
      animation_id = [$1.to_i]
    when "SKILL ANIMATION", "ANIMATION"
      return unless @subject.current_action.item
      animation_id = [@subject.current_action.item.animation_id]
    when "ATTACK ANIMATION"
      animation_id = [@subject.atk_animation_id1]
      animation_id = [@subject.atk_animation_id2] if @subject.atk_animation_id2 > 0 && @action_values[1].to_i == 2
    when "LAST ANIMATION"
      animation_id = [@last_animation_id]
    end
    mirror = true if @action_values.include?("MIRROR")
    #---
    animation_id = [@subject.atk_animation_id1] if animation_id == [-1]
    #---
    ani_count = 0
    animation_id.each { |id|
      wait_for_animation if ani_count > 0
      mirror = !mirror if ani_count > 0
      animation = $data_animations[id]
      #---
      return unless animation
      if animation.to_screen?; targets[0].animation_id = id; end
      if !animation.to_screen?
        targets.each {|target| target.animation_id = id}
      end
      targets.each {|target| target.animation_mirror = mirror}
      ani_count += 1
    }
    @last_animation_id = animation_id[0]
    return unless @action_values.include?("WAIT")
    wait_for_animation
  end
  
  #--------------------------------------------------------------------------
  # new method: action_skill_effect
  #--------------------------------------------------------------------------
  def action_skill_effect
    return unless @subject
    return unless @subject.alive?
    return unless @subject.current_action.item
    targets = @action_targets.uniq
    item = @subject.current_action.item
    #---
    if @action_values.include?("CLEAR")
      targets.each { |target| target.result.set_calc; target.result.clear }
      return
    end
    #---
    if @action_values.include?("COUNTER CHECK")
      targets.each { |target| target.result.set_counter }
      return
    elsif @action_values.include?("REFLECT CHECK")
      targets.each { |target| target.result.set_reflection }
      return
    end
    #---
    array = []
    array.push("calc") if @action_values.include?("CALC")
    array = ["perfect"] if @action_values.include?("PERFECT")
    @action_values.each {|value| array.push(value.downcase) unless ["PERFECT", "CALC"].include?(value)}
    array = ["calc", "dmg", "effect"] if @action_values.include?("WHOLE") || @action_values.size == 0
    #---
    targets.each {|target|
      target.result.clear_bes_flag
      array.each {|value| str = "target.result.set_#{value}"; eval(str)}
      item.repeats.times { invoke_item(target, item) }
      target.result.clear_change_target
    }
  end
  
  #--------------------------------------------------------------------------
  # new method: action_autosymphony
  #--------------------------------------------------------------------------
  def action_autosymphony
    key = @action_values[0].to_s.upcase
    return unless SYMPHONY::AUTO_SYMPHONY.include?(key)
    actions_list = SYMPHONY::AUTO_SYMPHONY[key]
    perform_actions_list(actions_list, @action_targets)
  end
  
  #--------------------------------------------------------------------------
  # new method: action_create_icon
  #--------------------------------------------------------------------------
  def action_create_icon
    targets = get_action_targets
    return if targets.size == 0
    return if SYMPHONY::View::EMPTY_VIEW
    #---
    case @action_values[1]
    when "WEAPON", "WEAPON1"
      symbol = :weapon1
      attachment = :hand1
    when "WEAPON2"
      symbol = :weapon2
      attachment = :hand2
    when "SHIELD"
      symbol = :shield
      attachment = :shield
    when "ITEM"
      symbol = :item
      attachment = :middle
    else
      symbol = @action_values[1]
      attachment = :middle
    end
    #---
    case @action_values[2]
    when "HAND", "HAND1"
      attachment = :hand1
    when "HAND2", "SHIELD"
      attachment = :hand2
    when "ITEM"
      attachment = :item
    when "MIDDLE", "BODY"
      attachment = :middle
    when "TOP", "HEAD"
      attachment = :top
    when "BOTTOM", "FEET", "BASE"
      attachment = :base
    end
    #---
    targets.each { |target|
      next if target.sprite.nil?
      next if !target.use_charset? && !SYMPHONY::Visual::WEAPON_ICON_NON_CHARSET && [:weapon1, :weapon2].include?(symbol)
      target.create_icon(symbol, @action_values[3].to_i)
      next if target.icons[symbol].nil?
      target.icons[symbol].set_origin(attachment)
    }
  end
  
  #--------------------------------------------------------------------------
  # new method: action_delete_icon
  #--------------------------------------------------------------------------
  def action_delete_icon
    targets = get_action_targets
    return if targets.size == 0
    #---
    case @action_values[1]
    when "WEAPON", "WEAPON1"
      symbol = :weapon1
    when "WEAPON2"
      symbol = :weapon2
    when "SHIELD"
      symbol = :shield
    when "ITEM"
      symbol = :item
    else
      symbol = @action_values[1]
    end
    #---
    targets.each { |target| target.delete_icon(symbol) }
  end
  
  #--------------------------------------------------------------------------
  # new method: action_icon_effect
  #--------------------------------------------------------------------------
  def action_icon_effect
    targets = get_action_targets
    return if targets.size == 0
    #---
    case @action_values[1]
    when "WEAPON", "WEAPON1"
      symbol = :weapon1
    when "WEAPON2"
      symbol = :weapon2
    when "SHIELD"
      symbol = :shield
    when "ITEM"
      symbol = :item
    else
      symbol = @action_values[1]
    end
    #---
    targets.each { |target|
      icon = target.icons[symbol]
      next if icon.nil?
      total_frames = 8
      case @action_values[2]
      when "ANGLE"
        angle = @action_values[3].to_i
        icon.set_angle(angle)
      when "ROTATE", "REROTATE"
        angle = @action_values[3].to_i
        angle = -angle if @action_values[2] == "REROTATE"
        total_frames = @action_values[4].to_i
        total_frames = 8 if total_frames == 0
        icon.create_angle(angle, total_frames)
      when /ANIMATION[ ](\d+)/i
        animation = $1.to_i
        if $data_animations[animation].nil?; return; end
        total_frames = $data_animations[animation].frame_max
        total_frames *= 4 unless $imported["YEA-CoreEngine"]
        total_frames *= YEA::CORE::ANIMATION_RATE if $imported["YEA-CoreEngine"]
        icon.start_animation($data_animations[animation])
      when /MOVE_X[ ](\d+)/i
        move_x = $1.to_i
        total_frames = @action_values[3].to_i
        total_frames = 8 if total_frames == 0
        icon.create_movement(move_x, icon.y, total_frames)
      when /MOVE_Y[ ](\d+)/i
        move_y = $1.to_i
        total_frames = @action_values[3].to_i
        total_frames = 8 if total_frames == 0
        icon.create_movement(icon.x, move_y, total_frames)
      when /CUR_X[ ]([\-]?\d+)/i
        move_x = icon.x + $1.to_i
        total_frames = @action_values[3].to_i
        total_frames = 8 if total_frames == 0
        icon.create_movement(move_x, icon.y, total_frames)
      when /CUR_Y[ ]([\-]?\d+)/i
        move_y = icon.y + $1.to_i
        total_frames = @action_values[3].to_i
        total_frames = 8 if total_frames == 0
        icon.create_movement(icon.x, move_y, total_frames)
      when "FADE IN"
        total_frames = @action_values[3].to_i
        total_frames = 8 if total_frames == 0
        rate = Integer(256.0/total_frames)
        icon.set_fade(rate)
      when "FADE OUT"
        total_frames = @action_values[3].to_i
        total_frames = 8 if total_frames == 0
        rate = Integer(256.0/total_frames)
        icon.set_fade(-rate)
      when "FLOAT"
        total_frames = @action_values[3].to_i
        total_frames = 24 if total_frames == 0
        icon.create_move_direction(8, total_frames, total_frames)
      when "SWING"
        total_frames = 10
        icon.set_angle(0)
        icon.create_angle(90, total_frames)
      when "UPSWING"
        total_frames = 10
        icon.set_angle(90)
        icon.create_angle(0, total_frames)
      when "STAB", "THRUST"
        total_frames = 8
        direction = Direction.direction(target.pose)
        direction = Direction.opposite(direction) if target.sprite.mirror
        case direction
        when 8
          icon_direction = 8
          icon.set_angle(-45)
        when 4
          icon_direction = 4
          icon.set_angle(45)
        when 6
          icon_direction = 6
          icon.set_angle(-135)
        when 2
          icon_direction = 2
          icon.set_angle(135)
        end
        icon.create_move_direction(Direction.opposite(icon_direction), 40, 1)
        icon.update
        icon.create_move_direction(icon_direction, 32, total_frames)
      when "CLAW"
        total_frames = 8
        direction = Direction.direction(target.pose)
        direction = Direction.opposite(direction) if target.sprite.mirror
        case direction
        when 8
          icon_direction = 7
          back_direction = 3
        when 4
          icon_direction = 1
          back_direction = 9
        when 6
          icon_direction = 3
          back_direction = 7
        when 2
          icon_direction = 9
          back_direction = 1
        end
        icon.create_move_direction(back_direction, 32, 1)
        icon.update
        icon.create_move_direction(icon_direction, 52, total_frames)
      end
      #---
      if @action_values.include?("WAIT")
        update_basic while icon.effecting?
      end
    }
  end
  
  #--------------------------------------------------------------------------
  # new method: action_icon_throw
  #--------------------------------------------------------------------------
  def action_icon_throw
    mains = get_action_mains
    targets = get_action_targets
    return if mains.size == 0
    #---
    case @action_values[1]
    when "WEAPON", "WEAPON1"
      symbol = :weapon1
    when "WEAPON2"
      symbol = :weapon2
    when "SHIELD"
      symbol = :shield
    when "ITEM"
      symbol = :item
    else
      symbol = @action_values[1]
    end
    #---
    mains.each { |main|
      icon = main.icons[symbol]
      next if icon.nil?
      total_frames = @action_values[3].to_i
      total_frames = 12 if total_frames <= 0
      arc = @action_values[2].to_f
      #---
      targets.each { |target|
        move_x = target.screen_x
        move_y = target.screen_y - target.sprite.height / 2
        icon.create_movement(move_x, move_y, total_frames)
        icon.create_arc(arc)
        if @action_values.include?("WAIT")
          update_basic while icon.effecting?
        end
      }
    }
  end
  
  #--------------------------------------------------------------------------
  # new method: action_condition
  #--------------------------------------------------------------------------
  def action_condition
    @action_condition ||= []
    @action_condition.push(@action.dup)
  end
  
  #--------------------------------------------------------------------------
  # new method: action_message
  #--------------------------------------------------------------------------
  def action_message
    user = @subject
    return unless user
    item = @subject.current_action.item
    return unless item
    @log_window.display_use_item(@subject, item)
  end
  
  #--------------------------------------------------------------------------
  # new method: action_move
  #--------------------------------------------------------------------------
  def action_move
    movers = get_action_mains
    return unless movers.size > 0
    return if SYMPHONY::View::EMPTY_VIEW
    #--- Get Location ---
    case @action_values[0]
    #---
    when "FORWARD", "BACKWARD"
      distance = @action_values[1].to_i
      distance = @action_values[0] == "FORWARD" ? 16 : 8 if distance <= 0
      frames = @action_values[2].to_i
      frames = 8 if frames <= 0
      movers.each { |mover|
        next unless mover.exist?
        direction = mover.direction
        destination_x = mover.screen_x
        destination_y = mover.screen_y
        case direction
        when 1; move_x = distance / -2; move_y = distance /  2
        when 2; move_x = distance *  0; move_y = distance *  1
        when 3; move_x = distance / -2; move_y = distance /  2
        when 4; move_x = distance * -1; move_y = distance *  0
        when 6; move_x = distance *  1; move_y = distance *  0
        when 7; move_x = distance / -2; move_y = distance / -2
        when 8; move_x = distance *  0; move_y = distance * -1
        when 9; move_x = distance /  2; move_y = distance / -2
        else; return
        end
        destination_x += @action_values[0] == "FORWARD" ? move_x : - move_x
        destination_y += @action_values[0] == "FORWARD" ? move_y : - move_y
        mover.face_coordinate(destination_x, destination_y) unless @action_values[0] == "BACKWARD"
        mover.create_movement(destination_x, destination_y, frames)
        case @action.upcase
        when /JUMP[ ](.*)/i
          arc_scan = $1.scan(/(?:ARC)[ ](\d+)/i)
          arc = $1.to_i
          mover.create_jump(arc)
        end
      }
    #---
    when "ORIGIN", "RETURN"
      frames = @action_values[1].to_i
      frames = 20 if frames <= 0
      movers.each { |mover|
        next unless mover.exist?
        destination_x = mover.origin_x
        destination_y = mover.origin_y
        next if destination_x == mover.screen_x && destination_y == mover.screen_y
        if @action_values[0] == "ORIGIN"
          mover.face_coordinate(destination_x, destination_y)
        end
        mover.create_movement(destination_x, destination_y, frames)
        case @action.upcase
        when /JUMP[ ](.*)/i
          arc_scan = $1.scan(/(?:ARC)[ ](\d+)/i)
          arc = $1.to_i
          mover.create_jump(arc)
        end
      }
    #---
    when "TARGET", "TARGETS", "USER"
      frames = @action_values[2].to_i
      frames = 20 if frames <= 0
      #---
      case @action_values[0]
      when "USER"
        targets = [@subject]
      when "TARGET", "TARGETS"
        targets = @action_targets
      end
      #---
      destination_x = destination_y = 0
      case @action_values[1]
      when "BASE", "FOOT", "FEET"
        targets.each { |target|
          destination_x += target.screen_x; destination_y += target.screen_y
          side_l = target.screen_x - target.sprite.width/2
          side_r = target.screen_x + target.sprite.width/2
          side_u = target.screen_y - target.sprite.height
          side_d = target.screen_y
          movers.each { |mover|
            next unless mover.exist?
            if side_l > mover.origin_x
              destination_x -= target.sprite.width/2
              destination_x -= mover.sprite.width/2
            elsif side_r < mover.origin_x
              destination_x += target.sprite.width/2
              destination_x += mover.sprite.width/2
            elsif side_u > mover.origin_y - mover.sprite.height
              destination_y -= target.sprite.height
            elsif side_d < mover.origin_y - mover.sprite.height
              destination_y += mover.sprite.height
            end
          }
        }
      #---
      when "BODY", "MIDDLE", "MID"
        targets.each { |target|
          destination_x += target.screen_x
          destination_y += target.screen_y - target.sprite.height / 2
          side_l = target.screen_x - target.sprite.width/2
          side_r = target.screen_x + target.sprite.width/2
          side_u = target.screen_y - target.sprite.height
          side_d = target.screen_y
          movers.each { |mover|
            next unless mover.exist?
            if side_l > mover.origin_x
              destination_x -= target.sprite.width/2
              destination_x -= mover.sprite.width/2
            elsif side_r < mover.origin_x
              destination_x += target.sprite.width/2
              destination_x += mover.sprite.width/2
            elsif side_u > mover.origin_y - mover.sprite.height
              destination_y -= target.sprite.height
            elsif side_d < mover.origin_y - mover.sprite.height
              destination_y += mover.sprite.height
            end
            destination_y += mover.sprite.height
            destination_y -= mover.sprite.height/2
            if $imported["BattleSymphony-8D"] && $imported["BattleSymphony-HB"]
              destination_y += mover.sprite.height if mover.use_8d? && target.use_hb?
              destination_y -= mover.sprite.height/4 if mover.use_hb? && target.use_8d?
            end
          }
        }
      #---
      when "CENTER"
        targets.each { |target|
          destination_x += target.screen_x
          destination_y += target.screen_y - target.sprite.height/2
        }
      #---
      when "HEAD", "TOP"
        targets.each { |target|
          destination_x += target.screen_x
          destination_y += target.screen_y - target.sprite.height
          side_l = target.screen_x - target.sprite.width/2
          side_r = target.screen_x + target.sprite.width/2
          side_u = target.screen_y - target.sprite.height
          side_d = target.screen_y
          movers.each { |mover|
            next unless mover.exist?
            if side_l > mover.origin_x
              destination_x -= target.sprite.width/2
              destination_x -= mover.sprite.width/2
            elsif side_r < mover.origin_x
              destination_x += target.sprite.width/2
              destination_x += mover.sprite.width/2
            elsif side_u > mover.origin_y - mover.sprite.height
              destination_y -= target.sprite.height
            elsif side_d < mover.origin_y - mover.sprite.height
              destination_y += mover.sprite.height
            end
            destination_y += mover.sprite.height
            destination_y -= mover.sprite.height/2
            if $imported["BattleSymphony-8D"] && $imported["BattleSymphony-HB"]
              destination_y += mover.sprite.height if mover.use_8d? && target.use_hb?
              destination_y -= mover.sprite.height/4 if mover.use_hb? && target.use_8d?
            end
          }
        }
      #---
      when "BACK"
        targets.each { |target|
          destination_x += target.screen_x
          destination_y += target.screen_y - target.sprite.height
          side_l = target.screen_x - target.sprite.width/2
          side_r = target.screen_x + target.sprite.width/2
          side_u = target.screen_y - target.sprite.height
          side_d = target.screen_y
          movers.each { |mover|
            next unless mover.exist?
            if side_l > mover.origin_x
              destination_x += target.sprite.width/2
              destination_x += mover.sprite.width/2
            elsif side_r < mover.origin_x
              destination_x -= target.sprite.width/2
              destination_x -= mover.sprite.width/2
            elsif side_u > mover.origin_y - mover.sprite.height
              destination_y -= target.sprite.height
            elsif side_d < mover.origin_y - mover.sprite.height
              destination_y += mover.sprite.height
            end
            destination_y += mover.sprite.height
            destination_y -= mover.sprite.height/2
            if $imported["BattleSymphony-8D"] && $imported["BattleSymphony-HB"]
              destination_y += mover.sprite.height if mover.use_8d? && target.use_hb?
              destination_y -= mover.sprite.height/4 if mover.use_hb? && target.use_8d?
            end
          }
        }
      #---
      else
        targets.each { |target|
          destination_x += target.screen_x
          destination_y += target.screen_y
        }
      end
      #---
      destination_x /= targets.size
      destination_y /= targets.size
      movers.each { |mover|
        next unless mover.exist?
        next if mover.screen_x == destination_x && mover.screen_y == destination_y
        case @action.upcase
        when /MOVE[ ](.*)/i
          mover.face_coordinate(destination_x, destination_y)
          mover.create_movement(destination_x, destination_y, frames)
        when /TELEPORT[ ](.*)/i
          mover.screen_x = destination_x
          mover.screen_y = destination_y
        when /JUMP[ ](.*)/i
          arc_scan = $1.scan(/(?:ARC)[ ](\d+)/i)
          arc = $1.to_i
          mover.face_coordinate(destination_x, destination_y)
          mover.create_movement(destination_x, destination_y, frames)
          mover.create_jump(arc)
        end
      }
    #---
    end
    #---
    return unless @action_values.include?("WAIT")
    wait_for_move
  end
  
  #--------------------------------------------------------------------------
  # new method: action_immortal
  #--------------------------------------------------------------------------
  def action_immortal
    targets = get_action_targets
    return unless targets.size > 0
    targets.each { |target|
      next unless target.alive?
      case @action_values[1].upcase
      when "TRUE", "ON", "ENABLE"
        target.immortal = true
      when "OFF", "FALSE", "DISABLE"
        target.immortal = false
        target.refresh
        perform_collapse_check(target)
      end
    }
  end
  
  #--------------------------------------------------------------------------
  # new method: action_pose
  #--------------------------------------------------------------------------
  def action_pose
    targets = get_action_targets
    return unless targets.size > 0
    #---
    case @action_values[1]
    when "BREAK", "CANCEL", "RESET", "NORMAL"
      targets.each { |target| target.break_pose }
      return
    when "IDLE", "READY"
      pose_key = :ready
    when "DAMAGE", "DMG"
      pose_key = :damage
    when "PIYORI", "CRITICAL", "DAZED", "DAZE", "DIZZY"
      pose_key = :critical
    when "MARCH", "FORWARD"
      pose_key = :marching
    when "VICTORY", "POSE"
      pose_key = :victory
    when "EVADE", "DODGE"
      pose_key = :dodge
    when "DOWN", "DOWNED", "FALLEN"
      pose_key = :fallen
    when "2H", "2H SWING"
      pose_key = :swing2h
    when "1H", "1H SWING"
      pose_key = :swing1h
    when "2H REVERSE", "2H SWING REVERSE"
      pose_key = :r2hswing
      reverse_pose = true
    when "1H REVERSE", "1H SWING REVERSE"
      pose_key = :r1hswing
      reverse_pose = true
    when "CAST", "INVOKE", "ITEM", "MAGIC"
      pose_key = :cast
    when "CHANT", "CHANNEL", "CHARGE"
      pose_key = :channeling
    else; return
    end
    #---
    return unless $imported["BattleSymphony-8D"]
    #---
    targets.each { |target|
      next unless target.exist?
      next unless target.use_8d?
      target.pose = pose_key
      target.force_pose = true
      target.reverse_pose = reverse_pose
    }
  end
  
  #--------------------------------------------------------------------------
  # new method: action_stance
  #--------------------------------------------------------------------------
  def action_stance
    targets = get_action_targets
    return unless targets.size > 0
    #---
    case @action_values[1]
    when "BREAK", "CANCEL", "RESET", "NORMAL"
      targets.each { |target| target.break_pose }
      return
    when "IDLE", "READY"
      pose_key = :idle
    when "DAMAGE", "DMG", "STRUCK"
      pose_key = :struck
    when "PIYORI", "CRITICAL", "DAZED", "DAZE", "DIZZY", "WOOZY"
      pose_key = :woozy
    when "VICTORY"
      pose_key = :victory
    when "EVADE", "DODGE", "DEFEND"
      pose_key = :defend
    when "DOWN", "DOWNED", "FALLEN", "DEAD"
      pose_key = :dead
    when "SWING", "ATTACK", "SLASH"
      pose_key = :attack
    when "CAST", "INVOKE", "MAGIC"
      pose_key = :magic
    when "ITEM"
      pose_key = :item
    when "SKILL", "PHYSICAL"
      pose_key = :skill
    when "FORWARD", "MOVE", "TARGET"
      pose_key = :advance
    when "ORIGIN", "BACK", "RETREAT"
      pose_key = :retreat
    else; return
    end
    #---
    return unless $imported["BattleSymphony-HB"]
    #---
    targets.each { |target|
      next unless target.exist?
      next unless target.use_hb?
      target.pose = pose_key
      target.force_pose = true
    }
  end
  
  #--------------------------------------------------------------------------
  # action_wait
  #--------------------------------------------------------------------------
  def action_wait
    case @action
    when "WAIT FOR ANIMATION"
      wait_for_animation
      return
    when "WAIT FOR MOVE", "WAIT FOR MOVEMENT"
      wait_for_move
      return
    end
    frames = @action_values[0].to_i
    frames *= $imported["YEA-CoreEngine"] ? YEA::CORE::ANIMATION_RATE : 4 if @action == "ANI WAIT"
    skip = @action_values.include?("SKIP")
    skip = true if @action == "WAIT SKIP"
    skip ? wait(frames) : abs_wait(frames)
  end
  
end # Scene_Battle

#==============================================================================
# Section V. Imports Symphony Tags (S-05)
# -----------------------------------------------------------------------------
# This section is the field for You to create your own Symphony Tags. Please
# read carefully the Tutorial at Creating Symphony Tags before touching this.
#==============================================================================
#==============================================================================
# ■ Scene_Battle - Imported Symphony Configuration
#==============================================================================
class Scene_Battle < Scene_Base

  #--------------------------------------------------------------------------
  # new method: imported_symphony
  #--------------------------------------------------------------------------
  def imported_symphony
    case @action.upcase
      
      #--- Start Importing ---
      
      #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      # sample symphony
      # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      # This is the most basic sample, it will put a line which contains
      # action name and action values in Console.
      #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
      when /SAMPLE SYMPHONY/i
        action_sample_symphony
      
      #--- End Importing ---
      else
        if SYMPHONY::AUTO_SYMPHONY.include?(@action.upcase)
          @action_values = [@action.upcase]
          @action = "AUTO SYMPHONY"
          action_autosymphony
        end
    end
  end

end # Scene_Battle
#==============================================================================
# ■ Scene_Battle - Imported Symphony Actions
#==============================================================================
class Scene_Battle < Scene_Base
  
  #--------------------------------------------------------------------------
  # new method: action_sample_symphony
  #--------------------------------------------------------------------------
  def action_sample_symphony
    str = "#{@action.upcase}: "
    @action_values.each {|value| str += "#{value} "}
    puts str
  end
  
end # Scene_Battle

#==============================================================================
# Section VI. Sprites Initialization (S-06)
# -----------------------------------------------------------------------------
# This section is the first section of core script. It will Initializes and
# Creates Sprites for all Battlers and Maintains them.
# -----------------------------------------------------------------------------
# Do not touch below script unless You know what You do and How it works.
#==============================================================================
#==============================================================================
# ■ Game_Battler
#==============================================================================

class Game_Battler < Game_BattlerBase
  
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :origin_x
  attr_accessor :origin_y
  attr_accessor :screen_x
  attr_accessor :screen_y
  attr_accessor :pose
  attr_accessor :immortal
  attr_accessor :icons
  attr_accessor :direction
  attr_accessor :force_pose
  attr_accessor :reverse_pose
  
  #--------------------------------------------------------------------------
  # alias method: initialize
  #--------------------------------------------------------------------------
  alias bes_initialize initialize
  def initialize
    bes_initialize
    @screen_x = 0
    @screen_y = 0
    #---
    @move_x_rate = 0
    @move_y_rate = 0
    #---
    @immortal = false
    #---
    @icons = {}
    @force_pose = false
    @reverse_pose = false
    #---
    @hp = 1 # Fix Change Party in Battle.
    #---
    @arc = 0
    @parabola = {}
    @f = 0
    @arc_y = 0
  end
  
  #--------------------------------------------------------------------------
  # new method: use_charset?
  #--------------------------------------------------------------------------
  def use_charset?
    return false
  end  
  
  #--------------------------------------------------------------------------
  # new method: emptyview?
  #--------------------------------------------------------------------------
  def emptyview?
    return SYMPHONY::View::EMPTY_VIEW
  end
  
  #--------------------------------------------------------------------------
  # new method: battler
  #--------------------------------------------------------------------------
  def battler
    self.actor? ? self.actor : self.enemy
  end
  
  #--------------------------------------------------------------------------
  # new method: use_custom_charset?
  #--------------------------------------------------------------------------
  def use_custom_charset?
    if $imported["BattleSymphony-8D"]; return true if use_8d?; end
    if $imported["BattleSymphony-HB"]; return true if use_hb?; end
    return false
  end
  
  #--------------------------------------------------------------------------
  # new method: screen_z
  #--------------------------------------------------------------------------
  def screen_z
    return 100
  end
  
  #--------------------------------------------------------------------------
  # alias method: on_battle_start
  #--------------------------------------------------------------------------
  alias bes_on_battle_start on_battle_start
  def on_battle_start
    reset_position
    #---
    bes_on_battle_start
    #---
    return if self.actor? && !$game_party.battle_members.include?(self)
    set_default_position
  end
  
  #--------------------------------------------------------------------------
  # new method: set_default_position
  #--------------------------------------------------------------------------
  def set_default_position
    @move_rate_x = 0
    @move_rate_y = 0
    #---
    @destination_x = self.screen_x
    @destination_y = self.screen_y
  end
  
  #--------------------------------------------------------------------------
  # new method: correct_origin_position
  #--------------------------------------------------------------------------
  def correct_origin_position
    # Compatible
  end
  
  #--------------------------------------------------------------------------
  # new method: reset_position
  #--------------------------------------------------------------------------
  def reset_position
    break_pose
  end
  
  #--------------------------------------------------------------------------
  # new method: break_pose
  #--------------------------------------------------------------------------
  def break_pose
    @direction = SYMPHONY::View::PARTY_DIRECTION
    @direction = Direction.opposite(@direction) if self.enemy?
    #---
    @pose = Direction.pose(@direction)
    #---
    @force_pose = false
    @reverse_pose = false
  end
  
  #--------------------------------------------------------------------------
  # new method: pose=
  #--------------------------------------------------------------------------
  def pose=(pose)
    @pose = pose
    return if self.actor? && !$game_party.battle_members.include?(self)
    self.sprite.correct_change_pose if SceneManager.scene.spriteset
  end
  
  #--------------------------------------------------------------------------
  # new method: can_collapse?
  #--------------------------------------------------------------------------
  def can_collapse?
    return false unless dead?
    unless actor?
      return false unless sprite.battler_visible
      array = [:collapse, :boss_collapse, :instant_collapse]
      return false if array.include?(sprite.effect_type)
    end
    return true
  end
  
  #--------------------------------------------------------------------------
  # new method: weapons
  #--------------------------------------------------------------------------
  def weapons
    return []
  end
  
  #--------------------------------------------------------------------------
  # new method: equips
  #--------------------------------------------------------------------------
  def equips
    return []
  end
  
  #--------------------------------------------------------------------------
  # alias method: add_state
  #--------------------------------------------------------------------------
  alias bes_add_state add_state
  def add_state(state_id)
    bes_add_state(state_id)
    #--- Fix Death pose ---
    return unless SceneManager.scene_is?(Scene_Battle)
    break_pose if state_id == death_state_id
  end
  
end # Game_Battler

#==============================================================================
# ■ Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
  
  #--------------------------------------------------------------------------
  # overwrite method: use_sprite?
  #--------------------------------------------------------------------------
  def use_sprite?
    return true
  end
  
  #--------------------------------------------------------------------------
  # new method: use_charset?
  #--------------------------------------------------------------------------
  def use_charset?
    return true
  end
  
  #--------------------------------------------------------------------------
  # new method: set_default_position
  #--------------------------------------------------------------------------
  def set_default_position
    super
    return if @origin_x && @origin_y
    return unless $game_party.battle_members.include?(self)
    @origin_x = @screen_x = @destination_x = SYMPHONY::View::ACTORS_POSITION[index][0]
    @origin_y = @screen_y = @destination_y = SYMPHONY::View::ACTORS_POSITION[index][1]
    return unless emptyview?
    @origin_x = @screen_x = @destination_x = self.screen_x
    @origin_y = @screen_y = @destination_y = self.screen_y
  end
  
  #--------------------------------------------------------------------------
  # new method: reset_position
  #--------------------------------------------------------------------------
  def reset_position
    super
    @origin_x = @origin_y = nil
  end
  
  #--------------------------------------------------------------------------
  # alias method: screen_x
  #--------------------------------------------------------------------------
  alias bes_screen_x screen_x
  def screen_x
    emptyview? ? bes_screen_x : @screen_x
  end
  
  #--------------------------------------------------------------------------
  # alias method: screen_y
  #--------------------------------------------------------------------------
  alias bes_screen_y screen_y
  def screen_y
    emptyview? ? bes_screen_y : @screen_y
  end
  
  #--------------------------------------------------------------------------
  # new method: correct_origin_position
  #--------------------------------------------------------------------------
  def correct_origin_position
    return if @origin_x && @origin_y
    @origin_x = @screen_x = SYMPHONY::View::ACTORS_POSITION[index][0]
    @origin_y = @screen_y = SYMPHONY::View::ACTORS_POSITION[index][1]
    return unless emptyview?
    @origin_x = @screen_x = @destination_x = self.screen_x
    @origin_y = @screen_y = @destination_y = self.screen_y
  end
  
  #--------------------------------------------------------------------------
  # new method: sprite
  #--------------------------------------------------------------------------
  def sprite
    index = $game_party.battle_members.index(self)
    return nil unless index
    return nil unless SceneManager.scene_is?(Scene_Battle)
    return SceneManager.scene.spriteset.actor_sprites[index]
  end
  
  #--------------------------------------------------------------------------
  # overwrite method: perform_collapse_effect
  #--------------------------------------------------------------------------
  def perform_collapse_effect
    if $game_party.in_battle
      @sprite_effect_type = :collapse unless self.use_custom_charset?
      Sound.play_actor_collapse
    end
  end
   
end # Game_Actor

#==============================================================================
# ■ Game_Enemy
#==============================================================================

class Game_Enemy < Game_Battler
  
  #--------------------------------------------------------------------------
  # new method: correct_origin_position
  #--------------------------------------------------------------------------
  def correct_origin_position
    @origin_x ||= @screen_x
    @origin_y ||= @screen_y
  end
  
  #--------------------------------------------------------------------------
  # new method: use_charset?
  #--------------------------------------------------------------------------
  def use_charset?
    return super
  end  
  
  #--------------------------------------------------------------------------
  # new method: sprite
  #--------------------------------------------------------------------------
  def sprite
    return nil unless SceneManager.scene_is?(Scene_Battle)
    return SceneManager.scene.spriteset.enemy_sprites.reverse[self.index]
  end
  
  #--------------------------------------------------------------------------
  # new method: atk_animation_id1
  #--------------------------------------------------------------------------
  def atk_animation_id1
    return enemy.atk_animation_id1
  end
  
  #--------------------------------------------------------------------------
  # new method: atk_animation_id2
  #--------------------------------------------------------------------------
  def atk_animation_id2
    return enemy.atk_animation_id2
  end
  
end # Game_Enemy

#==============================================================================
# ■ Sprite_Battler
#==============================================================================

class Sprite_Battler < Sprite_Base
  
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :effect_type
  attr_accessor :battler_visible
  
  #--------------------------------------------------------------------------
  # new method: pose
  #--------------------------------------------------------------------------
  alias bes_initialize initialize
  def initialize(viewport, battler = nil)
    bes_initialize(viewport, battler)
    correct_change_pose if @battler
    #---
    self.visible = false if SYMPHONY::View::EMPTY_VIEW && (@battler.nil? || @battler.actor?)
    #---
    return if SYMPHONY::View::EMPTY_VIEW
    #---
    return unless SYMPHONY::Visual::BATTLER_SHADOW
    #---
    @charset_shadow = Sprite.new(viewport)
    @charset_shadow.bitmap = Cache.system("Shadow")
    @charset_shadow.ox = @charset_shadow.width / 2
    @charset_shadow.oy = @charset_shadow.height
  end
  
  #--------------------------------------------------------------------------
  # new method: pose
  #--------------------------------------------------------------------------
  def pose
    @battler.pose
  end
  
  #--------------------------------------------------------------------------
  # alias method: update
  #--------------------------------------------------------------------------
  alias bes_update update
  def update
    bes_update
    #---
    return if SYMPHONY::View::EMPTY_VIEW
    #---
    return unless SYMPHONY::Visual::BATTLER_SHADOW
    #---
    @charset_shadow.opacity = self.opacity
    @charset_shadow.visible = self.visible
    @charset_shadow.x = self.x + (self.mirror ? 0 : - 2)
    @charset_shadow.y = self.y + 2
    @charset_shadow.z = self.z - 1
    #---
    @charset_shadow.opacity = 0 if @battler.nil?
  end
  
  #--------------------------------------------------------------------------
  # alias method: update_bitmap
  #--------------------------------------------------------------------------
  alias bes_update_bitmap update_bitmap
  def update_bitmap
    correct_change_pose if @timer.nil?
    @battler.use_charset? ? update_charset : bes_update_bitmap
  end
  
  #--------------------------------------------------------------------------
  # alias method: update_origin
  #--------------------------------------------------------------------------
  alias bes_update_origin update_origin
  def update_origin
    @battler.update_visual
    @battler.use_charset? ? update_charset_origin : bes_update_origin
  end
  
  #--------------------------------------------------------------------------
  # new method: update_charset
  #--------------------------------------------------------------------------
  def update_charset
    @battler.set_default_position unless pose
    #---
    update_charset_bitmap
    update_src_rect
  end
  
  #--------------------------------------------------------------------------
  # new method: correct_change_pose
  #--------------------------------------------------------------------------
  def correct_change_pose
    @pattern = 1
    @timer = 15
    @back_step = false
    @last_pose = pose
  end
  
  #--------------------------------------------------------------------------
  # new method: update_charset_origin
  #--------------------------------------------------------------------------
  def update_charset_origin
    if bitmap
      self.ox = @cw / 2
      self.oy = @ch
    end
  end
  
  #--------------------------------------------------------------------------
  # new method: graphic_changed?
  #--------------------------------------------------------------------------
  def graphic_changed?
    self.bitmap.nil? || @character_name != @battler.character_name ||
    @character_index != @battler.character_index
  end
  
  #--------------------------------------------------------------------------
  # new method: set_character_bitmap
  #--------------------------------------------------------------------------
  def set_character_bitmap
    self.bitmap = Cache.character(@character_name)
    sign = @character_name[/^[\!\$]./]
    if sign && sign.include?('$')
      @cw = bitmap.width / 3
      @ch = bitmap.height / 4
    else
      @cw = bitmap.width / 12
      @ch = bitmap.height / 8
    end
  end
  
  #--------------------------------------------------------------------------
  # new method: update_charset_bitmap
  #--------------------------------------------------------------------------
  def update_charset_bitmap
    if graphic_changed?
      @character_name = @battler.character_name
      @character_index = @battler.character_index
      set_character_bitmap
    end
  end
  
  #--------------------------------------------------------------------------
  # new method: update_src_rect
  #--------------------------------------------------------------------------
  def update_src_rect
    @timer -= 1
    if @battler.force_pose
      array = []
      array = Direction.index_8d(pose) if $imported["BattleSymphony-8D"] && @battler.use_8d?
      if [email protected]_pose && @pattern < 2 && @timer <= 0
        @pattern += 1
        @timer = array[2].nil? ? 15 : array[2]
      elsif @battler.reverse_pose && @pattern > 0 && @timer <= 0
        @pattern -= 1
        @timer = array[2].nil? ? 15 : array[2]
      end
    else
      #--- Quick Fix
      @pattern = 2 if @pattern > 2
      @pattern = 0 if @pattern < 0
      #--- End
      if @timer <= 0
        @pattern += @back_step ? -1 : 1
        @back_step = true if @pattern >= 2
        @back_step = false if @pattern <= 0
        @timer = 15
      end
    end
    #---
    @battler.break_pose unless pose
    direction = Direction.direction(pose)
    character_index = @character_index
    #---
    if $imported["BattleSymphony-8D"] && @battler.use_8d?
      array = Direction.index_8d(pose)
      character_index = array[0]
      direction = array[1]
    end
    sx = (character_index % 4 * 3 + @pattern) * @cw
    sy = (character_index / 4 * 4 + (direction - 2) / 2) * @ch
    self.src_rect.set(sx, sy, @cw, @ch)
  end
  
  #--------------------------------------------------------------------------
  # overwrite method: revert_to_normal
  #--------------------------------------------------------------------------
  def revert_to_normal
    self.blend_type = 0
    self.color.set(0, 0, 0, 0)
    self.opacity = 255
  end
  
  #--------------------------------------------------------------------------
  # alias method: animation_set_sprites
  # Make Animation Opacity independent of Sprite Opacity
  #--------------------------------------------------------------------------
  alias bes_animation_set_sprites animation_set_sprites
  def animation_set_sprites(frame)
    bes_animation_set_sprites(frame)
    cell_data = frame.cell_data
    @ani_sprites.each_with_index do |sprite, i|
      next unless sprite
      pattern = cell_data[i, 0]
      if !pattern || pattern < 0
        sprite.visible = false
        next
      end
      sprite.opacity = cell_data[i, 6]
    end
  end
  
end # Sprite_Battler

#==============================================================================
# ■ Spriteset_Battle
#==============================================================================

class Spriteset_Battle
  
  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :actor_sprites
  attr_accessor :enemy_sprites
  
  #--------------------------------------------------------------------------
  # overwrite method: create_actors
  # Fixed Large Party.
  #--------------------------------------------------------------------------
  def create_actors
    max_members = $game_party.max_battle_members
    @actor_sprites = Array.new(max_members) { Sprite_Battler.new(@viewport1) }
  end
  
  #--------------------------------------------------------------------------
  # overwrite method: update_actors
  # Fixed Change Party.
  #--------------------------------------------------------------------------
  def update_actors
    @actor_sprites.each_with_index do |sprite, i|
      party_member = $game_party.battle_members
      if party_member != sprite.battler
        sprite.battler = $game_party.battle_members
        #---
        if party_member
          party_member.reset_position
          party_member.correct_origin_position
          party_member.break_pose if party_member.dead?
        end
        sprite.init_visibility if sprite.battler && !sprite.battler.use_custom_charset?
      end
      sprite.update
    end
  end
  
end # Spriteset_Battle

#==============================================================================
# Section VII. Icons Sprites Initialization (S-07)
# -----------------------------------------------------------------------------
# This section is the second section of core script. It will Initializes and
# Creates Sprites for all Object like Weapons, Items and Maintains them.
# -----------------------------------------------------------------------------
# Do not touch below script unless You know what You do and How it works.
#==============================================================================
#==============================================================================
# ■ Sprite_Object
#==============================================================================

class Sprite_Object < Sprite_Base
  
  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(viewport = nil)
    super(viewport)
    #---
    @dest_angle = 0
    @dest_x = 0
    @dest_y = 0
    #---
    @angle_rate = 0
    @move_x_rate = 0
    @move_y_rate = 0
    @fade_rate = 0
    #---
    @arc = 0
    @parabola = {}
    @f = 0
    @arc_y = 0
    #---
    @battler = nil
    @offset_x = 0
    @offset_y = 0
    @offset_z = 0
    @attach_x = 0
    @attach_y = 0
    @attachment = :middle
  end
  
  #--------------------------------------------------------------------------
  # set_battler
  #--------------------------------------------------------------------------
  def set_battler(battler = nil)
    @battler = battler
    update
  end
  
  #--------------------------------------------------------------------------
  # set_position
  #--------------------------------------------------------------------------
  def set_position(x, y)
    @dest_x = self.x = x
    @dest_y = self.y = y
  end
  
  #--------------------------------------------------------------------------
  # set_angle
  #--------------------------------------------------------------------------
  def set_angle(angle)
    @dest_angle = self.angle = angle
    @dest_angle = self.angle = -angle if mirror_battler?
  end
  
  #--------------------------------------------------------------------------
  # set_icon
  #--------------------------------------------------------------------------
  def set_icon(index)
    return if index <= 0
    bitmap = Cache.system("Iconset")
    self.bitmap ||= bitmap
    self.src_rect.set(index % 16 * 24, index / 16 * 24, 24, 24)
    self.ox = self.oy = 12
  end
  
  #--------------------------------------------------------------------------
  # set_origin
  #--------------------------------------------------------------------------
  def set_origin(type)
    @offset_z = 2
    @attachment = type
    case type
    when :item
      self.ox = 12
      self.oy = 12
      @offset_y = [email protected]
      @offset_x = [email protected] / 2
    when :hand1
      self.ox = 24
      self.oy = 24
      @attach_y = [email protected]/3
      @attach_x = [email protected]/5
    when :hand2
      self.ox = 24
      self.oy = 24
      @attach_y = [email protected]/3
      @attach_x = @battler.sprite.width/5
    when :middle
      self.ox = 12
      self.oy = 12
      @offset_y = [email protected]/2
    when :top
      self.ox = 12
      self.oy = 24
      @offset_y = [email protected]
    when :base
      self.ox = 12
      self.oy = 24
    end
    self.y = @battler.screen_y + @attach_y + @offset_y + @arc_y
  end
  
  #--------------------------------------------------------------------------
  # set_fade
  #--------------------------------------------------------------------------
  def set_fade(rate)
    @fade_rate = rate
  end
  
  #--------------------------------------------------------------------------
  # create_angle
  #--------------------------------------------------------------------------
  def create_angle(angle, frames = 8)
    return if angle == self.angle
    @dest_angle = angle
    @dest_angle = - @dest_angle if mirror_battler?
    frames = [frames, 1].max
    @angle_rate = [(self.angle - @dest_angle).abs / frames, 2].max
  end
  
  #--------------------------------------------------------------------------
  # create_arc
  #--------------------------------------------------------------------------
  def create_arc(arc)
    @arc = arc
    @parabola[:x] = 0
    @parabola[:y0] = 0
    @parabola[:y1] = @dest_y - self.y
    @parabola[:h]  = - (@parabola[:y0] + @arc * 5)
    @parabola[:d]  = (self.x - @dest_x).abs
  end
  
  #--------------------------------------------------------------------------
  # create_movement
  #--------------------------------------------------------------------------
  def create_movement(destination_x, destination_y, frames = 12)
    return if self.x == destination_x && self.y == destination_y
    @arc = 0
    @dest_x = destination_x
    @dest_y = destination_y
    frames = [frames, 1].max
    @f = frames.to_f / 2
    @move_x_rate = [(self.x - @dest_x).abs / frames, 2].max
    @move_y_rate = [(self.y - @dest_y).abs / frames, 2].max
  end
  
  #--------------------------------------------------------------------------
  # create_move_direction
  #--------------------------------------------------------------------------
  def create_move_direction(direction, distance, frames = 12)
    case direction
    when 1; move_x = distance / -2; move_y = distance /  2
    when 2; move_x = distance *  0; move_y = distance *  1
    when 3; move_x = distance / -2; move_y = distance /  2
    when 4; move_x = distance * -1; move_y = distance *  0
    when 6; move_x = distance *  1; move_y = distance *  0
    when 7; move_x = distance / -2; move_y = distance / -2
    when 8; move_x = distance *  0; move_y = distance * -1
    when 9; move_x = distance /  2; move_y = distance / -2
    else; return
    end
    #---
    move_x += self.x
    move_y += self.y
    #---
    create_movement(move_x, move_y, frames)
  end
  
  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    update_angle
    @arc == 0 ? update_movement : update_arc
    update_position
    update_opacity
  end
  
  #--------------------------------------------------------------------------
  # update_angle
  #--------------------------------------------------------------------------
  def update_angle
    return if @angle_rate == 0
    @angle_rate = 0 if self.angle == @dest_angle
    value = [(self.angle - @dest_angle).abs, @angle_rate].min
    self.angle += (@dest_angle > self.angle) ? value : -value
  end
  
  #--------------------------------------------------------------------------
  # update_arc
  #--------------------------------------------------------------------------
  def update_arc
    return unless [@move_x_rate, @move_y_rate].any? { |x| x != 0 }
    #---
    value = [(self.x - @dest_x).abs, @move_x_rate].min
    @offset_x += (@dest_x > self.x) ? value : -value
    @parabola[:x] += value
    #---
    if @dest_x == self.x
      self.y = @dest_y
    else
      a = (2*(@parabola[:y0]+@parabola[:y1])-4*@parabola[:h])/(@parabola[:d]**2)
      b = (@parabola[:y1]-@parabola[:y0]-a*(@parabola[:d]**2))/@parabola[:d]
      @arc_y = a * @parabola[:x] * @parabola[:x] + b * @parabola[:x] + @parabola[:y0]
    end
    #---
    @move_x_rate = 0 if self.x == @dest_x
    @move_y_rate = 0 if self.y == @dest_y
  end
  
  #--------------------------------------------------------------------------
  # update_movement
  #--------------------------------------------------------------------------
  def update_movement
    return unless [@move_x_rate, @move_y_rate].any? { |x| x != 0 }
    @move_x_rate = 0 if self.x == @dest_x
    @move_y_rate = 0 if self.y == @dest_y
    value = [(self.x - @dest_x).abs, @move_x_rate].min
    @offset_x += (@dest_x > self.x) ? value : -value
    value = [(self.y - @dest_y).abs, @move_y_rate].min
    @offset_y += (@dest_y > self.y) ? value : -value
  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 + @arc_y
      self.z = @battler.screen_z + @offset_z
    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 = [email protected]/3
      @attach_x = [email protected]/5
    when :hand2
      self.ox = mirror ? 0 : 24
      self.oy = 24
      @attach_y = [email protected]/3
      @attach_x = @battler.sprite.width/5
    else
      @attach_x = 0
      @attach_y = 0
    end
  end
  
  #--------------------------------------------------------------------------
  # update_attachment
  #--------------------------------------------------------------------------
  def update_opacity
    self.opacity += @fade_rate
  end
  
  #--------------------------------------------------------------------------
  # mirror_battler?
  #--------------------------------------------------------------------------
  def mirror_battler?
    return false if @battler.sprite == nil
    direction = Direction.direction(@battler.pose)
    return true if [9, 6, 3].include?(direction)
    return true if @battler.sprite.mirror
    return false
  end
  
  #--------------------------------------------------------------------------
  # effecting?
  #--------------------------------------------------------------------------
  def effecting?
    [@angle_rate,@move_y_rate,@move_x_rate,@fade_rate].any? { |x| x > 0 }
  end
  
end # Sprite_Object

#==============================================================================
# Section VIII. Core Script (S-08)
# -----------------------------------------------------------------------------
# This section is the most important section of Core SCript. It will Initialize
# Database as well as Symphony Tags and put them in actions.
# -----------------------------------------------------------------------------
# Do not touch below script unless You know what You do and How it works.
#==============================================================================
#==============================================================================
# ■ Regular Expression
#==============================================================================

module REGEXP
  module SYMPHONY
    SETUP_ANI_ON   = /<(?:SETUP_ACTION|setup action|setup)>/i
    SETUP_ANI_OFF  = /<\/(?:SETUP_ACTION|setup action|setup)>/i
    WHOLE_ANI_ON   = /<(?:WHOLE_ACTION|whole action|whole)>/i
    WHOLE_ANI_OFF  = /<\/(?:WHOLE_ACTION|whole action|whole)>/i
    TARGET_ANI_ON  = /<(?:TARGET_ACTION|target action|target)>/i
    TARGET_ANI_OFF = /<\/(?:TARGET_ACTION|target action|target)>/i
    FOLLOW_ANI_ON  = /<(?:FOLLOW_ACTION|follow action|follow)>/i
    FOLLOW_ANI_OFF = /<\/(?:FOLLOW_ACTION|follow action|follow)>/i
    FINISH_ANI_ON  = /<(?:FINISH_ACTION|finish action|finish)>/i
    FINISH_ANI_OFF = /<\/(?:FINISH_ACTION|finish action|finish)>/i
   
    SYMPHONY_TAG_NONE = /[ ]*(.*)/i
    SYMPHONY_TAG_VALUES = /[ ]*(.*):[ ]*(.*)/i
   
    ATK_ANI1 = /<(?:ATK_ANI_1|atk ani 1):[ ]*(\d+)>/i
    ATK_ANI2 = /<(?:ATK_ANI_2|atk ani 2):[ ]*(\d+)>/i

  end
end

# Scan values: /\w+[\s*\w+]*/i

#==============================================================================
# ■ DataManager
#==============================================================================

module DataManager
  
  #--------------------------------------------------------------------------
  # alias method: load_database
  #--------------------------------------------------------------------------
  class <<self; alias load_database_bes load_database; end
  def self.load_database
    load_database_bes
    load_notetags_bes
  end
  
  #--------------------------------------------------------------------------
  # new method: load_notetags_bes
  #--------------------------------------------------------------------------
  def self.load_notetags_bes
    groups = [$data_skills, $data_items, $data_weapons, $data_enemies]
    groups.each { |group|
      group.each { |obj|
        next if obj.nil?
        obj.battle_symphony_initialize
      }
    }
  end
  
end # DataManager

#==============================================================================
# ■ RPG::BaseItem
#==============================================================================

class RPG::BaseItem
  
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :setup_actions_list
  attr_accessor :whole_actions_list
  attr_accessor :target_actions_list
  attr_accessor :follow_actions_list
  attr_accessor :finish_actions_list
  attr_accessor :atk_animation_id1
  attr_accessor :atk_animation_id2
  
  #--------------------------------------------------------------------------
  # new method: battle_symphony_initialize
  #--------------------------------------------------------------------------
  def battle_symphony_initialize
    create_default_animation
    create_default_symphony
    create_tags_symphony
  end
  
  #--------------------------------------------------------------------------
  # new method: create_default_animation
  #--------------------------------------------------------------------------
  def create_default_animation
    @atk_animation_id1 = SYMPHONY::Visual::ENEMY_ATTACK_ANIMATION
    @atk_animation_id2 = 0
    self.note.split(/[\r\n]+/).each { |line|
      case line
      when REGEXP::SYMPHONY::ATK_ANI1
        @atk_animation_id1 = $1.to_i
      when REGEXP::SYMPHONY::ATK_ANI2
        @atk_animation_id2 = $1.to_i
      end
    }
  end
  
  #--------------------------------------------------------------------------
  # new method: create_default_symphony
  #--------------------------------------------------------------------------
  def create_default_symphony
    @setup_actions_list = []; @finish_actions_list = []
    @whole_actions_list = []; @target_actions_list = []
    @follow_actions_list = []
    #---
    if self.is_a?(RPG::Skill) and !self.physical?
      @setup_actions_list = SYMPHONY::DEFAULT_ACTIONS::MAGIC_SETUP
      @whole_actions_list = SYMPHONY::DEFAULT_ACTIONS::MAGIC_WHOLE
      @target_actions_list = SYMPHONY::DEFAULT_ACTIONS::MAGIC_TARGET
      @follow_actions_list = SYMPHONY::DEFAULT_ACTIONS::MAGIC_FOLLOW
      @finish_actions_list = SYMPHONY::DEFAULT_ACTIONS::MAGIC_FINISH
      return
    elsif self.is_a?(RPG::Skill) and self.physical?
      @setup_actions_list = SYMPHONY::DEFAULT_ACTIONS::PHYSICAL_SETUP
      @whole_actions_list = SYMPHONY::DEFAULT_ACTIONS::PHYSICAL_WHOLE
      @target_actions_list = SYMPHONY::DEFAULT_ACTIONS::PHYSICAL_TARGET
      @follow_actions_list = SYMPHONY::DEFAULT_ACTIONS::PHYSICAL_FOLLOW
      @finish_actions_list = SYMPHONY::DEFAULT_ACTIONS::PHYSICAL_FINISH
      return
    elsif self.is_a?(RPG::Item)
      @setup_actions_list = SYMPHONY::DEFAULT_ACTIONS::ITEM_SETUP
      @whole_actions_list = SYMPHONY::DEFAULT_ACTIONS::ITEM_WHOLE
      @target_actions_list = SYMPHONY::DEFAULT_ACTIONS::ITEM_TARGET
      @follow_actions_list = SYMPHONY::DEFAULT_ACTIONS::ITEM_FOLLOW
      @finish_actions_list = SYMPHONY::DEFAULT_ACTIONS::ITEM_FINISH
      return
    end
  end
  
  #--------------------------------------------------------------------------
  # new method: create_tags_symphony
  #--------------------------------------------------------------------------
  def create_tags_symphony
    self.note.split(/[\r\n]+/).each { |line|
      case line
      when REGEXP::SYMPHONY::SETUP_ANI_ON
        @symphony_tag = true
        @setup_actions_list = []
        @setup_action_flag = true
      when REGEXP::SYMPHONY::SETUP_ANI_OFF
        @symphony_tag = false
        @setup_action_flag = false
      when REGEXP::SYMPHONY::WHOLE_ANI_ON
        @symphony_tag = true
        @whole_actions_list = []
        @whole_action_flag = true
      when REGEXP::SYMPHONY::WHOLE_ANI_OFF
        @symphony_tag = false
        @whole_action_flag = false
      when REGEXP::SYMPHONY::TARGET_ANI_ON
        @symphony_tag = true
        @target_actions_list = []
        @target_action_flag = true
      when REGEXP::SYMPHONY::TARGET_ANI_OFF
        @symphony_tag = false
        @target_action_flag = false
      when REGEXP::SYMPHONY::FOLLOW_ANI_ON
        @symphony_tag = true
        @follow_actions_list = []
        @follow_action_flag = true
      when REGEXP::SYMPHONY::FOLLOW_ANI_OFF
        @symphony_tag = false
        @follow_action_flag = false
      when REGEXP::SYMPHONY::FINISH_ANI_ON
        @symphony_tag = true
        @finish_actions_list = []
        @finish_action_flag = true
      when REGEXP::SYMPHONY::FINISH_ANI_OFF
        @symphony_tag = false
        @finish_action_flag = false
      #---
      else
        next unless @symphony_tag
        case line
        when REGEXP::SYMPHONY::SYMPHONY_TAG_VALUES
          action = $1
          value = $2.scan(/[^, ]+[^,]*/i)
        when REGEXP::SYMPHONY::SYMPHONY_TAG_NONE
          action = $1
          value = [nil]
        else; next
        end
        array = [action, value]
        if @setup_action_flag
          @setup_actions_list.push(array)
        elsif @whole_action_flag
          @whole_actions_list.push(array)
        elsif @target_action_flag
          @target_actions_list.push(array)
        elsif @follow_action_flag
          @follow_actions_list.push(array)
        elsif @finish_action_flag
          @finish_actions_list.push(array)
        end
      end
    }
  end
  
  #--------------------------------------------------------------------------
  # new method: valid_actions?
  #--------------------------------------------------------------------------
  def valid_actions?(phase)
    case phase
    when :setup
      return @setup_actions_list.size > 0
    when :whole
      return @whole_actions_list.size > 0
    when :target
      return @target_actions_list.size > 0
    when :follow
      return @follow_actions_list.size > 0
    when :finish
      return @finish_actions_list.size > 0
    end
  end
  
end # RPG::BaseItem

#==============================================================================
# ■ Direction
#==============================================================================

module Direction
  
  #--------------------------------------------------------------------------
  # self.pose
  #--------------------------------------------------------------------------
  def self.pose(direction)
    case direction
    when 4; return :left
    when 6; return :right
    when 8; return :up
    when 2; return :down
    when 7; return :left
    when 1; return :left
    when 9; return :right
    when 3; return :right
    end
  end
  
  #--------------------------------------------------------------------------
  # self.non8d_pose
  #--------------------------------------------------------------------------
  def self.non8d_pose(pose)
    case pose
    when :down_l; return :left
    when :down_r; return :right
    when :up_l; return :left
    when :up_r; return :right
    end
  end
  
  #--------------------------------------------------------------------------
  # self.pose
  #--------------------------------------------------------------------------
  def self.direction(pose)
    case pose
    when :left; return 4
    when :right; return 6
    when :up; return 8
    when :down; return 2
    end
  end
  
  #--------------------------------------------------------------------------
  # self.opposite
  #--------------------------------------------------------------------------
  def self.opposite(direction)
    case direction
    when 1; return 9
    when 2; return 8
    when 3; return 7
    when 4; return 6
    when 6; return 4
    when 7; return 3
    when 8; return 2
    when 9; return 1
    else; return direction
    end
  end
  
  #--------------------------------------------------------------------------
  # self.face_coordinate
  #--------------------------------------------------------------------------
  def self.face_coordinate(screen_x, screen_y, destination_x, destination_y)
    x1 = Integer(screen_x)
    x2 = Integer(destination_x)
    y1 = Graphics.height - Integer(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
    return direction
  end
  
end # Direction

#==============================================================================
# ■ Game_ActionResult
#==============================================================================

class Game_ActionResult
  
  #--------------------------------------------------------------------------
  # alias method: clear_hit_flags
  #--------------------------------------------------------------------------
  alias bes_clear_hit_flags clear_hit_flags
  def clear_hit_flags
    return unless @calc
    bes_clear_hit_flags
    @temp_missed = @temp_evaded = @temp_critical = nil
  end
  
  #--------------------------------------------------------------------------
  # new method: clear_bes_flag
  #--------------------------------------------------------------------------
  def clear_bes_flag
    @perfect_hit = false
    @calc = false
    @dmg = false
    @effect = false
  end
  
  #--------------------------------------------------------------------------
  # new method: clear_change_target
  #--------------------------------------------------------------------------
  def clear_change_target
    @check_counter = false
    @check_reflection = false
  end
  
  #--------------------------------------------------------------------------
  # new method: set_perfect
  #--------------------------------------------------------------------------
  def set_perfect
    @perfect_hit = true
  end
  
  #--------------------------------------------------------------------------
  # new method: set_calc
  #--------------------------------------------------------------------------
  def set_calc
    @calc = true
  end
  
  #--------------------------------------------------------------------------
  # new method: set_dmg
  #--------------------------------------------------------------------------
  def set_dmg
    @dmg = true
  end
  
  #--------------------------------------------------------------------------
  # new method: set_effect
  #--------------------------------------------------------------------------
  def set_effect
    @effect = true
  end
  
  #--------------------------------------------------------------------------
  # new method: set_counter
  #--------------------------------------------------------------------------
  def set_counter
    @check_counter = true
  end
  
  #--------------------------------------------------------------------------
  # new method: set_reflection
  #--------------------------------------------------------------------------
  def set_reflection
    @check_reflection = true
  end
  
  #--------------------------------------------------------------------------
  # new method: used=
  #--------------------------------------------------------------------------
  def evaded=(flag)
    @evaded = @temp_evaded.nil? ? flag : @temp_evaded
  end
  
  #--------------------------------------------------------------------------
  # new method: used=
  #--------------------------------------------------------------------------
  def critical=(flag)
    @critical = @temp_critical.nil? ? flag : @temp_critical
  end
  
  #--------------------------------------------------------------------------
  # new method: used=
  #--------------------------------------------------------------------------
  def misssed=(flag)
    @missed = @temp_missed.nil? ? flag : @temp_missed
  end
  
  #--------------------------------------------------------------------------
  # alias method: hit?
  #--------------------------------------------------------------------------
  alias bes_hit? hit?
  def hit?
    bes_hit? || (@used && @perfect_hit)
  end
  
  #--------------------------------------------------------------------------
  # new method: dmg?
  #--------------------------------------------------------------------------
  def dmg?
    @dmg || !SceneManager.scene_is?(Scene_Battle)
  end
  
  #--------------------------------------------------------------------------
  # new method: effect?
  #--------------------------------------------------------------------------
  def effect?
    @effect || !SceneManager.scene_is?(Scene_Battle)
  end
  
  #--------------------------------------------------------------------------
  # new method: has_damage?
  #--------------------------------------------------------------------------
  def has_damage?
    [@hp_damage, @mp_damage, @tp_damage].any? { |x| x > 0 }
  end
  
  #--------------------------------------------------------------------------
  # new method: check_counter?
  #--------------------------------------------------------------------------
  def check_counter?
    @check_counter
  end
  
  #--------------------------------------------------------------------------
  # new method: check_reflection?
  #--------------------------------------------------------------------------
  def check_reflection?
    @check_reflection
  end
  
end # Game_ActionResult

#==============================================================================
# ■ Game_Battler
#==============================================================================

class Game_Battler < Game_BattlerBase
  
  #--------------------------------------------------------------------------
  # new method: backup_actions
  #--------------------------------------------------------------------------
  def backup_actions
    @backup_actions = @actions.dup if @actions
  end
  
  #--------------------------------------------------------------------------
  # new method: restore_actions
  #--------------------------------------------------------------------------
  def restore_actions
    @actions = @backup_actions.dup if @backup_actions
    @backup_actions.clear
    @backup_actions = nil
  end
  
  #--------------------------------------------------------------------------
  # alias method: item_cnt
  #--------------------------------------------------------------------------
  alias bes_item_cnt item_cnt
  def item_cnt(user, item)
    return 0 unless @result.check_counter?
    return bes_item_cnt(user, item)
  end
  
  #--------------------------------------------------------------------------
  # alias method: item_mrf
  #--------------------------------------------------------------------------
  alias bes_item_mrf item_mrf
  def item_mrf(user, item)
    return 0 unless @result.check_reflection?
    return 0 if @magic_reflection
    return bes_item_mrf(user, item)
  end
  
  #--------------------------------------------------------------------------
  # alias method: state_resist_set
  #--------------------------------------------------------------------------
  alias bes_state_resist_set state_resist_set
  def state_resist_set
    result = bes_state_resist_set
    result += [death_state_id] if @immortal
    result
  end
  
  #--------------------------------------------------------------------------
  # alias method: execute_damage
  #--------------------------------------------------------------------------
  alias bes_execute_damage execute_damage
  def execute_damage(user)
    return unless @result.dmg?
    bes_execute_damage(user)
  end
  
  #--------------------------------------------------------------------------
  # alias method: make_damage_value
  #--------------------------------------------------------------------------
  alias bes_make_damage_value make_damage_value
  def make_damage_value(user, item)
    return unless @result.dmg?
    bes_make_damage_value(user, item)
  end
  
  #--------------------------------------------------------------------------
  # alias method: item_effect_apply
  #--------------------------------------------------------------------------
  alias bes_item_effect_apply item_effect_apply
  def item_effect_apply(user, item, effect)
    return unless @result.effect?
    bes_item_effect_apply(user, item, effect)
  end
  
  #--------------------------------------------------------------------------
  # alias method: item_user_effect
  #--------------------------------------------------------------------------
  alias bes_item_user_effect item_user_effect
  def item_user_effect(user, item)
    return unless @result.effect?
    bes_item_user_effect(user, item)
  end
  
  #--------------------------------------------------------------------------
  # alias method: make_miss_popups
  #--------------------------------------------------------------------------
  if $imported["YEA-BattleEngine"]
  alias bes_make_miss_popups make_miss_popups
  def make_miss_popups(user, item)
    @result.restore_damage unless @result.effect?
    bes_make_miss_popups(user, item)
    unless @result.effect?
      @result.store_damage
      @result.clear_damage_values
    end
  end
  end
  
  #--------------------------------------------------------------------------
  # new method: face_coordinate
  #--------------------------------------------------------------------------
  def face_coordinate(destination_x, destination_y)
    direction = Direction.face_coordinate(self.screen_x, self.screen_y, destination_x, destination_y)
    #direction = Direction.opposite(direction) if self.sprite.mirror
    @direction = direction
    return if $imported["BattleSymphony-HB"] && self.use_hb?
    return if SYMPHONY::Visual::DISABLE_AUTO_MOVE_POSE && self.use_custom_charset?
    @pose = Direction.pose(direction)
  end
  
  #--------------------------------------------------------------------------
  # new method: create_movement
  #--------------------------------------------------------------------------
  def create_movement(destination_x, destination_y, frames = 12)
    return if @screen_x == destination_x && @screen_y == destination_y
    @destination_x = destination_x
    @destination_y = destination_y
    frames = [frames, 1].max
    @f = frames.to_f / 2
    @move_x_rate = [(@screen_x - @destination_x).abs / frames, 2].max
    @move_y_rate = [(@screen_y - @destination_y).abs / frames, 2].max
  end
  
  #--------------------------------------------------------------------------
  # new method: create_jump
  #--------------------------------------------------------------------------
  def create_jump(arc)
    @arc = arc
    @parabola[:x] = 0
    @parabola[:y0] = 0
    @parabola[:y1] = @destination_y - @screen_y
    @parabola[:h]  = - (@parabola[:y0] + @arc * 5)
    @parabola[:d]  = (@screen_x - @destination_x).abs
  end
  
  #--------------------------------------------------------------------------
  # new method: create_icon
  #--------------------------------------------------------------------------
  def create_icon(symbol, icon_id = 0)
    delete_icon(symbol)
    #---
    icon = Sprite_Object.new(self.sprite.viewport)
    case symbol
    when :weapon1
      object = self.weapons[0]
      icon_id = object.nil? ? nil : object.icon_index
    when :weapon2
      object = dual_wield? ? self.weapons[1] : nil
      icon_id = object.nil? ? nil : object.icon_index
    when :shield
      object = dual_wield? ? nil : self.equips[1]
      icon_id = object.nil? ? nil : object.icon_index
    when :item
      object = self.current_action.item
      icon_id = object.nil? ? nil : object.icon_index
    else; end
    return if icon_id.nil? || icon_id <= 0
    icon.set_icon(icon_id)
    icon.set_battler(self)
    #---
    @icons[symbol] = icon
  end
   
  #--------------------------------------------------------------------------
  # new method: delete_icon
  #--------------------------------------------------------------------------
  def delete_icon(symbol)
    return unless @icons[symbol]
    @icons[symbol].dispose
    @icons.delete(symbol)
  end
  
  #--------------------------------------------------------------------------
  # new method: clear_icons
  #--------------------------------------------------------------------------
  def clear_icons
    @icons.each { |key, value|
      value.dispose
      @icons.delete(key)
    }
  end
  
  #--------------------------------------------------------------------------
  # new method: update_movement
  #--------------------------------------------------------------------------
  def update_movement
    return unless self.is_moving?
    @move_x_rate = 0 if @screen_x == @destination_x || @move_x_rate.nil?
    @move_y_rate = 0 if @screen_y == @destination_y || @move_y_rate.nil?
    value = [(@screen_x - @destination_x).abs, @move_x_rate].min
    @screen_x += (@destination_x > @screen_x) ? value : -value
    value = [(@screen_y - @destination_y).abs, @move_y_rate].min
    @screen_y += (@destination_y > @screen_y) ? value : -value
  end
  
  #--------------------------------------------------------------------------
  # new method: update_jump
  #--------------------------------------------------------------------------
  def update_jump
    return unless self.is_moving?
    #---
    value = [(@screen_x - @destination_x).abs, @move_x_rate].min
    @screen_x += (@destination_x > @screen_x) ? value : -value
    @parabola[:x] += value
    @screen_y -= @arc_y
    #---
    if @destination_x == @screen_x
      @screen_y = @destination_y
      @arc_y = 0
      @arc = 0
    else
      a = (2.0*(@parabola[:y0]+@parabola[:y1])-4*@parabola[:h])/(@parabola[:d]**2)
      b = (@parabola[:y1]-@parabola[:y0]-a*(@parabola[:d]**2))/@parabola[:d]
      @arc_y = a * @parabola[:x] * @parabola[:x] + b * @parabola[:x] + @parabola[:y0]
    end
    #---
    @screen_y += @arc_y
    @move_x_rate = 0 if @screen_x == @destination_x
    @move_y_rate = 0 if @screen_y == @destination_y
  end
  
  #--------------------------------------------------------------------------
  # new method: update_icons
  #--------------------------------------------------------------------------
  def update_icons
    @icons ||= {}
    @icons.each_value { |value| value.update }
  end
  
  #--------------------------------------------------------------------------
  # new method: update_visual
  #--------------------------------------------------------------------------
  def update_visual
    return unless SceneManager.scene_is?(Scene_Battle)
    return unless SceneManager.scene.spriteset
    correct_origin_position
    #---
    @arc == 0 ? update_movement : update_jump
    update_icons
  end
  
  #--------------------------------------------------------------------------
  # new method: is_moving?
  #--------------------------------------------------------------------------
  def is_moving?
    [@move_x_rate, @move_y_rate].any? { |x| x != 0 }
  end
  
  #--------------------------------------------------------------------------
  # new method: is_moving?
  #--------------------------------------------------------------------------
  def dual_attack?
    self.actor? && self.current_action.attack? && self.dual_wield? && self.weapons.size > 1
  end
  
end # Game_Battler

#==============================================================================
# ■ Sprite_Battler
#==============================================================================

class Sprite_Battler < Sprite_Base
  
  #--------------------------------------------------------------------------
  # new method: is_moving?
  #--------------------------------------------------------------------------
  def is_moving?
    return unless @battler
    @battler.is_moving?
  end
  
end # Sprite_Battler

#==============================================================================
# ■ Spriteset_Battle
#==============================================================================

class Spriteset_Battle
  
  #--------------------------------------------------------------------------
  # new method: is_moving?
  #--------------------------------------------------------------------------
  def is_moving?
    self.battler_sprites.any? { |sprite| sprite.is_moving? }
  end
  
end # Spriteset_Battle

#==============================================================================
# ■ Window_BattleLog
#==============================================================================

class Window_BattleLog < Window_Selectable
  
  
  
end # Window_BattleLog

#==============================================================================
# ■ Scene_Battle
#==============================================================================

class Scene_Battle < Scene_Base
  
  #--------------------------------------------------------------------------
  # overwrite method: use_item
  #--------------------------------------------------------------------------
  def use_item
    @scene_item = item = @subject.current_action.item
    targets = @subject.current_action.make_targets.compact
    #---
    attack = @subject.current_action.attack?
    weapon = @subject.weapons[0]
    w_action = attack && weapon
    #---
    targets = targets * 2 if attack && @subject.dual_attack?
    #--- Setup Actions ---
    actions_list = item.setup_actions_list
    actions_list = weapon.setup_actions_list if w_action && weapon.valid_actions?(:setup)
    perform_actions_list(actions_list, targets)
    #--- Item Costs ---
    @subject.use_item(item)
    refresh_status
    #--- YEA - Cast Animation
    process_casting_animation if $imported["YEA-CastAnimations"]
    #--- YEA - Lunatic Object
    if $imported["YEA-LunaticObjects"]
      lunatic_object_effect(:before, item, @subject, @subject)
    end
    #--- Whole Actions ---
    actions_list = item.whole_actions_list
    actions_list = weapon.whole_actions_list if w_action && weapon.valid_actions?(:whole)
    perform_actions_list(actions_list, targets)
    #--- Target Actions ---
    actions_list = item.target_actions_list
    actions_list = weapon.target_actions_list if w_action && weapon.valid_actions?(:target)
    targets.each { |target|
      next if target.dead?
      perform_actions_list(actions_list, [target])
    }
    #--- Follow Actions ---
    actions_list = item.follow_actions_list
    actions_list = weapon.follow_actions_list if w_action && weapon.valid_actions?(:follow)
    perform_actions_list(actions_list, targets)
    #--- Finish Actions ---
    actions_list = item.finish_actions_list
    actions_list = weapon.finish_actions_list if w_action && weapon.valid_actions?(:finish)
    immortal_flag = ["IMMORTAL", ["TARGETS", "FALSE"]]
    if !actions_list.include?(immortal_flag)
      if SYMPHONY::Fixes::AUTO_IMMORTAL_OFF
        actions_list = [immortal_flag] + actions_list
      end
    end
    perform_actions_list(actions_list, targets)
    #--- YEA - Lunatic Object
    if $imported["YEA-LunaticObjects"]
      lunatic_object_effect(:after, item, @subject, @subject)
    end
    targets.each { |target|
      next unless target.actor?
      @status_window.draw_item(target.index)
    }
  end
  
  #--------------------------------------------------------------------------
  # alias method: invoke_item
  #--------------------------------------------------------------------------
  alias bes_invoke_item invoke_item
  def invoke_item(target, item)
    if $imported["YEA-TargetManager"]
      target = alive_random_target(target, item) if item.for_random?
    end
    bes_invoke_item(target, item)
    #--- Critical Actions ---
    actions_list = SYMPHONY::DEFAULT_ACTIONS::CRITICAL_ACTIONS
    perform_actions_list(actions_list, [target]) if target.result.critical
    #--- Miss Actions ---
    actions_list = SYMPHONY::DEFAULT_ACTIONS::MISS_ACTIONS
    perform_actions_list(actions_list, [target]) if target.result.missed
    #--- Evade Actions ---
    actions_list = SYMPHONY::DEFAULT_ACTIONS::EVADE_ACTIONS
    perform_actions_list(actions_list, [target]) if target.result.evaded
    #--- Fail Actions ---
    actions_list = SYMPHONY::DEFAULT_ACTIONS::FAIL_ACTIONS
    perform_actions_list(actions_list, [target]) if !target.result.success
    #--- Damaged Actions
    actions_list = SYMPHONY::DEFAULT_ACTIONS::DAMAGED_ACTION
    perform_actions_list(actions_list, [target]) if target.result.has_damage?
  end
  
  #--------------------------------------------------------------------------
  # alias method: execute_action
  #--------------------------------------------------------------------------
  alias bes_execute_action execute_action
  def execute_action
    bes_execute_action
    #--- Reset Flags ---
    ($game_party.battle_members + $game_troop.members).each { |battler|
      battler.result.set_calc; battler.result.clear
      battler.clear_icons
      battler.set_default_position
      battler.break_pose
    }
    $game_troop.screen.clear_bes_ve if $imported["BattleSymphony-VisualEffect"]
    @status_window.draw_item(@status_window.index)
  end
  
  #--------------------------------------------------------------------------
  # overwrite method: invoke_counter_attack
  #--------------------------------------------------------------------------
  def invoke_counter_attack(target, item)
    @log_window.display_counter(target, item)
    last_subject = @subject
    @counter_subject = target
    @subject = target
    #---
    @subject.backup_actions
    #---
    @subject.make_actions
    @subject.current_action.set_attack
    #---
    actions_list = SYMPHONY::DEFAULT_ACTIONS::COUNTER_ACTION
    perform_actions_list(actions_list, [last_subject])
    #---
    @subject.clear_actions
    @subject = last_subject
    #---
    @counter_subject.restore_actions
    #---
    @counter_subject = nil
    @log_window.display_action_results(@subject, item)
    refresh_status
    perform_collapse_check(@subject)
    perform_collapse_check(target)
  end
  
  #--------------------------------------------------------------------------
  # overwrite method: invoke_magic_reflection
  #--------------------------------------------------------------------------
  def invoke_magic_reflection(target, item)
    @subject.magic_reflection = true
    @log_window.display_reflection(target, item)
    last_subject = @subject
    @reflect_subject = target
    @subject = target
    #---
    @subject.backup_actions
    #---
    @subject.make_actions
    if item.is_a?(RPG::Skill); @subject.current_action.set_skill(item.id)
      else; @subject.current_action.set_item(item.id); end
    #---
    actions_list = SYMPHONY::DEFAULT_ACTIONS::REFLECT_ACTION
    perform_actions_list(actions_list, [last_subject])
    #---
    @subject.clear_actions
    @subject = last_subject
    #---
    @reflect_subject.restore_actions
    #---
    @reflect_subject = nil
    @log_window.display_action_results(@subject, item)
    refresh_status
    perform_collapse_check(@subject)
    perform_collapse_check(target)
    @subject.magic_reflection = false
  end
   
  #--------------------------------------------------------------------------
  # new method: wait_for_move
  #--------------------------------------------------------------------------
  def wait_for_move
    update_for_wait
    update_for_wait while @spriteset.is_moving?
  end
  
  #--------------------------------------------------------------------------
  # new method: spriteset
  #--------------------------------------------------------------------------
  def spriteset
    @spriteset
  end
  
  #--------------------------------------------------------------------------
  # compatible overwrite method: separate_ani?
  #--------------------------------------------------------------------------
  if $imported["YEA-BattleEngine"]
  def separate_ani?(target, item)
    return false
  end
  end

  #--------------------------------------------------------------------------
  # new method: perform_collapse_check
  #--------------------------------------------------------------------------
  def perform_collapse_check(target)
    target.perform_collapse_effect if target.can_collapse?
    @log_window.wait_for_effect
  end
  
  #--------------------------------------------------------------------------
  # overwrite method: create_log_window
  #--------------------------------------------------------------------------
#~   def create_log_window
#~     @log_window = Window_BattleLog.new
#~   end
  
end # Scene_Battle

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