Страница 131 из 185 ПерваяПервая ... 3181121129130131132133141181 ... ПоследняяПоследняя
Показано с 1,301 по 1,310 из 1847

Тема: Поиск скриптов

  1. #1301
    Супер-модератор Аватар для dirge
    Информация о пользователе
    Регистрация
    25.02.2013
    Сообщений
    725
    Репутация: 58 Добавить или отнять репутацию

    По умолчанию

    В общем воспроизвел ошибку у себя. Мануалами ты ее не исправишь. Косяк в том, что виктор походу накосячил с расположением классов. Расставил как надо - ошибка пропала.
    Вот исправленная версия, не уверен вылезет ли еще чего, но как минимум боёвка запускается.
    Код:
    #============================================================================== 
    # ** Victor Engine - Animated Battle 
    #------------------------------------------------------------------------------ 
    # Author : Victor Sant 
    # 
    # Aditional Credit : 
    #   - Fomar0153 (Help with icons placement) 
    # 
    # Version History: 
    #  v beta - 2012.01.28 > Beta release 
    #  v 1.00 - 2012.03.08 > Full release 
    #  v 1.01 - 2012.03.11 > Better automatic facing direction handling 
    #                      > Added tags to control intro and victory poses 
    #                      > Added tags to assign equipment icons for enemies 
    #  v 1.02 - 2012.03.15 > Fixed enemies turing back when unmovable 
    #                      > Better active battler handling 
    #  v 1.03 - 2012.03.19 > Fixed last text error on fast damage skill 
    #                      > Fixed bug if number of members exceeds battle members 
    #  v 1.04 - 2012.03.21 > Fixed pose freeze error 
    #  v 1.05 - 2012.05.20 > Compatibility with Map Turn Battle 
    #  v 1.06 - 2012.05.22 > Compatibility with Passive States 
    #  v 1.07 - 2012.05.24 > Compatibility with State Auto Apply 
    #                      > Added note tags for cast poses 
    #  v 1.08 - 2012.05.25 > Fixed Counter and Reflect endless loop 
    #                      > Fixed freeze at the battle end 
    #  v 1.09 - 2012.07.17 > Fixed throw wait and effect animation 
    #                      > Fixed icons placement (Thanks to Fomar0153) 
    #                      > Fixed directions of actions 
    #                      > Fixed battle log showing too fast 
    #                      > Fixed freeze when escaping 
    #                      > Improved Dual Wielding options 
    #  v 1.10 - 2012.07.18 > Compatibility with Retaliation Damage 
    #                      > Improved direction handling 
    #                      > Improved animation wait time handling 
    #                      > Fixed throw animation skip if targets are near 
    #                      > Fixed shield icon flashing after defending 
    #                      > Fixed some log messages not showing 
    #                      > Fixed typo with move forward (replace all 'foward' 
    #                        text with 'forward') 
    #  v 1.11 - 2012.07.24 > Fixed game closing when cause death state on targets 
    #                      > Fixed issue with animation wait 
    #                      > Added "last" target tag for actions, this tag will 
    #                        use for the action the same target from the previous 
    #                        action. 
    #  v 1.12 - 2012.08.01 > Compatibility with State Aura 
    #  v 1.13 - 2012.08.02 > Compatibility with Custom Slip Effect 
    #                      > Compatibility with Basic Module 1.27 
    #  v 1.14 - 2012.08.17 > Compatibility with Custom Hit Formula 
    #  v 1.15 - 2012.11.03 > Added "frame size" value for pose settings, allowing 
    #                        to setup different frame sizes for each pose. Needed 
    #                        to use CCOA styled battlers. 
    #                      > Fixed issue with freeze when battlers enters the 
    #                        battle with events. 
    #                      > Fixed small jump during actions without movement. 
    #                      > Fixed issue with notetags priority. 
    #                      > Fixed issue with collapse time on battle end. 
    #  v 1.16 - 2012.12.13 > Compatibility with State Graphics 
    #  v 1.17 - 2012.12.24 > Compatibility with Active Time Battle 
    #                      > Compatibility with Counter Options 
    #  v 1.18 - 2012.12.30 > Compatibility with Leap Attack 
    #  v 1.19 - 2013.01.07 > Improved frame setup precision 
    #                      > Added target setting "next" that allows the sequence 
    #                        to select the "next" valid target 
    #                      > Added possibility to use script codes to setup the 
    #                        number of actions repeats, any valid game battler 
    #                        method that returns numeric values can be used. 
    #  v 1.20 - 2013.01.24 > Improved frame setup precision. 
    #  v 1.21 - 2013.01.13 > Major changes on various setups. More deatais at thr 
    #                        Additional Instructions. 
    #                      > Added new sprite settings: ox: and oy:. It can be used 
    #                        to adjust the positon of some battle graphics. 
    #                      > Added values: "condition", "script", "afterimage", 
    #                        "transform", "appear", "target". More information 
    #                        about those on the user manual. 
    #                      > Fixed issue with zoomed icons position. 
    #------------------------------------------------------------------------------ 
    #  This script provides a totally customized animated battle system. 
    # This script allows a full customization of actions sequences, spritesheet 
    # and many things related to in battle display. 
    # This script ins't newbie friendly, be *VERY CAREFUL* with the settings. 
    #------------------------------------------------------------------------------ 
    # Compatibility 
    #   Requires the script 'Victor Engine - Basic Module' v 1.35 or higher 
    #   If used with 'Victor Engine - Custom Slip Effect' place this bellow it. 
    #   If used with 'Victor Engine - Custom Hit Formula' place this bellow it. 
    # 
    # 
    # * Overwrite methods 
    #   class Game_BattlerBase 
    #     def refresh 
    # 
    #   class Game_Battler < Game_BattlerBase 
    #     def dead? 
    # 
    #   class Game_Actor < Game_Battler 
    #     def perform_collapse_effect 
    #     def perform_damage_effect 
    # 
    #   class Game_Enemy < Game_Battler 
    #     def perform_damage_effect 
    # 
    #   class Sprite_Battler < Sprite_Base 
    #     def update_bitmap 
    #     def init_visibility 
    #     def update_origin 
    # 
    #   class Spriteset_Battle 
    #     def create_actors 
    # 
    #   class Window_BattleLog < Window_Selectable 
    #     def wait_and_clear 
    #     def wait 
    #     def back_to(line_number) 
    #     def display_added_states(target) 
    # 
    #   class Scene_Battle < Scene_Base 
    #     def abs_wait_short 
    #     def process_action 
    #     def apply_item_effects(target, item) 
    #     def execute_action 
    #     def use_item 
    #     def show_animation(targets, animation_id) 
    #     def invoke_counter_attack(target, item) 
    #     def invoke_magic_reflection(target, item) 
    #     def apply_substitute(target, item) 
    # 
    # * Alias methods 
    #   class << BattleManager 
    #     def init_members 
    #     def battle_end(result) 
    #     def process_victory 
    #     def process_escape 
    #     def process_abort 
    # 
    #   class Game_Screen 
    #     def clear_tone 
    #     def update 
    # 
    #   class Game_Battler < Game_BattlerBase 
    #     def initialize 
    #     def item_apply(user, item) 
    #     def make_damage_value(user, item) 
    #     def regenerate_hp 
    #     def die 
    #     def revive 
    # 
    #   class Game_Actor < Game_Battler 
    #     def param_plus(param_id) 
    #  
    #   class Game_Enemy < Game_Battler 
    #     def perform_collapse_effect 
    # 
    #   class Sprite_Battler < Sprite_Base 
    #     def initialize(viewport, battler = nil) 
    #     def update_effect 
    #     def revert_to_normal 
    #     def setup_new_effect 
    # 
    #   class Spriteset_Battle 
    #     def initialize 
    #     def update 
    #     def dispose 
    #     def create_pictures 
    #     def create_viewports 
    #     def update_viewports 
    # 
    #   class Window_BattleLog < Window_Selectable 
    #     def add_text(text) 
    # 
    #   class Scene_Battle < Scene_Base 
    #     def create_spriteset 
    #     def update_basic 
    #     def turn_end 
    #     def next_command 
    #     def prior_command 
    # 
    #------------------------------------------------------------------------------ 
    # Instructions: 
    #  To instal the script, open you script editor and paste this script on 
    #  a new section bellow the Materials section. This script must also 
    #  be bellow the script 'Victor Engine - Basic'. 
    #  This script requires a very heavy user setup, refer to the User Manual 
    #  at http://victorscripts.wordpress.com/ for more information. 
    #------------------------------------------------------------------------------ 
    # Weapons note tags: 
    #   Tags to be used on Weapons note boxes.  
    # 
    #  <attack pose: action> 
    #   Changes the normal attack pose when using a weapon with this tag 
    #     action : action name 
    # 
    #  <dual pose: action> 
    #   Changes the double attack pose when using a weapon with this tag 
    #     action : action name 
    # 
    #  <skill pose: action> 
    #   Changes the physical skill pose when using a weapon with this tag 
    #     action : action name 
    # 
    #  <magic pose: action> 
    #   Changes the magical skill pose when using a weapon with this tag 
    #     action : action name 
    # 
    #  <item pose: action> 
    #   Changes the item pose when using a weapon with this tag 
    #     action : action name 
    # 
    #  <advance pose: action> 
    #   Changes the movement for actions when using a weapon with this tag 
    #   this change the movement of all actions that have movement (by default 
    #   only normal attacks and physical skills) 
    #     action : movement type name 
    # 
    #------------------------------------------------------------------------------ 
    # Skills and Items note tags: 
    #   Tags to be used on Skills and Items note boxes.  
    # 
    #  <action pose: action> 
    #   Changes the pose of the skill or item with this tag 
    #     action : action name 
    #  
    #  <action movement> 
    #   By default, only physical skills have movement. So, if you want to add 
    #   movement to non-physical skills and items, add this tag. 
    # 
    #  <allow dual attack> 
    #   By default, skills and items do a single hit even if the character is 
    #   dual wielding, adding this tag to the skill will allow the actor to 
    #   attack twice when dual wielding. This only if the action don't use a 
    #   custom pose. 
    # 
    #------------------------------------------------------------------------------ 
    # Actors note tags: 
    #   Tags to be used on Actors note boxes. 
    # 
    #  <no intro> 
    #   This tag will make the actor display no intro pose at the battle start. 
    #   By default, all actor display intro pose 
    # 
    #  <no victory> 
    #   This tag will make the actor display no victory pose at the battle start. 
    #   By default, all actors display victory pose 
    # 
    #------------------------------------------------------------------------------ 
    # Enemies note tags: 
    #   Tags to be used on Enemies note boxes. 
    # 
    #  <intro pose> 
    #   This tag will make the enemy display intro pose at the battle start. 
    #   By default, no enemy display intro pose 
    # 
    #  <victory pose> 
    #   This tag will make the enemy display victory pose at the battle start. 
    #   By default, no enemy display victory pose 
    # 
    #  <weapon x: y> 
    #   This allows to display weapons for enemies when using the pose value 
    #   'icon: weapon *'. 
    #     x : the slot index of the weapon (1: right hand, 2: left hand) 
    #     y : the incon index 
    # 
    #  <armor x: y> 
    #   This allows to display armors for enemies when using the pose value 
    #   'icon: armor *'. 
    #     x : the slot index of the armor (1: shield, 2: helm, 3: armor, 4: acc) 
    #     y : the incon index 
    # 
    #------------------------------------------------------------------------------ 
    # Actors, Enemies, Classes, States, Weapons and Armors note tags: 
    #   Tags to be used on Actors, Enemies, Classes, States, Weapons and Armors 
    #   note boxes. 
    # 
    #  <unmovable>  
    #   This tag allows to make a totally unmovable battler. The battler will not 
    #   move to attack, neither be can forced to move by any action. 
    #   
    #  <use dual attack> 
    #   By default, the attack when dual wielding calls the action sequence from 
    #   the equiped weapons. Adding this tag will make the actor use the custom 
    #   dual attack sequence <action: dual attack, reset> 
    # 
    #------------------------------------------------------------------------------ 
    # Comment calls note tags: 
    #  Tags to be used in events comment box, works like a script call. 
    #  
    #  <no intro> 
    #   When called, the next battle will have no intro pose. 
    # 
    #  <no victory> 
    #   When called, the next battle will have no victory pose. 
    # 
    #------------------------------------------------------------------------------ 
    # Additional Instructions: 
    # 
    #  More detailed info about the settings can be found on the User Manual at: 
    #   http://victorscripts.wordpress.com/ 
    # 
    #  From version 1.09 and later the dual attack pose is opitional, if not set 
    #  the actor will use the default attack for each weapon instead (wich 
    #  allows to use weapons with totally different poses), also it's possible  
    #  to setup skills to inherit the double attack effect. So you can make 
    #  you physical single hit skills to deal 2 strikes if dual wielding. 
    # 
    #  From version 1.21 and later the "effect:" and "throw:" values have been 
    #  changed. Now you must refer two targets values. 
    #  For the "effect" value, the first is the user of the action, the second the 
    #  targets.  
    #  For the "throw:" value, the first is the target of the throw, the second  
    #  battler throwing. 
    #  Actions sequences made before this update might need to be ajusted to these 
    #  new settings if not working properly. So if a custom action made before 
    #  this update shows problems, update those actions before asking for help. 
    # 
    #============================================================================== 
    
    #============================================================================== 
    # ** Victor Engine 
    #------------------------------------------------------------------------------ 
    #   Setting module for the Victor Engine 
    #============================================================================== 
    
    module Victor_Engine 
      #-------------------------------------------------------------------------- 
      # * Initialize Variables 
      #-------------------------------------------------------------------------- 
      VE_ACTION_SETTINGS = {} # Don't remove or change 
      #-------------------------------------------------------------------------- 
      # * Animated battler sufix 
      #   When using sprites, add this to the animated sprite sheet of the battler, 
      #   that way you can keep the original battler a single sprite and make  
      #   easier to setup their position on the troop 
      #-------------------------------------------------------------------------- 
      VE_SPRITE_SUFIX = "[anim]" 
      #-------------------------------------------------------------------------- 
      # * Intro fade 
      #   When true, there will be a small fade effect on the battlers during 
      #   the battle start (like RMXP default battle) 
      #-------------------------------------------------------------------------- 
      VE_BATTLE_INTRO_FADE = false
      #-------------------------------------------------------------------------- 
      # * Default sprite settings 
      #   This is the settings for all battler graphics that doesn't have 
      #   their own custom setting 
      #-------------------------------------------------------------------------- 
      VE_DEFAULT_SPRITE = { 
      # Basic Settings 
      # name:   value, 
        frames: 3,        # Number of frames 
        rows:   4,       # Number of rows 
        ox:     0,        # Adjust sprite X position 
        oy:     0,        # Adjust sprite Y position 
        mirror: false,     # Mirror battler when facing right 
        invert: false,    # Invert the battler graphic 
        mode:   :charset,  # Graphic style (:sprite or :chasert) 
        action: :charset, # Action settings 
        # IMPORTANT: using the ox: and oy: value will make the battle animation to 
        # be moved also, if you want to adjust the battler position without 
        # changing the position of the animation, use the script  
        # 'VE - Animations Settings' together with the batte. 
         
      # Main Poses 
      # name:       row, 
        idle:      1,   # Idle pose 
        guard:     2,   # Guard pose 
        evade:     2,   # Evade pose 
        danger:    3,   # Low HP pose 
        hurt:      4,   # Damage pose 
        attack:    5,   # Physical attack pose 
        use:       6,   # No type use pose 
        item:      6,   # Item use pose 
        skill:     7,   # Skill use pose 
        magic:     8,   # Magic use pose 
        advance:   9,   # Advance pose 
        retreat:   10,  # Retreat pose 
        escape:    10,  # Escape pose 
        victory:   11,  # Victory pose 
        intro:     12,  # Battle start pose 
        dead:      13,  # Incapacited pose 
        ready:     nil, # Ready pose 
        itemcast:  nil, # Item cast pose 
        skillcast: nil, # Skill cast pose 
        magiccast: nil, # Magic cast pose 
        command:   nil, # Command pose 
        input:     nil, # Input pose 
        cancel:    nil, # Cancel pose 
        # You can add other pose names and call them within the action settings 
        # use only lowcase letters 
        # IMPORTANT: the ready, itemcast, skillcast, magiccast, command, input and 
        # cancel poses are skiped if nil, no matter what you setup on the pose 
        # setting, so even using charset mode you need to setup a value to turn 
        # on these poses. 
      } # Don't remove 
      #-------------------------------------------------------------------------- 
      # * Custom sprite settings 
      #   Theses settings are set individually based on the battler graphic 
      #   filename (even if using the charset mode, the setting will be based 
      #   on the battler name, so it's suggested to use the same name for 
      #   the battler and charset graphic when using charset mode) 
      #   Any value from the default setting can be used, if a value is not set 
      #   it's automatically uses the value from basic setting 
      #-------------------------------------------------------------------------- 
      VE_SPRITE_SETTINGS = { 
      # 'Filename' => {settings}, 
      # 
      # 'Sample 1' => {frames: 4, rows: 14, mirror: true, mode: :sprite, 
      #                action: :default}, 
      # 'Sample 2' => {frames: 3, rows: 4, mirror: true, invert: false, 
      #                mode: :charset, action: :charset}, 
      # 'Sample 3' => {frames: 3, rows: 4, mirror: false, invert: false, 
      #                mode: :charset, action: :kaduki}, 
      # 'Sample 1' => {frames: 4, rows: 14, mirror: true, mode: :sprite, 
      #                action: :default, oy: 20, evade: 1, skill: 4}, 
        'Holder'   => {frames: 4, rows: 14, mirror: true, mode: :sprite, 
                       action: :default}, 
        'Charset'  => {frames: 3, rows: 4, mirror: false, invert: false, 
                       mode: :charset, action: :charset}, 
        'Kaduki'   => {frames: 3, rows: 4, mirror: true, invert: false, 
                       mode: :charset, action: :kaduki}, 
      } # Don't remove 
      #-------------------------------------------------------------------------- 
      # * Settings Used For all battlers that doesn't have specific settings 
      #-------------------------------------------------------------------------- 
      VE_DEFAULT_ACTION = " 
    
        # Pose displayed for skip actions 
        <action: do nothing, reset> 
        </action> 
    
        # Pose displayed when idle 
        <action: idle, loop> 
        pose: self, row idle, all frames, wait 12; 
        wait: self, pose; 
        </action> 
       
        # Pose displayed when incapacited 
        <action: dead, loop> 
        pose: self, row dead, all frames, wait 16; 
        wait: self, pose; 
        </action> 
       
        # Pose displayed when hp is low 
        <action: danger, loop> 
        pose: self, row danger, all frames, wait 12; 
        wait: self, pose; 
        </action> 
       
        # Pose displayed when guarding 
        <action: guard, loop> 
        pose: self, row guard, all frames, wait 24; 
        wait: self, pose; 
        </action> 
       
        # Pose displayed during the battle start 
        <action: intro, reset> 
        pose: self, row intro, all frames, wait 16; 
        wait: self, pose; 
        </action> 
       
        # Pose displayed during battle victory 
        <action: victory, wait> 
        pose: self, row victory, all frames, wait 16; 
        wait: self, pose; 
        </action> 
         
        # Pose displayed when escaping (for ATB) 
        <action: escaping, loop> 
        pose: self, row retreat, all frames, wait 4, loop; 
        wait: self, pose; 
        </action> 
       
        # Pose displayed while waiting to perfom actions 
        <action: ready, loop> 
        pose: self, row ready, frame 1; 
        wait: self, pose; 
        </action> 
         
        # Pose displayed while waiting to perfom item actions 
        <action: item cast, loop> 
        pose: self, row itemcast, frame 1; 
        wait: self, pose; 
        </action> 
         
        # Pose displayed while waiting to perfom skill actions 
        <action: skill cast, loop> 
        pose: self, row skillcast, frame 1; 
        wait: self, pose; 
        </action> 
         
        # Pose displayed while waiting to perfom magic actions 
        <action: magic cast, loop> 
        pose: self, row magiccast, frame 1; 
        wait: self, pose; 
        </action> 
         
        # Pose displayed before inputing commands 
        <action: command, reset> 
        </action> 
         
        # Pose displayed after inputing commands 
        <action: input, reset> 
        </action> 
         
        # Pose displayed when cancel inputing commands 
        <action: cancel, reset> 
        </action> 
         
        # Pose displayed when recive damage 
        <action: hurt, reset> 
        action: self, hurt pose; 
        wait: 16; 
        </action> 
         
        # Pose displayed when hurt 
        <action: hurt pose, reset> 
        pose: self, row hurt, all frames, wait 4; 
        </action> 
    
        # Pose displayed when evading attacks 
        <action: evade, reset> 
        pose: self, row evade, all frames, wait 4; 
        wait: 16; 
        </action> 
       
        # Pose displayed when a attack miss 
        <action: miss, reset> 
        </action> 
       
        # Pose displayed when reviving 
        <action: revive, reset> 
        </action> 
       
        # Pose displayed when dying 
        <action: die, reset> 
        </action> 
       
        # Make the target inactive (important, avoid change) 
        <action: inactive> 
        countered; 
        wait: self, countered; 
        inactive; 
        </action> 
       
        # Finish offensive action (important, avoid change) 
        <action: finish> 
        finish; 
        </action> 
         
        # Reset to idle after action (important, avoid change) 
        <action: clear, reset> 
        </action> 
    
        # Pose displayed during move reset (important, avoid change) 
        <action: reset, reset> 
        pose: self, row idle, all frames, wait 8, loop; 
        </action> 
         
        # Pose for counter attack preparation (important, avoid change) 
        <action: prepare counter, reset> 
        wait: self, action; 
        wait: targets, counter; 
        </action> 
    
        # Pose for counter attack activation (important, avoid change) 
        <action: counter on, reset> 
        counter: self, on; 
        </action> 
         
        # Pose for counter attack deactivation (important, avoid change) 
        <action: counter off, reset> 
        counter: targets, off; 
        </action> 
         
        # Pose for magic reflection (important, avoid change) 
        <action: reflection, reset> 
        wait: self, animation; 
        wait: 4; 
        anim: self, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: self, animation; 
        </action> 
         
        # Pose for substitution activation (important, avoid change) 
        <action: substitution on, reset> 
        pose: self, row advance, all frames, wait 4, loop; 
        move: self, substitution, move over; 
        wait: self, movement; 
        </action> 
         
        # Pose for substitution deactivation (important, avoid change) 
        <action: substitution off, reset> 
        pose: self, row advance, all frames, wait 4, loop; 
        move: self, retreat, move over; 
        wait: self, movement; 
        </action> 
         
        # Set action advance 
        <action: advance, reset> 
        action: self, move to target; 
        wait: self, action; 
        </action> 
         
        # Movement to target 
        <action: move to target, reset> 
        wait: targets, movement; 
        move: self, move to; 
        direction: self, subjects; 
        jump: self, move, height 7; 
        pose: self, row advance, all frames, wait 4, loop; 
        wait: self, movement; 
        </action> 
         
        # Step forward movement 
        <action: step forward, reset> 
        wait: targets, movement; 
        move: self, step forward, speed 6; 
        pose: self, row advance, all frames, wait 4, loop; 
        wait: self, movement; 
        </action> 
         
        # Step backward movement 
        <action: step backward, reset> 
        move: self, step backward, speed 6; 
        pose: self, row retreat, all frames, wait 4, invert, loop; 
        wait: self, movement; 
        </action> 
    
        # Return to original spot 
        <action: retreat, reset> 
        move: self, retreat; 
        pose: self, row retreat, all frames, wait 4, loop; 
        jump: self, move, height 7; 
        wait: self, movement; 
        direction: self, default; 
        </action> 
         
        # Move outside of the screen 
        <action: escape, reset> 
        move: self, escape; 
        pose: self, row retreat, all frames, wait 4, invert, loop; 
        wait: self, movement; 
        </action> 
         
        # Pose used for Defend command 
        <action: defend, reset> 
        pose: self, row guard, all frames, wait 8; 
        wait: 4; 
        anim: targets, effect; 
        wait: 4; 
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for physical attacks 
        <action: attack, reset> 
        wait: targets, movement; 
        pose: self, row attack, all frames, wait 4, y +1; 
        wait: 4; 
        anim: targets, weapon; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for physical attack with two weapons 
        <action: dual attack, reset> 
        wait: targets, movement; 
        pose: self, row attack, all frames, wait 4, y +1; 
        wait: 4; 
        anim: targets, weapon 1; 
        wait: 8; 
        effect: self, targets 75%, weapon 1; 
        wait: targets, animation; 
        pose: self, row skill, all frames, wait 4, y +1; 
        wait: 8; 
        anim: targets, weapon 2; 
        wait: 8; 
        effect: self, targets 75%, weapon 2; 
        wait: 20; 
        </action> 
             
        # Pose for using actions without type 
        <action: use, reset> 
        wait: targets, movement; 
        pose: self, row item, all frames, wait 4; 
        wait: 4; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for magical skill use 
        <action: magic, reset> 
        wait: targets, movement; 
        pose: self, row magic, all frames, wait 4; 
        wait: 4; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for physical skill use 
        <action: skill, reset> 
        wait: targets, movement; 
        pose: self, row attack, all frames, wait 4; 
        wait: 4; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
    
        # Pose for item use  
        <action: item, reset> 
        wait: targets, movement; 
        pose: self, row item, all frames, wait 4; 
        wait: 4; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
    
        # Pose for the skill 'Dual Attack' 
        <action: double attack skill, reset> 
        wait: targets, movement; 
        pose: self, row attack, all frames, wait 4, y +1; 
        wait: 4; 
        anim: targets, weapon; 
        wait: 8; 
        effect: self, targets 75%; 
        wait: targets, animation; 
        pose: self, row skill, all frames, wait 4, y +1; 
        wait: 8; 
        anim: targets, weapon; 
        wait: 8; 
        effect: self, targets 75%; 
        wait: 20; 
        </action> 
         
        # Pose for the skills 'Life Drain' and 'Manda Drain' 
        <action: drain, reset> 
        wait: targets, movement; 
        wait: animation; 
        pose: self, row magic, all frames, wait 4; 
        wait: 4; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        action: targets, user drain; 
        wait: targets, action; 
        </action> 
    
        # Pose for the targets of the skills 'Life Drain' and 'Manda Drain' 
        <action: user drain, reset> 
        throw: self, user, icon 187, return, revert, init y -12, end y -12; 
        wait: self, throw; 
        drain: active; 
        </action>     
         
        # Pose for the sample skill 'Throw Weapon' 
        <action: throw weapon, reset> 
        wait: targets, movement; 
        pose: self, row attack, all frames, wait 4; 
        action: targets, target throw; 
        wait: targets, action; 
        wait: 20; 
        </action> 
         
        # Pose for the targets of the sample skill 'Throw Weapon' 
        <action: target throw, reset> 
        throw: self, user, weapon, arc 12, spin +45, init y -12, end y -12; 
        wait: self, throw; 
        throw: self, user, weapon, arc 12, spin +45, return, revert, init y -12, end y -12; 
        anim: self, weapon; 
        wait: 8; 
        effect: active, targets, 100%, clear; 
        wait: self, throw; 
        </action> 
         
        # Pose for the sample skill 'Lightning Strike' 
        <action: lightning strike, 5 times> 
        direction: self, subjects; 
        clear: targets, damage; 
        move: targets, retreat, teleport; 
        pose: self, row attack, frame 1, all frames, wait 2; 
        move: self, x -48, speed 50; 
        anim: targets, effect; 
        effect: self, targets 30%; 
        </action> 
         
        # Pose for the sample skill 'Tempest' 
        <action: tempest, reset> 
        wait: targets, movement; 
        pose: self, row magic, all frames, wait 4; 
        wait: 4; 
        tone: black, high priority, duration 20; 
        wait: tone; 
        movie: name 'Tempest', white, high priority; 
        tone: clear, high priority, duration 20; 
        wait: 15; 
        anim: targets, effect; 
        flash: screen, duration 10;  
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for the sample skill 'Meteor' 
        <action: meteor, reset> 
        wait: targets, movement; 
        pose: self, row magic, all frames, wait 4; 
        wait: 4; 
        tone: black, high priority, duration 20; 
        wait: tone; 
        movie: name 'Meteor'; 
        tone: clear, high priority, duration 20; 
        anim: targets, effect; 
        wait: 20; 
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for 'Bow' type weapons 
        <action: bow, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row attack, all frames, wait 4; 
        action: targets, arrow; 
        wait: targets, action; 
        wait: 20; 
        </action> 
         
        # Pose for the targets of 'Bow' attack 
        <action: arrow, reset> 
        throw: self, user, image 'Arrow', arc 10, angle 45, init x -6, init y -12; 
        wait: self, throw; 
        anim: self, weapon; 
        wait: 8; 
        effect: active, targets, 100%; 
        </action> 
    
        # Pose for the skill 'Multi Attack' 
        <action: multi attack, opponents_unit.targetable_members.size times> 
        wait: next; 
        move: self, move to front; 
        pose: self, row advance, all frames, wait 4, loop; 
        wait: self, movement; 
        direction: self, subjects; 
        pose: self, row attack, all frames, wait 4; 
        wait: 4; 
        anim: last, effect, clear; 
        wait: 8; 
        effect: self, last, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for the skill 'Aura Spell' 
        <action: aura spell, reset> 
        wait: targets, movement; 
        action: self, step forward; 
        direction: self, subjects; 
        pose: self, row magic, all frames, wait 4; 
        action: aura effect; 
        wait: action 
        action: self, step backward; 
        </action> 
    
        <action: aura effect, friends_unit.targetable_members.size times> 
        wait: next; 
        anim: last, effect; 
        wait: 4; 
        effect: self, last, 100%; 
        wait: last, animation; 
        </action> 
         
        " 
      #-------------------------------------------------------------------------- 
      # * Sample settings used for battlers tagged as 'charset' 
      #-------------------------------------------------------------------------- 
      VE_ACTION_SETTINGS[:charset] = " 
    
        # Pose displayed for skip actions 
        <action: do nothing, reset> 
        </action> 
    
        # Pose displayed when idle 
        <action: idle, loop> 
        pose: self, row direction, frame 2; 
        wait: pose; 
        </action> 
       
        # Pose displayed when incapacited 
        <action: dead, loop> 
        pose: self, row 4, frame 2, angle -90, x -16, y -12; 
        wait: pose; 
        </action> 
       
        # Pose displayed when hp is low 
        <action: danger, loop> 
        pose: self, row direction, frame 2; 
        wait: pose; 
        </action> 
       
        # Pose displayed when guarding 
        <action: guard, loop> 
        icon: self, shield, y +8, above; 
        pose: self, row direction, frame 1; 
        wait: 16; 
        </action> 
       
        # Pose displayed during the battle start 
        <action: intro, reset> 
        pose: self, row direction, frame 2; 
        wait: 64; 
        </action> 
       
        # Pose displayed during battle victory 
        <action: victory, wait> 
        pose: self, row 2, frame 2; 
        wait: 2; 
        pose: self, row 4, frame 2; 
        wait: 2; 
        pose: self, row 3, frame 2; 
        wait: 2; 
        pose: self, row 1, frame 2; 
        wait: 2; 
        pose: self, row 2, frame 2; 
        wait: 2; 
        pose: self, row 4, frame 2; 
        wait: 2; 
        pose: self, row 3, frame 2; 
        wait: 2; 
        pose: self, row 1, frame 2; 
        wait: 2; 
        jump: self, height 8, speed 8; 
        wait: 10 
        </action> 
       
        # Pose displayed when escaping (for ATB) 
        <action: escaping, loop> 
        pose: self, row direction, all frames, return, wait 4, loop, invert; 
        wait: pose; 
        </action> 
         
        # Pose displayed while waiting to perfom actions 
        <action: ready, loop> 
        pose: self, row direction, all frames, return, wait 8; 
        wait: pose; 
        </action> 
         
        # Pose displayed while waiting to perfom item actions 
        <action: item cast, loop> 
        pose: self, row direction, all frames, return, wait 8; 
        wait: pose; 
        </action> 
         
        # Pose displayed while waiting to perfom skill actions 
        <action: skill cast, loop> 
        pose: self, row direction, all frames, return, wait 8; 
        wait: pose; 
        </action> 
         
        # Pose displayed while waiting to perfom magic actions 
        <action: magic cast, loop> 
        pose: self, row direction, all frames, return, wait 8; 
        wait: pose; 
        </action> 
         
        # Pose displayed before inputing commands 
        <action: command, reset> 
        action: self, step forward; 
        wait: action; 
        </action> 
         
        # Pose displayed after inputing commands 
        <action: input, reset> 
        action: self, step backward; 
        wait: action; 
        </action> 
         
        # Pose displayed when cancel inputing commands 
        <action: cancel, reset> 
        action: self, step backward; 
        wait: action; 
        </action> 
         
        # Pose displayed when recive damage 
        <action: hurt, reset> 
        direction: self, active; 
        pose: self, row direction, all frames, wait 4, return; 
        move: self, step backward, speed 4; 
        wait: self, movement; 
        pose: self, row direction, frame 2; 
        wait: 4; 
        pose: self, row direction, all frames, wait 4, return; 
        move: self, step forward, speed 5; 
        wait: self, movement; 
        direction: self, default; 
        </action> 
         
        # Pose displayed when hurt 
        <action: hurt pose, reset> 
        pose: self, row direction, frame 1; 
        </action> 
         
        # Pose displayed when evading attacks 
        <action: evade, reset> 
        direction: self, active; 
        pose: self, row 1, frame 2; 
        move: self, step backward, speed 4; 
        jump: self, move; 
        wait: self, movement; 
        pose: self, row direction, frame 2; 
        wait: 4; 
        pose: self, row direction, all frames, wait 4, return; 
        move: self, step forward, speed 5; 
        wait: self, movement; 
        direction: self, default; 
        </action> 
       
        # Pose displayed when a attack miss 
        <action: miss, reset> 
        </action> 
       
        # Pose displayed when reviving 
        <action: revive, reset> 
        </action> 
       
        # Pose displayed when dying 
        <action: die, reset> 
        </action> 
       
        # Make the target inactive (important, avoid change) 
        <action: inactive> 
        countered; 
        wait: self, countered; 
        inactive; 
        </action> 
       
        # Finish offensive action (important, avoid change) 
        <action: finish> 
        finish; 
        </action> 
    
        # Reset to idle after action (important, avoid change) 
        <action: clear, reset> 
        </action> 
         
        # Pose displayed during move reset (important, avoid change) 
        <action: reset, reset> 
        pose: self, row direction, frame 2, loop; 
        </action> 
         
        # Pose for counter attack preparation (important, avoid change) 
        <action: prepare counter, reset> 
        wait: self, action; 
        </action> 
    
        # Pose for counter attack deactivation (important, avoid change) 
        <action: counter on, reset> 
        counter: self, on; 
        wait: counter; 
        </action> 
    
        # Pose for counter attack activation (important, avoid change) 
        <action: counter off, reset> 
        counter: targets, off; 
        </action> 
    
        # Pose for magic reflection (important, avoid change) 
        <action: reflection, reset> 
        wait: animation; 
        wait: 4; 
        anim: self, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: animation; 
        </action> 
         
        # Pose for substitution activation (important, avoid change) 
        <action: substitution on, reset> 
        pose: self, row direction, all frames, return, wait 4, loop; 
        move: self, substitution, move over; 
        wait: self, movement; 
        </action> 
         
        # Pose for substitution deactivation (important, avoid change) 
        <action: substitution off, reset> 
        pose: self, row direction, all frames, return, wait 4, loop; 
        move: self, retreat, move over; 
        wait: self, movement; 
        </action> 
    
        # Set action advance 
        <action: advance, reset> 
        action: self, move to target; 
        wait: action; 
        </action> 
         
        # Movement to target 
        <action: move to target, reset> 
        wait: targets, movement; 
        move: self, move to; 
        direction: self, subjects; 
        pose: self, row direction, all frames, return, wait 4, loop; 
        wait: self, movement; 
        </action> 
         
        # Step forward movement 
        <action: step forward, reset> 
        wait: targets, movement; 
        move: self, step forward, speed 6; 
        pose: self, row direction, all frames, return, wait 4, loop; 
        wait: self, movement; 
        </action> 
    
        # Step backward movement 
        <action: step backward, reset> 
        move: self, step backward, speed 6; 
        pose: self, row direction, all frames, return, wait 4, loop; 
        wait: self, movement; 
        </action> 
    
        # Return to original spot 
        <action: retreat, reset> 
        direction: self, return; 
        move: self, retreat; 
        pose: self, row direction, all frames, return, wait 4, loop; 
        wait: self, movement; 
        direction: self, default; 
        </action> 
         
        # Move outside of the screen 
        <action: escape, reset> 
        move: self, escape; 
        pose: self, row direction, all frames, return, wait 4, loop; 
        wait: self, movement; 
        </action> 
         
        # Pose used for Defend command 
        <action: defend, reset> 
        pose: self, row direction, all frames, wait 2, y +1; 
        wait: 4; 
        anim: targets, effect; 
        wait: 4; 
        effect: self, targets, 100%; 
        wait: 20; 
        wait: pose; 
        </action> 
         
        # Pose for physical attacks 
        <action: attack, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 2, y +1; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0, x -6; 
        anim: targets, weapon; 
        icon: self, weapon, angle 45, x -10, y +8; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for physical attack with two weapons 
        <action: dual attack, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 2, y +1; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0, x -6; 
        anim: targets, weapon; 
        icon: self, weapon, angle 45, x -10, y +8; 
        effect: self, targets 75%, weapon; 
        wait: targets, animation; 
        icon: self, delete; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 2, revert, y +1; 
        icon: self, weapon 2, angle -90, x +12, y -16; 
        icon: self, weapon 2, angle -45, x +6, y -16; 
        icon: self, weapon 2, angle 0; 
        anim: targets, weapon; 
        icon: self, weapon 2, angle 45, x -6, y +8; 
        effect: self, targets 75%, weapon 2; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for using actions without type 
        <action: use, reset> 
        wait: targets, movement; 
        action: self, step forward; 
        pose: self, row direction, all frames, wait 4; 
        wait: 4; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        action: self, step backward; 
        </action> 
         
        # Pose for magical skill use 
        <action: magic, reset> 
        wait: targets, movement; 
        action: self, step forward; 
        wait: self, action; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 4; 
        wait: 4; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        action: self, step backward; 
        </action> 
         
        # Pose for physical skill use 
        <action: skill, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 2; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0, x -6; 
        anim: targets, effect; 
        icon: self, weapon, angle 45, x -10, y +8; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for item use 
        <action: item, reset> 
        wait: targets, movement; 
        action: self, step forward; 
        wait: self, action; 
        wait: 10; 
        pose: self, row direction, frame 1; 
        icon: action, x -8, above; 
        wait: 4; 
        pose: self, row direction, frame 2; 
        icon: action, x -4, y -4, above; 
        wait: 4; 
        pose: self, row direction, frame 3; 
        icon: action, y -8, above; 
        wait: 4; 
        pose: self, row direction, frame 2; 
        icon: action, y -8, x +4, above; 
        wait: 12; 
        icon: self, delete; 
        pose: self, row direction, frame 1; 
        throw: targets, self, action, arc 10, init y -8; 
        wait: targets, throw; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        action: self, step backward; 
        </action> 
    
        # Pose for the skill 'Dual Attack' 
        <action: dual attack skill, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 2, y +1; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0, x -6; 
        anim: targets, effect; 
        icon: self, weapon, angle 45, x -10, y +8; 
        effect: self, targets, 100%; 
        wait: targets, animation; 
        icon: self, delete; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 2, revert, y +1; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0; 
        anim: targets, effect; 
        icon: self, weapon, angle 45, x -6, y +8; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for the skills 'Life Drain' and 'Mana Drain' 
        <action: drain, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 4; 
        wait: 4; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        action: targets, user drain; 
        wait: targets, action; 
        </action> 
    
        # Pose for the targets of the skills 'Life Drain' and 'Mana Drain 
        <action: user drain, reset> 
        throw: self, user, icon 187, return, revert, init y -12, end y -12; 
        wait: self, throw; 
        drain: active; 
        </action>     
         
        # Pose for the sample skill 'Throw Weapon' 
        <action: throw weapon, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row direction, frame 1; 
        pose: self, row direction, frame 2; 
        action: targets, target throw; 
        pose: self, row direction, frame 3; 
        wait: targets, action; 
        </action> 
         
        # Pose for the targets of the sample skill 'Throw Weapon' 
        <action: target throw, reset> 
        throw: self, user, weapon, arc 12, spin +45, init y -12, end y -12; 
        wait: self, throw; 
        throw: self, user, weapon, arc 12, spin +45, return, revert, init y -12, end y -12; 
        anim: self, weapon; 
        wait: 8; 
        effect: active, targets, 100%, clear; 
        wait: self, throw; 
        wait: animation; 
        </action> 
         
        # Pose for the sample skill 'Lightning Strike' 
        <action: lightning strike, 5 times> 
        direction: self, subjects; 
        clear: targets, damage; 
        move: targets, retreat, teleport; 
        pose: self, row direction, frame 3, y +1; 
        move: self, x -48, speed 50; 
        icon: self, weapon, angle 45, x -12, y +8; 
        anim: targets, effect; 
        effect: self, targets 30%; 
        icon: self, delete; 
        </action> 
         
        # Pose for the sample skill 'Tempest' 
        <action: tempest, reset> 
        wait: targets, movement; 
        wait: animation; 
        pose: self, row direction, all frames, wait 4; 
        wait: 4; 
        tone: black, high priority, duration 20; 
        wait: tone; 
        movie: name 'Tempest', white, high priority; 
        tone: clear, high priority, duration 20; 
        wait: 15; 
        anim: targets, effect; 
        flash: screen, duration 10;  
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for the sample skill 'Meteor' 
        <action: meteor, reset> 
        wait: targets, movement; 
        wait: animation; 
        pose: self, row direction, all frames, wait 4; 
        wait: 4; 
        tone: black, high priority, duration 20; 
        wait: tone; 
        movie: name 'Meteor'; 
        tone: clear, high priority, duration 20; 
        anim: targets, effect; 
        wait: 20; 
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for 'Claw' type weapons 
        <action: claw, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 3, y +1; 
        icon: self, weapon, angle -45, x +16, y -16; 
        icon: self, weapon, angle -30, x +10, y -16; 
        icon: self, weapon, angle -15, x -2; 
        anim: targets, weapon; 
        icon: self, weapon, angle 0, x -6, y +8; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for 'Spear' type weapons 
        <action: spear, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 3, y +1; 
        icon: self, weapon, angle 45, x +12, y +8; 
        icon: self, weapon, angle 45, x +12, y +8; 
        icon: self, weapon, angle 45, x 0, y +8; 
        anim: targets, weapon; 
        icon: self, weapon, angle 45, x -12, y +8; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for 'Gun' type weapons 
        <action: gun, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 3; 
        icon: self, weapon, angle -135, x +12, y -16; 
        icon: self, weapon, angle -105, x +6, y -10; 
        icon: self, weapon, angle -75, x 0, y -2; 
        icon: self, weapon, angle -45, x -6, y +4; 
        wait: 30; 
        sound: name 'Gun1'; 
        pose: self, row direction, frame 3; 
        icon: self, weapon, angle -75, x 0, y -2; 
        pose: self, row direction, frame 2; 
        icon: self, weapon, angle -105, x +6, y -10; 
        pose: self, row direction, frame 1; 
        anim: targets, weapon; 
        icon: self, weapon, angle -135, x +12, y -16; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for 'Bow' type weapons 
        <action: bow, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row 2, all frames, sufix _3, wait 4; 
        icon: self, image 'Bow1', x +6, above; 
        icon: self, image 'Bow2', x +6, above; 
        icon: self, image 'Bow3', x +6, above; 
        wait: 10; 
        action: targets, arrow; 
        icon: self, image 'Bow2', x +6, above; 
        icon: self, image 'Bow1', x +6, above; 
        wait: self, action; 
        </action> 
    
        # Pose for the targets of 'Bow' attack 
        <action: arrow, reset> 
        throw: self, user, image 'Arrow', arc 10, angle 45, init x -6, init y -12; 
        wait: self, throw; 
        anim: self, weapon; 
        wait: 8; 
        effect: active, targets, 100%; 
        </action> 
    
        # Pose for the skill 'Multi Attack' 
        <action: multi attack, opponents_unit.targetable_members.size times> 
        target: next; 
        move: self, move to front; 
        pose: self, row direction, all frames, return, wait 4, loop; 
        wait: self, movement; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 2, y +1; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0, x -6; 
        anim: last, effect; 
        icon: self, weapon, angle 45, x -10, y +8; 
        effect: self, last, 100%, clear; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for the skill 'Aura Spell' 
        <action: aura spell, reset> 
        wait: targets, movement; 
        wait: animation; 
        action: self, step forward; 
        wait: self, action; 
        direction: self, subjects; 
        pose: self, row direction, all frames, wait 4; 
        action: aura effect; 
        wait: action 
        action: self, step backward; 
        </action> 
    
        <action: aura effect, friends_unit.targetable_members.size times> 
        wait: next; 
        anim: last, effect; 
        wait: 4; 
        effect: self, last, 100%; 
        wait: last, animation; 
        </action> 
         
        " 
      #-------------------------------------------------------------------------- 
      # * Sample settings used for battlers tagged as 'kaduki' style 
      #-------------------------------------------------------------------------- 
      VE_ACTION_SETTINGS[:kaduki] = " 
    
        # Pose displayed for skip actions 
        <action: do nothing, reset> 
        </action> 
    
        # Pose displayed when idle 
        <action: idle, loop> 
        pose: self, row 1, all frames, sufix _1, return, wait 16; 
        wait: pose; 
        </action> 
    
        # Pose displayed when incapacited 
        <action: dead, loop> 
        pose: self, row 4, all frames, sufix _2, return, wait 8; 
        wait: pose; 
        </action> 
       
        # Pose displayed when hp is low 
        <action: danger, loop> 
        pose: self, row 3, all frames, sufix _1, return, wait 16; 
        wait: pose; 
        </action> 
       
        # Pose displayed when guarding 
        <action: guard, loop> 
        icon: self, shield, y +8, above; 
        pose: self, row 4, frame 3, sufix _1; 
        wait: 16; 
        </action> 
       
        # Pose displayed during the battle start 
        <action: intro, reset> 
        pose: self, row 1, frame 2, sufix _1; 
        wait: 12; 
        </action> 
       
        # Pose displayed during battle victory 
        <action: victory, wait> 
        pose: self, row 1, all frames, sufix _2, wait 8; 
        wait: pose; 
        </action> 
       
        # Pose displayed when escaping (for ATB) 
        <action: escaping, loop> 
        pose: self, row 4, all frames, sufix _1, return, loop, wait 8, invert; 
        wait: pose; 
        </action> 
    
        # Pose displayed while waiting to perfom actions 
        <action: ready, loop> 
        pose: self, row 1, frame 2, sufix _1; 
        wait: pose; 
        </action> 
         
        # Pose displayed while waiting to perfom item actions 
        <action: item cast, loop> 
        pose: self, row 1, frame 2, sufix _1; 
        wait: pose; 
        </action> 
         
        # Pose displayed while waiting to perfom skill actions 
        <action: skill cast, loop> 
        pose: self, row 1, frame 2, sufix _1; 
        wait: pose; 
        </action> 
         
        # Pose displayed while waiting to perfom magic actions 
        <action: magic cast, loop> 
        pose: self, row 4, all frames, sufix _3, loop, wait 8; 
        wait: pose; 
        </action> 
         
        # Pose displayed before inputing commands 
        <action: command, reset> 
        action: self, step forward; 
        wait: self, action; 
        </action> 
         
        # Pose displayed after inputing commands 
        <action: input, reset> 
        action: self, step backward; 
        wait: self, action; 
        </action> 
         
        # Pose displayed when cancel inputing commands 
        <action: cancel, reset> 
        action: self, step backward; 
        wait: self, action; 
        </action> 
             
        # Pose displayed when recive damage 
        <action: hurt, reset> 
        pose: self, row 2, all frames, sufix _1, wait 4; 
        move: self, step backward, speed 4; 
        wait: self, movement; 
        pose: self, row direction, frame 2; 
        wait: 4; 
        pose: self, row 4, all frames, wait 4, return, sufix _1; 
        move: self, step forward, speed 5; 
        wait: self, movement; 
        </action> 
          
        # Pose displayed when hurt 
        <action: hurt pose, reset> 
        pose: self, row 2, frame 1, sufix _1; 
        </action> 
    
        # Pose displayed when evading attacks 
        <action: evade, reset> 
        pose: self, row 2, sufix _2, all frames, wait 4; 
        move: self, step backward, speed 4; 
        jump: self, move; 
        wait: self, movement; 
        pose: self, row 1, frame 2, sufix _2; 
        wait: 4; 
        pose: self, row 4, all frames, wait 4, return, sufix _1; 
        move: self, step forward, speed 5; 
        wait: self, movement; 
        </action> 
       
        # Pose displayed when a attack miss 
        <action: miss, reset> 
        </action> 
       
        # Pose displayed when reviving 
        <action: revive, reset> 
        </action> 
       
        # Pose displayed when dying 
        <action: die, reset> 
        </action> 
         
        # Make the target inactive (important, avoid change) 
        <action: inactive> 
        countered; 
        wait: self, counter; 
        inactive; 
        </action> 
       
        # Finish offensive action (important, avoid change) 
        <action: finish> 
        finish; 
        </action> 
         
        # Reset to idle after action (important, avoid change) 
        <action: clear, reset> 
        </action> 
    
        # Pose displayed during move reset (important, avoid change) 
        <action: reset, reset> 
        pose: self, row 1, all frames, sufix _1, return, wait 16, loop; 
        </action> 
         
        # Pose for counter attack preparation (important, avoid change) 
        <action: prepare counter, reset> 
        wait: self, action; 
        wait: targets, countered; 
        </action> 
         
        # Pose for counter attack deactivation (important, avoid change) 
        <action: counter off, reset> 
        counter: targets; 
        </action> 
         
        # Pose for magic reflection (important, avoid change) 
        <action: reflection, reset> 
        wait: animation; 
        wait: 4; 
        anim: self, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: animation; 
        </action> 
         
        # Pose for substitution activation (important, avoid change) 
        <action: substitution on, reset> 
        pose: self, row 4, all frames, sufix _1, return, wait 8, loop; 
        move: self, substitution, move over; 
        wait: self, movement; 
        </action> 
         
        # Pose for substitution deactivation (important, avoid change) 
        <action: substitution off, reset> 
        pose: self, row 4, all frames, sufix _1, return, wait 8, loop; 
        move: self, retreat, move over; 
        wait: self, movement; 
        </action> 
         
        # Set action advance 
        <action: advance, reset> 
        action: self, move to target; 
        wait: action; 
        </action> 
         
        # Movement to target 
        <action: move to target, reset> 
        wait: targets, movement; 
        wait: animation; 
        move: self, move to; 
        direction: self, subjects; 
        pose: self, row 4, all frames, sufix _1, return, wait 8, loop; 
        wait: self, movement; 
        </action> 
         
        # Step forward movement 
        <action: step forward, reset> 
        wait: targets, movement; 
        move: self, step forward, speed 6; 
        pose: self, row 4, all frames, sufix _1, return, wait 8, loop; 
        wait: self, movement; 
        </action> 
    
        # Step backward movement 
        <action: step backward, reset> 
        wait: animation; 
        move: self, step backward, speed 6; 
        pose: self, row 4, all frames, sufix _1, return, wait 8, loop; 
        </action> 
         
        # Return to original spot 
        <action: retreat, reset> 
        direction: self, return; 
        move: self, retreat; 
        pose: self, row 4, all frames, sufix _1, return, loop, wait 8; 
        wait: self, movement; 
        direction: self, default; 
        </action> 
         
        # Move outside of the screen 
        <action: escape, reset> 
        move: self, escape; 
        pose: self, row 4, all frames, sufix _1, return, loop, wait 8, invert; 
        wait: self, movement; 
        </action> 
         
        # Pose used for Defend command 
        <action: defend, reset> 
        pose: self, row 4, frame 2, sufix _1; 
        icon: self, shield, y +8, above; 
        pose: self, row 4, frame 3, sufix _1; 
        wait: 4; 
        anim: targets, effect; 
        wait: 4; 
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for physical attacks 
        <action: attack, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row 1, all frames, sufix _3, wait 3, y +1; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0, x -6; 
        anim: targets, weapon; 
        icon: self, weapon, angle 45, x -10, y +8; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for physical attack with two weapons 
        <action: dual attack, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row 1, all frames, sufix _3, wait 3, y +1; 
        icon: self, weapon, angle -180, x +12, y -16; 
        icon: self, weapon, angle -135, x +12, y -16; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0, x -6; 
        anim: targets, weapon 1; 
        icon: self, weapon, angle 45, x -10, y +8; 
        effect: self, targets 75%, weapon 1; 
        wait: targets, animation; 
        icon: self, delete; 
        direction: self, subjects; 
        pose: self, row 1, all frames, sufix _3, wait 3, y +1; 
        icon: self, weapon 2, angle -180, x +12, y -16; 
        icon: self, weapon 2, angle -135, x +12, y -16; 
        icon: self, weapon 2, angle -90, x +12, y -16; 
        icon: self, weapon 2, angle -45, x +6, y -16; 
        icon: self, weapon 2, angle 0; 
        anim: targets, weapon 2; 
        icon: self, weapon 2, angle 45, x -6, y +8; 
        effect: self, targets 75%, weapon 2; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for using actions without type 
        <action: use, reset> 
        wait: targets, movement; 
        action: self, step forward; 
        wait: self, action; 
        pose: self, row 2, all frames, sufix _3, wait 3; 
        wait: 4; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        action: self, step backward; 
        </action> 
         
        # Pose for magical skill use 
        <action: magic, reset> 
        wait: targets, movement; 
        action: self, step forward; 
        wait: self, action; 
        direction: self, subjects; 
        pose: self, row 3, all frames, sufix _3, wait 3; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        action: self, step backward; 
        </action> 
    
        # Pose for physical skill use 
        <action: skill, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row 1, all frames, sufix _3, wait 3, y +1; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0, x -6; 
        anim: targets, effect; 
        icon: self, weapon, angle 45, x -10, y +8; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
    
        # Pose for item use 
        <action: item, reset> 
        wait: targets, movement; 
        action: self, step forward; 
        wait: 10; 
        pose: self, row 2, all frames, sufix _3, wait 3; 
        icon: self, action, x -8, above; 
        wait: 4; 
        icon: self, action, x -4, y -4, above; 
        wait: 4; 
        icon: self, action, y -8, above; 
        wait: 4; 
        icon: self, action, y -8, x +4, above; 
        wait: 12; 
        pose: self, row 1, all frames, sufix _3, wait 2; 
        icon: self, delete; 
        throw: targets, self, action, arc 10, init y -8; 
        wait: targets, throw; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        action: self, step backward; 
        </action> 
    
        # Pose for the skill 'Dual Attack' 
        <action: dual attack skill, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row 1, all frames, sufix _3, wait 3, y +1; 
        icon: self, weapon, angle -180, x +12, y -16; 
        icon: self, weapon, angle -135, x +12, y -16; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0, x -6; 
        anim: targets, effect; 
        icon: self, weapon, angle 45, x -10, y +8; 
        wait: targets, animation; 
        wait: self, animation; 
        icon: self, delete; 
        direction: self, subjects; 
        pose: self, row 1, all frames, sufix _3, wait 3, y +1; 
        icon: self, weapon, angle -180, x +12, y -16; 
        icon: self, weapon, angle -135, x +12, y -16; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0; 
        anim: targets, effect; 
        icon: self, weapon, angle 45, x -6, y +8; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for the skills 'Life Drain' and 'Manda Drain' 
        <action: drain, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row 3, all frames, sufix _3, wait 3; 
        wait: 4; 
        anim: targets, effect; 
        wait: 8; 
        effect: self, targets, 100%; 
        wait: 20; 
        action: targets, user drain; 
        wait: action; 
        </action> 
    
        # Pose for the targets of the skills 'Life Drain' and 'Manda Drain' 
        <action: user drain, reset> 
        throw: self, user, icon 187, return, revert, init y -12, end y -12; 
        wait: self, throw; 
        drain: active; 
        </action>     
    
        # Pose for the sample skill 'Throw Weapon' 
        <action: throw weapon, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row 1, all frames, sufix _3, wait 3; 
        wait: 4; 
        action: targets, target throw; 
        wait: targets, action; 
        </action> 
         
        # Pose for the targets of the sample skill 'Throw Weapon' 
        <action: target throw, reset> 
        throw: self, user, weapon, arc 12, spin +45, init y -12, end y -12; 
        wait: self, throw; 
        throw: self, user, weapon, arc 12, spin +45, return, revert, init y -12, end y -12; 
        anim: self, weapon; 
        wait: 8; 
        effect: active, targets, 100%, clear; 
        wait: self, throw; 
        wait: self, animation; 
        </action> 
         
        # Pose for the sample skill 'Lightning Strike' 
        <action: lightning strike, 5 times> 
        direction: self, subjects; 
        clear: targets, damage; 
        move: targets, retreat, teleport; 
        pose: self, row 1, frame 3, sufix _3, y +1; 
        move: self, x -48, speed 50; 
        icon: self, weapon, angle 45, x -12, y +8; 
        anim: targets, effect; 
        effect: self, targets 30%; 
        icon: self, delete; 
        </action> 
         
        # Pose for the sample skill 'Tempest' 
        <action: tempest, reset> 
        wait: targets, movement; 
        pose: self, row 3, all frames, sufix _3, wait 3; 
        wait: 4; 
        tone: black, high priority, duration 20; 
        wait: tone; 
        movie: name 'Tempest', white, high priority; 
        tone: clear, high priority, duration 20; 
        wait: 15; 
        anim: targets, effect; 
        flash: screen, duration 10;  
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for the sample skill 'Meteor' 
        <action: meteor, reset> 
        wait: targets, movement; 
        pose: self, row 3, all frames, sufix _3, wait 3; 
        wait: 4; 
        tone: black, high priority, duration 20; 
        wait: tone; 
        movie: name 'Meteor'; 
        tone: clear, high priority, duration 20; 
        anim: targets, effect; 
        wait: 20; 
        effect: self, targets, 100%; 
        wait: 20; 
        </action> 
         
        # Pose for 'Claw' type weapons 
        <action: claw, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row 1, all frames, sufix _3, wait 3, y +1; 
        icon: self, weapon, angle -45, x +16, y -16; 
        icon: self, weapon, angle -30, x +10, y -16; 
        icon: self, weapon, angle -15, x -2; 
        anim: targets, weapon; 
        icon: self, weapon, angle 0, x -6, y +8; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for 'Spear' type weapons 
        <action: spear, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row 1, all frames, sufix _3, wait 3, y +1; 
        icon: self, weapon, angle 45, x +12, y +8; 
        icon: self, weapon, angle 45, x +12, y +8; 
        icon: self, weapon, angle 45, x 0, y +8; 
        anim: targets, weapon; 
        icon: self, weapon, angle 45, x -12, y +8; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for 'Gun' type weapons 
        <action: gun, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row 1, all frames, sufix _3, wait 3; 
        icon: self, weapon, angle -135, x +12, y -16; 
        icon: self, weapon, angle -105, x +6, y -10; 
        icon: self, weapon, angle -75, x 0, y -2; 
        icon: self, weapon, angle -45, x -6, y +4; 
        wait: 30; 
        sound: name 'Gun1'; 
        pose: self, row 1, frame 3, sufix _3; 
        icon: self, weapon, angle -75, x -6, y -2; 
        pose: self, row 1, frame 2, sufix _3; 
        icon: self, weapon, angle -105, y -10; 
        pose: self, row 1, frame 1, sufix _3; 
        anim: targets, effect; 
        effect: self, targets, 100%; 
        wait: 20; 
        icon: self, delete; 
        </action> 
         
        # Pose for 'Bow' type weapons 
        <action: bow, reset> 
        wait: targets, movement; 
        direction: self, subjects; 
        pose: self, row 2, all frames, sufix _3, wait 4; 
        icon: self, image 'Bow1', x +6, above; 
        icon: self, image 'Bow2', x +6, above; 
        icon: self, image 'Bow3', x +6, above; 
        wait: 10; 
        action: targets, arrow; 
        icon: self, image 'Bow2', x +6, above; 
        icon: self, image 'Bow1', x +6, above; 
        wait: targets, action; 
        </action> 
         
        # Pose for the targets of 'Bow' attack 
        <action: arrow, reset> 
        throw: self, user, image 'Arrow', arc 10, angle 45, init x -6, init y -12; 
        wait: self, throw; 
        anim: self, weapon; 
        wait: 8; 
        effect: active, targets, 100%; 
        </action> 
    
        # Movement to target for the skill 'Aura Blade' 
        <action: aura blade move to, reset> 
        wait: targets, movement; 
        wait: self, animation; 
        move: self, move to, x +52; 
        direction: self, subjects; 
        pose: self, row 4, all frames, sufix _1, return, wait 8; 
        wait: self, movement; 
        </action> 
         
        # Pose for the skill 'Aura Blade' 
        <action: aura blade, reset> 
        wait: targets, movement; 
        pose: self, row 4, sufix _3, all frames, wait 8, loop; 
        anim: self, id 81; 
        wait: self, animation; 
        pose: self, row 2, sufix _3, all frames, wait 3, y +1; 
        icon: self, weapon, angle 45, x -6, y +6; 
        icon: self, weapon, angle 30, x -10, y +0; 
        icon: self, weapon, angle 15, x -14, y -6; 
        icon: self, weapon, angle 0, x -10, y -10; 
        wait: 30; 
        anim: self, id 110; 
        wait: self, animation; 
        wait: 30; 
        afterimage: on, red 160, green 160, alpha 128; 
        move: self, x -144, speed 15; 
        pose: self, row 1, sufix _3, all frames, wait 3, y +1; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0, x -6; 
        icon: self, weapon, angle 45, x -10, y +8; 
        anim: targets, effect; 
        effect: self, targets, 100%; 
        wait: self, movement; 
        afterimage: self, off; 
        wait: 20; 
        icon: self, delete; 
        </action> 
    
        # Pose for the skill 'Multi Attack' 
        <action: multi attack, opponents_unit.targetable_members.size times> 
        target: next; 
        afterimage: self, on; 
        move: self, move to front; 
        pose: self, row 4, all frames, sufix _1, return, wait 8, loop; 
        wait: self, movement; 
        afterimage: self, off; 
        direction: self, subjects; 
        pose: self, row 1, all frames, sufix _3, wait 3, y +1; 
        icon: self, weapon, angle -90, x +12, y -16; 
        icon: self, weapon, angle -45, x +6, y -16; 
        icon: self, weapon, angle 0, x -6; 
        anim: last, effect; 
        icon: self, weapon, angle 45, x -10, y +8; 
        effect: self, last, 100%, clear; 
        wait: 20; 
        icon: self, delete; 
        </action> 
    
        # Pose for the skill 'Aura Spell' 
        <action: aura spell, reset> 
        wait: targets, movement; 
        action: self, step forward; 
        wait: self, action; 
        pose: self, row 3, all frames, sufix _3, wait 3; 
        action: self, aura effect; 
        wait: self, action 
        action: self, step backward; 
        </action> 
    
        <action: aura effect, friends_unit.targetable_members.size times> 
        target: next; 
        anim: last, effect; 
        wait: 4; 
        effect: self, last, 100%; 
        wait: last, animation; 
        </action> 
         
        " 
      #-------------------------------------------------------------------------- 
      # * required 
      #   This method checks for the existance of the basic module and other 
      #   VE scripts required for this script to work, don't edit this 
      #-------------------------------------------------------------------------- 
      def self.required(name, req, version, type = nil) 
        if !$imported[:ve_basic_module] 
          msg = "The script '%s' requires the script\n" 
          msg += "'VE - Basic Module' v%s or higher above it to work properly\n" 
          msg += "Go to http://victorscripts.wordpress.com/ to download this script." 
          msgbox(sprintf(msg, self.script_name(name), version)) 
          exit 
        else 
          self.required_script(name, req, version, type) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * script_name 
      #   Get the script name base on the imported value, don't edit this 
      #-------------------------------------------------------------------------- 
      def self.script_name(name, ext = "VE") 
        name = name.to_s.gsub("_", " ").upcase.split 
        name.collect! {|char| char == ext ? "#{char} -" : char.capitalize } 
        name.join(" ") 
      end 
    end 
    
    $imported ||= {} 
    $imported[:ve_animated_battle] = 1.21 
    Victor_Engine.required(:ve_animated_battle, :ve_basic_module, 1.35, :above) 
    Victor_Engine.required(:ve_animated_battle, :ve_actor_battlers, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_animations_settings, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_passive_states, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_map_battle, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_state_cancel, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_tech_points, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_trait_control, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_mp_level, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_automatic_battlers, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_state_auto_apply, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_element_states, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_counter_options, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_state_aura, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_state_graphics, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_active_time_battle, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_damage_popup, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_action_streghten, 1.00, :bellow) 
    Victor_Engine.required(:ve_animated_battle, :ve_element_strenghten, 1.00, :bellow) 
    
    #============================================================================== 
    # ** Object 
    #------------------------------------------------------------------------------ 
    #  This class is the superclass of all other classes. 
    #============================================================================== 
    
    class Object 
      #-------------------------------------------------------------------------- 
      # * New method: custom_pose 
      #-------------------------------------------------------------------------- 
      def custom_pose(type) 
        note =~ /<#{type.upcase} POSE: (\w[\w ]+)>/i ? make_symbol($1) : nil 
      end 
    end 
    
    #============================================================================== 
    # ** BattleManager 
    #------------------------------------------------------------------------------ 
    #  This module handles the battle processing 
    #============================================================================== 
    
    class << BattleManager 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_accessor :old_tone 
      #-------------------------------------------------------------------------- 
      # * Alias method: init_members 
      #-------------------------------------------------------------------------- 
      alias :init_members_ve_animated_battle :init_members 
      def init_members 
        $game_party.members.each {|member| member.poses.clear_poses } 
        init_members_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: battle_end 
      #-------------------------------------------------------------------------- 
      alias :battle_end_ve_animated_battle :battle_end 
      def battle_end(result) 
        $game_party.members.each {|member| member.poses.clear_poses } 
        $game_system.no_intro   = false 
        $game_system.no_victory = false 
        battle_end_ve_animated_battle(result) 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: process_victory 
      #-------------------------------------------------------------------------- 
      alias :process_victory_ve_animated_battle :process_victory 
      def process_victory 
        @phase = nil 
        process_battle_end_pose($game_party) 
        process_victory_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: process_defeat 
      #-------------------------------------------------------------------------- 
      alias :process_defeat_ve_animated_battle :process_defeat 
      def process_defeat 
        @phase = nil 
        process_battle_end_pose($game_troop) 
        process_defeat_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: process_escape 
      #-------------------------------------------------------------------------- 
      alias :process_escape_ve_animated_battle :process_escape 
      def process_escape 
        @escaping = true 
        success   = process_escape_ve_animated_battle 
        @escaping = false 
        return success 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: process_abort 
      #-------------------------------------------------------------------------- 
      alias :process_abort_ve_animated_battle :process_abort 
      def process_abort 
        @phase = nil 
        process_escape_pose if @escaping 
        process_abort_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: process_battle_end_pose 
      #-------------------------------------------------------------------------- 
      def process_battle_end_pose(party) 
        SceneManager.scene.log_window_clear 
        SceneManager.scene.update_basic while end_wait?(party) 
        SceneManager.scene.update_basic 
        party.movable_members.each do |member|  
          next if $game_system.no_victory || !member.victory_pose? 
          member.poses.clear_loop 
          member.poses.call_pose(:victory) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: end_wait? 
      #-------------------------------------------------------------------------- 
      def end_wait?(party) 
        party.not_in_position? || party.active? || processing_collapse? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: processing_collapse? 
      #-------------------------------------------------------------------------- 
      def processing_collapse? 
        SceneManager.scene.spriteset.collapse? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: process_escape_pose 
      #-------------------------------------------------------------------------- 
      def process_escape_pose 
        $game_party.movable_members.each do |member|  
          member.poses.clear_loop 
          member.poses.call_pose(:escape) 
        end 
        SceneManager.scene.abs_wait(5) 
        SceneManager.scene.update_basic while $game_party.moving? 
        SceneManager.scene.close_window 
        Graphics.fadeout(30) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: clear_active_pose 
      #-------------------------------------------------------------------------- 
      def clear_active_pose 
        return unless actor && actor.poses.active_pose 
        actor.poses.active_pose = nil 
        actor.reset_pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: active 
      #-------------------------------------------------------------------------- 
      def active 
        SceneManager.scene_is?(Scene_Battle) ? SceneManager.scene.active : nil 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: targets 
      #-------------------------------------------------------------------------- 
      def targets 
        return [] unless active 
        active.poses.current_action_targets 
      end  
      #-------------------------------------------------------------------------- 
      # * New method: last_targets 
      #-------------------------------------------------------------------------- 
      def last_targets 
        return [] unless active 
        active.poses.last_targets 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: battler_active? 
      #-------------------------------------------------------------------------- 
      def battler_active? 
        return false unless active 
        active.poses.active? 
      end 
    end 
    
    #============================================================================== 
    # ** Game_System 
    #------------------------------------------------------------------------------ 
    #  This class handles system-related data. Also manages vehicles and BGM, etc. 
    # The instance of this class is referenced by $game_system. 
    #============================================================================== 
    
    class Game_System 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_accessor :no_intro 
      attr_accessor :no_victory 
      attr_accessor :intro_fade 
      #-------------------------------------------------------------------------- 
      # * Alias method: initialize 
      #-------------------------------------------------------------------------- 
      alias :initialize_ve_animated_battle :initialize 
      def initialize 
        initialize_ve_animated_battle 
        @intro_fade = VE_BATTLE_INTRO_FADE 
      end 
    end 
    
    #============================================================================== 
    # ** Game_Screen 
    #------------------------------------------------------------------------------ 
    #  This class handles screen maintenance data, such as change in color tone, 
    # flashes, etc. It's used within the Game_Map and Game_Troop classes. 
    #============================================================================== 
    
    class Game_Screen 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_reader   :low_tone 
      attr_reader   :high_tone 
      attr_accessor :old_tone 
      attr_accessor :old_low_tone 
      attr_accessor :old_high_tone 
      #-------------------------------------------------------------------------- 
      # * Alias method: clear_tone 
      #-------------------------------------------------------------------------- 
      alias :clear_tone_ve_animated_battle :clear_tone 
      def clear_tone 
        clear_tone_ve_animated_battle 
        @low_tone  = Tone.new 
        @high_tone = Tone.new 
        @low_tone_target  = Tone.new 
        @high_tone_target = Tone.new 
        @low_tone_duration  = 0 
        @high_tone_duration = 0 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: update 
      #-------------------------------------------------------------------------- 
      alias :update_ve_animated_battle :update 
      def update 
        update_ve_animated_battle 
        low_update_tone 
        high_update_tone 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: start_low_tone_change 
      #-------------------------------------------------------------------------- 
      def start_low_tone_change(tone, duration) 
        @low_tone_target = tone.clone 
        @low_tone_duration = duration 
        @low_tone = @low_tone_target.clone if @low_tone_duration == 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: start_high_tone_change 
      #-------------------------------------------------------------------------- 
      def start_high_tone_change(tone, duration) 
        @high_tone_target = tone.clone 
        @high_tone_duration = duration 
        @high_tone = @high_tone_target.clone if @high_tone_duration == 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: low_update_tone 
      #-------------------------------------------------------------------------- 
      def low_update_tone 
        if @low_tone_duration > 0 
          d    = @low_tone_duration 
          tone = @low_tone_target 
          @low_tone.red   = (@low_tone.red   * (d - 1) + tone.red)   / d 
          @low_tone.green = (@low_tone.green * (d - 1) + tone.green) / d 
          @low_tone.blue  = (@low_tone.blue  * (d - 1) + tone.blue)  / d 
          @low_tone.gray  = (@low_tone.gray  * (d - 1) + tone.gray)  / d 
          @low_tone_duration -= 1 
        end 
      end   
      #-------------------------------------------------------------------------- 
      # * New method: high_update_tone 
      #-------------------------------------------------------------------------- 
      def high_update_tone 
        if @high_tone_duration > 0 
          d    = @high_tone_duration 
          tone = @high_tone_target 
          @high_tone.red   = (@high_tone.red   * (d - 1) + tone.red)   / d 
          @high_tone.green = (@high_tone.green * (d - 1) + tone.green) / d 
          @high_tone.blue  = (@high_tone.blue  * (d - 1) + tone.blue)  / d 
          @high_tone.gray  = (@high_tone.gray  * (d - 1) + tone.gray)  / d 
          @high_tone_duration -= 1 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: tone_change? 
      #-------------------------------------------------------------------------- 
      def tone_change? 
        @tone_duration > 0 || @low_tone_duration > 0 || @high_tone_duration > 0 
      end 
    end 
    
    #============================================================================== 
    # ** Game_ActionResult 
    #------------------------------------------------------------------------------ 
    #  This class handles the results of actions. This class is used within the 
    # Game_Battler class. 
    #============================================================================== 
    
    class Game_ActionResult 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_accessor :hurt_pose 
      #-------------------------------------------------------------------------- 
      # * New method: damage_adjust 
      #-------------------------------------------------------------------------- 
      def damage_adjust(value, item) 
        return unless value 
        @hp_damage *= value 
        @mp_damage *= value 
        @hp_damage  = @hp_damage.to_i 
        @mp_damage  = [@battler.mp, @mp_damage.to_i].min 
        @hp_drain   = @hp_damage if item.damage.drain? 
        @mp_drain   = @mp_damage if item.damage.drain? 
        @hp_drain   = [@battler.hp, @hp_drain].min 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_drain 
      #-------------------------------------------------------------------------- 
      def setup_drain(user) 
        user.hp_drain += @hp_drain 
        user.mp_drain += @mp_drain 
        @hp_drain = 0 
        @mp_drain = 0 
      end 
    end 
    
    #============================================================================== 
    # ** Game_BattlerBase 
    #------------------------------------------------------------------------------ 
    #  This class handles battlers. It's used as a superclass of the Game_Battler 
    # classes. 
    #============================================================================== 
    
    class Game_BattlerBase 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: refresh 
      #-------------------------------------------------------------------------- 
      def refresh 
        state_resist_set.each {|state_id| erase_state(state_id) } 
        @hp = [[@hp, mhp].min, 0].max 
        @mp = [[@mp, mmp].min, 0].max 
        die if @dying && !immortal? 
        return if @dying 
        valid = @hp == 0 && !immortal? 
        valid ? add_state(death_state_id) : remove_state(death_state_id) 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: element_set 
      #-------------------------------------------------------------------------- 
      alias :element_set_ve_animated_battle :element_set 
      def element_set(item) 
        element_set  = element_set_ve_animated_battle(item) 
        element_set += poses.element_flag 
        element_set.compact 
      end 
    end 
    
    #============================================================================== 
    # ** Game_Battler 
    #------------------------------------------------------------------------------ 
    #  This class deals with battlers. It's used as a superclass of the Game_Actor 
    # and Game_Enemy classes. 
    #============================================================================== 
    
    class Game_Battler < Game_BattlerBase 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_accessor :poses 
      attr_accessor :hp_drain 
      attr_accessor :mp_drain 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: dead? 
      #-------------------------------------------------------------------------- 
      def dead? 
        super && !immortal? 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: item_element_rate 
      #-------------------------------------------------------------------------- 
      def item_element_rate(user, item) 
        elements = user.element_set(item) 
        elements.empty? ? 1.0 : elements_max_rate(elements) 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: initialize 
      #-------------------------------------------------------------------------- 
      alias :initialize_ve_animated_battle :initialize 
      def initialize 
        @hp_drain = 0 
        @mp_drain = 0 
        @poses = Game_BattlerPose.new(self) 
        initialize_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: item_apply 
      #-------------------------------------------------------------------------- 
      alias :item_apply_ve_animated_battle :item_apply 
      def item_apply(user, item) 
        item_apply_ve_animated_battle(user, item) 
        poses.call_damage_pose(item, user) if movable? 
        poses.substitution     = false 
        user.poses.result_flag = @result.hit? ? :hit : :miss 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: make_damage_value 
      #-------------------------------------------------------------------------- 
      alias :make_damage_value_ve_animated_battle :make_damage_value 
      def make_damage_value(user, item) 
        make_damage_value_ve_animated_battle(user, item) 
        active_effect_make_damage(user, item) 
        clear_elemental_flag(user, item) 
        @result.damage_adjust(user.poses.damage_flag, item) 
        @result.hurt_pose = !user.poses.no_hurt_flag 
        @result.setup_drain(user) 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: item_apply 
      #-------------------------------------------------------------------------- 
      alias :execute_damage_ve_animated_battle :execute_damage 
      def execute_damage(user) 
        execute_damage_ve_animated_battle(user) 
        poses.clear_immortal if self.hp <= 0 && poses.clear_flag 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: regenerate_hp 
      #-------------------------------------------------------------------------- 
      alias :regenerate_hp_ve_animated_battle :regenerate_hp 
      def regenerate_hp 
        regenerate_hp_ve_animated_battle 
        if @result.hp_damage > 0 && movable? && $imported[:ve_damage_pop] 
          poses.call_pose(:hurt, :clear) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: die 
      #-------------------------------------------------------------------------- 
      alias :die_ve_animated_battle :die 
      def die 
        return @dying = true if immortal? 
        poses.call_pose(:die, :clear) 
        @dying = false 
        die_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: revive 
      #-------------------------------------------------------------------------- 
      alias :revive_ve_animated_battle :revive 
      def revive 
        call_pose(:revive, :clear) 
        revive_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: get_all_poses 
      #-------------------------------------------------------------------------- 
      def get_all_poses(note = "") 
        note + get_all_notes + battler_settings + default_settings 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: default_settings 
      #-------------------------------------------------------------------------- 
      def default_settings 
        VE_DEFAULT_ACTION 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: battler_settings 
      #-------------------------------------------------------------------------- 
      def battler_settings 
        VE_ACTION_SETTINGS[battler_mode] ? VE_ACTION_SETTINGS[battler_mode] : "" 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: battler_mode 
      #-------------------------------------------------------------------------- 
      def battler_mode 
        sprite_value(:action) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: sprite_value 
      #-------------------------------------------------------------------------- 
      def sprite_value(n) 
        sprite_settings[n].nil? ? VE_DEFAULT_SPRITE[n] : sprite_settings[n] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: sprite_settings 
      #-------------------------------------------------------------------------- 
      def sprite_settings 
        VE_SPRITE_SETTINGS[@battler_name] ? VE_SPRITE_SETTINGS[@battler_name] : 
        VE_DEFAULT_SPRITE 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: script_processing 
      #-------------------------------------------------------------------------- 
      def script_processing(code) 
        eval(code) rescue false 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_pose_frames 
      #-------------------------------------------------------------------------- 
      def set_pose_frames(value) 
        if value =~ /(\d+) FRAMES/i 
          [@pose[:frame] + $1.to_i, sprite_value(:frames)].min - 1 
        else 
          sprite_value(:frames) - 1 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: weapon_icon 
      #-------------------------------------------------------------------------- 
      def weapon_icon(index) 
        actor? ? actor_weapon_icon(index) : enemy_weapon_icon(index) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: actor_weapon_icon 
      #-------------------------------------------------------------------------- 
      def actor_weapon_icon(index) 
        weapons[index - 1] ? weapons[index - 1].icon_index : nil 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: enemy_weapon_icon 
      #-------------------------------------------------------------------------- 
      def enemy_weapon_icon(index) 
        note =~ /<WEAPON #{index}: (\d+)>/i ? $1.to_i : 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: armor_icon 
      #-------------------------------------------------------------------------- 
      def armor_icon(index) 
       actor? ? actor_armor_icon(index) : enemy_armor_icon(index) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: equip_list 
      #-------------------------------------------------------------------------- 
      def actor_armor_icon(index) 
        slot = equip_slots[index] 
        return nil unless slot && slot != 0 && equip_list[slot] 
        equip = equip_list[slot] 
        equip.object ? equip.object.icon_index : nil 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: equip_list 
      #-------------------------------------------------------------------------- 
      def enemy_armor_icon(index) 
        note =~ /<ARMOR #{index}: (\d+)>/i ? $1.to_i : 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: equip_list 
      #-------------------------------------------------------------------------- 
      def equip_list 
        @equips 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: action_icon 
      #-------------------------------------------------------------------------- 
      def action_icon 
        poses.current_item ? poses.current_item.icon_index : 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: current_origin? 
      #-------------------------------------------------------------------------- 
      def current_origin? 
        current_x == screen_x && current_y == screen_y 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: target_origin? 
      #-------------------------------------------------------------------------- 
      def target_origin? 
        target_x == screen_x && target_y == screen_y 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: target_current? 
      #-------------------------------------------------------------------------- 
      def target_current? 
        current_x == target_x  && current_y == target_y 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: not_origin? 
      #-------------------------------------------------------------------------- 
      def not_origin? 
        !origin? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: current_x 
      #-------------------------------------------------------------------------- 
      def current_x 
        poses.current_position[:x] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: current_y 
      #-------------------------------------------------------------------------- 
      def current_y 
        poses.current_position[:y] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: current_h 
      #-------------------------------------------------------------------------- 
      def current_h 
        poses.current_position[:h] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: current_j 
      #-------------------------------------------------------------------------- 
      def current_j 
        poses.current_position[:j] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: target_x 
      #-------------------------------------------------------------------------- 
      def target_x 
        poses.target_position[:x] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: target_y 
      #-------------------------------------------------------------------------- 
      def target_y 
        poses.target_position[:y] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: target_h 
      #-------------------------------------------------------------------------- 
      def target_h 
        poses.target_position[:h] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: target_j 
      #-------------------------------------------------------------------------- 
      def target_j 
        poses.target_position[:j] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: item_attack? 
      #-------------------------------------------------------------------------- 
      def item_attack?(item) 
        item.skill? && item.id == attack_skill_id 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: item_defend? 
      #-------------------------------------------------------------------------- 
      def item_defend?(item) 
        item.skill? && item.id == guard_skill_id 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: use_dual_attack? 
      #-------------------------------------------------------------------------- 
      def use_dual_attack?(item) 
        get_all_notes =~ /<USE DUAL ATTACK>/i && double_attack?(item) 
      end 
      # * New method: use_dual_attack? 
      #-------------------------------------------------------------------------- 
      def use_double_attack?(item) 
       double_attack?(item) && !use_dual_attack?(item) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: double_attack? 
      #-------------------------------------------------------------------------- 
      def double_attack?(item) 
        actor? && dual_wield? && weapons.size > 1 && (item_attack?(item) || 
        (item  && item.note =~ /<ALLOW DUAL ATTACK>/i)) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: immortal? 
      #-------------------------------------------------------------------------- 
      def immortal? 
        poses.immortal? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: down? 
      #-------------------------------------------------------------------------- 
      def down? 
        poses.down? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: left? 
      #-------------------------------------------------------------------------- 
      def left? 
        poses.left? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: right? 
      #-------------------------------------------------------------------------- 
      def right? 
        poses.right? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: up? 
      #-------------------------------------------------------------------------- 
      def up? 
        poses.up? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: unmovable? 
      #-------------------------------------------------------------------------- 
      def unmovable? 
        get_all_notes =~ /<UNMOVABLE>/i 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: hurt_pose? 
      #-------------------------------------------------------------------------- 
      def hurt_pose? 
        @result.hit? && @result.hp_damage > 0 && @result.hurt_pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: command_pose 
      #-------------------------------------------------------------------------- 
      def command_pose 
        poses.call_pose(:command, :clear) if sprite_value(:command) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: input_pose 
      #-------------------------------------------------------------------------- 
      def input_pose 
        poses.call_pose(:input, :clear) if sprite_value(:input) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: cancel_pose 
      #-------------------------------------------------------------------------- 
      def cancel_pose 
        poses.call_pose(:cancel, :clear) if sprite_value(:cancel) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_counter_targets 
      #-------------------------------------------------------------------------- 
      def setup_counter_targets(target, item) 
        [target] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: counter_action 
      #-------------------------------------------------------------------------- 
      def counter_action 
        $data_skills[attack_skill_id] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: drain_setup 
      #-------------------------------------------------------------------------- 
      def drain_setup 
        self.hp += @hp_drain 
        self.mp += @mp_drain 
        @result.hp_damage = -@hp_drain 
        @result.mp_damage = -@mp_drain 
        @hp_drain = 0 
        @mp_drain = 0 
        @damaged  = true if $imported[:ve_damage_pop] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: perform_damage_effect 
      #-------------------------------------------------------------------------- 
      def perform_fast_collapse 
        reset_pose 
        @sprite_effect_type = :instant_collapse 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: reset_pose 
      #-------------------------------------------------------------------------- 
      def reset_pose 
        return unless $game_party.in_battle 
        sprite.reset_pose if sprite 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: clear_flag= 
      #-------------------------------------------------------------------------- 
      def clear_flag=(n) 
        poses.clear_flag = n 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: clear_elemental_flag 
      #-------------------------------------------------------------------------- 
      def clear_elemental_flag(user, item) 
        user.poses.element_flag.clear 
        user.poses.active_effect.each {|member| member.poses.element_flag.clear } 
        user.poses.active_effect.clear 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: active_effect_make_damage 
      #-------------------------------------------------------------------------- 
      def active_effect_make_damage(user, item) 
        return if user.poses.active_effect.empty? 
        setup_old_results 
        apply_new_results(user, item) 
        restore_old_results(item) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: cooperation_make_damage 
      #-------------------------------------------------------------------------- 
      def setup_old_results 
        @result_critical  = @result.critical 
        @result_hp_damage = @result.hp_damage 
        @result_mp_damage = @result.mp_damage 
        @result_hp_drain  = @result.hp_drain 
        @result_mp_drain  = @result.mp_drain 
        @result_resist    = @result.resist if $imported[:ve_damage_pop] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: cooperation_make_damage 
      #-------------------------------------------------------------------------- 
      def apply_new_results(user, item) 
        user.poses.active_effect.each do |battler| 
          next if battler == user 
          make_damage_value_ve_animated_battle(battler, item) 
          @result_critical  |= @result.critical 
          @result_hp_damage += @result.hp_damage 
          @result_mp_damage += @result.mp_damage 
          @result_hp_drain  += @result.hp_drain 
          @result_mp_drain  += @result.mp_drain 
          @result_success   |= @result.success 
          @result_resist    *= @result.resist if $imported[:ve_damage_pop] 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: cooperation_make_damage 
      #-------------------------------------------------------------------------- 
      def restore_old_results(item) 
        @result.critical  = @result_critical 
        @result.hp_damage = @result_hp_damage 
        @result.mp_damage = @result_mp_damage 
        @result.hp_drain  = @result_hp_drain 
        @result.mp_drain  = @result_mp_drain 
        @result.resist    = @result_resist if $imported[:ve_damage_pop] 
        @result.success   = item.damage.to_hp? || @result.mp_damage != 0 
      end 
    end 
    
    #============================================================================== 
    # ** Game_Actor 
    #------------------------------------------------------------------------------ 
    #  This class handles actors. It's used within the Game_Actors class 
    # ($game_actors) and referenced by the Game_Party class ($game_party). 
    #============================================================================== 
    
    class Game_Actor < Game_Battler 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: perform_collapse_effect 
      #-------------------------------------------------------------------------- 
      def perform_collapse_effect 
        if $game_party.in_battle 
          reset_pose 
          case collapse_type 
          when 0 
            @sprite_effect_type = :collapse 
            Sound.play_enemy_collapse 
          when 1 
            @sprite_effect_type = :boss_collapse 
            Sound.play_boss_collapse1 
          when 2 
            @sprite_effect_type = :instant_collapse 
          end 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: perform_damage_effect 
      #-------------------------------------------------------------------------- 
      def perform_damage_effect 
        $game_troop.screen.start_shake(5, 5, 10) unless use_sprite? 
        Sound.play_actor_damage 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: param_plus 
      #-------------------------------------------------------------------------- 
      alias :param_plus_ve_animated_battle :param_plus 
      def param_plus(param_id) 
        if param_id > 1 && @attack_flag 
          atk_equips.compact.inject(super) {|r, item| r += item.params[param_id] } 
        else 
          param_plus_ve_animated_battle(param_id) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: atk_feature_objects 
      #-------------------------------------------------------------------------- 
      def atk_feature_objects 
        list = @attack_flag ? atk_equips : equips.compact 
        states + [actor] + [self.class] + list 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: atk_all_features 
      #-------------------------------------------------------------------------- 
      def atk_all_features 
        atk_feature_objects.inject([]) {|r, obj| r + obj.features } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: atk_features 
      #-------------------------------------------------------------------------- 
      def atk_features(code) 
        atk_all_features.select {|ft| ft.code == code } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: atk_features_set 
      #-------------------------------------------------------------------------- 
      def atk_features_set(code) 
        atk_features(code).inject([]) {|r, ft| r |= [ft.data_id] } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: atk_elements 
      #-------------------------------------------------------------------------- 
      def atk_elements 
        set = atk_features_set(FEATURE_ATK_ELEMENT) 
        set |= [1] if weapons.compact.empty? 
        return set 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: atk_states 
      #-------------------------------------------------------------------------- 
      def atk_states 
        atk_features_set(FEATURE_ATK_STATE) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: atk_equips 
      #-------------------------------------------------------------------------- 
      def atk_equips 
        ([weapons[@attack_flag - 1]] + armors).collect {|item| item }.compact 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: screen_x 
      #-------------------------------------------------------------------------- 
      def screen_x 
        return 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: screen_y 
      #-------------------------------------------------------------------------- 
      def screen_y 
        return 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: character_hue 
      #-------------------------------------------------------------------------- 
      def character_hue 
        hue 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: intro_pose? 
      #-------------------------------------------------------------------------- 
      def intro_pose? 
        !(note =~ /<NO INTRO>/i) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: victory_pose? 
      #-------------------------------------------------------------------------- 
      def victory_pose? 
        !(note =~ /<NO VICTORY>/i) 
      end 
    end 
    
    #============================================================================== 
    # ** Game_Enemy 
    #------------------------------------------------------------------------------ 
    #  This class handles enemy characters. It's used within the Game_Troop class 
    # ($game_troop). 
    #============================================================================== 
    
    class Game_Enemy < Game_Battler 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: perform_damage_effect 
      #-------------------------------------------------------------------------- 
      def perform_damage_effect 
        Sound.play_enemy_damage 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: perform_collapse_effect 
      #-------------------------------------------------------------------------- 
      alias :perform_collapse_effect_ve_animated_battle :perform_collapse_effect 
      def perform_collapse_effect 
        reset_pose 
        perform_collapse_effect_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: atk_animation_id1 
      #-------------------------------------------------------------------------- 
      def atk_animation_id1 
        return 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: atk_animation_id2 
      #-------------------------------------------------------------------------- 
      def atk_animation_id2 
        return 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: character_name 
      #-------------------------------------------------------------------------- 
      def character_name 
        @character_name = @battler_name 
        @character_name 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: character_hue 
      #-------------------------------------------------------------------------- 
      def character_hue 
        @character_hue = @battler_hue 
        @character_hue 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: character_index 
      #-------------------------------------------------------------------------- 
      def character_index 
        note =~ /<CHARACTER INDEX: (\d+)>/i ? $1.to_i - 1 : 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: visual_items 
      #-------------------------------------------------------------------------- 
      def visual_items 
        [default_part] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: default_part 
      #-------------------------------------------------------------------------- 
      def default_part 
        {name: character_name, index1: character_index, index2: character_index, 
         hue: character_hue, priority: 0} 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: intro_pose? 
      #-------------------------------------------------------------------------- 
      def intro_pose? 
        note =~ /<INTRO POSE>/i 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: victory_pose? 
      #-------------------------------------------------------------------------- 
      def victory_pose? 
        note =~ /<VICTORY POSE>/i 
      end 
    end 
    
    #============================================================================== 
    # ** Game_Unit 
    #------------------------------------------------------------------------------ 
    #  This class handles units. It's used as a superclass of the Game_Party and 
    # Game_Troop classes. 
    #============================================================================== 
    
    class Game_Unit 
      #-------------------------------------------------------------------------- 
      # * New method: moving? 
      #-------------------------------------------------------------------------- 
      def not_in_position? 
        movable_members.any? {|member| member.poses.not_in_position? } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: moving? 
      #-------------------------------------------------------------------------- 
      def moving? 
        movable_members.any? {|member| member.poses.moving? } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: active? 
      #-------------------------------------------------------------------------- 
      def active? 
        movable_members.any? {|member| member.poses.active? } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: targetable_members 
      #--------------------------------------------------------------------------   
      def targetable_members 
        alive_members 
      end 
    end 
    
    #============================================================================== 
    # ** Game_Interpreter 
    #------------------------------------------------------------------------------ 
    #  An interpreter for executing event commands. This class is used within the 
    # Game_Map, Game_Troop, and Game_Event classes. 
    #============================================================================== 
    
    class Game_Interpreter 
      #-------------------------------------------------------------------------- 
      # * Alias method: comment_call 
      #-------------------------------------------------------------------------- 
      alias :comment_call_ve_animated_battle :comment_call 
      def comment_call 
        call_animated_battle_comments 
        comment_call_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_animated_battle_comments 
      #-------------------------------------------------------------------------- 
      def call_animated_battle_comments 
        $game_system.no_intro   = true if note =~ /<NO INTRO>/i 
        $game_system.no_victory = true if note =~ /<NO VICTORY>/i 
      end 
    end 
    
    #============================================================================== 
    # ** Game_BattlerPose 
    #------------------------------------------------------------------------------ 
    #  This class deals with battlers poses. 
    #============================================================================== 
    
    class Game_BattlerPose 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_accessor :row 
      attr_accessor :spin 
      attr_accessor :angle 
      attr_accessor :sufix 
      attr_accessor :frame 
      attr_accessor :shake 
      attr_accessor :reset 
      attr_accessor :x_adj 
      attr_accessor :y_adj 
      attr_accessor :f_size 
      attr_accessor :f_init 
      attr_accessor :timing 
      attr_accessor :freeze 
      attr_accessor :active 
      attr_accessor :jumping 
      attr_accessor :targets 
      attr_accessor :teleport 
      attr_accessor :call_end 
      attr_accessor :icon_list 
      attr_accessor :invisible 
      attr_accessor :direction 
      attr_accessor :immortals 
      attr_accessor :animation 
      attr_accessor :countered 
      attr_accessor :call_anim 
      attr_accessor :dual_flag 
      attr_accessor :pose_list 
      attr_accessor :move_over 
      attr_accessor :pose_loop 
      attr_accessor :afterimage 
      attr_accessor :move_speed 
      attr_accessor :reset_move 
      attr_accessor :throw_list 
      attr_accessor :clear_flag 
      attr_accessor :counter_on 
      attr_accessor :call_effect 
      attr_accessor :next_target 
      attr_accessor :attack_flag 
      attr_accessor :damage_flag 
      attr_accessor :result_flag 
      attr_accessor :active_pose 
      attr_accessor :substitution 
      attr_accessor :last_targets 
      attr_accessor :anim_targets 
      attr_accessor :element_flag 
      attr_accessor :current_item 
      attr_accessor :no_hurt_flag 
      attr_accessor :active_effect 
      attr_accessor :action_targets 
      attr_accessor :counter_target 
      attr_accessor :target_position 
      attr_accessor :previous_action 
      attr_accessor :current_position 
      #-------------------------------------------------------------------------- 
      # * New method: initialize 
      #-------------------------------------------------------------------------- 
      def initialize(battler) 
        @battler = battler 
        clear_poses 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: clear_poses 
      #-------------------------------------------------------------------------- 
      def clear_poses 
        @sufix = "" 
        @row   = 0 
        @frame = 0 
        @angle = 0 
        @spin  = 0 
        @x_adj = 0 
        @y_adj = 0 
        @f_init   = 0 
        @hp_drain = 0 
        @mp_drain = 0 
        @direction  = 2 
        @move_speed = 1.0 
        @targets    = [] 
        @immortals  = [] 
        @throw_list = [] 
        @icon_list  = {} 
        @timing     = {} 
        @element_flag   = [] 
        @active_effect  = [] 
        @action_targets = [] 
        @pose_list = Game_PoseList.new(@battler) 
        clear_shake 
        clear_position 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: immortal? 
      #-------------------------------------------------------------------------- 
      def immortal? 
        return false unless $game_party.in_battle 
        members = BattleManager.all_battle_members 
        members.any? {|member| member.poses.immortals.include?(@battler) } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: clear_shake 
      #-------------------------------------------------------------------------- 
      def clear_shake 
        @shake_power = 0 
        @shake_speed = 0 
        @shake_duration = 0 
        @shake_direction = 1 
        @shake = 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: clear_position 
      #-------------------------------------------------------------------------- 
      def clear_position 
        @target_position  = {x: 0, y: 0, h: 0, j: 0} 
        @current_position = {x: 0, y: 0, h: 0, j: 0} 
        @default_position = {x: 0, y: 0, h: 0, j: 0} 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_pose 
      #-------------------------------------------------------------------------- 
      def call_pose(pose, insert = nil, item = nil, battler = nil) 
        return if insert == :clear && pose_list.include?(pose) 
        notes = @battler.get_all_poses(item ? item.note : "") 
        setup_pose(pose, notes, make_string(pose), insert, battler) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_pose 
      #-------------------------------------------------------------------------- 
      def setup_pose(pose, notes, code, insert, battler) 
        regexp = get_all_values("ACTION: *#{code}((?: *, *[^>]+)+)?", "ACTION") 
        result = [] 
        if notes.gsub(/\r\n/i, "") =~ regexp 
          value = $1 
          setup = $2 
          time  = value =~ /([^,]+) TIMES/i ? [script_processing($1), 1].max : 1 
          last  = value =~ /(\w[\w ]+)/i    ? make_symbol($1) : nil 
          layer = insert.numeric? ? insert : 1 
          time.times { result.push(setup_value(setup, pose, last, layer, battler)) } 
          insert_poses(insert, result) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: script_processing 
      #-------------------------------------------------------------------------- 
      def script_processing(value) 
        @battler.script_processing(value) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: insert_poses 
      #-------------------------------------------------------------------------- 
      def insert_poses(insert, next_pose) 
        case insert 
        when :clear, :insert then @pose_list.insert(1, 0, next_pose) 
        when Numeric         then @pose_list.insert(insert, 0, next_pose) 
        else @pose_list.insert(1, -1, next_pose) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_value 
      #-------------------------------------------------------------------------- 
      def setup_value(setup, pose, last, layer, battler) 
        values = Game_PoseAction.new(pose, last, layer, @battler) 
        setup.scan(/(\w+)(?:: *([^;\n\r]+)[;\n\r])?/i) do |name, value| 
          value = value ? value : "" 
          values.push(Game_PoseValue.new(name, value, @battler, battler, layer)) 
        end 
        values 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: pose_name_list 
      #-------------------------------------------------------------------------- 
      def pose_name_list 
        pose_list.list[1] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: pose_name 
      #-------------------------------------------------------------------------- 
      def pose_name 
        pose_list.name[1] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: clear_loop 
      #-------------------------------------------------------------------------- 
      def clear_loop 
        @pose_list.clear_loop 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: clear_damage 
      #-------------------------------------------------------------------------- 
      def clear_damage 
        @pose_list.clear_damage 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: states_pose 
      #-------------------------------------------------------------------------- 
      def states_pose 
        $data_states.compact.collect {|state| state.custom_pose("STATE") }.compact 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: current_action_targets 
      #-------------------------------------------------------------------------- 
      def current_action_targets 
        next_target ? [@action_targets[next_target]] : @action_targets 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: active? 
      #-------------------------------------------------------------------------- 
      def active? 
        @active 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: down? 
      #-------------------------------------------------------------------------- 
      def down? 
        @direction == 2 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: left? 
      #-------------------------------------------------------------------------- 
      def left? 
        @direction == 4 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: right? 
      #-------------------------------------------------------------------------- 
      def right? 
        @direction == 6 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: up? 
      #-------------------------------------------------------------------------- 
      def up? 
        @direction == 8 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: target_direction 
      #-------------------------------------------------------------------------- 
      def target_direction(x, y) 
        relative_x = @battler.current_x - x 
        relative_y = @battler.current_y - y 
        if isometric? 
          @direction = 2 if relative_x > 0 && relative_y < 0 
          @direction = 4 if relative_x > 0 && relative_y > 0 
          @direction = 6 if relative_x < 0 && relative_y < 0 
          @direction = 8 if relative_x < 0 && relative_y > 0 
        elsif relative_x.abs >= relative_y.abs && !frontview? 
          @direction = relative_x < 0 ? 6 : 4 
        elsif relative_y.abs >= relative_x.abs && !sideview? 
          @direction = relative_y < 0 ? 2 : 8 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: action_direction 
      #-------------------------------------------------------------------------- 
      def action_direction(units) 
        x = units.collect {|member| member.current_x }.average 
        y = units.collect {|member| member.current_y }.average 
        target_direction(x, y) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: active_direction 
      #-------------------------------------------------------------------------- 
      def active_direction 
        units = BattleManager.all_battle_members 
        action_direction(units.select {|member| member.poses.active? }) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: default_direction 
      #-------------------------------------------------------------------------- 
      def default_direction 
        action_direction(@battler.opponents_unit.members) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: targets_direction 
      #-------------------------------------------------------------------------- 
      def targets_direction 
        action_direction(BattleManager.targets) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: origin_direction 
      #-------------------------------------------------------------------------- 
      def origin_direction 
        target_direction(@battler.screen_x, @battler.screen_y) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: adjust_position 
      #-------------------------------------------------------------------------- 
      def adjust_position(value) 
        if isometric? 
          x, y =  value, -value * 0.75 if down? 
          x, y =  value,  value * 0.75 if left? 
          x, y = -value, -value * 0.75 if right? 
          x, y = -value,  value * 0.75 if up? 
        else 
          x, y = 0, -value if down? 
          x, y =  value, 0 if left? 
          x, y = -value, 0 if right? 
          x, y = 0,  value if up? 
        end 
        @target_position[:x] += x.to_i 
        @target_position[:y] += y.to_i 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: sharing_position? 
      #-------------------------------------------------------------------------- 
      def sharing_position? 
        sharing_list.size > 1 && !move_over 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: sharing_list 
      #-------------------------------------------------------------------------- 
      def sharing_list 
        BattleManager.all_battle_members.select {|other| position_overlap?(other) } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: position_overlap?(other) 
      #-------------------------------------------------------------------------- 
      def position_overlap?(other) 
        x = target_position[:x] - other.poses.target_position[:x] 
        y = target_position[:y] - other.poses.target_position[:y] 
        x.abs <= 12 && y.abs <= 12 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: position_fix 
      #-------------------------------------------------------------------------- 
      def position_fix 
        sharing_list.each do |other| 
          next if other == @battler || !position_overlap?(other) 
          fix_vert(other) if left?  || right?  
          fix_horz(other) if down?  || up?  
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method:  fix_vert 
      #-------------------------------------------------------------------------- 
      def fix_vert(other) 
        adjust = @battler.current_y > other.current_x ? 4 : -4 
        @target_position[:y] += adjust 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: fix_horz 
      #-------------------------------------------------------------------------- 
      def fix_horz(other) 
        adjust = @battler.current_x > other.current_x ? 4 : -4 
        @target_position[:x] += adjust 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: fix_position 
      #-------------------------------------------------------------------------- 
      def fix_position 
        @target_position = @current_position.dup 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: sideview? 
      #-------------------------------------------------------------------------- 
      def sideview? 
        $imported[:ve_actor_battlers] && VE_BATTLE_FORMATION == :side 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: frontview? 
      #-------------------------------------------------------------------------- 
      def frontview? 
        $imported[:ve_actor_battlers] && VE_BATTLE_FORMATION == :front 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: isometric 
      #-------------------------------------------------------------------------- 
      def isometric? 
        $imported[:ve_actor_battlers] && VE_BATTLE_FORMATION == :iso 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: target_distance 
      #-------------------------------------------------------------------------- 
      def target_distance(symbol) 
        @target_position[symbol] - @current_position[symbol] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: moving? 
      #-------------------------------------------------------------------------- 
      def moving? 
        @current_position != @target_position 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: moving? 
      #-------------------------------------------------------------------------- 
      def damage_pose? 
        pose_list.damage_pose? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: no_pose? 
      #-------------------------------------------------------------------------- 
      def pose? 
        timing[:time] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: state_pose? 
      #-------------------------------------------------------------------------- 
      def state_pose? 
        state_pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: state_pose 
      #-------------------------------------------------------------------------- 
      def state_pose 
        @battler.states.collect {|state| state.custom_pose("STATE") }.first 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: state_pose 
      #-------------------------------------------------------------------------- 
      def cast_pose 
        call_active_pose(@battler.cast_action.item) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: activate 
      #-------------------------------------------------------------------------- 
      def activate 
        return unless current_action && current_action.item 
        @active         = true 
        @active_pose    = nil 
        @action_targets = make_action_targets 
        setup_immortals 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: make_action_targets 
      #-------------------------------------------------------------------------- 
      def make_action_targets 
        targets = current_action.make_targets.compact.dup 
        return targets.sort {|a, b| b.current_x <=> a.current_x } if frontview? 
        return targets.sort {|a, b| b.current_y <=> a.current_y } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_immortals 
      #-------------------------------------------------------------------------- 
      def setup_immortals 
        @action_targets.each {|target| @immortals.push(target) unless target.dead? } 
        @immortals.uniq! 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: deactivate 
      #-------------------------------------------------------------------------- 
      def deactivate 
        @active      = false 
        @attack_flag = nil 
        @result_flag = nil 
        @next_target = nil 
        @call_end    = true 
        clear_immortals 
        @action_targets.clear 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: clear_immortals 
      #-------------------------------------------------------------------------- 
      def clear_immortals 
        members   = BattleManager.all_battle_members 
        immortals = members.inject([]) {|r, member| r += member.poses.immortals } 
        members.each   {|member| member.poses.immortals.clear } 
        immortals.each {|member| member.refresh } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: action_pose 
      #-------------------------------------------------------------------------- 
      def action_pose(item) 
        @current_item = item 
        call_action_poses 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_action_poses 
      #-------------------------------------------------------------------------- 
      def call_action_poses 
        clear_loop 
        set_action_pose 
        call_pose(:inactive) 
        call_custom_pose("RETREAT", :retreat, @current_item) 
        call_pose(:clear) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_action_pose 
      #-------------------------------------------------------------------------- 
      def set_action_pose 
        set_attack_pose 
        set_attack_pose(true) if use_double_attack? 
        @attack_flag = use_double_attack? ? 1 : nil 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_attack_pose 
      #-------------------------------------------------------------------------- 
      def set_attack_pose(dual = false) 
        item       = @current_item 
        @dual_flag = dual 
        call_move_pose("ADVANCE", :advance,   dual) if item && need_move?(item) 
        call_pose(setup_pose_type(dual), nil, item) if item 
        call_pose(:finish, nil) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_pose_type 
      #-------------------------------------------------------------------------- 
      def setup_pose_type(dual = false) 
        pose = setup_basic_pose(dual) 
        pose = :defend if item_defend? 
        pose = setup_custom_pose(pose) 
        pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_basic_pose 
      #-------------------------------------------------------------------------- 
      def setup_basic_pose(dual) 
        pose = weapons_pose("USE",    :use,    dual) 
        pose = weapons_pose("ITEM",   :item,   dual) if @current_item.item? 
        pose = weapons_pose("MAGIC",  :magic,  dual) if @current_item.magical? 
        pose = weapons_pose("SKILL",  :skill,  dual) if @current_item.physical? 
        pose = weapons_pose("ATTACK", :attack, dual) if item_attack? 
        pose = weapons_pose("DUAL",   :dual_attack)  if use_dual_attack? 
        pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method:  
      #-------------------------------------------------------------------------- 
      def item_attack? 
        @battler.item_attack?(@current_item) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method:  
      #-------------------------------------------------------------------------- 
      def item_defend? 
        @battler.item_defend?(@current_item) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method:  
      #-------------------------------------------------------------------------- 
      def use_double_attack? 
        @battler.use_double_attack?(@current_item) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method:  
      #-------------------------------------------------------------------------- 
      def use_dual_attack? 
        @battler.use_dual_attack?(@current_item) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method:  
      #-------------------------------------------------------------------------- 
      def current_action 
        @battler.current_action 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: frames 
      #-------------------------------------------------------------------------- 
      def frames 
        @battler.character_name[/\[F(\d+)\]/i] ? $1.to_i : 3 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: not_in_position? 
      #-------------------------------------------------------------------------- 
      def not_in_position? 
        pose_list.first_name == :retreat 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_custom_pose 
      #-------------------------------------------------------------------------- 
      def setup_custom_pose(pose) 
        item = @current_item 
        pose = battler_pose("ACTION", pose, item) 
        pose = battler_pose("ITEM"  , pose, item) if item.item? 
        pose = battler_pose("MAGIC" , pose, item) if item.magical? 
        pose = battler_pose("SKILL" , pose, item) if item.physical? 
        pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: weapons_pose 
      #-------------------------------------------------------------------------- 
      def weapons_pose(type, pose, dual = false) 
        valid = @battler.actor? ? @battler.weapons + [@battler] : [@battler] 
        list  = valid.collect {|item| item.custom_pose(type) } 
        list.shift if dual 
        list.empty? || !pose_exist?(list.first) ? pose : list.first 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: battler_pose 
      #-------------------------------------------------------------------------- 
      def battler_pose(type, pose, item) 
        note   = item ? item.note : "" 
        custom = item.custom_pose(type) 
        custom && pose_exist?(custom, note) ? custom : pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: pose_exist? 
      #-------------------------------------------------------------------------- 
      def pose_exist?(pose, note = "") 
        value  = "ACTION: #{make_string(pose)}(?:(?: *, *[^>]+)+)?" 
        regexp = get_all_values(value, "ACTION") 
        @battler.get_all_poses(note) =~ regexp 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_move_pose 
      #-------------------------------------------------------------------------- 
      def call_move_pose(type, pose, dual) 
        pose = weapons_pose(type, pose, dual)  
        pose = battler_pose(type, pose, @current_item) 
        call_pose(pose, nil, @current_item) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_custom_pose 
      #-------------------------------------------------------------------------- 
      def call_custom_pose(type, pose, item) 
        pose = battler_pose(type, pose, item) 
        call_pose(pose, nil, item) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: need_move? 
      #-------------------------------------------------------------------------- 
      def need_move?(item) 
        return false if @battler.unmovable? 
        return true  if item.note =~ /<ACTION MOVEMENT>/i 
        return true  if item.skill? && item.physical? 
        return true  if item.skill? && item.id == @battler.attack_skill_id 
        return false 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_damage_pose 
      #-------------------------------------------------------------------------- 
      def call_damage_pose(item, user) 
        call_pose(:hurt,     :clear, item) if @battler.hurt_pose? 
        call_pose(:miss,     :clear, item) if @battler.result.missed 
        call_pose(:evade,    :clear, item) if @battler.result.evaded 
        call_pose(:critical, :clear, item) if @battler.result.critical 
        call_subsititution if @substitution 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_damage_pose 
      #-------------------------------------------------------------------------- 
      def clear_immortal 
        @clear_flag = false 
        BattleManager.all_battle_members.select do |member|  
          member.poses.immortals.delete(@battler) 
          member.poses.action_targets.delete(@battler) 
        end 
        @battler.refresh 
        @battler.result.added_states.delete(1) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_subsititution 
      #-------------------------------------------------------------------------- 
      def call_subsititution 
        call_pose(:substitution_on, :insert) 
        @battler.sprite.update 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_active_pose 
      #-------------------------------------------------------------------------- 
      def set_active_pose 
        return if !current_item && (!current_action || !current_action.item) 
        item = current_action ? current_action.item : current_item 
        setup_active_pose(item) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_active_pose 
      #-------------------------------------------------------------------------- 
      def setup_active_pose(item) 
        @active_pose = call_active_pose(item) 
        @battler.reset_pose if @active_pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_active_pose 
      #-------------------------------------------------------------------------- 
      def call_active_pose(item) 
        pose = :ready      if @battler.sprite_value(:ready) 
        pose = :item_cast  if item.item?     && @battler.sprite_value(:itemcast) 
        pose = :magic_cast if item.magical?  && @battler.sprite_value(:magiccast) 
        pose = :skill_cast if item.physical? && @battler.sprite_value(:skillcast) 
        pose = battler_pose("ITEM CAST", pose, item)  if pose && item.item? 
        pose = battler_pose("MAGIC CAST", pose, item) if pose && item.magical? 
        pose = battler_pose("SKILL CAST", pose, item) if pose && item.physical? 
        pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_counter 
      #-------------------------------------------------------------------------- 
      def setup_counter(target, item) 
        return if @counter_target 
        target.poses.counter_on = true 
        target.poses.countered  = true 
        action          = @battler.counter_action 
        @current_item   = action 
        @action_targets = make_counter_targets(target, action) 
        @counter_target = target 
        setup_immortals 
        @battler.use_item(action) 
        call_pose(:prepare_counter) 
        call_action_poses 
        call_pose(:counter_off) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: make_counter_targets 
      #-------------------------------------------------------------------------- 
      def make_counter_targets(target, item) 
        targets = @battler.setup_counter_targets(target, item) 
        return targets.sort {|a, b| b.current_x <=> a.current_x } if frontview? 
        return targets.sort {|a, b| b.current_y <=> a.current_y } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_reflect 
      #-------------------------------------------------------------------------- 
      def setup_reflect(item) 
        @action_targets = [@battler] 
        setup_immortals 
        @current_item = item 
        call_pose(:reflection, :insert, item) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_substitute 
      #-------------------------------------------------------------------------- 
      def setup_substitute(target) 
        @action_targets = [target] 
        @substitution   = true 
        call_pose(:substitution_off, :insert) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: start_shake 
      #-------------------------------------------------------------------------- 
      def start_shake(power, speed, duration) 
        @shake_power = power 
        @shake_speed = speed 
        @shake_duration = duration 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_shake 
      #-------------------------------------------------------------------------- 
      def update_shake 
        return unless shaking? 
        delta  = (@shake_power * @shake_speed * @shake_direction) / 10.0 
        clear  = @shake_duration <= 1 && @shake * (@shake + delta) < 0 
        @shake = clear ? 0 : @shake + delta 
        @shake_direction = -1 if @shake > @shake_power * 2 
        @shake_direction = 1  if @shake < - @shake_power * 2 
        @shake_duration -= 1 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_freeze 
      #-------------------------------------------------------------------------- 
      def update_freeze 
        return if @freeze == 0 || !@freeze.numeric? 
        @freeze -= 1 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: shaking? 
      #-------------------------------------------------------------------------- 
      def shaking? 
        @shake_duration > 0 || @shake != 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: frozen? 
      #-------------------------------------------------------------------------- 
      def frozen? 
        (@freeze.numeric? && @freeze > 0) || @freeze == :lock || @battler.unmovable? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: frozen? 
      #-------------------------------------------------------------------------- 
      def action?(layer) 
        @pose_list.layer > layer 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_subject 
      #-------------------------------------------------------------------------- 
      def setup_subject(subject) 
        @immortals      = subject.poses.immortals.dup 
        @current_item   = subject.poses.current_item 
        @action_targets = subject.poses.action_targets.dup 
      end 
    end 
    
    #============================================================================== 
    # ** Game_PoseValue 
    #------------------------------------------------------------------------------ 
    #  This class deals with battlers pose values. 
    #============================================================================== 
    
    class Game_PoseValue 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_reader   :name 
      attr_reader   :data 
      attr_reader   :layer 
      attr_reader   :battler 
      attr_reader   :subjects 
      attr_reader   :targets 
      attr_reader   :active 
      attr_reader   :icon_battler 
      #-------------------------------------------------------------------------- 
      # * New method: initialize 
      #-------------------------------------------------------------------------- 
      def initialize(name, value, battler, active, layer) 
        @name     = make_symbol(name) 
        @layer    = layer 
        @battler  = battler 
        @active   = active 
        @subjects = set_subjects(value) 
        @data     = {} 
        @targets  = [] 
        setup_pose(value) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: [] 
      #-------------------------------------------------------------------------- 
      def [](value) 
        @data[value] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: []= 
      #-------------------------------------------------------------------------- 
      def []=(id, value) 
        @data[id] = value 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: poses 
      #-------------------------------------------------------------------------- 
      def poses 
        battler.poses 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_pose 
      #-------------------------------------------------------------------------- 
      def setup_pose(value) 
        case @name 
        when :pose       then set_pose(value) 
        when :wait       then set_wait(value) 
        when :move       then set_move(value) 
        when :jump       then set_jump(value) 
        when :anim       then set_anim(value) 
        when :icon       then set_icon(value) 
        when :loop       then set_loop(value) 
        when :tone       then set_tone(value) 
        when :hide       then set_hide(value) 
        when :throw      then set_throw(value) 
        when :sound      then set_sound(value) 
        when :plane      then set_plane(value) 
        when :flash      then set_flash(value) 
        when :shake      then set_shake(value) 
        when :movie      then set_movie(value) 
        when :count      then set_count(value) 
        when :clear      then set_clear(value) 
        when :state      then set_state(value) 
        when :action     then set_action(value) 
        when :freeze     then set_freeze(value) 
        when :effect     then set_effect(value) 
        when :script     then set_script(value) 
        when :picture    then set_picture(value) 
        when :counter    then set_counter(value) 
        when :direction  then set_direction(value) 
        when :condition  then set_condition(value) 
        when :transform  then set_transform(value) 
        when :afterimage then set_afterimage(value) 
        when :transition then set_transition(value) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_pose 
      #-------------------------------------------------------------------------- 
      def set_pose(value) 
        @data[:row]   = set_row(value) 
        @data[:sufix] = set_sufix(value) 
        @data[:frame] = value =~ /FRAME (\d+)/i      ? $1.to_i : 1 
        @data[:angle] = value =~ /ANGLE ([+-]?\d+)/i ? $1.to_i : 0 
        @data[:spin]  = value =~ /SPIN ([+-]?\d+)/i  ? $1.to_i : 0 
        @data[:x]     = value =~ /X ([+-]?\d+)/i     ? $1.to_i : 0 
        @data[:y]     = value =~ /Y ([+-]?\d+)/i     ? $1.to_i : 0 
        @data[:size]  = value =~ /FRAME SIZE (\d+)/i ? $1.to_i : nil 
        @data[:pose]  = setl_all_frames(value) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_wait 
      #-------------------------------------------------------------------------- 
      def set_wait(value) 
        value.scan(/\w+/i) {|result| set_wait_value(result) } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_move 
      #-------------------------------------------------------------------------- 
      def set_move(value) 
        @data[:value]    = make_symbol($1) if value =~ /(#{movement_words})/i 
        @targets         = active_targets if @data[:value] == :move_to 
        @targets         = active_targets if @data[:value] == :move_to_front 
        @data[:x]        = value =~ /X ([+-]?\d+)/i ? $1.to_i : 0 
        @data[:y]        = value =~ /Y ([+-]?\d+)/i ? $1.to_i : 0 
        @data[:h]        = value =~ /HEIGHT (\d+)/i ? $1.to_i : 0 
        @data[:speed]    = value =~ /SPEED (\d+)/i  ? $1.to_i / 10.0 : 1.0 
        @data[:teleport] = true if value =~ /TELEPORT/i 
        @data[:reset]    = true if value =~ /RESET/i 
        @data[:over]     = true if value =~ /OVER/i 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_jump 
      #-------------------------------------------------------------------------- 
      def set_jump(value) 
        @data[:move]   = true if value =~ /MOVE/i 
        @data[:reset]  = true if value =~ /RESET/i 
        @data[:height] = value =~ /HEIGHT (\d+)/i ? [$1.to_i, 1].max : nil 
        @data[:speed]  = value =~ /SPEED (\d+)/i  ? [$1.to_i, 1].max : 10 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_clear 
      #-------------------------------------------------------------------------- 
      def set_clear(value) 
        @data[:idle]   = true if value =~ /IDLE/i 
        @data[:damage] = true if value =~ /DAMAGE/i 
        @data[:pose]   = true if value =~ /POSE/i 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_state 
      #-------------------------------------------------------------------------- 
      def set_state(value) 
        @data[:add]    = get_values(value, "ADD").compact 
        @data[:remove] = get_values(value, "REMOVE").compact 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_action 
      #-------------------------------------------------------------------------- 
      def set_action(value) 
        value.scan(/(\w[\w ]+)/) { @data[:action] = make_symbol($1) } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_freeze 
      #-------------------------------------------------------------------------- 
      def set_freeze(value) 
        @data[:duration] = value =~ /DURATION (\d+)/i ? [$1.to_i, 1].max : 1 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_sound 
      #-------------------------------------------------------------------------- 
      def set_sound(value) 
        @data[:name]   = value =~ /NAME #{get_filename}/i ? $1 : "" 
        @data[:volume] = value =~ /VOLUME (\d+)/i ? $1.to_i : 100 
        @data[:pitch]  = value =~ /PITCH (\d+)/i  ? $1.to_i : 100 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_hide 
      #-------------------------------------------------------------------------- 
      def set_hide(value) 
        @data[:all_battler] = true if value =~ /ALL BATTLERS/i 
        @data[:all_enemies] = true if value =~ /ALL ENEMIES/i 
        @data[:all_friends] = true if value =~ /ALL FRIENDS/i 
        @data[:all_targets] = true if value =~ /ALL TARGETS/i 
        @data[:not_targets] = true if value =~ /NOT TARGETS/i 
        @data[:exc_user]    = true if value =~ /EXCLUDE USER/i 
        @data[:inc_user]    = true if value =~ /INCLUDE USER/i 
        @data[:unhide]      = true if value =~ /UNHIDE/i 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_anim 
      #-------------------------------------------------------------------------- 
      def set_anim(value) 
        @data[:anim] = set_anim_id(value) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_icon 
      #-------------------------------------------------------------------------- 
      def set_icon(value) 
        @targets       = set_subjects(value, ",") 
        @data[:index]  = value =~ /INDEX ([+-]?\d+)/i      ? $1.to_i : 0 
        @data[:image]  = value =~ /IMAGE #{get_filename}/i ? $1.to_s : nil 
        @data[:delete] = true if value =~ /DELETE/i 
        @data[:above]  = true if value =~ /ABOVE/i 
        return if @data[:delete] 
        set_action_icon(value) 
        @data[:x]    = value =~ /X ([+-]?\d+)/i     ? $1.to_i : 0 
        @data[:y]    = value =~ /Y ([+-]?\d+)/i     ? $1.to_i : 0 
        @data[:a]    = value =~ /ANGLE ([+-]?\d+)/i ? $1.to_i : 0 
        @data[:o]    = value =~ /OPACITY (\d+)/i    ? $1.to_i : 255 
        @data[:spin] = value =~ /SPIN ([+-]\d+)/i   ? $1.to_i : 0 
        @data[:fin]  = value =~ /FADE IN (\d+)/i    ? $1.to_i : 0 
        @data[:fout] = value =~ /FADE OUT (\d+)/i   ? $1.to_i : 0 
        @data[:izm]  = value =~ /INIT ZOOM (\d+)/i  ? $1.to_i / 100.0 : 1.0 
        @data[:ezm]  = value =~ /END ZOOM (\d+)/i   ? $1.to_i / 100.0 : 1.0 
        @data[:szm]  = value =~ /ZOOM SPD (\d+)/i   ? $1.to_i / 100.0 : 0.1 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_picture 
      #-------------------------------------------------------------------------- 
      def set_picture(value) 
        @data[:id]     = value =~ /ID (\d+)/i ? [$1.to_i, 1].max : 1 
        @data[:delete] = true if value =~ /DELETE/i 
        return if @data[:delete] 
        nm = value =~ /NAME #{get_filename}/i ? $1.to_s : "" 
        og = value =~ /CENTER/i            ? 1       : 0 
        x  = value =~ /POS X ([+-]?\d+)/i  ? $1.to_i : 0 
        y  = value =~ /POS Y ([+-]?\d+)/i  ? $1.to_i : 0 
        zx = value =~ /ZOOM X ([+-]?\d+)/i ? $1.to_i : 100.0 
        zy = value =~ /ZOOM X ([+-]?\d+)/i ? $1.to_i : 100.0 
        op = value =~ /OPACITY (\d+)/i     ? $1.to_i : 255 
        bt = value =~ /BLEND ([+-]\d+)/i   ? $1.to_i : 0 
        dr = value =~ /DURATION (\d+)/i    ? $1.to_i : 0 
        @data[:show] = [n, og, x, y, zx, zy, op, bt]  if value =~ /SHOW/i 
        @data[:move] = [og, x, y, zx, zy, op, bt, dr] if value =~ /MOVE/i 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_plane 
      #-------------------------------------------------------------------------- 
      def set_plane(value) 
        @data[:delete]   = value =~ /DELETE/i ? true : false 
        @data[:duration] = value =~ /DURATION (\d+)/i ? $1.to_i : 0 
        return if @data[:delete] 
        name     = value =~ /NAME #{get_filename}/i ? $1.to_s : "" 
        x        = value =~ /MOVE X ([+-]?\d+)/i    ? $1.to_i : 0 
        y        = value =~ /MOVE Y ([+-]?\d+)/i    ? $1.to_i : 0 
        z        = value =~ /Z ([+-]?\d+)/i         ? $1.to_i : 500 
        zoom_x   = value =~ /ZOOM X (\d+)/i         ? $1.to_i : 100.0 
        zoom_y   = value =~ /ZOOM Y (\d+)/i         ? $1.to_i : 100.0 
        opacity  = value =~ /OPACITY (\d+)/i        ? $1.to_i : 160 
        blend    = value =~ /BLEND (\d+)/i          ? $1.to_i : 0 
        duration = @data[:duration] 
        @data[:list] = [name, x, y, z, zoom_x, zoom_y, opacity, blend, duration] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_throw 
      #-------------------------------------------------------------------------- 
      def set_throw(value) 
        @targets       = set_subjects(value, ",") 
        @data[:image]  = value =~ /IMAGE #{get_filename}/i ? $1.to_s : nil 
        set_action_icon(value) 
        @data[:revert] = true if value =~ /REVERT/i 
        @data[:return] = true if value =~ /RETURN/i 
        @data[:anim]   = value =~ /ANIM (\d+)/i        ? $1.to_i : nil 
        @data[:init_x] = value =~ /INIT X ([+-]?\d+)/i ? $1.to_i : 0 
        @data[:init_y] = value =~ /INIT Y ([+-]?\d+)/i ? $1.to_i : 0 
        @data[:end_x]  = value =~ /END X ([+-]?\d+)/i  ? $1.to_i : 0 
        @data[:end_y]  = value =~ /END Y ([+-]?\d+)/i  ? $1.to_i : 0 
        @data[:arc]    = value =~ /ARC (\d+)/i         ? $1.to_i : 0 
        @data[:spin]   = value =~ /SPIN ([+-]\d+)/i    ? $1.to_i : 0 
        @data[:fin]    = value =~ /FADE IN (\d+)/i     ? $1.to_i : 0 
        @data[:fout]   = value =~ /FADE OUT (\d+)/i    ? $1.to_i : 0 
        @data[:a]      = value =~ /ANGLE (\d+)/i       ? $1.to_i : 0 
        @data[:o]      = value =~ /OPACITY (\d+)/i     ? $1.to_i : 255 
        @data[:speed]  = value =~ /SPEED (\d+)/i       ? $1.to_i / 10.0  : 1.0 
        @data[:izm]    = value =~ /INIT ZOOM (\d+)/i   ? $1.to_i / 100.0 : 1.0 
        @data[:ezm]    = value =~ /END ZOOM (\d+)/i    ? $1.to_i / 100.0 : 1.0 
        @data[:szm]    = value =~ /ZOOM SPD (\d+)/i    ? $1.to_i / 100.0 : 0.1 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_shake 
      #-------------------------------------------------------------------------- 
      def set_shake(value) 
        @data[:screen] = true if value =~ /SCREEN/i 
        power    = value =~ /POWER (\d+)/i    ? [$1.to_i, 2].max : 5 
        speed    = value =~ /SPEED (\d+)/i    ? [$1.to_i, 2].max : 5 
        duration = value =~ /DURATION (\d+)/i ? [$1.to_i, 1].max : 10 
        @data[:shake] = [power / 2.0, speed / 2.0, duration] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_movie 
      #-------------------------------------------------------------------------- 
      def set_movie(value) 
        @data[:name] = value =~ /NAME #{get_filename}/i ? $1.to_s : "" 
        set_tone(value) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_tone 
      #-------------------------------------------------------------------------- 
      def set_tone(value) 
        r = value =~ /RED ([+-]?\d+)/i   ? $1.to_i : 0 
        g = value =~ /GREEN ([+-]?\d+)/i ? $1.to_i : 0 
        b = value =~ /BLUE ([+-]?\d+)/i  ? $1.to_i : 0 
        a = value =~ /GRAY ([+-]?\d+)/i  ? $1.to_i : 0 
        tone = [r, g, b, a] 
        tone = [ 255,  255,  255, 0] if value =~ /WHITE/i 
        tone = [-255, -255, -255, 0] if value =~ /BLACK/i 
        @data[:tone]     = Tone.new(*tone) 
        @data[:clear]    = true if value =~ /CLEAR/i 
        @data[:duration] = value =~ /DURATION (\d+)/i ? $1.to_i : 0 
        @data[:priority] = :normal 
        @data[:priority] = :high if value =~ /HIGH PRIORITY/i 
        @data[:priority] = :low  if value =~ /LOW PRIORITY/i 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_flash 
      #-------------------------------------------------------------------------- 
      def set_flash(value) 
        @data[:screen] = true if value =~ /SCREEN/i 
        r = value =~ /RED (\d+)/i   ? $1.to_i : 255 
        g = value =~ /GREEN (\d+)/i ? $1.to_i : 255 
        b = value =~ /BLUE (\d+)/i  ? $1.to_i : 255 
        a = value =~ /ALPHA (\d+)/i ? $1.to_i : 160 
        duration = value =~ /DURATION (\d+)/i ? [$1.to_i, 1].max : 10 
        @data[:flash] = [Color.new(r, g, b, a), duration] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_loop 
      #-------------------------------------------------------------------------- 
      def set_loop(value) 
        @data[:loop_anim] = value =~ /ANIM (\d+)/i ? $1.to_i : 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_effect 
      #-------------------------------------------------------------------------- 
      def set_effect(value) 
        @targets         = set_subjects(value, ",") 
        @data[:damage]   = $1.to_i / 100.0  if value =~ /(\d+)%/i 
        @data[:weapon]   = [$1.to_i, 1].max if value =~ /WEAPON (\d+)/i 
        @data[:no_pose]  = true if value =~ /NO POSE/i 
        @data[:clear]    = true if value =~ /CLEAR/i 
        @data[:active]   = true if value =~ /ACTIVE/i 
        @data[:elements] = get_values(value, "ELEMENTS").compact 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_condition 
      #-------------------------------------------------------------------------- 
      def set_condition(value) 
        @data[:condition] = value =~ /^END/i ? :end : value.dup 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_script 
      #-------------------------------------------------------------------------- 
      def set_script(value) 
        @data[:script]  = value.dup 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_counter 
      #-------------------------------------------------------------------------- 
      def set_counter(value) 
        @data[:counter] = true  if value =~ /ON/i  
        @data[:counter] = false if value =~ /OFF/i  
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_direction 
      #-------------------------------------------------------------------------- 
      def set_direction(value) 
        @targets          = battler.poses.last_targets if value =~ /SUBJECTS/i 
        @data[:targets]   = true if value =~ /SUBJECTS/i 
        @data[:active]    = true if value =~ /ACTIVE/i 
        @data[:return]    = true if value =~ /RETURN/i 
        @data[:default]   = true if value =~ /DEFAULT/i 
        @data[:direction] = 2 if value =~ /DOWN/i 
        @data[:direction] = 4 if value =~ /LEFT/i 
        @data[:direction] = 6 if value =~ /RIGHT/i 
        @data[:direction] = 8 if value =~ /UP/i 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_transition 
      #-------------------------------------------------------------------------- 
      def set_transition(value) 
        @data[:prepare]  = true if value =~ /PREPARE/i 
        @data[:execute]  = true if value =~ /EXECUTE/i 
        @data[:duration] = value =~ /DURATION (\d+)/i ? $1.to_i : 40 
        @data[:name]     = value =~ /NAME #{get_filename}/i ? $1.to_s : "" 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_transform 
      #-------------------------------------------------------------------------- 
      def set_transform(value) 
        @data[:id] = $1.to_i if value =~ /ID (\d+)/i 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_afterimage 
      #-------------------------------------------------------------------------- 
      def set_afterimage(value) 
        @data[:off]     = true if value =~ /OFF/i 
        @data[:opacity] = value =~ /OPACITY (\d+)/i ? $1.to_i : 200 
        @data[:blend]   = value =~ /BLEND (\d+)/i   ? $1.to_i : 0 
        @data[:wait]    = value =~ /WAIT (\d+)/i    ? $1.to_i : 2 
        @data[:fade]    = value =~ /FADE (\d+)/i   ? $1.to_i : 10 
        r = value =~ /RED (\d+)/i   ? $1.to_i : 0 
        g = value =~ /GREEN (\d+)/i ? $1.to_i : 0 
        b = value =~ /BLUE (\d+)/i  ? $1.to_i : 0 
        a = value =~ /ALPHA (\d+)/i ? $1.to_i : 0 
        @data[:color] = [r, g, b, a] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_subjects 
      #-------------------------------------------------------------------------- 
      def set_subjects(value, code = "^") 
        case value 
        when /#{code} *USER/i 
          [active ? active : battler] 
        when /#{code} *ACTIVE/i 
          [BattleManager.active ? BattleManager.active : battler] 
        when /#{code} *ACTOR ([^>,;]+)/i 
          actor = $game_actors[battler.script_processing($1)] 
          $game_party.battle_members.include?(actor) ? [actor] : [] 
        when /#{code} *FRIEND ([^>,;]+)/i 
          [$game_party.battle_members[battler.script_processing($1) - 1]].compact 
        when /#{code} *ENEMY ([^>,;]+)/i 
          [$game_troop.members[battler.script_processing($1) - 1]].compact 
        when /#{code} *RANDOM ENEMY/i 
          poses.last_targets = [battler.opponents_unit.members.random] 
          poses.last_targets 
        when /#{code} *RANDOM FRIEND/i 
          poses.last_targets = [battler.friends_unit.members.random] 
          poses.last_targets 
        when /#{code} *ALL ENEMIES/i 
          poses.last_targets = battler.opponents_unit.members 
          poses.last_targets 
        when /#{code} *ALL FRIENDS/i 
          poses.last_targets = battler.friends_unit.members 
          poses.last_targets 
        when /#{code} *TARGETS/i 
          poses.last_targets = poses.action_targets.dup 
          poses.last_targets 
        when /#{code} *LAST/i 
          poses.last_targets 
        when /#{code} *NEXT/i 
          poses.next_target  += 1 if poses.next_target 
          poses.next_target ||= 0 
          poses.next_target  %=  poses.action_targets.size 
          poses.last_targets  = [poses.current_action_targets.first] 
          poses.last_targets 
        when /#{code} *PREVIOUS/i 
          poses.next_target  -= 1 if battler.next_target 
          poses.next_target ||= 0 
          poses.next_target  %=  poses.action_targets.size 
          poses.last_targets  = [poses.current_action_targets.first] 
          poses.last_targets 
        else 
          [battler] 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_row 
      #-------------------------------------------------------------------------- 
      def set_row(value) 
        pose = battler.sprite_value(make_symbol($1)) if value =~ /ROW (\w+)/i 
        pose = :direction if value =~ /ROW DIRECTION/i 
        pose = $1.to_i    if value =~ /ROW (\d+)/i 
        pose ? pose : 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_sufix 
      #-------------------------------------------------------------------------- 
      def set_sufix(value) 
        pose = value =~ /SUFIX ([\[\]\w]+)/i ? $1.to_s : "" 
        if pose.downcase == "[direction]" 
          pose = case poses.direction 
          when 2 then "[down]" 
          when 4 then "[left]" 
          when 6 then "[right]" 
          when 8 then "[up]" 
          end 
        end 
        pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_action_icon 
      #-------------------------------------------------------------------------- 
      def set_action_icon(value) 
        id = battler.poses.dual_flag ? 2 : 1 
        @icon_battler  = battler if value =~ /ACTIVE/i 
        @data[:weapon] = id      if value =~ /WEAPON/i 
        @data[:weapon] = $1.to_i if value =~ /WEAPON (\d+)/i 
        @data[:armor]  = $1.to_i if value =~ /ARMOR (\d+)/i 
        @data[:armor]  = 1       if value =~ /SHIELD/i 
        @data[:custom] = $1.to_i if value =~ /ICON (\d+)/i 
        @data[:action] = true    if value =~ /ACTION/i 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setl_all_frames 
      #-------------------------------------------------------------------------- 
      def setl_all_frames(value) 
        if value =~ /(?:\d+|ALL) FRAMES?/i 
          w = value =~ /WAIT (\d+)/i ? [$1.to_i, 1].max : 1 
          l = value =~ /LOOP/i   ? true : false 
          r = value =~ /RETURN/i ? true : false 
          v = value =~ /REVERT/i ? true : false 
          i = value =~ /INVERT/i ? true : false 
          f = battler.set_pose_frames(value) rescue 0 
          {wait: w, time: w, frame: f, loop: l, return: r, revert: v, invert: i} 
        else 
          {invert: value =~ /INVERT/i ? true : false } 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_wait_value 
      #-------------------------------------------------------------------------- 
      def set_wait_value(value) 
        case value 
        when /(\d+)/i 
          @data[:time] = $1.to_i 
          @data[:wait] = $1.to_i 
        when /(#{wait_words})/i 
          @data[:time] = 2 
          @data[:wait] = make_symbol($1) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_anim_id 
      #-------------------------------------------------------------------------- 
      def set_anim_id(value) 
        item = battler.poses.current_item 
        case value 
        when /CAST/i 
          cast = item && $imported[:ve_cast_animation] 
          anim = cast ? battler.cast_animation_id(item) : 0 
          anim 
        when /EFFECT/i 
          item ? item.animation_id : 0 
        when /ID (\d+)/i 
          $1.to_i 
        when /WEAPON(?: *(\d+)?)?/i 
          dual = battler.poses.dual_flag || ($1 && $1.to_i == 2) 
          dual ? battler.atk_animation_id2 : battler.atk_animation_id1 
        else 
          return 0 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: get_values 
      #-------------------------------------------------------------------------- 
      def get_values(value, code) 
        regexp = /#{code} *((?:\d+%?|, *\d+%?)+)/i 
        value.scan(regexp).inject([]) do |r, obj|  
          r += obj.first.scan(/\d+%?/i).collect {|i| i[/%/i] ? nil : i.to_i} 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: wait_words 
      #-------------------------------------------------------------------------- 
      def wait_words 
        words  = 'ANIMATION|ACTIVE|ACTION|MOVEMENT|ORIGIN|COUNTERED|COUNTER|' 
        words += 'SUBSTITUTION|TONE|THROW|POSE|FREEZE|LOG' 
        words 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: movement_words 
      #-------------------------------------------------------------------------- 
      def movement_words 
        'MOVE TO(?: FRONT)?|STEP (?:FORWARD|BACKWARD)|RETREAT|ESCAPE|SUBSTITUTION' 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: active_targets 
      #-------------------------------------------------------------------------- 
      def active_targets 
        battler.poses.current_action_targets 
      end 
    end 
    
    #============================================================================== 
    # ** Game_PoseAction 
    #------------------------------------------------------------------------------ 
    #  This class deals with battlers pose actions. 
    #============================================================================== 
    
    class Game_PoseAction 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_reader   :name 
      attr_reader   :next 
      attr_reader   :data 
      attr_reader   :layer 
      attr_reader   :battler 
      #-------------------------------------------------------------------------- 
      # * New method: initialize 
      #-------------------------------------------------------------------------- 
      def initialize(name, last, layer, battler) 
        @name    = name 
        @next    = last 
        @layer   = layer 
        @battler = battler 
        @data    = [] 
        @current = [] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: [] 
      #-------------------------------------------------------------------------- 
      def [](id) 
        @data[id] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: []= 
      #-------------------------------------------------------------------------- 
      def []=(id, value) 
        @data[id] = value 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: push 
      #-------------------------------------------------------------------------- 
      def push(value) 
        @data.push(value) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: empty? 
      #-------------------------------------------------------------------------- 
      def empty? 
        @data.empty? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: poses 
      #-------------------------------------------------------------------------- 
      def poses 
        @battler.poses 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: pose_list 
      #-------------------------------------------------------------------------- 
      def pose_list 
        @battler.poses.pose_list 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update 
      #-------------------------------------------------------------------------- 
      def update 
        setup_pose 
        update_pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_pose 
      #-------------------------------------------------------------------------- 
      def setup_pose 
        return unless @data.first && changed_pose? 
        @current = @data.dup 
        @pose    = @current.first 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: changed_pose? 
      #-------------------------------------------------------------------------- 
      def changed_pose? 
        @current.size != @data.size || @current.first.name != @data.first.name 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose 
      #-------------------------------------------------------------------------- 
      def update_pose 
        if @pose && @pose.name.symbol? 
          update_current_pose 
          next_pose unless waiting? 
        else 
          next_pose 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: next_pose 
      #-------------------------------------------------------------------------- 
      def next_pose 
        return unless @data 
        case @next 
        when :loop 
          @data.next_item 
        when :wait 
          @data.shift if @data.size > 1 
        when :reset 
          @data.shift 
        when Symbol 
          @data.shift 
          poses.pose_list.setup_pose(layer, false) if @data.empty? 
          poses.call_pose(@next, :clear)           if @data.empty? 
        else 
          last = @data.shift 
          poses.pose_list.setup_pose(layer) if !@data.empty? 
          @data.unshift(last) if @data.empty? && pose_list[@layer].empty? 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_type 
      #-------------------------------------------------------------------------- 
      def update_current_pose 
        @wait = false 
        send("update_pose_#{@pose.name}") 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: get_subjects 
      #-------------------------------------------------------------------------- 
      def get_subjects 
        @pose ? @pose.subjects.compact : [active] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: active 
      #-------------------------------------------------------------------------- 
      def active 
        @pose.active ? @pose.active : @battler 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: pose_list 
      #-------------------------------------------------------------------------- 
      def pose_list 
        poses.pose_list 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_wait 
      #-------------------------------------------------------------------------- 
      def update_pose_wait 
        case @pose[:wait] 
        when :animation 
          @pose[:time] -= 1 
          anim  = get_subjects.any? {|subject| subject.sprite.animation? } 
          @wait = anim || @pose[:time] > 0 
        when :active 
          @wait = get_subjects.any? {|subject| subject.poses.active? } 
        when :action 
          @wait = get_subjects.any? {|subject| subject.poses.action?(@layer) } 
        when :movement 
          @wait = get_subjects.any? {|subject| subject.poses.moving? } 
        when :origin 
          @wait = get_subjects.any? {|subject| subject.poses.not_origin? } 
        when :counter 
          @wait = get_subjects.any? {|subject| subject.poses.counter_on } 
        when :countered 
          @wait = get_subjects.any? {|subject| subject.poses.countered } 
        when :substitution 
          @wait = get_subjects.any? {|subject| subject.poses.substitution } 
        when :throw 
          @wait = get_subjects.any? {|subject| subject.sprite.throwing? } 
        when :pose 
          @wait = get_subjects.any? {|subject| subject.poses.pose? } 
        when :freeze 
          @wait = get_subjects.any? {|subject| subject.poses.frozen? } 
        when :tone 
          @wait = $game_troop.screen.tone_change? 
        when :log 
          @wait = SceneManager.scene.log_window_wait? 
        when Numeric 
          @pose[:time] -= 1 
          @pose[:time]  = @pose[:wait] if @pose[:time] == 0 
          @wait         = @pose[:time] != @pose[:wait] 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: waiting? 
      #-------------------------------------------------------------------------- 
      def waiting? 
        @wait 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_clear 
      #-------------------------------------------------------------------------- 
      def update_pose_clear 
        get_subjects.each do |subject| 
          subject.poses.clear_loop   if @pose[:idle] 
          subject.poses.clear_damage if @pose[:damage] 
          subject.poses.reset = true if @pose[:pose] 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_action 
      #-------------------------------------------------------------------------- 
      def update_pose_action 
        get_subjects.each do |subject| 
          item  = poses.current_item 
          layer = subject.poses.pose_list.layer + 1 
          subject.poses.clear_loop 
          subject.poses.call_pose(@pose[:action], layer, item, @battler)  
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_finish 
      #-------------------------------------------------------------------------- 
      def update_pose_finish 
        poses.attack_flag += 1 if poses.attack_flag 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_state 
      #-------------------------------------------------------------------------- 
      def update_pose_state 
        get_subjects.each do |subject| 
          @pose[:add].each    {|id| subject.add_state(id) } 
          @pose[:remove].each {|id| subject.remove_state(id) } 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_appear 
      #-------------------------------------------------------------------------- 
      def update_pose_appear 
        get_subjects.each do |subject| 
          next if subject.actor? 
          subject.appear 
          $game_troop.make_unique_names 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_transform 
      #-------------------------------------------------------------------------- 
      def update_pose_transform 
        get_subjects.each do |subject| 
          next if subject.actor? || !@pose[:id] 
          subject.transform(@pose[:id]) 
          $game_troop.make_unique_names 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_anim 
      #-------------------------------------------------------------------------- 
      def update_pose_anim 
        active.poses.anim_targets ||= [] 
        active.poses.anim_targets += get_subjects.dup 
        active.poses.anim_targets.uniq! 
        active.poses.call_anim = true 
        active.poses.animation = @pose[:anim] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_effect 
      #-------------------------------------------------------------------------- 
      def update_pose_effect 
        battler = get_subjects.include?(active) ? active : get_subjects.first 
        battler.poses.call_effect = true if battler 
        get_subjects.each do |subject| 
          battler.poses.active_effect.push(subject) if battler != subject 
          subject.poses.setup_subject(battler)      if battler != subject 
          subject.poses.damage_flag  = @pose[:damage] 
          subject.poses.attack_flag  = @pose[:weapon] if @pose[:weapon] 
          subject.poses.no_hurt_flag = @pose[:no_pose] 
          subject.poses.element_flag = @pose[:elements] 
          if @pose.targets.empty? 
            subject.poses.targets = subject.poses.action_targets 
          else 
            subject.poses.targets = @pose.targets.dup 
          end 
          subject.poses.targets.each {|target| target.clear_flag = @pose[:clear] } 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_loop 
      #-------------------------------------------------------------------------- 
      def update_pose_loop 
        get_subjects.each {|subject| subject.pose_loop = @pose[:loop_anim] } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_plane 
      #-------------------------------------------------------------------------- 
      def update_pose_plane 
        if @pose[:delete] 
          SceneManager.scene.spriteset.delete_plane(@pose[:duration]) 
        elsif @pose[:list] 
          SceneManager.scene.spriteset.action_plane(*@pose[:list]) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_sound 
      #-------------------------------------------------------------------------- 
      def update_pose_sound 
        se = RPG::SE.new(@pose[:name], @pose[:volume], @pose[:pitch]) 
        se.play 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_pose 
      #-------------------------------------------------------------------------- 
      def update_pose_pose 
        get_subjects.each do |subject| 
          poses = subject.poses 
          poses.row    = @pose[:row] - 1          if @pose[:row].numeric? 
          poses.row    = poses.direction / 2  - 1 if @pose[:row].symbol? 
          poses.sufix  = @pose[:sufix] 
          poses.angle  = @pose[:angle] 
          poses.spin   = @pose[:spin] 
          poses.x_adj  = @pose[:x] 
          poses.y_adj  = @pose[:y] 
          poses.timing = @pose[:pose] 
          poses.f_size = @pose[:size] 
          poses.frame  = (@pose[:frame] - 1) % subject.sprite_value(:frames) 
          poses.f_init = (@pose[:frame] - 1) % subject.sprite_value(:frames) 
          poses.frame  = poses.timing[:frame] if poses.timing[:revert] 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_move 
      #-------------------------------------------------------------------------- 
      def update_pose_move 
        get_subjects.each do |subject| 
          subject.poses.teleport   = @pose[:teleport] 
          subject.poses.reset_move = @pose[:reset] 
          subject.poses.move_over  = @pose[:over] 
          setup_target_position(subject) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_counter 
      #-------------------------------------------------------------------------- 
      def update_pose_counter 
        subject = poses.counter_target ? poses.counter_target : @battler 
        subject.poses.counter_on = false 
        poses.counter_target     = nil 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_substitution 
      #-------------------------------------------------------------------------- 
      def update_pose_substitution 
        substitution = @pose[:substitution] 
        get_subjects.each {|subject| subject.poses.substitution = substitution } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_jump 
      #-------------------------------------------------------------------------- 
      def update_pose_jump 
        get_subjects.each do |subject| 
          poses  = subject.poses 
          height = @pose[:height] ? @pose[:height] : 5 
          if @pose[:move] 
            x_plus = (poses.target_distance(:x) / 32.0).abs 
            y_plus = (poses.target_distance(:y) / 32.0).abs 
            speed = Math.sqrt((x_plus ** 2) + (y_plus ** 2)) / poses.move_speed 
            poses.jumping[:speed] = height * 5.0 / [speed, 1].max 
          else 
            poses.jumping[:speed] = @pose[:speed] 
          end 
          if @pose[:height] 
            poses.jumping[:reset]  = @pose[:reset] 
            poses.jumping[:height] = @pose[:height] 
            poses.jumping[:count]  = poses.jumping[:height] * 2 
          end 
        end     
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_inactive 
      #-------------------------------------------------------------------------- 
      def update_pose_inactive 
        @battler.poses.deactivate 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_inactive 
      #-------------------------------------------------------------------------- 
      def update_pose_countered 
        @battler.poses.countered = false 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_target 
      #-------------------------------------------------------------------------- 
      def update_pose_target 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_direction 
      #-------------------------------------------------------------------------- 
      def update_pose_direction 
        get_subjects.each do |subject| 
          subject.poses.origin_direction  if @pose[:return] 
          subject.poses.active_direction  if @pose[:active] 
          subject.poses.default_direction if @pose[:default] 
          subject.poses.action_direction(@pose.targets) if @pose[:targets] 
          subject.poses.direction = @pose[:direction]   if @pose[:direction] 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_condition 
      #-------------------------------------------------------------------------- 
      def update_pose_condition 
        return if condition_met || @pose[:condition] == :end 
        loop do 
          next_pose 
          setup_pose 
          break if @current.empty? || [@pose && @pose[:condition] == :end] 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_script 
      #-------------------------------------------------------------------------- 
      def update_pose_script 
        @battler.script_processing(@pose[:script]) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_icon 
      #-------------------------------------------------------------------------- 
      def update_pose_icon 
        get_subjects.each do |subject| 
          if @pose[:delete] 
            subject.poses.icon_list.delete(@pose[:index]) 
          else 
            icon = Game_PoseIcon.new(@pose, subject, subject) 
            subject.poses.icon_list[@pose[:index]] = icon 
          end 
          subject.sprite.update_icon 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_picture 
      #-------------------------------------------------------------------------- 
      def update_pose_picture 
        if @pose[:show] 
          $game_troop.screen.pictures[@pose[:id]].show(*@pose[:show]) 
        elsif @pose[:move] 
          $game_troop.screen.pictures[@pose[:id]].move(*@pose[:move]) 
        elsif @pose[:delete] 
         $game_troop.screen.pictures[@pose[:id]].erase 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_throw 
      #-------------------------------------------------------------------------- 
      def update_pose_throw 
        get_subjects.each do |subject| 
          @pose.targets.each do |target| 
            icon = Game_PoseIcon.new(@pose.data.dup, target, subject) 
            subject.poses.throw_list.push(icon) 
          end 
          subject.sprite.update_throw 
        end    
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_shake 
      #-------------------------------------------------------------------------- 
      def update_pose_shake 
        if @pose[:screen] 
          $game_troop.screen.start_shake(*@pose[:shake]) 
        else 
          get_subjects.each {|subject| subject.poses.start_shake(*@pose[:shake]) } 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_flash 
      #-------------------------------------------------------------------------- 
      def update_pose_flash 
        if @pose[:screen] 
          $game_troop.screen.start_flash(*@pose[:flash]) 
        else 
          get_subjects.each {|subject| subject.sprite.flash(*@pose[:flash]) } 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_freeze 
      #-------------------------------------------------------------------------- 
      def update_pose_freeze 
        get_subjects.each {|subject| subject.poses.freeze = @pose[:duration] } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_movie 
      #-------------------------------------------------------------------------- 
      def update_pose_movie 
        Graphics.play_movie("Movies/" + @pose[:name]) if @pose[:name] != "" 
        update_pose_tone 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_drain 
      #-------------------------------------------------------------------------- 
      def update_pose_drain 
        get_subjects.each do |subject| 
          subject.drain_setup if subject.hp_drain != 0 || subject.mp_drain != 0 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_transition 
      #-------------------------------------------------------------------------- 
      def update_pose_transition 
        if @pose[:prepare] 
          Graphics.freeze 
        elsif @pose[:execute] 
          time  = @pose[:duration] 
          name  = "Graphics/System/" + @pose[:name] 
          value = @pose[:name] == "" ? [time] : [time, name] 
          Graphics.transition(*value) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_hide 
      #-------------------------------------------------------------------------- 
      def update_pose_hide 
        hidden_list.each {|subject| subject.poses.invisible = !@pose[:unhide] } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_tone 
      #-------------------------------------------------------------------------- 
      def update_pose_tone 
        send("update_#{@pose[:priority]}_tone") 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_afterimage 
      #-------------------------------------------------------------------------- 
      def update_pose_afterimage 
        get_subjects.each do |subject| 
          if @pose[:off] 
            subject.poses.afterimage = nil 
          else 
            subject.poses.afterimage = {} 
            subject.poses.afterimage[:wait]    = @pose[:wait] 
            subject.poses.afterimage[:opacity] = @pose[:opacity] 
            subject.poses.afterimage[:color]   = @pose[:color] 
            subject.poses.afterimage[:fade]    = @pose[:fade] 
            subject.poses.afterimage[:blend]   = @pose[:blend] 
          end 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: hidden_list 
      #-------------------------------------------------------------------------- 
      def hidden_list 
        list = [] 
        if @pose[:all_battler] 
          list += BattleManager.all_battle_members 
        elsif @pose[:all_enemies] 
          list += @battler.opponents_unit 
        elsif @pose[:all_friends] 
          list += @battler.friends_unit 
        elsif @pose[:all_targets] 
          list += @battler.poses.action_targets 
        elsif @pose[:not_targets] 
          list += BattleManager.all_battle_members - @battler.poses.action_targets 
        end 
        if @pose[:exc_user] 
          list -= [active] 
        elsif @pose[:inc_user] 
          list += [active] 
        end 
        list = get_subjects.dup if list.empty? 
        list 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_low_tone 
      #-------------------------------------------------------------------------- 
      def update_low_tone 
        screen = $game_troop.screen 
        screen.old_low_tone = screen.low_tone.dup unless screen.old_low_tone 
        tone = @pose[:clear] ? screen.old_low_tone.dup : @pose[:tone]  
        $game_troop.screen.old_low_tone = nil if @pose[:clear] 
        $game_troop.screen.start_low_tone_change(tone, @pose[:duration]) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_normal_tone 
      #-------------------------------------------------------------------------- 
      def update_normal_tone 
        screen = $game_troop.screen 
        screen.old_tone = screen.tone.dup unless screen.old_tone 
        tone = @pose[:clear] ? $game_troop.screen.old_tone.dup : @pose[:tone]  
        $game_troop.screen.old_tone = nil if @pose[:clear] 
        $game_troop.screen.start_tone_change(tone, @pose[:duration]) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_high_tone 
      #--------------------------------------------------------------------------   
      def update_high_tone 
        screen = $game_troop.screen 
        screen.old_high_tone = screen.high_tone.dup unless screen.old_high_tone 
        tone = @pose[:clear] ? screen.old_high_tone.dup : @pose[:tone]  
        $game_troop.screen.old_high_tone = nil if @pose[:clear] 
        $game_troop.screen.start_high_tone_change(tone, @pose[:duration]) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: condition_met 
      #-------------------------------------------------------------------------- 
      def condition_met 
        @pose[:condition].string? && @battler.script_processing(@pose[:condition]) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_target_position 
      #-------------------------------------------------------------------------- 
      def setup_target_position(subject) 
        return unless @battler.use_sprite? 
        if @pose[:value] == :move_to 
          setup_move_to_target_position(subject) 
        elsif @pose[:value] == :move_to_front 
          setup_move_to_front_position(subject) 
        elsif @pose[:value] == :step_forward 
          setup_step_forward_position(subject) 
        elsif @pose[:value] == :step_backward 
          setup_step_backward_position(subject) 
        elsif @pose[:value] == :escape 
          setup_escape_position(subject) 
        elsif @pose[:value] == :retreat 
          setup_retreat_position(subject) 
        elsif @pose[:value] == :substitution 
          setup_substitution_position(subject) 
        end 
        return if waiting? 
        subject.poses.position_fix while subject.poses.sharing_position? 
        subject.poses.move_over = false 
        setup_final_target_position(subject) 
        subject.poses.fix_position if subject.unmovable? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_move_to_target_position 
      #-------------------------------------------------------------------------- 
      def setup_move_to_target_position(subject) 
        targets = @pose.targets.select {|member| member.use_sprite? } 
        return if targets.empty? 
        return @wait = true if targets.any? {|member| member.poses.moving? } 
        return @wait = true if targets.any? {|member| member.poses.damage_pose? } 
        x = targets.collect {|member| member.current_x}.average 
        y = targets.collect {|member| member.current_y}.average 
        subject.poses.target_position[:x] = x 
        subject.poses.target_position[:y] = y 
        return if subject.target_current? 
        subject.poses.target_direction(x, y) 
        subject.poses.adjust_position(32) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_move_to_target_position 
      #-------------------------------------------------------------------------- 
      def setup_move_to_front_position(subject) 
        targets = @pose.targets.select {|member| member.use_sprite? } 
        return if targets.empty? 
        return @wait = true if targets.any? {|member| member.poses.moving?} 
        return @wait = true if targets.any? {|member| member.poses.damage_pose? } 
        battler = targets.first 
        adjustx = battler.poses.right? ? 32 : battler.poses.left? ? -32 : 0 
        adjusty = battler.poses.down?  ? 32 : battler.poses.up?   ? -32 : 0 
        x = battler.current_x + adjustx 
        y = battler.current_y + adjusty 
        subject.poses.target_position[:x] = x 
        subject.poses.target_position[:y] = y 
        return if subject.target_current? 
        subject.poses.target_direction(x, y) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_step_forward_position 
      #-------------------------------------------------------------------------- 
      def setup_step_forward_position(subject) 
        subject.poses.adjust_position(-48) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_step_backward_position 
      #-------------------------------------------------------------------------- 
      def setup_step_backward_position(subject) 
        subject.poses.adjust_position(48) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_escape_position 
      #-------------------------------------------------------------------------- 
      def setup_escape_position(subject) 
        subject.poses.adjust_position(320) 
        subject.poses.target_direction(subject.target_x, subject.target_y) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_retreat_position 
      #-------------------------------------------------------------------------- 
      def setup_retreat_position(subject) 
        return if subject.target_origin? || subject.current_origin? 
        x = subject.poses.target_position[:x] = subject.screen_x 
        y = subject.poses.target_position[:y] = subject.screen_y 
        subject.poses.target_direction(x, y) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_substitution_position 
      #-------------------------------------------------------------------------- 
      def setup_substitution_position(subject) 
        battler = subject.poses.action_targets.first 
        subject.poses.target_position = battler.poses.current_position.dup 
        x = battler.left? ? -16 : battler.right? ? 16 : 0 
        y = battler.up?   ? -16 : battler.down?  ? 16 : 1 
        subject.poses.target_position[:x] += x 
        subject.poses.target_position[:y] += y 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_final_target_positio 
      #-------------------------------------------------------------------------- 
      def setup_final_target_position(subject) 
        poses = subject.poses 
        if subject.left?  || subject.right? 
          poses.target_position[:x] += subject.left? ? @pose[:x] : -@pose[:x] 
          poses.target_position[:y] += @pose[:y] 
        elsif subject.up? || subject.down? 
          poses.target_position[:y] += subject.up?   ? @pose[:x] : -@pose[:x] 
          poses.target_position[:x] += @pose[:y] 
        end 
        poses.target_position[:h] += @pose[:h] 
        poses.move_speed           = @pose[:speed] 
      end 
    end 
    
    #============================================================================== 
    # ** Game_PoseIcon 
    #------------------------------------------------------------------------------ 
    #  This class deals with pose icons. 
    #============================================================================== 
    
    class Game_PoseIcon 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_reader   :user 
      attr_reader   :data 
      attr_reader   :icon 
      attr_reader   :target 
      #-------------------------------------------------------------------------- 
      # * New method: initialize 
      #-------------------------------------------------------------------------- 
      def initialize(data, user, target) 
        @user   = user 
        @target = target 
        @data   = data 
        @icon   = setup_pose_icon(user) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_pose_icon 
      #-------------------------------------------------------------------------- 
      def setup_pose_icon(subject) 
        icon = subject.weapon_icon(@data[:weapon]) if @data[:weapon] 
        icon = subject.armor_icon(@data[:armor])   if @data[:armor] 
        icon = subject.action_icon if @data[:action] 
        icon = @data[:custom]      if @data[:custom] 
        icon = @data[:image]       if @data[:image] 
        icon ? icon : 0 
      end 
    end 
    
    #============================================================================== 
    # ** Game_PoseList 
    #------------------------------------------------------------------------------ 
    #  This class deals with battlers pose list. 
    #============================================================================== 
    
    class Game_PoseList 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_reader   :data 
      attr_reader   :pose 
      attr_reader   :list 
      attr_reader   :name 
      #-------------------------------------------------------------------------- 
      # * New method: initialize 
      #-------------------------------------------------------------------------- 
      def initialize(battler) 
        @battler = battler 
        @data    = {} 
        @pose    = {} 
        @list    = {} 
        @name    = {} 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: [] 
      #-------------------------------------------------------------------------- 
      def [](id) 
        @data[id] ||= [] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: []= 
      #-------------------------------------------------------------------------- 
      def []=(id, value) 
        @data[id] = value 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: insert 
      #-------------------------------------------------------------------------- 
      def insert(id, index, value) 
        self[id].insert(index, *value) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: shift 
      #-------------------------------------------------------------------------- 
      def shift(id) 
        self[id].shift 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: delete 
      #-------------------------------------------------------------------------- 
      def delete(value) 
        @data.delete(value) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: include? 
      #-------------------------------------------------------------------------- 
      def include?(pose) 
        all_names.include?(pose) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: keys 
      #-------------------------------------------------------------------------- 
      def keys 
        @data.keys.compact.collect {|key| yield key } if block_given? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: any? 
      #-------------------------------------------------------------------------- 
      def any? 
        @data.keys.compact.any? {|key| yield key } if block_given? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update 
      #-------------------------------------------------------------------------- 
      def update 
        @data.keys.compact.each do |key| 
          setup_pose(key)  if @pose[key] != self[key].first 
          update_pose(key) if @pose[key] 
          self.delete(key) if self[key].empty? && key != 1 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_pose 
      #-------------------------------------------------------------------------- 
      def setup_pose(key, update = true) 
        @pose[key] = self[key].first 
        @name[key] = @pose[key] ? @pose[key].name : nil 
        @list[key] = self[key].collect {|value| value.name } 
        @battler.poses.icon_list.clear if !inactive_pose?(@name[key]) 
        @pose[key].update if @pose[key] && update 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose 
      #-------------------------------------------------------------------------- 
      def update_pose(key) 
        @pose[key].update 
        return if @pose[key].waiting? || !@pose[key].empty? 
        self[key].shift 
        self[key].shift if no_retreat?(first_name(key)) 
        @battler.reset_pose if @pose[key].next == :reset 
        @battler.poses.afterimage = nil 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: first_name 
      #-------------------------------------------------------------------------- 
      def first_name(key = 1) 
        self[key].first ? self[key].first.name : nil 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: all_names 
      #-------------------------------------------------------------------------- 
      def all_names 
        @data.keys.compact.inject([]) {|r, key| r += get_names(key) } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: get_names 
      #-------------------------------------------------------------------------- 
      def get_names(key) 
        self[key].collect {|value| value.name } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_all_poses 
      #-------------------------------------------------------------------------- 
      def setup_all_poses 
        @data.keys.compact.reverse.each do |key| 
          self[key].first.setup_pose if self[key].first 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: layer 
      #-------------------------------------------------------------------------- 
      def layer 
        @data.keys.compact.size 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: clear_loop 
      #-------------------------------------------------------------------------- 
      def clear_loop 
        keys {|key| self[key].delete_if {|pose| pose.next == :loop } } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: clear_damage 
      #-------------------------------------------------------------------------- 
      def clear_damage 
        keys {|key| self[key].delete_if {|pose| is_damage_pose?(pose.name)} } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: is_damage_pose? 
      #-------------------------------------------------------------------------- 
      def is_damage_pose?(name) 
        name == :hurt || name == :miss || name == :evade || name == :critical 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: damage_pose? 
      #-------------------------------------------------------------------------- 
      def damage_pose? 
        any? {|key| self[key].first && is_damage_pose?(self[key].first.name) } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: inactive_pose? 
      #-------------------------------------------------------------------------- 
      def inactive_pose?(name) 
        name.nil? || name == :inactive || name == :finish || name == :retreat 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: no_retreat? 
      #-------------------------------------------------------------------------- 
      def no_retreat?(name) 
        name == :retreat && @battler.current_origin? 
      end 
    end 
    
    #============================================================================== 
    # ** Sprite_Battler 
    #------------------------------------------------------------------------------ 
    #  This sprite is used to display battlers. It observes a instance of the 
    # Game_Battler class and automatically changes sprite conditions. 
    #============================================================================== 
    
    class Sprite_Battler < Sprite_Base 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_accessor :battler 
      attr_reader   :battler_name 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: update_bitmap 
      #-------------------------------------------------------------------------- 
      def update_bitmap 
        setup_bitmap if graphic_changed? 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: init_visibility 
      #-------------------------------------------------------------------------- 
      def init_visibility 
        @battler_visible = !@battler.hidden? 
        self.opacity = 0 unless @battler_visible 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: update_origin 
      #-------------------------------------------------------------------------- 
      def update_origin 
        update_rect if bitmap 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: initialize 
      #-------------------------------------------------------------------------- 
      alias :initialize_ve_animated_battle :initialize 
      def initialize(viewport, battler = nil) 
        initialize_ve_animated_battle(viewport, battler) 
        init_variables 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: update_effect 
      #-------------------------------------------------------------------------- 
      alias :update_effect_ve_animated_battle :update_effect 
      def update_effect 
        setup_collapse 
        update_effect_ve_animated_battle 
        update_pose 
        update_afterimage 
        update_pose_loop if $imported[:ve_loop_animation] 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: revert_to_normal 
      #-------------------------------------------------------------------------- 
      alias :revert_to_normal_ve_animated_battle :revert_to_normal 
      def revert_to_normal 
        revert_to_normal_ve_animated_battle 
        update_rect if bitmap 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: setup_new_effect 
      #-------------------------------------------------------------------------- 
      alias :setup_new_effect_ve_animated_battle :setup_new_effect 
      def setup_new_effect 
        if @battler_visible && !@invisible && @battler.poses.invisible 
          @invisible = true 
          @effect_type = :disappear 
          @effect_duration = 12 
        elsif @battler_visible && @invisible && !@battler.poses.invisible 
          @invisible = false 
          @effect_type = :appear 
          @effect_duration = 12 
        end 
        setup_new_effect_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: init_variables 
      #-------------------------------------------------------------------------- 
      def init_variables 
        @spin  = 0 
        @frame = 0 
        @sufix = "" 
        @pose_sufix = "" 
        @anim_sufix = VE_SPRITE_SUFIX 
        @returning    = 0 
        @frame_width  = 0 
        @frame_height = 0 
        @icon_list    = {} 
        @throw_list   = [] 
        @afterimage_wait    = 0 
        @afterimage_sprites = [] 
        start_effect(:appear) if $game_system.intro_fade && !@battler.hidden? 
        poses.clear_poses 
        setup_positions 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_collapse 
      #-------------------------------------------------------------------------- 
      def setup_collapse 
        if @battler.dead? && !@dead 
          @battler.perform_collapse_effect if !@fast_collapse 
          @battler.perform_fast_collapse   if  @fast_collapse 
          @fast_collapse = false 
          @dead = true 
        elsif @dead && !@battler.dead? 
          @dead = false 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: subject 
      #-------------------------------------------------------------------------- 
      def subject 
        @pose_battler ? @pose_battler : @battler 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: poses 
      #-------------------------------------------------------------------------- 
      def poses 
        @battler.poses 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: sprite_value 
      #-------------------------------------------------------------------------- 
      def sprite_value(value) 
        @battler.sprite_value(value) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: graphic_changed? 
      #-------------------------------------------------------------------------- 
      def graphic_changed? 
        actor_name_change? || battler_name_change? || misc_change? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: actor_name_change? 
      #-------------------------------------------------------------------------- 
      def actor_name_change? 
        use_charset? && (@battler_name != @battler.character_name || 
        @battler_index != @battler.character_index || 
        @battler_hue   != @battler.character_hue) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: battler_name_change? 
      #-------------------------------------------------------------------------- 
      def battler_name_change? 
        !use_charset? && (@battler_name != @battler.battler_name || 
        @battler_hue  != @battler.battler_hue) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: misc_change? 
      #-------------------------------------------------------------------------- 
      def misc_change? 
        (visual_equip? && @visual_items != @battler.visual_items) || 
         @direction != poses.direction || @frame_size != poses.f_size || 
         @sufix != poses.sufix 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: use_charset? 
      #-------------------------------------------------------------------------- 
      def use_charset? 
        sprite_value(:mode) == :charset 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: visual_equip? 
      #-------------------------------------------------------------------------- 
      def visual_equip? 
        $imported[:ve_visual_equip] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: collapse? 
      #-------------------------------------------------------------------------- 
      def collapse? 
        @effect_type == :collapse || @effect_type == :custom_collapse 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_bitmap 
      #-------------------------------------------------------------------------- 
      def setup_bitmap 
        if use_charset? 
          @battler_name  = @battler.character_name 
          @battler_hue   = @battler.character_hue 
          @battler_index = @battler.character_index 
        else 
          @battler_name  = @battler.battler_name 
          @battler_hue   = @battler.battler_hue 
        end 
        @frame_size   = poses.f_size 
        @sufix        = poses.sufix 
        @direction    = poses.direction 
        @visual_items = @battler.visual_items.dup if visual_equip? 
        init_bitmap 
        init_frame 
        init_visibility 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: init_bitmap 
      #-------------------------------------------------------------------------- 
      def init_bitmap 
        self.bitmap = setup_bitmap_sprite 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_bitmap_sprite 
      #-------------------------------------------------------------------------- 
      def setup_bitmap_sprite 
        case sprite_value(:mode) 
        when :charset 
          if visual_equip? 
            args = [@battler_name, @battler_hue, @visual_items, sufix] 
            Cache.character(*args) 
          else 
            Cache.character(get_character_name, @battler_hue) 
          end 
        when :single 
          Cache.battler(get_battler_name, @battler_hue) 
        when :sprite 
          Cache.battler(get_battler_name, @battler_hue) 
        else 
          Cache.battler(@battler_name, @battler_hue) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: sufix 
      #-------------------------------------------------------------------------- 
      def sufix 
        case sprite_value(:mode) 
        when :charset then @sufix 
        when :sprite  then @anim_sufix + @sufix 
        else @sufix 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: get_battler_name 
      #-------------------------------------------------------------------------- 
      def get_battler_name 
        name = @battler_name + sufix 
        battler_exist?(name) ? name : @battler_name 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: get_character_name 
      #-------------------------------------------------------------------------- 
      def get_character_name 
        name = @battler_name + sufix 
        character_exist?(name) ? name : @battler_name 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: init_frame 
      #-------------------------------------------------------------------------- 
      def init_frame 
        @frame_width  = bitmap.width  / frame_number 
        @frame_height = bitmap.height / row_number 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: frame_number 
      #-------------------------------------------------------------------------- 
      def frame_number 
        return poses.frames     if single_char? 
        return poses.frames * 4 if multi_char? 
        return 1 unless battler_exist?(@battler_name + sufix) 
        return poses.f_size     if poses.f_size 
        return sprite_value(:frames) if sprite_value(:mode) == :sprite 
        return 1 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: row_number 
      #-------------------------------------------------------------------------- 
      def row_number 
        return 4 if single_char? 
        return 8 if multi_char? 
        return 1 unless battler_exist?(@battler_name + sufix) 
        return sprite_value(:rows) if sprite_value(:mode) == :sprite 
        return 1 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: single_char? 
      #-------------------------------------------------------------------------- 
      def single_char? 
        use_charset? && (single_normal? && !visual_equip?) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: multi_char? 
      #-------------------------------------------------------------------------- 
      def multi_char? 
        use_charset? && (multi_normal? || visual_equip?) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: single_normal? 
      #-------------------------------------------------------------------------- 
      def single_normal? 
        !visual_equip? && @battler_name[/^[!]?[$]./] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: multi_normal? 
      #-------------------------------------------------------------------------- 
      def multi_normal? 
        !visual_equip? && !@battler_name[/^[!]?[$]./] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: get_sign 
      #-------------------------------------------------------------------------- 
      def get_sign 
        @visual_items.any? {|part| !part[:name][/^[!]?[$]./] } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_rect 
      #-------------------------------------------------------------------------- 
      def update_rect 
        setup_frame2 
        setup_rect 
        self.ox = @frame_width / 2 
        self.oy = @frame_height 
        self.mirror = pose_mirror 
        reset_frame if poses.reset 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: pose_mirror 
      #-------------------------------------------------------------------------- 
      def pose_mirror 
        mirror = sprite_value(:invert) 
        mirror = !mirror if timing && timing[:invert] 
        mirror = !mirror if right? && sprite_value(:mirror) 
        mirror 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: down? 
      #-------------------------------------------------------------------------- 
      def down? 
        poses.down? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: left? 
      #-------------------------------------------------------------------------- 
      def left? 
        poses.left? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: right? 
      #-------------------------------------------------------------------------- 
      def right? 
        poses.right? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: up? 
      #-------------------------------------------------------------------------- 
      def up? 
        poses.up? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: timing 
      #-------------------------------------------------------------------------- 
      def timing 
        poses.timing 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_frame 
      #-------------------------------------------------------------------------- 
      def setup_frame2 
        return if !poses.pose? 
        timing[:time] -= 1 
        timing[:time]  = timing[:wait] if timing[:time] == 0 
        return if timing[:time] != timing[:wait] 
        return if poses.reset 
        update_frame 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_frame 
      #-------------------------------------------------------------------------- 
      def update_frame 
        @max_frame = timing[:frame] 
        @min_frame = poses.f_init 
        update_frame_return if  timing[:return] && !timing[:revert] 
        update_frame_revert if !timing[:return] &&  timing[:revert] 
        update_frame_normal if !timing[:return] && !timing[:revert] 
        poses.frame = [@frame, sprite_value(:frames) - 1].min 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_frame_return 
      #-------------------------------------------------------------------------- 
      def update_frame_return 
        @returning += 1 
        @frame = returning_value(@returning, @max_frame) 
        poses.reset = true if !timing[:loop] && @returning > @max_frame * 2 - 1 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_frame_revert 
      #-------------------------------------------------------------------------- 
      def update_frame_revert 
        @frame -= 1  
        @frame  = @max_frame if @frame < @min_frame 
        poses.reset = true   if !timing[:loop] && @frame < @min_frame 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_frame_normal 
      #-------------------------------------------------------------------------- 
      def update_frame_normal 
        @frame += 1 
        @frame  = @min_frame if @frame < @min_frame || @frame > @max_frame + 1 
        poses.reset = true   if !timing[:loop] && @frame > @max_frame 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: reset_frame 
      #-------------------------------------------------------------------------- 
      def reset_frame 
        invert       = timing[:invert] 
        poses.timing = {invert: invert} 
        poses.reset  = false 
        @returning   = 0 
        @frame       = 0 
        @spin        = 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_rect 
      #-------------------------------------------------------------------------- 
      def setup_rect 
        sign = @battler_name[/^[$]./] 
        if use_charset? && !sign 
          index = @battler_index 
          frame = (index % 4 * poses.frames + poses.frame) * @frame_width 
          row   = (index / 4 * 4 + poses.row) * @frame_height 
        else 
          frame = [[poses.frame, 0].max, frame_number - 1].min * @frame_width 
          row   = [[poses.row,   0].max,   row_number - 1].min * @frame_height 
        end 
        self.src_rect.set(frame, row, @frame_width, @frame_height) 
      end   
      #-------------------------------------------------------------------------- 
      # * New method: update_pose 
      #-------------------------------------------------------------------------- 
      def update_pose 
        poses.pose_list.update 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: reset_pose 
      #-------------------------------------------------------------------------- 
      def reset_pose 
        next_pose = get_idle_pose 
        return if next_pose == poses.pose_list.name 
        reset_frame 
        poses.clear_loop 
        poses.call_pose(next_pose) 
        poses.pose_list.setup_all_poses 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: get_idle_pose 
      #-------------------------------------------------------------------------- 
      def get_idle_pose 
        value = :idle 
        value = :danger if @battler.danger? 
        value = :guard  if @battler.guard? 
        value = poses.state_pose  if poses.state_pose? 
        value = poses.active_pose if poses.active_pose 
        value = poses.cast_pose   if cast_pose? 
        value = :escaping if escaping? && @battler.actor? 
        value = :dead     if @battler.dead? 
        value 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: cast_pose? 
      #-------------------------------------------------------------------------- 
      def cast_pose? 
        $imported[:ve_active_time_battle] && @battler.cast_action && 
        @battler.cast_action.item 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: escaping? 
      #-------------------------------------------------------------------------- 
      def escaping? 
        $imported[:ve_active_time_battle] && BattleManager.escaping? && 
        VE_ATB_ESCAPING_ANIM 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_positions 
      #-------------------------------------------------------------------------- 
      def setup_positions 
        positions   = {x: @battler.screen_x, y: @battler.screen_y, h: 0, j: 0} 
        poses.target_position  = positions.dup 
        poses.current_position = positions.dup 
        poses.jumping   = {count: 0, height: 0, speed: 10} 
        @fast_collapse = true if @battler.dead? && @battler.collapse_type != 3 
        reset_pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: position 
      #-------------------------------------------------------------------------- 
      def position 
        poses.current_position 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_position 
      #-------------------------------------------------------------------------- 
      def update_position 
        update_misc 
        update_movement 
        update_jumping 
        self.x  = position[:x] + adjust_x 
        self.y  = position[:y] + adjust_y 
        self.z  = [[self.y / (Graphics.height / 100.0), 1].max, 100].min 
        self.ox = @frame_width / 2 
        self.oy = @frame_height + position[:h] + position[:j]  
        @spin += 1 if Graphics.frame_count % 2 == 0 
        self.angle = poses.angle + poses.spin * @spin 
        update_ajust 
        update_icon 
        update_throw 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_movement 
      #-------------------------------------------------------------------------- 
      def update_ajust 
        angle_move(:x, sprite_value(:ox)) if sprite_value(:ox) 
        angle_move(:y, sprite_value(:oy)) if sprite_value(:oy) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: angle_move 
      #-------------------------------------------------------------------------- 
      def angle_move(axis, amount) 
        a = (360 - angle) * Math::PI / 180 
        cos = Math.cos(a) 
        sin = Math.sin(a) 
        self.ox += (axis == :x ? -cos : -sin) * amount 
        self.oy += (axis == :x ?  sin : -cos) * amount 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_misc 
      #-------------------------------------------------------------------------- 
      def update_misc 
        poses.update_shake 
        poses.update_freeze 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: adjust_x 
      #-------------------------------------------------------------------------- 
      def adjust_x 
        poses.x_adj + [1, -1].random * rand(poses.shake + 1) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: adjust_y 
      #-------------------------------------------------------------------------- 
      def adjust_y 
        poses.y_adj + [1, -1].random * rand(poses.shake + 1) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_movement 
      #-------------------------------------------------------------------------- 
      def update_movement 
        return if poses.frozen? || !poses.moving? 
        poses.teleport ? update_teleport_movement : update_normal_movement 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_teleport_movement 
      #-------------------------------------------------------------------------- 
      def update_teleport_movement 
        poses.current_position[:x] = poses.target_position[:x] 
        poses.current_position[:y] = poses.target_position[:y] 
        poses.current_position[:h] = [poses.target_position[:h], 0].max 
        poses.teleport = false 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_afterimage 
      #--------------------------------------------------------------------------   
      def update_afterimage 
        update_afterimage_sprites 
        setup_afterimage_sprites if poses.afterimage && @afterimage_wait <= 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_afterimage_sprites 
      #--------------------------------------------------------------------------   
      def update_afterimage_sprites 
        @afterimage_wait -= 1 if @afterimage_wait > 0 
        @afterimage_sprites.each do |sprite|  
          sprite.update 
          next if sprite.opacity > 0 
          sprite.dispose 
          @afterimage_sprites.delete(sprite) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_afterimage_sprites 
      #--------------------------------------------------------------------------   
      def setup_afterimage_sprites 
        @afterimage_sprites.push(Sprite_AfterImage.new(self)) 
        @afterimage_wait = poses.afterimage[:wait] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_normal_movement 
      #-------------------------------------------------------------------------- 
      def update_normal_movement 
        distance = set_distance 
        move     = {x: 1.0, y: 1.0, h: 1.0} 
        if distance[:x].abs < distance[:y].abs 
          move[:x] = 1.0 / (distance[:y].abs.to_f / distance[:x].abs) 
        elsif distance[:y].abs < distance[:x].abs 
          move[:y] = 1.0 / (distance[:x].abs.to_f / distance[:y].abs) 
        elsif distance[:h].abs < distance[:x].abs 
          move[:h] = 1.0 / (distance[:x].abs.to_f / distance[:h].abs) 
        end 
        speed = set_speed(distance) 
        x = move[:x] * speed[:x] 
        y = move[:y] * speed[:y] 
        h = move[:h] * speed[:h] 
        set_movement(x, y, h) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_distance 
      #-------------------------------------------------------------------------- 
      def set_distance 
        x = poses.target_distance(:x) 
        y = poses.target_distance(:y) 
        h = poses.target_distance(:h) 
        {x: x, y: y, h: h} 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_speed 
      #-------------------------------------------------------------------------- 
      def set_speed(distance) 
        move_speed = poses.move_speed 
        x = move_speed * (distance[:x] == 0 ? 0 : (distance[:x] > 0 ? 8 : -8)) 
        y = move_speed * (distance[:y] == 0 ? 0 : (distance[:y] > 0 ? 8 : -8)) 
        h = move_speed * (distance[:h] == 0 ? 0 : (distance[:h] > 0 ? 8 : -8)) 
        {x: x, y: y, h: h} 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_movement 
      #-------------------------------------------------------------------------- 
      def set_movement(x, y, h) 
        target  = poses.target_position 
        current = poses.current_position 
        current[:x] += x 
        current[:y] += y 
        current[:h] += h 
        current[:x] = target[:x] if in_distance?(current[:x], target[:x], x) 
        current[:y] = target[:y] if in_distance?(current[:y], target[:y], y) 
        current[:h] = target[:h] if in_distance?(current[:h], target[:h], h) 
        reset_move if poses.reset_move && !poses.moving? 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: reset_move 
      #-------------------------------------------------------------------------- 
      def reset_move 
        poses.reset_move = nil 
        poses.call_pose(:reset, :clear) 
        poses.targets_direction 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: in_distance? 
      #-------------------------------------------------------------------------- 
      def in_distance?(x, y, z) 
        x.between?(y - z - 1, y + z + 1) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_jumping 
      #-------------------------------------------------------------------------- 
      def update_jumping 
        return if poses.jumping[:count] == 0 || poses.frozen? 
        jump = poses.jumping 
        jump[:count] = [jump[:count] - (1 * jump[:speed] / 10.0), 0].max.to_f 
        count  = jump[:count] 
        speed  = jump[:speed] 
        peak   = jump[:height] 
        result = (peak ** 2 - (count - peak).abs ** 2) / 2 
        poses.current_position[:j] = [result, 0].max 
        if poses.current_position[:j] == 0 
          jump[:count] = 0 
          reset_move if jump[:reset] 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_icon 
      #-------------------------------------------------------------------------- 
      def update_icon 
        poses.icon_list.each do |key, value| 
          @icon_list[key] = Sprite_Icon.new(value) unless @icon_list[key] 
          @icon_list[key].refresh(value) if @icon_list[key].changed_icon?(value) 
        end 
        @icon_list.each do |key, value| 
          value.update 
          delete_icon(key) if value && !poses.icon_list[key] 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_throw 
      #-------------------------------------------------------------------------- 
      def update_throw 
        poses.throw_list.each do |value| 
          @throw_list.push(Sprite_Throw.new(value)) 
          poses.throw_list.delete(value) 
        end 
        @throw_list.each_with_index do |value, index| 
          value.update 
          delete_throw(index) if value.disposing? 
        end 
        @throw_list.compact! 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: delete_icon 
      #-------------------------------------------------------------------------- 
      def delete_icon(key) 
        @icon_list[key].dispose 
        @icon_list.delete(key) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: delete_throw 
      #-------------------------------------------------------------------------- 
      def delete_throw(index) 
        @throw_list[index].dispose 
        @throw_list.delete_at(index) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: throwing? 
      #-------------------------------------------------------------------------- 
      def throwing? 
        @throw_list.any? {|value| value.target == @battler } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose_loop 
      #-------------------------------------------------------------------------- 
      def update_pose_loop 
        if poses.pose_loop && !loop_anim?(:pose_anim) 
          @pose_name = poses.pose_name 
          animation  = {type: :pose_anim, anim: poses.pose_loop, loop: 1}      
          add_loop_animation(animation) 
        end 
        if poses.pose_loop && loop_anim?(:pose_anim) &&  
           @pose_name_list != poses.pose_name.first 
          @pose_loop = nil 
          poses.pose_loop = nil 
          end_loop_anim(:pose_anim) 
        end 
      end 
    end 
    
    #============================================================================== 
    # ** Spriteset_Battle 
    #------------------------------------------------------------------------------ 
    #  This class brings together battle screen sprites. It's used within the 
    # Scene_Battle class. 
    #============================================================================== 
    
    #============================================================================== 
    # ** Sprite_AfterImag 
    #------------------------------------------------------------------------------ 
    #  This sprite is used to display battlers afterimages. 
    #============================================================================== 
    
    class Sprite_AfterImage < Sprite_Battler 
      #-------------------------------------------------------------------------- 
      # * New method: initialize 
      #-------------------------------------------------------------------------- 
      def initialize(sprite) 
        info = sprite.battler.poses.afterimage 
        @afterimage_opacity  = [info[:opacity], sprite.opacity].min 
        @afterimage_fade     = info[:fade] 
        @afterimage_color    = info[:color] 
        @afterimage_blend    = info[:blend] 
        @original_battler    = sprite.battler 
        @battler_icons       = @original_battler.poses.icon_list.dup 
        @poses               = @original_battler.poses.clone 
        super(sprite.viewport, @original_battler.dup) 
        update_icon 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: poses 
      #-------------------------------------------------------------------------- 
      def poses 
        @poses  
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update 
      #-------------------------------------------------------------------------- 
      def update 
        super 
        self.color.set(*@afterimage_color) 
        self.blend_type      = @afterimage_blend 
        self.opacity         = @afterimage_opacity 
        @afterimage_opacity -= @afterimage_fade 
        update_icon 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: init_bitmap 
      #-------------------------------------------------------------------------- 
      def init_bitmap 
        self.bitmap = setup_bitmap_sprite.clone 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_positions 
      #-------------------------------------------------------------------------- 
      def setup_positions 
        poses.current_position       = @original_battler.poses.current_position.dup 
        poses.target_position        = poses.current_position  
        @sufix     = poses.sufix     = @original_battler.poses.sufix 
        @frame     = poses.frame     = @original_battler.poses.frame 
        @direction = poses.direction = @original_battler.poses.direction 
        poses.jumping = {count: 0, height: 0, speed: 10} 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_icon 
      #-------------------------------------------------------------------------- 
      def update_icon 
        @battler_icons.each do |key, value| 
          @icon_list[key] = Sprite_Icon.new(value) unless @icon_list[key] 
          @icon_list[key].refresh(value) if @icon_list[key].changed_icon?(value) 
        end 
        @icon_list.each do |key, value| 
          value.update 
          value.opacity    = self.opacity 
          value.blend_type = self.blend_type 
          value.color.set(*@afterimage_color) 
          delete_icon(key) if value && !@battler_icons[key] 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_pose 
      #-------------------------------------------------------------------------- 
      def update_pose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_afterimage 
      #-------------------------------------------------------------------------- 
      def update_afterimage 
      end 
    end 
    
    #============================================================================== 
    # ** Sprite_IconBase 
    #------------------------------------------------------------------------------ 
    #  This the base sprite used to display icons and throw animations. 
    #============================================================================== 
    
    class Sprite_IconBase < Sprite_Base 
      #-------------------------------------------------------------------------- 
      # * Public Instance Variables 
      #-------------------------------------------------------------------------- 
      attr_reader   :data 
      attr_reader   :user 
      attr_reader   :icon 
      attr_reader   :value 
      attr_reader   :target 
      #-------------------------------------------------------------------------- 
      # * New method: initialize 
      #-------------------------------------------------------------------------- 
      def initialize(viewport) 
        super(viewport) 
        @right    = user.right? 
        @left     = user.left? 
        @down     = user.down? 
        @up       = user.up? 
        @spin     = 0 
        @zooming  = 0 
        @fade_in  = 0 
        @fade_out = 0 
        self.zoom_x = @data[:izm] 
        self.zoom_y = @data[:izm] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: refresh 
      #--------------------------------------------------------------------------  
      def refresh(value) 
        @user   = value.user 
        @target = value.target 
        @icon   = value.icon 
        @data   = value.data.dup 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: changed_icon? 
      #-------------------------------------------------------------------------- 
      def changed_icon?(value) 
        @user != value.user || @target != value.target || @icon != value.icon || 
        @data != value.data 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update 
      #-------------------------------------------------------------------------- 
      def update 
        super 
        update_zoom 
        update_angle 
        update_opacity 
        update_position 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_opacity 
      #-------------------------------------------------------------------------- 
      def update_opacity 
        if @data[:fin] > 0 
          @fade_in += 1 
          self.opacity = [@fade_in * @data[:fin], @data[:o]].min 
        elsif @data[:fout] > 0 
          @fade_out += 1 
          self.opacity = [@data[:o] - @fade_out * @data[:fin], 0].max 
        else 
          self.opacity =  @data[:o] 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_angle 
      #-------------------------------------------------------------------------- 
      def update_angle 
        @spin      += 1 if Graphics.frame_count % 2 == 0 
        self.angle  = @data[:a] + @data[:spin] * @spin 
        self.angle *= -1 if @right  
        self.angle -= 90 if @up 
        self.angle += 90 if @down 
        self.angle  = 360 + self.angle if self.angle < 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_zoom 
      #-------------------------------------------------------------------------- 
      def update_zoom 
        if self.zoom_x < @data[:ezm] 
          @zooming += 1 
          self.zoom_x = [@data[:izm] + @zooming * @data[:szm], @data[:ezm]].min 
          self.zoom_y = [@data[:izm] + @zooming * @data[:szm], @data[:ezm]].min 
        elsif self.zoom_x > @data[:ezm] 
          @zooming += 1 
          self.zoom_x = [@data[:izm] - @zooming * @data[:szm], @data[:ezm]].max 
          self.zoom_y = [@data[:izm] - @zooming * @data[:szm], @data[:ezm]].max 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_icon 
      #-------------------------------------------------------------------------- 
      def setup_icon 
        @current_icon = @icon 
        if @icon.string? 
          self.bitmap = Cache.picture(icon) 
          self.src_rect.set(0, 0, bitmap.width, bitmap.height) 
          @icon_ox = bitmap.width  / 2 
          @icon_oy = bitmap.height / 2 
        else 
          self.bitmap = Cache.system("Iconset") 
          size = bitmap.width / 16 
          self.src_rect.set(icon % 16 * size, icon / 16 * size, size, size) 
          @icon_ox = size / 2 
          @icon_oy = size / 2 
        end 
      end   
    end 
    
    #============================================================================== 
    # ** Sprite_Icon 
    #------------------------------------------------------------------------------ 
    #  This sprite is used to display icons. 
    #============================================================================== 
    
    class Sprite_Icon < Sprite_IconBase 
      #-------------------------------------------------------------------------- 
      # * New method: initialize 
      #-------------------------------------------------------------------------- 
      def initialize(value) 
        refresh(value) 
        super(target.sprite.viewport) 
        setup_icon 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_position 
      #-------------------------------------------------------------------------- 
      def update_position 
        setup_icon if @current_icon != @icon 
        self.x      = user.sprite.x 
        self.y      = user.sprite.y - 1 
        self.z      = user.sprite.z + (@data[:above] ? 1 : 0) 
        self.ox     = @icon_ox 
        self.oy     = @icon_oy 
        self.mirror = @right 
        update_movement 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_movement 
      #-------------------------------------------------------------------------- 
      def update_movement 
        if @right || @left 
          angle_move(:x, (@right ? adjust_x : -adjust_x)) 
          angle_move(:y, adjust_y) 
        elsif @up || @down 
          angle_move(:x, (@down ? adjust_y : -adjust_y)) 
          angle_move(:y, (@down ? adjust_x : -adjust_x) - 8) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: angle_move 
      #-------------------------------------------------------------------------- 
      def angle_move(axis, amount) 
        a = (360 - angle) * Math::PI / 180 
        cos = Math.cos(a) 
        sin = Math.sin(a) 
        self.ox += (axis == :x ? -cos : -sin) * amount 
        self.oy += (axis == :x ?  sin : -cos) * amount 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: adjust_x 
      #-------------------------------------------------------------------------- 
      def adjust_x 
        user.sprite.ox / 2 - @data[:x]  
      end 
      #-------------------------------------------------------------------------- 
      # * New method: adjust_y 
      #-------------------------------------------------------------------------- 
      def adjust_y 
        @data[:y] - (position[:h] + position[:j] + user.sprite.oy) / 2 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: position 
      #-------------------------------------------------------------------------- 
      def position 
        user.sprite.position 
      end 
    end 
    
    #============================================================================== 
    # ** Sprite_Throw 
    #------------------------------------------------------------------------------ 
    #  This sprite is used to display throw animations. 
    #============================================================================== 
    
    class Sprite_Throw < Sprite_IconBase 
      #-------------------------------------------------------------------------- 
      # * New method: initialize 
      #-------------------------------------------------------------------------- 
      def initialize(value) 
        refresh(value) 
        super(target.sprite.viewport) 
        setup_throw 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_throw 
      #-------------------------------------------------------------------------- 
      def setup_throw 
        set_initial_position 
        setup_arc 
        setup_icon 
        setup_animation if $imported[:ve_loop_animation] && @data[:anim] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_initial_position 
      #-------------------------------------------------------------------------- 
      def set_initial_position 
        value = set_initial_values(user, target)  
        value = set_initial_values(target, user) if @data[:return] 
        @current_position[:x] += @data[:init_x] + value[:init_ox] 
        @current_position[:y] += @data[:init_y] + value[:init_oy] 
        @target_position[:x]  += @data[:end_x]  + value[:end_ox] 
        @target_position[:y]  += @data[:end_y]  + value[:end_oy] 
        @initial_position = @current_position.dup 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_initial_values 
      #-------------------------------------------------------------------------- 
      def set_initial_values(battler1, battler2) 
        @current_position = battler1.sprite.position.dup 
        @target_position  = battler2.sprite.position.dup 
        x1 = battler1.right? ? -@data[:init_x] : @data[:init_x] 
        y1 = battler1.up?    ? -@data[:init_x] : @data[:init_x] 
        x2 = battler2.right? ? -@data[:end_x]  : @data[:end_x] 
        y2 = battler2.up?    ? -@data[:end_y]  : @data[:end_y] 
        {init_ox:  x1, init_oy: y1, end_ox: x2, end_oy: y2} 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_arc 
      #-------------------------------------------------------------------------- 
      def setup_arc 
        @arc   = {} 
        x_plus = (target_distance(:x) / 32.0).abs 
        y_plus = (target_distance(:y) / 32.0).abs 
        speed  = Math.sqrt((x_plus ** 2) + (y_plus ** 2)) / @data[:speed] 
        @arc[:speed]  = @data[:arc] * 5.0 / [speed, 1].max 
        @arc[:height] = @data[:arc] 
        @arc[:count]  = @data[:arc] * 2 
        @current_position[:a] = 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_icon 
      #-------------------------------------------------------------------------- 
      def setup_icon 
        super 
        self.angle = @data[:a] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_animation 
      #-------------------------------------------------------------------------- 
      def setup_animation 
        animation = {type: :throw, anim: @data[:anim], loop: 1} 
        add_loop_animation(animation) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update 
      #-------------------------------------------------------------------------- 
      def update 
        super 
        update_move 
        update_arc 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_move 
      #-------------------------------------------------------------------------- 
      def update_move 
        distance = set_distance 
        move     = {x: 1.0, y: 1.0} 
        if distance[:x].abs < distance[:y].abs 
          move[:x] = 1.0 / (distance[:y].abs.to_f / distance[:x].abs) 
        elsif distance[:y].abs < distance[:x].abs 
          move[:y] = 1.0 / (distance[:x].abs.to_f / distance[:y].abs) 
        end 
        speed = set_speed(distance) 
        x = move[:x] * speed[:x] 
        y = move[:y] * speed[:y] 
        set_movement(x, y) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_distance 
      #-------------------------------------------------------------------------- 
      def set_distance 
        {x: target_distance(:x), y: target_distance(:y)} 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: target_distance 
      #-------------------------------------------------------------------------- 
      def target_distance(symbol) 
        @target_position[symbol] - @current_position[symbol] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_speed 
      #-------------------------------------------------------------------------- 
      def set_speed(distance) 
        x = @data[:speed] * (distance[:x] == 0 ? 0 : (distance[:x] > 0 ? 8 : -8)) 
        y = @data[:speed] * (distance[:y] == 0 ? 0 : (distance[:y] > 0 ? 8 : -8)) 
        {x: x, y: y} 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: set_movement 
      #-------------------------------------------------------------------------- 
      def set_movement(x, y) 
        target  = @target_position 
        current = @current_position 
        current[:x] += x 
        current[:y] += y 
        current[:x] = target[:x] if in_distance?(current[:x], target[:x], x) 
        current[:y] = target[:y] if in_distance?(current[:y], target[:y], y) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: in_distance? 
      #-------------------------------------------------------------------------- 
      def in_distance?(x, y, z) 
        x.between?(y - z - 1, y + z + 1) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_arc 
      #-------------------------------------------------------------------------- 
      def update_arc 
        return if @arc[:count] == 0 
        @arc[:count] = [@arc[:count] - (1 * @arc[:speed] / 10.0), 0].max.to_f 
        count = @arc[:count] 
        speed = @arc[:speed] 
        peak  = @arc[:height]    
        result = (peak ** 2 - (count - peak).abs ** 2) / 2 
        @current_position[:a] = @data[:revert] ? -result : result 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_position 
      #-------------------------------------------------------------------------- 
      def update_position 
        setup_icon if @current_icon != @icon 
        self.x      = current[:x] 
        self.y      = current[:y] - current[:h] - current[:a] 
        self.z      = [target.sprite.z, user.sprite.z].max 
        self.ox     = @icon_ox 
        self.oy     = @icon_oy 
        self.mirror = @right || @up 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: current 
      #-------------------------------------------------------------------------- 
      def current 
        @current_position 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: disposing? 
      #-------------------------------------------------------------------------- 
      def disposing? 
        current[:x] == @target_position[:x] && current[:y] == @target_position[:y] 
      end 
    end 
    
    
    
    
    class Plane_ActionPlane < Plane 
      #-------------------------------------------------------------------------- 
      # * New method: initialize 
      #-------------------------------------------------------------------------- 
      def initialize(viewport) 
        super(viewport) 
        @settings = {x: 0, y: 0, opacity: 0, zoom_x: 1.0, zoom_y: 1.0} 
        @duration = 1 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: dispose 
      #-------------------------------------------------------------------------- 
      def dispose 
        bitmap.dispose if bitmap 
        super 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup 
      #-------------------------------------------------------------------------- 
      def setup(name, x, y, z, zoom_x, zoom_y, opacity, blend, duration) 
        self.bitmap = Cache.picture(name) 
        self.z = z 
        @settings[:x] = x 
        @settings[:y] = y 
        @settings[:zoom_x]  = zoom_x / 100.0 
        @settings[:zoom_y]  = zoom_y / 100.0 
        @settings[:opacity] = opacity 
        @blend_type = blend 
        @delete     = false 
        @duration   = [duration, 1].max 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: delete 
      #-------------------------------------------------------------------------- 
      def delete(duration = 60) 
        @settings[:opacity] = 0 
        @duration = [duration, 1].max 
        @delete   = true 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: value 
      #-------------------------------------------------------------------------- 
      def value 
        @settings 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update 
      #-------------------------------------------------------------------------- 
      def update 
        update_position 
        update_opacity 
        update_zoom 
        update_delete 
        @duration -= 1 if @duration > 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_position 
      #-------------------------------------------------------------------------- 
      def update_position 
        self.ox += value[:x] 
        self.oy += value[:y] 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_opacity 
      #-------------------------------------------------------------------------- 
      def update_opacity 
        return if @duration == 0 
        d = @duration 
        self.opacity = (self.opacity * (d - 1) + value[:opacity]) / d 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_zoom 
      #-------------------------------------------------------------------------- 
      def update_zoom 
        return if @duration == 0 
        d = @duration 
        self.zoom_x = (self.zoom_x * (d - 1) + value[:zoom_x]) / d 
        self.zoom_y = (self.zoom_y * (d - 1) + value[:zoom_y]) / d 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_delete 
      #-------------------------------------------------------------------------- 
      def update_delete 
        return if !@delete || @duration > 0 
        self.bitmap.dispose 
        self.bitmap = nil 
        @settings   = {x: 0, y: 0, opacity: 0, zoom_x: 100.0, zoon_y: 100.0} 
        @blend_type = 0 
        @delete = false 
      end 
    end 
      
    
    class Spriteset_Battle 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: create_actors 
      #-------------------------------------------------------------------------- 
      def create_actors 
        @actor_sprites = $game_party.battle_members.reverse.collect do |actor| 
          Sprite_Battler.new(@viewport1, actor) 
        end 
        @actors_party = $game_party.battle_members.dup 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: update_actors 
      #-------------------------------------------------------------------------- 
      def update_actors 
        update_party if $game_party.battle_members != @actors_party 
        @actor_sprites.each {|sprite| sprite.update } 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: initialize 
      #-------------------------------------------------------------------------- 
      alias :initialize_ve_animated_battle :initialize 
      def initialize 
        init_action_plane 
        initialize_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: update 
      #-------------------------------------------------------------------------- 
      alias :update_ve_animated_battle :update 
      def update 
        update_ve_animated_battle 
        update_action_plane 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: dispose 
      #-------------------------------------------------------------------------- 
      alias :dispose_ve_animated_battle :dispose 
      def dispose 
        dispose_ve_animated_battle 
        dispose_action_plane 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: create_pictures 
      #-------------------------------------------------------------------------- 
      alias :create_pictures_ve_animated_battle :create_pictures 
      def create_pictures 
        battler_sprites.each {|battler| battler.setup_positions } 
        create_pictures_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: create_viewports 
      #-------------------------------------------------------------------------- 
      alias :create_viewports_ve_animated_battle :create_viewports 
      def create_viewports 
        create_viewports_ve_animated_battle 
        @viewport4   = Viewport.new 
        @viewport4.z = 200 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: update_viewports 
      #-------------------------------------------------------------------------- 
      alias :update_viewports_ve_animated_battle :update_viewports 
      def update_viewports 
        update_viewports_ve_animated_battle 
        @viewport1.ox = [1, -1].random * rand($game_troop.screen.shake) 
        @viewport1.oy = [1, -1].random * rand($game_troop.screen.shake) 
        @back1_sprite.tone.set($game_troop.screen.low_tone) if @back1_sprite 
        @back2_sprite.tone.set($game_troop.screen.low_tone) if @back2_sprite 
        @viewport4.tone.set($game_troop.screen.high_tone) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_party 
      #-------------------------------------------------------------------------- 
      def update_party 
        @actor_sprites.each_index do |i| 
          next if $game_party.battle_members.include?(@actor_sprites[i].battler) 
          @actor_sprites[i].dispose 
          @actor_sprites[i] = nil 
        end 
        $game_party.battle_members.collect do |actor| 
          next if @actors_party.include?(actor) 
          @actor_sprites.push(Sprite_Battler.new(@viewport1, actor)) 
        end 
        @actor_sprites.compact! 
        @actors_party = $game_party.battle_members.dup 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: collapse? 
      #-------------------------------------------------------------------------- 
      def collapse? 
        battler_sprites.compact.any? {|sprite| sprite.collapse? } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: init_action_plane 
      #-------------------------------------------------------------------------- 
      def init_action_plane 
        @action_plane = Plane_ActionPlane.new(@viewport1) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_action_plane 
      #-------------------------------------------------------------------------- 
      def update_action_plane 
        @action_plane.update 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: dispose_action_plane 
      #-------------------------------------------------------------------------- 
      def dispose_action_plane 
        @action_plane.dispose 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: action_plane 
      #-------------------------------------------------------------------------- 
      def action_plane(name, x, y, z, zx, zy, opacity, blend, duration) 
        @action_plane.setup(name, x, y, z, zx, zy, opacity, blend, duration) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: delete_plane 
      #-------------------------------------------------------------------------- 
      def delete_plane(duration) 
        @action_plane.delete(duration) 
      end 
    end 
    
    
    
    #============================================================================== 
    # ** Window_BattleLog 
    #------------------------------------------------------------------------------ 
    #  This window shows the battle progress. Do not show the window frame. 
    #============================================================================== 
    
    class Window_BattleLog < Window_Selectable 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: wait_and_clear 
      #-------------------------------------------------------------------------- 
      def wait_and_clear 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: wait 
      #-------------------------------------------------------------------------- 
      def wait 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: back_to 
      #-------------------------------------------------------------------------- 
      def back_to(line_number) 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: back_one 
      #-------------------------------------------------------------------------- 
      def back_one 
        return unless last_text.empty? 
        @lines.pop 
        refresh 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: display_added_states 
      #-------------------------------------------------------------------------- 
      def display_added_states(target) 
        target.result.added_state_objects.each do |state| 
          state_msg = target.actor? ? state.message1 : state.message2 
          next if state_msg.empty? 
          replace_text(target.name + state_msg) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: wait_and_clear 
      #-------------------------------------------------------------------------- 
      alias :add_text_ve_animated_battle :add_text 
      def add_text(text) 
        skip_second_line while @lines.size > max_line_number 
        add_text_ve_animated_battle(text) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: skip_second_line 
      #-------------------------------------------------------------------------- 
      def skip_second_line 
        first_line = @lines.shift 
        @lines.shift 
        @lines.unshift(first_line) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: wait_message_end 
      #-------------------------------------------------------------------------- 
      def wait_message_end 
        @method_wait.call(message_speed) if @method_wait && line_number > 0 
        clear 
      end 
    end 
    
    #============================================================================== 
    # ** Scene_Battle 
    #------------------------------------------------------------------------------ 
    #  This class performs battle screen processing. 
    #============================================================================== 
    
    class Scene_Battle < Scene_Base 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: abs_wait_short 
      #-------------------------------------------------------------------------- 
      def abs_wait_short 
        update_for_wait 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: apply_item_effects 
      #-------------------------------------------------------------------------- 
      def apply_item_effects(target, item) 
        target.item_apply(@subject, item) 
        refresh_status 
        @log_window.display_action_results(target, item) 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: execute_action 
      #-------------------------------------------------------------------------- 
      def execute_action 
        @subject.poses.activate 
        use_item 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: use_item 
      #-------------------------------------------------------------------------- 
      def use_item 
        item = @subject.current_action.item 
        @log_window.display_use_item(@subject, item) 
        @subject.poses.action_pose(item) 
        @subject.use_item(item) 
        refresh_status 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: show_animation 
      #-------------------------------------------------------------------------- 
      def show_animation(targets, animation_id) 
        if animation_id < 0 
          show_animated_battle_attack_animation(targets) 
        else 
          show_normal_animation(targets, animation_id) 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: invoke_counter_attack 
      #-------------------------------------------------------------------------- 
      def invoke_counter_attack(target, item) 
        if target == @subject || target.poses.counter_on 
          return if retaliation_counter?(target, item) 
          target.counter = false if $imported[:ve_damage_pop] 
          apply_item_effects(apply_substitute(target, item), item) 
          return 
        end 
        target.poses.setup_counter(@subject, item) 
        @counter_flag.push(target) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: retaliation_counter?(target, item) 
      #-------------------------------------------------------------------------- 
      def retaliation_counter?(target, item) 
        $imported[:ve_retaliation_damage] && damage_on_counter?(target, item) 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: invoke_magic_reflection 
      #-------------------------------------------------------------------------- 
      def invoke_magic_reflection(target, item) 
        if target == @subject 
          target.reflect = false if $imported[:ve_damage_pop] 
          apply_item_effects(apply_substitute(target, item), item) 
          return 
        end 
        @subject.poses.setup_reflect(item) 
        @reflect_flag.push(target) 
      end 
      #-------------------------------------------------------------------------- 
      # * Overwrite method: apply_substitute 
      #-------------------------------------------------------------------------- 
      def apply_substitute(target, item) 
        if check_substitute(target, item) 
          substitute = target.friends_unit.substitute_battler 
          if substitute && target != substitute 
            @substitution = {target: target, substitute: substitute} 
            substitute.poses.setup_substitute(target) 
            return substitute 
          end 
        end 
        target 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: create_spriteset 
      #-------------------------------------------------------------------------- 
      alias :create_spriteset_ve_animated_battle :create_spriteset 
      def create_spriteset 
        create_spriteset_ve_animated_battle 
        setup_spriteset 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: update_basic 
      #-------------------------------------------------------------------------- 
      alias :update_basic_ve_animated_battle :update_basic 
      def update_basic 
        update_basic_ve_animated_battle 
        update_sprite_action 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: process_action 
      #-------------------------------------------------------------------------- 
      alias :process_action_ve_animated_battle :process_action 
      def process_action 
        return if active? 
        process_action_ve_animated_battle 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: turn_end 
      #-------------------------------------------------------------------------- 
      alias :turn_end_ve_animated_battle :turn_end 
      def turn_end 
        turn_end_ve_animated_battle 
        @spriteset.battler_sprites.each {|sprite| sprite.reset_pose } 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: next_command 
      #-------------------------------------------------------------------------- 
      alias :next_command_ve_animated_battle :next_command 
      def next_command 
        previous =  BattleManager.actor 
        BattleManager.actor.input_pose   if BattleManager.actor 
        next_command_ve_animated_battle 
        previous.poses.set_active_pose   if previous  
        BattleManager.actor.command_pose if BattleManager.actor 
      end 
      #-------------------------------------------------------------------------- 
      # * Alias method: prior_command 
      #-------------------------------------------------------------------------- 
      alias :prior_command_ve_animated_battle :prior_command 
      def prior_command 
        BattleManager.actor.cancel_pose  if BattleManager.actor 
        prior_command_ve_animated_battle 
        BattleManager.clear_active_pose 
        BattleManager.actor.command_pose if BattleManager.actor 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: close_window 
      #-------------------------------------------------------------------------- 
      def close_window 
        abs_wait(10) 
        update_for_wait while @message_window.openness > 0 
        $game_message.clear 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: setup_spriteset 
      #-------------------------------------------------------------------------- 
      def setup_spriteset 
        all_battle_members.each {|member| member.poses.default_direction } 
        BattleManager.all_movable_members.each do |member|  
          next 
    
     if $game_system.no_intro || !member.intro_pose? 
          member.poses.call_pose(:intro, :clear) 
        end 
        2.times { @spriteset.update } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: log_window_wait? 
      #-------------------------------------------------------------------------- 
      def log_window_wait? 
        @log_window.line_number > 0 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: log_window_clear 
      #-------------------------------------------------------------------------- 
      def log_window_clear 
        @log_window.clear 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: show_animated_battle_attack_animation 
      #-------------------------------------------------------------------------- 
      def show_animated_battle_attack_animation(targets) 
        if @subject.actor? || $imported[:ve_actor_battlers] 
          show_normal_animation(targets, @subject.atk_animation_id1, false) 
        else 
          Sound.play_enemy_attack 
          abs_wait_short 
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: next_subject? 
      #-------------------------------------------------------------------------- 
      def next_subject? 
        !@subject || !@subject.current_action 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: active? 
      #-------------------------------------------------------------------------- 
      def active? 
        all_battle_members.any? {|member| member.poses.active? } 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: active 
      #-------------------------------------------------------------------------- 
      def active 
        all_battle_members.select {|member| member.poses.active? }.first 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: update_sprite_action 
      #-------------------------------------------------------------------------- 
      def update_sprite_action 
        @old_subject = @subject 
        all_battle_members.each do |subject| 
          @subject = subject 
          call_animation if @subject.poses.call_anim 
          call_effect    if @subject.poses.call_effect 
          call_end       if @subject.poses.call_end 
        end 
        @subject = @old_subject 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_animation 
      #-------------------------------------------------------------------------- 
      def call_animation 
        @subject.poses.call_anim = false 
        animation = @subject.poses.animation 
        targets   = @subject.poses.anim_targets.dup 
        @subject.poses.animation = 0 
        @subject.poses.anim_targets.clear 
        show_animation(targets, animation) 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_effect 
      #-------------------------------------------------------------------------- 
      def call_effect 
        @counter_flag = [] 
        @reflect_flag = [] 
        @substitution = nil 
        @subject.poses.call_effect = false 
        targets = @subject.poses.targets.dup 
        item    = @subject.poses.current_item 
        @subject.poses.targets.clear 
        targets.each {|target| item.repeats.times { invoke_item(target, item) } } 
        @counter_flag.each {|target| @log_window.display_counter(target, item) } 
        @reflect_flag.each {|target| @log_window.display_reflection(target, item) } 
        if @substitution 
          substitute = @substitution[:substitute] 
          target     = @substitution[:target] 
          @log_window.display_substitute(substitute, target)  
        end 
      end 
      #-------------------------------------------------------------------------- 
      # * New method: call_end 
      #-------------------------------------------------------------------------- 
      def call_end 
        @subject.poses.call_end = false 
        process_action_end if @subject.alive? && @old_subject == @subject 
        @log_window.wait_message_end 
      end 
    end 
    
    #============================================================================== 
    # ** Plane_ActionPlane 
    #------------------------------------------------------------------------------ 
    #  This is the plane used to display action plane images 
    #============================================================================== 
    
    end

  2. #1302
    Авторитет Аватар для Hosse
    Информация о пользователе
    Регистрация
    23.03.2010
    Адрес
    Королёв
    Сообщений
    1,511
    Записей в дневнике
    43
    Репутация: 22 Добавить или отнять репутацию

    По умолчанию

    воо, спасибо
    Хоссе - ударение на второй слог

  3. #1303
    Авторитет Аватар для Bloody
    Информация о пользователе
    Регистрация
    23.04.2008
    Сообщений
    1,609
    Записей в дневнике
    87
    Репутация: 21 Добавить или отнять репутацию

    По умолчанию

    Так, девочки и мальчики, мне для одного проекта на xp нужна боевка, где используются чарсеты персонажей, а не баттлеры. Боевку от Gubid'а не предлагать, она у меня в этом проекте и была как раз, от нее пришлось отказаться.

  4. #1304
    Мастер Форума Аватар для Рольф
    Информация о пользователе
    Регистрация
    14.04.2008
    Адрес
    Южно- Сахалинск/Пенза
    Сообщений
    8,208
    Записей в дневнике
    2
    Репутация: 85 Добавить или отнять репутацию

    По умолчанию

    Ты смотрел видео? Там все боевки известные.

  5. #1305

    По умолчанию

    Существует ли скрипт на выбор навыков (например, из двух) при повышении уровня? Пока нашел только скрипт на распределение статов. На навыки никак не могу найти.

  6. #1306
    Хранитель Форума Аватар для Валера
    Информация о пользователе
    Регистрация
    15.04.2008
    Адрес
    Москва
    Сообщений
    14,020
    Записей в дневнике
    3
    Репутация: 162 Добавить или отнять репутацию

    По умолчанию

    Это на командах делает элементарно.

    Спойлер И как тебе не стыдно-то, а, Валера?:


    Оборона форта: http://rghost.ru/8kLGxFtD2
    Сделать, чтоб все происходило, как я хочу, - вот, собственно, и весь мейкер!
    Адский Рейд: http://rpgmaker.su/downloads/%D0%B7%...-2010raid-full

  7. #1307

    По умолчанию

    Туплю. Точно

  8. #1308
    Пользователь Аватар для Ром4ик
    Информация о пользователе
    Регистрация
    24.09.2014
    Сообщений
    51
    Репутация: 3 Добавить или отнять репутацию

    По умолчанию

    Нужен скрипт, чтобы диалоги были в таких "пузырях" как в комиксах - облако с сообщением и чтобы "хвост" такого "пузыря" указывал на говорящего. Ну, надеюсь вы поняли

  9. #1309

  10. #1310
    Пользователь Аватар для Ром4ик
    Информация о пользователе
    Регистрация
    24.09.2014
    Сообщений
    51
    Репутация: 3 Добавить или отнять репутацию

    По умолчанию

    Они конфликтуют между собой и выходит ошибка. К тому же я не разбираюсь в английском, а с гугло-переводчиком получается невразумительный перевод, так что я даже не понял, как им пользоваться.

Страница 131 из 185 ПерваяПервая ... 3181121129130131132133141181 ... ПоследняяПоследняя

Информация о теме

Пользователи, просматривающие эту тему

Эту тему просматривают: 1 (пользователей: 0 , гостей: 1)

Метки этой темы

Социальные закладки

Социальные закладки

Ваши права

  • Вы не можете создавать новые темы
  • Вы не можете отвечать в темах
  • Вы не можете прикреплять вложения
  • Вы не можете редактировать свои сообщения
  •