Страница 130 из 187 ПерваяПервая ... 3080120128129130131132140180 ... ПоследняяПоследняя
Показано с 1,291 по 1,300 из 1863

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

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

    По умолчанию

    Посмотри видео чуть выше и выбери, там все боевки. Три посты выше

  2. #1292

    По умолчанию

    Цитата Сообщение от Рольф Посмотреть сообщение
    Посмотри видео чуть выше и выбери, там все боевки. Три посты выше
    Нифигасе сколько много
    Поищу Golden Sun, спасибо
    P.S. В гугле нашол скрипт чар из Golden Sun а боевку не могу найти, не знаете где может быть этот скриптиз видео?
    Последний раз редактировалось TDR; 04.10.2014 в 16:42. Причина: Добавил P.S.

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

    По умолчанию

    и вновь я туплю со скриптами
    VX Ace, скрипт Victor Engine - Animated Battle

    PHP код:
    #==============================================================================
    # ** 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 [url]http://victorscripts.wordpress.com/[/url] 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:
    #   [url]http://victorscripts.wordpress.com/[/url]
    #
    #  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 true
      
    #--------------------------------------------------------------------------
      # * 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,
        
    frames4,        # Number of frames
        
    rows:   14,       # Number of rows
        
    ox:     0,        # Adjust sprite X position
        
    oy:     0,        # Adjust sprite Y position
        
    mirrortrue,     # Mirror battler when facing right
        
    invertfalse,    # Invert the battler graphic
        
    mode:   :sprite,  # Graphic style (:sprite or :chasert)
        
    action: :default, # 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
        
    skillcastnil# Skill cast pose
        
    magiccastnil# 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'   => {frames4rows14mirrortruemode: :sprite,
                       
    action: :default},
        
    'Charset'  => {frames3rows4mirrorfalseinvertfalse,
                       
    mode: :charsetaction: :charset},
        
    'Kaduki'   => {frames3rows4mirrortrueinvertfalse,
                       
    mode: :charsetaction: :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(namereqversiontype 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 [url]http://victorscripts.wordpress.com/[/url] to download this script."
          
    msgbox(sprintf(msgself.script_name(name), version))
          exit
        else
          
    self.required_script(namereqversiontype)
        
    end
      end
      
    #--------------------------------------------------------------------------
      # * script_name
      #   Get the script name base on the imported value, don't edit this
      #--------------------------------------------------------------------------
      
    def self.script_name(nameext "VE")
        
    name name.to_s.gsub("_"" ").upcase.split
        name
    .collect! {|charchar == ext "#{char} -" char.capitalize }
        
    name.join(" ")
      
    end
    end

    $imported 
    ||= {}
    $imported[:ve_animated_battle] = 1.21
    Victor_Engine
    .required(:ve_animated_battle, :ve_basic_module1.35, :above)
    Victor_Engine.required(:ve_animated_battle, :ve_actor_battlers1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_animations_settings1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_passive_states1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_map_battle1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_state_cancel1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_tech_points1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_trait_control1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_mp_level1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_automatic_battlers1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_state_auto_apply1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_element_states1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_counter_options1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_state_aura1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_state_graphics1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_active_time_battle1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_damage_popup1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_action_streghten1.00, :bellow)
    Victor_Engine.required(:ve_animated_battle, :ve_element_strenghten1.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 {|membermember.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 {|membermember.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(toneduration)
        @
    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(toneduration)
        @
    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   * (1) + tone.red)   / d
          
    @low_tone.green = (@low_tone.green * (1) + tone.green) / d
          
    @low_tone.blue  = (@low_tone.blue  * (1) + tone.blue)  / d
          
    @low_tone.gray  = (@low_tone.gray  * (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   * (1) + tone.red)   / d
          
    @high_tone.green = (@high_tone.green * (1) + tone.green) / d
          
    @high_tone.blue  = (@high_tone.blue  * (1) + tone.blue)  / d
          
    @high_tone.gray  = (@high_tone.gray  * (1) + tone.gray)  / d
          
    @high_tone_duration -= 1
        end
      end
      
    #--------------------------------------------------------------------------
      # * New method: tone_change?
      #--------------------------------------------------------------------------
      
    def tone_change?
        @
    tone_duration || @low_tone_duration || @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(valueitem)
        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_iderase_state(state_id) }
        @
    hp = [[@hpmhp].min0].max
        
    @mp = [[@mpmmp].min0].max
        
    die if @dying && !immortal?
        return if @
    dying
        valid 
    = @hp == && !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(useritem)
        
    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
    (useritem)
        
    item_apply_ve_animated_battle(useritem)
        
    poses.call_damage_pose(itemuser) 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
    (useritem)
        
    make_damage_value_ve_animated_battle(useritem)
        
    active_effect_make_damage(useritem)
        
    clear_elemental_flag(useritem)
        @
    result.damage_adjust(user.poses.damage_flagitem)
        @
    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 <= && 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 && 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(
    coderescue false
      end
      
    #--------------------------------------------------------------------------
      # * New method: set_pose_frames
      #--------------------------------------------------------------------------
      
    def set_pose_frames(value)
        if 
    value =~ /(\d+) FRAMES/i
          
    [@pose[:frame] + $1.to_isprite_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 != && 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>/&& 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 && (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 && @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(targetitem)
        [
    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(useritem)
        
    user.poses.element_flag.clear
        user
    .poses.active_effect.each {|membermember.poses.element_flag.clear }
        
    user.poses.active_effect.clear
      end
      
    #--------------------------------------------------------------------------
      # * New method: active_effect_make_damage
      #--------------------------------------------------------------------------
      
    def active_effect_make_damage(useritem)
        return if 
    user.poses.active_effect.empty?
        
    setup_old_results
        apply_new_results
    (useritem)
        
    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(useritem)
        
    user.poses.active_effect.each do |battler|
          
    next if battler == user
          make_damage_value_ve_animated_battle
    (battleritem)
          @
    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(5510unless 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 && @attack_flag
          atk_equips
    .compact.inject(super) {|ritem+= 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([]) {|robjobj.features }
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: atk_features
      #--------------------------------------------------------------------------
      
    def atk_features(code)
        
    atk_all_features.select {|ftft.code == code }
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: atk_features_set
      #--------------------------------------------------------------------------
      
    def atk_features_set(code)
        
    atk_features(code).inject([]) {|rft|= [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 {|itemitem }.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+)>/? $1.to_i 0
      end
      
    #--------------------------------------------------------------------------
      # * New method: visual_items
      #--------------------------------------------------------------------------
      
    def visual_items
        
    [default_part]
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: default_part
      #--------------------------------------------------------------------------
      
    def default_part
        
    {namecharacter_nameindex1character_indexindex2character_index,
         
    huecharacter_huepriority0}
      
    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? {|membermember.poses.not_in_position? }
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: moving?
      #--------------------------------------------------------------------------
      
    def moving?
        
    movable_members.any? {|membermember.poses.moving? }
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: active?
      #--------------------------------------------------------------------------
      
    def active?
        
    movable_members.any? {|membermember.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? {|membermember.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  = {x0y0h0j0}
        @
    current_position = {x0y0h0j0}
        @
    default_position = {x0y0h0j0}
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: call_pose
      #--------------------------------------------------------------------------
      
    def call_pose(poseinsert nilitem nilbattler nil)
        return if 
    insert == :clear && pose_list.include?(pose)
        
    notes = @battler.get_all_poses(item item.note "")
        
    setup_pose(posenotesmake_string(pose), insertbattler)
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: setup_pose
      #--------------------------------------------------------------------------
      
    def setup_pose(posenotescodeinsertbattler)
        
    regexp get_all_values("ACTION: *#{code}((?: *, *[^>]+)+)?""ACTION")
        
    result = []
        if 
    notes.gsub(/\r\n/i"") =~ regexp
          value 
    = $1
          setup 
    = $2
          time  
    value =~ /([^,]+) TIMES/? [script_processing($1), 1].max 1
          last  
    value =~ /(\w[\]+)/i    make_symbol($1) : nil
          layer 
    insert.numeric? ? insert 1
          time
    .times result.push(setup_value(setupposelastlayerbattler)) }
          
    insert_poses(insertresult)
        
    end
      end
      
    #--------------------------------------------------------------------------
      # * New method: script_processing
      #--------------------------------------------------------------------------
      
    def script_processing(value)
        @
    battler.script_processing(value)
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: insert_poses
      #--------------------------------------------------------------------------
      
    def insert_poses(insertnext_pose)
        case 
    insert
        when 
    :clear, :insert then @pose_list.insert(10next_pose)
        
    when Numeric         then @pose_list.insert(insert0next_pose)
        else @
    pose_list.insert(1, -1next_pose)
        
    end
      end
      
    #--------------------------------------------------------------------------
      # * New method: setup_value
      #--------------------------------------------------------------------------
      
    def setup_value(setupposelastlayerbattler)
        
    values Game_PoseAction.new(poselastlayer, @battler)
        
    setup.scan(/(\w+)(?:: *([^;\n\r]+)[;\n\r])?/i) do |namevalue|
          
    value value value ""
          
    values.push(Game_PoseValue.new(namevalue, @battlerbattlerlayer))
        
    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 {|statestate.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(xy)
        
    relative_x = @battler.current_x x
        relative_y 
    = @battler.current_y y
        
    if isometric?
          @
    direction if relative_x && relative_y 0
          
    @direction if relative_x && relative_y 0
          
    @direction if relative_x && relative_y 0
          
    @direction if relative_x && relative_y 0
        elsif relative_x
    .abs >= relative_y.abs && !frontview?
          @
    direction relative_x 4
        elsif relative_y
    .abs >= relative_x.abs && !sideview?
          @
    direction relative_y 8
        end
      end
      
    #--------------------------------------------------------------------------
      # * New method: action_direction
      #--------------------------------------------------------------------------
      
    def action_direction(units)
        
    units.collect {|membermember.current_x }.average
        y 
    units.collect {|membermember.current_y }.average
        target_direction
    (xy)
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: active_direction
      #--------------------------------------------------------------------------
      
    def active_direction
        units 
    BattleManager.all_battle_members
        action_direction
    (units.select {|membermember.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=  value, -value 0.75 if down?
          
    x=  value,  value 0.75 if left?
          
    x= -value, -value 0.75 if right?
          
    x= -value,  value 0.75 if up?
        else
          
    x0, -value if down?
          
    x=  valueif left?
          
    x= -valueif right?
          
    x0,  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 && !move_over
      end
      
    #--------------------------------------------------------------------------
      # * New method: sharing_list
      #--------------------------------------------------------------------------
      
    def sharing_list
        BattleManager
    .all_battle_members.select {|otherposition_overlap?(other) }
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: position_overlap?(other)
      #--------------------------------------------------------------------------
      
    def position_overlap?(other)
        
    target_position[:x] - other.poses.target_position[:x]
        
    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
        
    @target_position[:y] += adjust
      end
      
    #--------------------------------------------------------------------------
      # * New method: fix_horz
      #--------------------------------------------------------------------------
      
    def fix_horz(other)
        
    adjust = @battler.current_x other.current_x : -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 {|statestate.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 {|abb.current_x <=> a.current_x } if frontview?
        return 
    targets.sort {|abb.current_y <=> a.current_y }
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: setup_immortals
      #--------------------------------------------------------------------------
      
    def setup_immortals
        
    @action_targets.each {|target| @immortals.push(targetunless 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([]) {|rmember+= member.poses.immortals }
        
    members.each   {|membermember.poses.immortals.clear }
        
    immortals.each {|membermember.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? ? 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), nilitem) if item
        call_pose
    (:finishnil)
      
    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", :attackdual) 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"poseitem)
        
    pose battler_pose("ITEM"  poseitem) if item.item?
        
    pose battler_pose("MAGIC" poseitem) if item.magical?
        
    pose battler_pose("SKILL" poseitem) if item.physical?
        
    pose
      end
      
    #--------------------------------------------------------------------------
      # * New method: weapons_pose
      #--------------------------------------------------------------------------
      
    def weapons_pose(typeposedual false)
        
    valid = @battler.actor? ? @battler.weapons + [@battler] : [@battler]
        list  = 
    valid.collect {|itemitem.custom_pose(type) }
        list.
    shift if dual
        
    list.empty? || !pose_exist?(list.first) ? pose : list.first
      end
      
    #--------------------------------------------------------------------------
      # * New method: battler_pose
      #--------------------------------------------------------------------------
      
    def battler_pose(typeposeitem)
        
    note   item item.note ""
        
    custom item.custom_pose(type)
        
    custom && pose_exist?(customnote) ? custom pose
      end
      
    #--------------------------------------------------------------------------
      # * New method: pose_exist?
      #--------------------------------------------------------------------------
      
    def pose_exist?(posenote "")
        
    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(typeposedual)
        
    pose weapons_pose(typeposedual
        
    pose battler_pose(typepose, @current_item)
        
    call_pose(posenil, @current_item)
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: call_custom_pose
      #--------------------------------------------------------------------------
      
    def call_custom_pose(typeposeitem)
        
    pose battler_pose(typeposeitem)
        
    call_pose(posenilitem)
      
    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(itemuser)
        
    call_pose(:hurt,     :clearitem) if @battler.hurt_pose?
        
    call_pose(:miss,     :clearitem) if @battler.result.missed
        call_pose
    (:evade,    :clearitem) if @battler.result.evaded
        call_pose
    (:critical, :clearitem) 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"poseitem)  if pose && item.item?
        
    pose battler_pose("MAGIC CAST"poseitem) if pose && item.magical?
        
    pose battler_pose("SKILL CAST"poseitem) if pose && item.physical?
        
    pose
      end
      
    #--------------------------------------------------------------------------
      # * New method: setup_counter
      #--------------------------------------------------------------------------
      
    def setup_counter(targetitem)
        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(targetaction)
        @
    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(targetitem)
        
    targets = @battler.setup_counter_targets(targetitem)
        return 
    targets.sort {|abb.current_x <=> a.current_x } if frontview?
        return 
    targets.sort {|abb.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, :insertitem)
      
    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(powerspeedduration)
        @
    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 <= && @shake * (@shake delta) < 0
        
    @shake clear : @shake delta
        
    @shake_direction = -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 == || !@freeze.numeric?
        @
    freeze -= 1
      end
      
    #--------------------------------------------------------------------------
      # * New method: shaking?
      #--------------------------------------------------------------------------
      
    def shaking?
        @
    shake_duration || @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(namevaluebattleractivelayer)
        @
    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 []=(idvalue)
        @
    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+)/? $1.to_i 0
        
    @data[:spin]  = value =~ /SPIN ([+-]?\d+)/i  ? $1.to_i 0
        
    @data[:x]     = value =~ /([+-]?\d+)/i     ? $1.to_i 0
        
    @data[:y]     = value =~ /([+-]?\d+)/i     ? $1.to_i 0
        
    @data[:size]  = value =~ /FRAME SIZE (\d+)/? $1.to_i nil
        
    @data[:pose]  = setl_all_frames(value)
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: set_wait
      #--------------------------------------------------------------------------
      
    def set_wait(value)
        
    value.scan(/\w+/i) {|resultset_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 =~ /([+-]?\d+)/? $1.to_i 0
        
    @data[:y]        = value =~ /([+-]?\d+)/? $1.to_i 0
        
    @data[:h]        = value =~ /HEIGHT (\d+)/? $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+)/? [$1.to_i1].max nil
        
    @data[:speed]  = value =~ /SPEED (\d+)/i  ? [$1.to_i1].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[\]+)/) { @data[:action] = make_symbol($1) }
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: set_freeze
      #--------------------------------------------------------------------------
      
    def set_freeze(value)
        @
    data[:duration] = value =~ /DURATION (\d+)/? [$1.to_i1].max 1
      end
      
    #--------------------------------------------------------------------------
      # * New method: set_sound
      #--------------------------------------------------------------------------
      
    def set_sound(value)
        @
    data[:name]   = value =~ /NAME #{get_filename}/i ? $1 : ""
        
    @data[:volume] = value =~ /VOLUME (\d+)/? $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 =~ /([+-]?\d+)/i     ? $1.to_i 0
        
    @data[:y]    = value =~ /([+-]?\d+)/i     ? $1.to_i 0
        
    @data[:a]    = value =~ /ANGLE ([+-]?\d+)/? $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+)/? [$1.to_i1].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+)/? $1.to_i 100.0
        zy 
    value =~ /ZOOM X ([+-]?\d+)/? $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] = [nogxyzxzyopbt]  if value =~ /SHOW/i
        
    @data[:move] = [ogxyzxzyopbtdr] if value =~ /MOVE/i
      end
      
    #--------------------------------------------------------------------------
      # * New method: set_plane
      #--------------------------------------------------------------------------
      
    def set_plane(value)
        @
    data[:delete]   = value =~ /DELETE/true false
        
    @data[:duration] = value =~ /DURATION (\d+)/? $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 =~ /([+-]?\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] = [namexyzzoom_xzoom_yopacityblendduration]
      
    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+)/? $1.to_i 0
        
    @data[:init_y] = value =~ /INIT Y ([+-]?\d+)/? $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_i2].max 5
        speed    
    value =~ /SPEED (\d+)/i    ? [$1.to_i2].max 5
        duration 
    value =~ /DURATION (\d+)/? [$1.to_i1].max 10
        
    @data[:shake] = [power 2.0speed 2.0duration]
      
    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)
        
    value =~ /RED ([+-]?\d+)/i   ? $1.to_i 0
        g 
    value =~ /GREEN ([+-]?\d+)/? $1.to_i 0
        b 
    value =~ /BLUE ([+-]?\d+)/i  ? $1.to_i 0
        a 
    value =~ /GRAY ([+-]?\d+)/i  ? $1.to_i 0
        tone 
    = [rgba]
        
    tone = [ 255,  255,  2550] if value =~ /WHITE/i
        tone 
    = [-255, -255, -2550] if value =~ /BLACK/i
        
    @data[:tone]     = Tone.new(*tone)
        @
    data[:clear]    = true if value =~ /CLEAR/i
        
    @data[:duration] = value =~ /DURATION (\d+)/? $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+)/? $1.to_i 255
        b 
    value =~ /BLUE (\d+)/i  ? $1.to_i 255
        a 
    value =~ /ALPHA (\d+)/? $1.to_i 160
        duration 
    value =~ /DURATION (\d+)/? [$1.to_i1].max 10
        
    @data[:flash] = [Color.new(rgba), duration]
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: set_loop
      #--------------------------------------------------------------------------
      
    def set_loop(value)
        @
    data[:loop_anim] = value =~ /ANIM (\d+)/? $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_i1].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/? :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/
        
    @data[:counter] = false if value =~ /OFF/
      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] = if value =~ /DOWN/i
        
    @data[:direction] = if value =~ /LEFT/i
        
    @data[:direction] = if value =~ /RIGHT/i
        
    @data[:direction] = 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+)/? $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+)/? $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+)/? $1.to_i 0
        b 
    value =~ /BLUE (\d+)/i  ? $1.to_i 0
        a 
    value =~ /ALPHA (\d+)/? $1.to_i 0
        
    @data[:color] = [rgba]
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: set_subjects
      #--------------------------------------------------------------------------
      
    def set_subjects(valuecode "^")
        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  += 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  -= 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]+)/? $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 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+|ALLFRAMES?/i
          w 
    value =~ /WAIT (\d+)/? [$1.to_i1].max 1
          l 
    value =~ /LOOP/i   true false
          r 
    value =~ /RETURN/true false
          v 
    value =~ /REVERT/true false
          i 
    value =~ /INVERT/true false
          f 
    battler.set_pose_frames(valuerescue 0
          
    {waitwtimewframefloopl, return: rrevertvinverti}
        else
          {
    invertvalue =~ /INVERT/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.to_i == 2)
          
    dual battler.atk_animation_id2 battler.atk_animation_id1
        
    else
          return 
    0
        end
      end
      
    #--------------------------------------------------------------------------
      # * New method: get_values
      #--------------------------------------------------------------------------
      
    def get_values(valuecode)
        
    regexp = /#{code} *((?:\d+%?|, *\d+%?)+)/i
        
    value.scan(regexp).inject([]) do |robj
          
    += obj.first.scan(/\d+%?/i).collect {|ii[/%/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(namelastlayerbattler)
        @
    name    name
        
    @next    last
        
    @layer   layer
        
    @battler battler
        
    @data    = []
        @
    current = []
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: []
      #--------------------------------------------------------------------------
      
    def [](id)
        @
    data[id]
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: []=
      #--------------------------------------------------------------------------
      
    def []=(idvalue)
        @
    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(layerfalse) 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? {|subjectsubject.sprite.animation? }
          @
    wait anim || @pose[:time] > 0
        when 
    :active
          
    @wait get_subjects.any? {|subjectsubject.poses.active? }
        
    when :action
          
    @wait get_subjects.any? {|subjectsubject.poses.action?(@layer) }
        
    when :movement
          
    @wait get_subjects.any? {|subjectsubject.poses.moving? }
        
    when :origin
          
    @wait get_subjects.any? {|subjectsubject.poses.not_origin? }
        
    when :counter
          
    @wait get_subjects.any? {|subjectsubject.poses.counter_on }
        
    when :countered
          
    @wait get_subjects.any? {|subjectsubject.poses.countered }
        
    when :substitution
          
    @wait get_subjects.any? {|subjectsubject.poses.substitution }
        
    when :throw
          @
    wait get_subjects.any? {|subjectsubject.sprite.throwing? }
        
    when :pose
          
    @wait get_subjects.any? {|subjectsubject.poses.pose? }
        
    when :freeze
          
    @wait get_subjects.any? {|subjectsubject.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], layeritem, @battler
        
    end
      end
      
    #--------------------------------------------------------------------------
      # * New method: update_pose_finish
      #--------------------------------------------------------------------------
      
    def update_pose_finish
        poses
    .attack_flag += if poses.attack_flag
      end
      
    #--------------------------------------------------------------------------
      # * New method: update_pose_state
      #--------------------------------------------------------------------------
      
    def update_pose_state
        get_subjects
    .each do |subject|
          @
    pose[:add].each    {|idsubject.add_state(id) }
          @
    pose[:remove].each {|idsubject.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 {|targettarget.clear_flag = @pose[:clear] }
        
    end
      end
      
    #--------------------------------------------------------------------------
      # * New method: update_pose_loop
      #--------------------------------------------------------------------------
      
    def update_pose_loop
        get_subjects
    .each {|subjectsubject.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  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 {|subjectsubject.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 / [speed1].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(@posesubjectsubject)
            
    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.duptargetsubject)
            
    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 {|subjectsubject.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 {|subjectsubject.sprite.flash(*@pose[:flash]) }
        
    end
      end
      
    #--------------------------------------------------------------------------
      # * New method: update_pose_freeze
      #--------------------------------------------------------------------------
      
    def update_pose_freeze
        get_subjects
    .each {|subjectsubject.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 != || 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] : [timename]
          
    Graphics.transition(*value)
        
    end
      end
      
    #--------------------------------------------------------------------------
      # * New method: update_pose_hide
      #--------------------------------------------------------------------------
      
    def update_pose_hide
        hidden_list
    .each {|subjectsubject.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 {|membermember.use_sprite? }
        return if 
    targets.empty?
        return @
    wait true if targets.any? {|membermember.poses.moving? }
        return @
    wait true if targets.any? {|membermember.poses.damage_pose? }
        
    targets.collect {|membermember.current_x}.average
        y 
    targets.collect {|membermember.current_y}.average
        subject
    .poses.target_position[:x] = x
        subject
    .poses.target_position[:y] = y
        
    return if subject.target_current?
        
    subject.poses.target_direction(xy)
        
    subject.poses.adjust_position(32)
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: setup_move_to_target_position
      #--------------------------------------------------------------------------
      
    def setup_move_to_front_position(subject)
        
    targets = @pose.targets.select {|membermember.use_sprite? }
        return if 
    targets.empty?
        return @
    wait true if targets.any? {|membermember.poses.moving?}
        return @
    wait true if targets.any? {|membermember.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(xy)
      
    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_xsubject.target_y)
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: setup_retreat_position
      #--------------------------------------------------------------------------
      
    def setup_retreat_position(subject)
        return if 
    subject.target_origin? || subject.current_origin?
        
    subject.poses.target_position[:x] = subject.screen_x
        y 
    subject.poses.target_position[:y] = subject.screen_y
        subject
    .poses.target_direction(xy)
      
    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(datausertarget)
        @
    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 []=(idvalue)
        @
    data[id] = value
      end
      
    #--------------------------------------------------------------------------
      # * New method: insert
      #--------------------------------------------------------------------------
      
    def insert(idindexvalue)
        
    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(keyupdate true)
        @
    pose[key] = self[key].first
        
    @name[key] = @pose[key] ? @pose[key].name nil
        
    @list[key] = self[key].collect {|valuevalue.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([]) {|rkey+= get_names(key) }
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: get_names
      #--------------------------------------------------------------------------
      
    def get_names(key)
        
    self[key].collect {|valuevalue.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 
    {|keyself[key].delete_if {|posepose.next == :loop } }
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: clear_damage
      #--------------------------------------------------------------------------
      
    def clear_damage
        keys 
    {|keyself[key].delete_if {|poseis_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? {|keyself[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
    (viewportbattler nil)
        
    initialize_ve_animated_battle(viewportbattler)
        
    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_itemssufix]
            
    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 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 if single_char?
        return 
    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 = [@framesprite_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 1
      end
      
    #--------------------------------------------------------------------------
      # * New method: update_frame_revert
      #--------------------------------------------------------------------------
      
    def update_frame_revert
        
    @frame -= 
        
    @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 = {invertinvert}
        
    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 poses.frames poses.frame) * @frame_width
          row   
    = (index poses.row) * @frame_height
        
    else
          
    frame = [[poses.frame0].maxframe_number 1].min * @frame_width
          row   
    = [[poses.row,   0].max,   row_number 1].min * @frame_height
        end
        self
    .src_rect.set(framerow, @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_xy: @battler.screen_yh0j0}
        
    poses.target_position  positions.dup
        poses
    .current_position positions.dup
        poses
    .jumping   = {count0height0speed10}
        @
    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./ (Graphics.height 100.0), 1].max100].min
        self
    .ox = @frame_width 2
        self
    .oy = @frame_height position[:h] + position[:j
        @
    spin += if Graphics.frame_count == 0
        self
    .angle poses.angle poses.spin * @spin
        update_ajust
        update_icon
        update_throw
      end
      
    #--------------------------------------------------------------------------
      # * New method: update_movement
      #--------------------------------------------------------------------------
      
    def update_ajust
        angle_move
    (:xsprite_value(:ox)) if sprite_value(:ox)
        
    angle_move(:ysprite_value(:oy)) if sprite_value(:oy)
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: angle_move
      #--------------------------------------------------------------------------
      
    def angle_move(axisamount)
        
    = (360 angle) * Math::PI 180
        cos 
    Math.cos(a)
        
    sin Math.sin(a)
        
    self.ox += (axis == :? -cos : -sin) * amount
        self
    .oy += (axis == :?  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 -= 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     
    = {x1.0y1.0h1.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)
        
    move[:x] * speed[:x]
        
    move[:y] * speed[:y]
        
    move[:h] * speed[:h]
        
    set_movement(xyh)
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: set_distance
      #--------------------------------------------------------------------------
      
    def set_distance
        x 
    poses.target_distance(:x)
        
    poses.target_distance(:y)
        
    poses.target_distance(:h)
        {
    xxyyhh}
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: set_speed
      #--------------------------------------------------------------------------
      
    def set_speed(distance)
        
    move_speed poses.move_speed
        x 
    move_speed * (distance[:x] == : (distance[:x] > : -8))
        
    move_speed * (distance[:y] == : (distance[:y] > : -8))
        
    move_speed * (distance[:h] == : (distance[:h] > : -8))
        {
    xxyyhh}
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: set_movement
      #--------------------------------------------------------------------------
      
    def set_movement(xyh)
        
    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?(xyz)
        
    x.between?(11)
      
    end
      
    #--------------------------------------------------------------------------
      # * New method: update_jumping
      #--------------------------------------------------------------------------
      
    def update_jumping
        
    return if poses.jumping[:count] == || poses.frozen?
        
    jump poses.jumping
        jump
    [:count] = [jump[:count] - (jump[:speed] / 10.0), 0].max.to_f
        count  
    jump[:count]
        
    speed  jump[:speed]
        
    peak   jump[:height]
        
    result = (peak ** - (count peak).abs ** 2) / 2
        poses
    .current_position[:j] = [result0].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 |keyvalue|
          @
    icon_list[key] = Sprite_Icon.new(valueunless @icon_list[key]
          @
    icon_list[key].refresh(value) if @icon_list[key].changed_icon?(value)
        
    end
        
    @icon_list.each do |keyvalue|
          
    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 |valueindex|
          
    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? {|valuevalue.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_animanimposes.pose_looploop1}     
          
    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.
    #==============================================================================

    class Spriteset_Battle
      
    #--------------------------------------------------------------------------
      # * Overwrite method: create_actors
      #--------------------------------------------------------------------------
      
    def create_actors
        
    @actor_sprites $game_party.battle_members.reverse.collect do |actor|
          
    Sprite_Battler.new(@viewport1actor)
        
    end
        
    @actors_party $game_party