#==============================================================================
#
# ¥ 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 and 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 !@battler.reverse_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[i]
     if party_member != sprite.battler
       sprite.battler = $game_party.battle_members[i]
       #---
       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 = -@battler.sprite.height
     @offset_x = -@battler.sprite.width / 2
   when :hand1
     self.ox = 24
     self.oy = 24
     @attach_y = -@battler.sprite.height/3
     @attach_x = -@battler.sprite.width/5
   when :hand2
     self.ox = 24
     self.oy = 24
     @attach_y = -@battler.sprite.height/3
     @attach_x = @battler.sprite.width/5
   when :middle
     self.ox = 12
     self.oy = 12
     @offset_y = -@battler.sprite.height/2
   when :top
     self.ox = 12
     self.oy = 24
     @offset_y = -@battler.sprite.height
   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 =
   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[] = 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[] += 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[] * @parabola[] + b * @parabola[] + @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 = -@battler.sprite.height/3
     @attach_x = -@battler.sprite.width/5
   when :hand2
     self.ox = mirror ? 0 : 24
     self.oy = 24
     @attach_y = -@battler.sprite.height/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 < 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[] = 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[] += 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[] * @parabola[] + b * @parabola[] + @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
#
#===============================================================================