Плохо! Плохо!:  0
Показано с 1 по 5 из 5

Тема: Проблема с работой скриптка "Ace Battle System"

  1. #1
    Новичок Аватар для rockman765
    Информация о пользователе
    Регистрация
    30.12.2013
    Адрес
    Забайкалье
    Сообщений
    27
    Репутация: 1 Добавить или отнять репутацию

    По умолчанию Проблема с работой скриптка "Ace Battle System"

    Здравствуйте товарищи. В общем пару дней назад, начал изучал сабж. Набросал карты, изменил базу данных и решил поменять стандартную систему боя, на Ace Battle System, которая дает возможность подключать сторонние системы боя. В скриптинге я полный 0, но установить я его смог. Проблем в том что при запуске теста битвы, вылазит ошибка в строке 827 данного скрипта:
    alias sprite_battler_update_bitmap_abe update_bitmap
    Я поставил DEFAULT_BATTLE_SYSTEM = :ATB_BS (название скрипта другой боевой системы), но собственно нужная система не выставляется и всё равно появляется та же ошибка.
    Спойлер код:

    #================================================= =============================
    # ** Victor Engine - Active Time Battle
    #------------------------------------------------------------------------------
    # Author : Victor Sant
    #
    # Version History:
    # v 1.00 - 2012.12.16 > First release
    # v 1.01 - 2012.12.24 > Fixed issue with changing party during battle
    # > Fixed ATB value during Surprise and Pre Emptive
    # > Fixed Command Window position to not cover the ATB
    # > Fixed issue with freezes after events
    # > Fixed issue with state timings
    # > Fixed issue with cast time at battle start
    # > Fixed issue with escape at battle start
    # > Added notetags <timed trigger: x> <cast protection: x>
    # and <delay protection>
    # > Fixed issue with command window not closing when
    # the actor is becomes unable to select action
    # v 1.02 - 2012.12.30 > Compatibility with Leap Attack
    # > Fixed issue with Guard command and ATB Reverse
    # v 1.03 - 2013.01.07 > Fixed issue with selection when all enemies are dead
    # v 1.04 - 2013.01.24 > Fixed issue with skill, item and target windows not
    # closing when the actor is becomes unable to act
    # v 1.05 - 2013.02.13 > Added notetag <atb speed: x%>
    # > Added setup for play a SE when the ATB is full
    #------------------------------------------------------------------------------
    # This scripts changes the turn management of battles. The default turn based
    # system is replaced by an active time system, where the order of actions
    # are decided by individual time bars
    #------------------------------------------------------------------------------
    # Compatibility
    # Requires the script 'Victor Engine - Basic Module' v 1.32 or higher
    # If used with 'Victor Engine - Animated Battle' place this bellow it.
    # If used with 'Victor Engine - Skip Battle Log' place this bellow it.
    #
    # * Overwrite methods
    # class << BattleManager
    # def next_command
    # def prior_command
    # def turn_start
    # def turn_end
    # def make_action_orders
    #
    # class Game_Enemy < Game_Battler
    # def conditions_met_turns?(param1, param2)
    #
    # class Window_BattleStatus < Window_Selectable
    # def window_width
    # def draw_basic_area(rect, actor)
    # def draw_gauge_area_with_tp(rect, actor)
    # def draw_gauge_area_without_tp(rect, actor)
    # def update
    #
    # * Alias methods
    # class << BattleManager
    # def init_members
    # def battle_start
    # def process_escape
    #
    # class Game_System
    # def initialize
    #
    # class Game_Action
    # def prepare
    #
    # class Game_BattlerBase
    # def inputable?
    #
    # class Game_Battler < Game_BattlerBase
    # def item_user_effect(user, item)
    #
    # class Game_Enemy < Game_Battler
    # def initialize(index, enemy_id)
    #
    # class Spriteset_Battle
    # def update_actors
    #
    # class Window_BattleLog < Window_Selectable
    # def last_text
    #
    # class Window_ActorCommand < Window_Command
    # def make_command_list
    #
    #------------------------------------------------------------------------------
    # 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'
    #
    #------------------------------------------------------------------------------
    # Actors, Classes, Enemies, Weapons, Armors, States, Skills and Items note tags:
    # Tags to be used on Actors, Classes, Enemies, Weapons, Armors, States,
    # Skills and Items note boxes.
    #
    # <cast cancel: x%>
    # Actions will have a chance of canceling spell casting of the targets.
    # x : success rate
    #
    # <atb delay: x%, y%>
    # Actions will have a chance of delaying the ATB of the targets.
    # x : success rate
    # y : delay rate
    #
    #------------------------------------------------------------------------------
    # Actors, Classes, Enemies, Weapons, Armors and States note tags:
    # Tags to be used on Actors, Classes, Enemies, Weapons, Armors and States
    # note boxes.
    #
    # <cast protection: x%>
    # Reduce the success rate of a cast cancel action.
    # x : reduction
    #
    # <delay protection: x%>
    # Reduce the success rate of a atb delay action.
    # x : reduction
    #
    # <atb speed: x%>
    # Changes the rate of a atb fill speed. if the value is higher then 100%
    # the bar fills faster, if it's lower than 100% the bar fills slower.
    # x : speed rate
    #
    #------------------------------------------------------------------------------
    # Skills note tags:
    # Tags to be used on Skills note boxes.
    #
    # <cast time: x>
    # <cast time: x, y>
    # Actions with this will have a cast time before executing, you can add
    # opitionally wich stat will be used to define the speed.
    # x : cast speed (100 = default speed)
    # y : stat (any valid battler stat)
    #
    # <atb cost: x%>
    # Changes the total ATB spent after executing an action. By default all
    # actions cost 100% of the ATB. Can't be lower than 1%
    # x : ATB cost rate
    #
    #------------------------------------------------------------------------------
    # States note tags:
    # Tags to be used on States note boxes.
    #
    # <timed trigger: x>
    # There is two options for state auto-removal on the database: Action End
    # and Turn End. This tag creates a third option, to make the state end
    # and trigger after a set time.
    # x : time for the trigger.
    #
    #------------------------------------------------------------------------------
    # Additional instructions:
    #
    # The <cast cancel: x%> and <atb delay: x%, y%> will have effect only on
    # physical actions when added to any object beside Skills and Items.
    #
    # The <cast protection: x%> and <delay protection: x%> are multiplied by
    # the cast cancel/atb delay rate. So if an action have 30% cast cancel, and
    # the target have 50% cast protection, the cast cancel will be reduced to 15%
    # Multiple cast cancel effects are added separately. So an action with 40%
    # cast cancel and a target with 50%, 50% and 30% cast protection from different
    # sourcers (let's say 3 different equips) will have the chance reduced to 7%
    # (40 - 50% = 20%, 20% - 50% = 10%, 10% - 30% = 7%)
    #
    # The <atb speed: x%> can be used to change the rate of a battler ATB speed
    # without the need of changing the AGI of the battler. Can be used to create
    # effect such as "Haste" and "Slow".
    #
    # You can use script calls to change the wait mode and the atb speed
    # $game_system.wait_mode = X
    # :full_wait : time stop to select commands and actions
    # :semi_wait : time stop to select actions
    # :active : time don't stop
    #
    # $game_system.atb_speed = X
    # 1.0 = default speed
    #
    #================================================= =============================

    #================================================= =============================
    # ** Victor Engine
    #------------------------------------------------------------------------------
    # Setting module for the Victor Engine
    #================================================= =============================

    module Victor_Engine
    #--------------------------------------------------------------------------
    # * Wait mode
    # :full_wait : time stop to select commands and actions
    # :semi_wait : time stop to select actions
    # :active : time don't stop
    #--------------------------------------------------------------------------
    VE_ATB_WAIT_MODE = :full_wait
    #--------------------------------------------------------------------------
    # * Action wait
    # if true, time will stop while executing actions
    #--------------------------------------------------------------------------
    VE_ATB_WAIT_ACTION = true
    #--------------------------------------------------------------------------
    # * Reverse ATB
    # This setting revert how the ATB works, instead waiting the bar to fill
    # up to select actions, you first select the action, the the bar start
    # to fill and the action is executed once it's full.
    #--------------------------------------------------------------------------
    VE_ATB_REVERSE = false
    #--------------------------------------------------------------------------
    # * Move status window
    # Setup this true to move the status window when the actor command
    # window or part command window shows up. If false, both windows will
    # be displayed above the status window.
    #--------------------------------------------------------------------------
    VE_MOVE_STATUS_WINDOW = true
    #--------------------------------------------------------------------------
    # * ATB Full Sound
    # Play a sound when the actor command window open. Leave nil for no sound
    # RPG::SE.new(filename, volume, pitch)
    #--------------------------------------------------------------------------
    VE_ATB_SOUND = RPG::SE.new("Decision2", 100, 100)
    #--------------------------------------------------------------------------
    # * Escape type
    # arty : open party menu by pressing the cancel key
    # :command : add the "Escape" option to actors command list
    # :key : press the set keys for a while to escape
    #--------------------------------------------------------------------------
    VE_ATB_ESCAPE_TYPE = :key
    #--------------------------------------------------------------------------
    # * Setup the key that must be pressed for escaping
    # :A >> keyboard Shift :B >> keyboard X :C >> keyboard Z
    # :X >> keyboard A :Y >> keyboard S :Z >> keyboard D
    # :L >> keyboard Q :R >> keyboard W
    # adding more than one key makes need to press all of them at same time
    #--------------------------------------------------------------------------
    VE_ATB_ESCAPE_KEYS = [:R, :L]
    #--------------------------------------------------------------------------
    # * Escape time
    # Average escape time in frames to escape if VE_ATB_ESCAPE_TYPE = :key
    # This value vary based on the battlers stats and the ATB speed
    #--------------------------------------------------------------------------
    VE_ATB_ESCAPE_TIME = 200
    #--------------------------------------------------------------------------
    # * Escape text
    # Display escape text when trying to escape if VE_ATB_ESCAPE_TYPE = :key
    #--------------------------------------------------------------------------
    VE_ATB_ESCAPE_TEXT = true
    #--------------------------------------------------------------------------
    # * Turn count control
    # This is used to control how the turn count will increase, the turn count
    # control the battle event conditions
    # :time : control by time (in frames)
    # :battlers : control by the number of alive battlers
    # :actions : control by the number of actions executed
    #--------------------------------------------------------------------------
    VE_ATB_TURN_COUNT = :time
    #--------------------------------------------------------------------------
    # * Time count
    # Valid only if VE_ATB_TURN_COUNT = :time, setup the number of frames
    # needed to increase the turn count. Is influenced by the ATB speed
    #--------------------------------------------------------------------------
    VE_ATB_TIME_COUNT = 200
    #--------------------------------------------------------------------------
    # * Action count
    # Valid only if VE_ATB_TURN_COUNT = :actions, setup the number of actions
    # needed to increase the turn count
    #--------------------------------------------------------------------------
    VE_ATB_ACTION_COUNT = 10
    #--------------------------------------------------------------------------
    # * ATB speed
    # Multiplier that controls the speed of the ATB bars
    #--------------------------------------------------------------------------
    VE_ATB_SPEED = 1.0
    #--------------------------------------------------------------------------
    # * Speed modifier
    # Value used to control the influence of the stats on the ATB speed
    # Higher values reduce the influence of the stats on the speed.
    #--------------------------------------------------------------------------
    VE_speed_modifier = 50
    #--------------------------------------------------------------------------
    # * Start rate
    # Initial ATB value on battle start, a random value between 0 and X%
    #--------------------------------------------------------------------------
    VE_ATB_START_RATE = 15
    #--------------------------------------------------------------------------
    # * Reverse ATB Guard Time
    # With VE_ATB_REVERSE = true the guard time is set by this value, not
    # by the value set on the database
    #--------------------------------------------------------------------------
    VE_ATB_REVERSE_GUARD_TIME = 150
    #--------------------------------------------------------------------------
    # * Default magic cast
    # Setup a default cast speed for all magic skills.
    # Leave nil for no cast time.
    # 100 = default speed (same as the default wait time for actions)
    #--------------------------------------------------------------------------
    VE_ATB_DEFAULT_CAST = nil
    #--------------------------------------------------------------------------
    # * Damage wait
    # Stop battler wait time during hurt animation. Available only for
    # Animated Battle
    #--------------------------------------------------------------------------
    VE_ATB_DAMAGE_WAIT = true
    #--------------------------------------------------------------------------
    # * Escaping animation
    # Add a steping animation while holding the escape key. Available only for
    # Animated Battle and if VE_ATB_ESCAPE_TYPE = :key
    #--------------------------------------------------------------------------
    VE_ATB_ESCAPING_ANIM = true
    #--------------------------------------------------------------------------
    # * Regenerarion Trigger
    # All regen effects triggers at same time no matter of the source, here
    # you can set when the regen trigger
    # :turn : at the turn end
    # :action : at the action end
    # :timing : at fixed intervals
    # It's highly recomended to setup all regen and poison states with the
    # same auto-removal condition to ensure the duration match the trigger
    #--------------------------------------------------------------------------
    VE_ATB_REGEN_TRIGGER = :action
    #--------------------------------------------------------------------------
    # * Regenerarion Timing
    # Time for regen effects to apply if VE_ATB_REGEN_TRIGGER = :timing
    # Is influenced by the ATB speed
    #--------------------------------------------------------------------------
    VE_ATB_REGEN_TIMING = 300
    #--------------------------------------------------------------------------
    # * 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 required(name, req, version, type = nil)
    if !$imported[:ve_basic_module]
    msg = "The script '%s' requires the script\n"
    msg += "'VE - Basic Module' v%s or higher above it to work properly\n"
    msg += "Go to http://victorscripts.wordpress.com/ to download this script."
    msgbox(sprintf(msg, self.script_name(name), version))
    exit
    else
    self.required_script(name, req, version, type)
    end
    end
    #--------------------------------------------------------------------------
    # * script_name
    # Get the script name base on the imported value
    #--------------------------------------------------------------------------
    def script_name(name, ext = "VE")
    name = name.to_s.gsub("_", " ").upcase.split
    name.collect! {|char| char == ext ? "#{char} -" : char.capitalize }
    name.join(" ")
    end
    end

    $imported ||= {}
    $imported[:ve_active_time_battle] = 1.05
    Victor_Engine.required(:ve_active_time_battle, :ve_basic_module, 1.32, :above)
    Victor_Engine.required(:ve_active_time_battle, :ve_state_auto_apply, 1.00, :bellow)
    Victor_Engine.required(:ve_active_time_battle, :ve_damage_pop, 1.00, :bellow)
    Victor_Engine.required(:ve_active_time_battle, :ve_leap_attack, 1.00, :bellow)
    Victor_Engine.required(:ve_active_time_battle, :ve_cooperation_skill, 1.00, :bellow)

    #================================================= =============================
    # ** Vocab
    #------------------------------------------------------------------------------
    # This module defines terms and messages. It defines some data as constant
    # variables. Terms in the database are obtained from $data_system.
    #================================================= =============================

    module Vocab

    # ATB stat name show above atb bar
    VE_ATB_Name = "ATB"

    # Message displayed when trying to escape using VE_ATB_ESCAPE_TYPE = :key
    VE_Escaping = "Escaping..."

    # Message displayed when can't escape using VE_ATB_ESCAPE_TYPE = :key
    VE_CantEscape = "Can't escape!"

    end

    #================================================= =============================
    # ** class RPG::BaseItem
    #------------------------------------------------------------------------------
    # Superclass of actor, class, skill, item, weapon, armor, enemy, and state.
    #================================================= =============================

    class RPG::BaseItem
    #--------------------------------------------------------------------------
    # * New method: atb_speed
    #--------------------------------------------------------------------------
    def atb_speed
    return @atb_speed if @atb_speed
    @atb_speed = note =~ /<ATB SPEED: *(\d+)%?>/i ? [$1.to_f, 1].max / 100 : 1
    @atb_speed
    end
    end

    #================================================= =============================
    # ** RPG::UsableItem
    #------------------------------------------------------------------------------
    # This is the superclass for skills and items.
    #================================================= =============================

    class RPG::UsableItem < RPG::BaseItem
    #--------------------------------------------------------------------------
    # * New method: castable?
    #--------------------------------------------------------------------------
    def castable?
    (cast_speed && not_cooperation?) ? true : false
    end
    #--------------------------------------------------------------------------
    # * New method: not_cooperation?
    #--------------------------------------------------------------------------
    def not_cooperation?
    !$imported[:ve_cooperation_skill] || !cooperation?
    end
    #--------------------------------------------------------------------------
    # * New method: cast_speed
    #--------------------------------------------------------------------------
    def cast_speed
    regexp = /<CAST TIME: (\d+)(?:, *(\w+))?>/i
    note =~ regexp ? {spd: $1.to_i, stat: ($2 ? $2 : "agi")} : default_cast
    end
    #--------------------------------------------------------------------------
    # * New method: default_cast
    #--------------------------------------------------------------------------
    def default_cast
    speed = VE_ATB_DEFAULT_CAST
    ((magical? && speed) || VE_ATB_REVERSE) ? {spd: speed, stat: "agi"} : nil
    end
    #--------------------------------------------------------------------------
    # * New method: atb_cost
    #--------------------------------------------------------------------------
    def atb_cost
    regexp = /<ATB COST: (\d+)%?>/i
    note =~ regexp ? [1.0 - ($1.to_f / 100), 0].max : 0
    end
    #--------------------------------------------------------------------------
    # * New method: cast_cancel
    #--------------------------------------------------------------------------
    def cast_cancel
    regexp = /<CAST CANCEL: (\d+)%?>/i
    note =~ regexp ? $1.to_f / 100 : 0
    end
    #--------------------------------------------------------------------------
    # * New method: atb_delay
    #--------------------------------------------------------------------------
    def guard_skill?
    effects.any? {|effect| effect.code == 21 && effect.data_id == 9 }
    end
    #--------------------------------------------------------------------------
    # * New method: atb_delay
    #--------------------------------------------------------------------------
    def atb_delay
    regexp = /<ATB DELAY: (\d+)%?, *([+-]?\d+)%?>/i
    note =~ regexp ? {rate: $1.to_f / 100, delay: $2.to_f / 100} :
    {rate: 0, delay: 0}
    end
    end

    #================================================= =============================
    # ** RPG::State
    #------------------------------------------------------------------------------
    # This is the data class for states
    #================================================= =============================

    class RPG::State < RPG::BaseItem
    #--------------------------------------------------------------------------
    # * Alias method: auto_removal_timing
    #--------------------------------------------------------------------------
    alias :auto_removal_timing_ve_active_time_battle :auto_removal_timing
    def auto_removal_timing
    timed_trigger ? 3 : auto_removal_timing_ve_active_time_battle
    end
    #--------------------------------------------------------------------------
    # * New method: timed_trigger
    #--------------------------------------------------------------------------
    def timed_trigger
    return @timed_trigger if @timed_trigger
    return VE_ATB_REVERSE_GUARD_TIME if guard_state?
    @timed_trigger = note =~ /<TIMED TRIGGER: (\d+)>/i ? $1.to_i : nil
    end
    #--------------------------------------------------------------------------
    # * New method: guard_state?
    #--------------------------------------------------------------------------
    def guard_state?
    features.any? {|ft| ft.code == 62 && ft.data_id == 1 }
    end
    end

    #================================================= =============================
    # ** BattleManager
    #------------------------------------------------------------------------------
    # This module handles the battle processing
    #================================================= =============================

    class << BattleManager
    #--------------------------------------------------------------------------
    # * Public Instance Variables
    #--------------------------------------------------------------------------
    attr_reader :input_battlers
    #--------------------------------------------------------------------------
    # * Overwrite method: next_command
    #--------------------------------------------------------------------------
    def next_command
    begin
    return false if !actor || !actor.next_command
    end until actor.inputable?
    return true
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: prior_command
    #--------------------------------------------------------------------------
    def prior_command
    begin
    if !actor || !actor.prior_command
    old_actor = actor
    @actor_index -= 1
    @actor_index %= $game_party.members.size
    return false if old_actor == actor
    end
    end until actor.inputable?
    return true
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: turn_start
    #--------------------------------------------------------------------------
    def turn_start
    @phase = :turn
    make_action_orders
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: turn_end
    #--------------------------------------------------------------------------
    def turn_end
    @phase = :turn_end
    $game_troop.increase_turn
    @atb_turn_count = 0
    @abt_turn_speed = setup_atb_turn_speed
    all_battle_members.each do |battler|
    battler.on_turn_end
    next if scene_changing?
    SceneManager.scene.refresh_status
    SceneManager.scene.log_window.display_auto_affecte d_status(battler)
    SceneManager.scene.log_window.wait_and_clear
    end
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: make_action_orders
    #--------------------------------------------------------------------------
    def make_action_orders
    @action_battlers += @active_members
    @active_members.clear
    end
    #--------------------------------------------------------------------------
    # * Alias method: init_members
    #--------------------------------------------------------------------------
    alias :init_members_ve_active_time_battle :init_members
    def init_members
    init_members_ve_active_time_battle
    @abt_turn_speed = setup_atb_turn_speed
    @escape_time = 0
    @atb_turn_count = 0
    @key_escape_count = 0
    @input_battlers = []
    @active_members = []
    @action_battlers = []
    end
    #--------------------------------------------------------------------------
    # * Alias method: battle_start
    #--------------------------------------------------------------------------
    alias :battle_start_ve_active_time_battle :battle_start
    def battle_start
    battle_start_ve_active_time_battle
    setup_initial_atb
    @phase = :turn
    end
    #--------------------------------------------------------------------------
    # * Alias method: process_escape
    #--------------------------------------------------------------------------
    alias rocess_escape_ve_active_time_battle rocess_escape
    def process_escape
    @preemptive = true if @escape_success
    @escape_success = false
    process_escape_ve_active_time_battle
    end
    #--------------------------------------------------------------------------
    # * New method: update_atb
    #--------------------------------------------------------------------------
    def update_atb
    clear_dead_atb
    return if scene_changing?
    return if $game_troop.interpreter.running?
    return if SceneManager.scene.party_window?
    return if $imported[:ve_animated_battle] && @escaping
    update_timing
    update_turn
    update_all_atb
    update_input
    update_escaping
    end
    #--------------------------------------------------------------------------
    # * New method: setup_initial_atb
    #--------------------------------------------------------------------------
    def setup_initial_atb
    @escape_success = false
    @key_escaping = false
    @escap_pose = false
    @party_escaping = false
    all_battle_members.each {|battler| battler.cast_action = nil }
    if @preemptive
    $game_party.members.each {|battler| battler.atb = battler.max_atb }
    $game_troop.members.each {|battler| battler.atb = 0 }
    elsif @surprise
    $game_party.members.each {|battler| battler.atb = 0 }
    $game_troop.members.each {|battler| battler.atb = battler.max_atb }
    else
    all_battle_members.each {|battler| battler.preset_atb }
    end
    end
    #--------------------------------------------------------------------------
    # * New method: scene_changing?
    #--------------------------------------------------------------------------
    def scene_changing?
    !SceneManager.scene_is?(Scene_Battle)
    end
    #--------------------------------------------------------------------------
    # * New method: update_all_atb
    #--------------------------------------------------------------------------
    def update_all_atb
    return if wating?
    all_battle_members.each {|member| member.atb_update }
    end
    #--------------------------------------------------------------------------
    # * New method: wating?
    #--------------------------------------------------------------------------
    def wating?
    return true if scene_changing?
    return true if $game_troop.interpreter.running?
    return true if SceneManager.scene.full_wait?
    return true if SceneManager.scene.semi_wait?
    return true if wait_action?
    return false
    end
    #--------------------------------------------------------------------------
    # * New method: update_escaping
    #--------------------------------------------------------------------------
    def update_escaping
    open_party_command if VE_ATB_ESCAPE_TYPE == arty
    process_party_escape if VE_ATB_ESCAPE_TYPE == arty && party_escape?
    key_press_escape if VE_ATB_ESCAPE_TYPE == :key
    process_escape if VE_ATB_ESCAPE_TYPE == :key && key_escape?
    end
    #--------------------------------------------------------------------------
    # * New method: open_party_command
    #--------------------------------------------------------------------------
    def open_party_command
    return if scene_changing?
    return if SceneManager.scene.windows_active?
    SceneManager.scene.open_party_command_selection if Input.trigger?(:B)
    end
    #--------------------------------------------------------------------------
    # * New method: party_escape?
    #--------------------------------------------------------------------------
    def party_escape?
    $game_party.alive_members.all? {|actor| actor.atb_full? } &&
    all_battle_members.all? {|battler| !active_battler?(battler) }
    end
    #--------------------------------------------------------------------------
    # * New method: process_party_escape
    #--------------------------------------------------------------------------
    def process_party_escape
    $game_party.members.each do |battler|
    battler.atb = 0
    battler.cast_action = nil
    battler.clear_actions
    end
    @party_escaping = false
    return if process_escape
    turn_start
    SceneManager.scene.battle_start_open_window unless scene_changing?
    end
    #--------------------------------------------------------------------------
    # * New method: key_press_escape
    #--------------------------------------------------------------------------
    def key_press_escape
    @key_escaping = VE_ATB_ESCAPE_KEYS.all? {|key| Input.press?(key)}
    update_escape_time
    end
    #--------------------------------------------------------------------------
    # * New method: key_escape?
    #--------------------------------------------------------------------------
    def key_escape?
    all_battle_members.all? {|battler| !active?(battler) } && @escape_success
    end
    #--------------------------------------------------------------------------
    # * New method: update_escape_time
    #--------------------------------------------------------------------------
    def update_escape_time
    return if @escape_success
    escaping? ? increase_escape_time : decrease_escape_time
    end
    #--------------------------------------------------------------------------
    # * New method: increase_escape_time
    #--------------------------------------------------------------------------
    def increase_escape_time
    reset_escape_pose if !reset_escape_pose?
    @escap_pose = true
    if BattleManager.can_escape?
    @escape_time = [@escape_time + 5 + rand, max_escape_time].min
    @escape_success = @escape_time == max_escape_time
    end
    end
    #--------------------------------------------------------------------------
    # * New method: decrease_escape_time
    #--------------------------------------------------------------------------
    def decrease_escape_time
    reset_escape_pose if reset_escape_pose?
    @escap_pose = false
    @escape_time = [@escape_time - 1, 0].max
    end
    #--------------------------------------------------------------------------
    # * New method: reset_escape_pose
    #--------------------------------------------------------------------------
    def reset_escape_pose
    $game_party.alive_members.each {|actor| actor.reset_pose if !actor.active? }
    end
    #--------------------------------------------------------------------------
    # * New method: reset_escape_pose?
    #--------------------------------------------------------------------------
    def reset_escape_pose?
    $imported[:ve_animated_battle] && @escap_pose && VE_ATB_ESCAPING_ANIM
    end
    #--------------------------------------------------------------------------
    # * New method: max_escape_time
    #--------------------------------------------------------------------------
    def max_escape_time
    10.0 * VE_ATB_ESCAPE_TIME * @escape_ratio * $game_system.atb_speed
    end
    #--------------------------------------------------------------------------
    # * New method: wait_action?
    #--------------------------------------------------------------------------
    def wait_action?
    $imported[:ve_animated_battle] && !scene_changing? &&
    SceneManager.scene.wait_action? && SceneManager.scene.active?
    end
    #--------------------------------------------------------------------------
    # * New method: update_turn
    #--------------------------------------------------------------------------
    def update_turn
    return if wating?
    increase_atb_turn_count(:time)
    SceneManager.scene.turn_ending if @atb_turn_count >= @abt_turn_speed
    end
    #--------------------------------------------------------------------------
    # * New method: update_timing
    #--------------------------------------------------------------------------
    def update_timing
    return if wating?
    all_battle_members.each {|battler| battler.on_timing }
    end
    #--------------------------------------------------------------------------
    # * New method: update_input
    #--------------------------------------------------------------------------
    def update_input
    all_battle_members.reverse.each do |battler|
    next if (@party_escaping && battler.actor?) || !battler.ready?
    @input_battlers.push(battler)
    battler.on_action_start
    skill_window.refresh if skill_window.active
    item_window.refresh if item_window.active
    end
    shift_input unless @input_battlers.empty?
    end
    #--------------------------------------------------------------------------
    # * New method: skill_window
    #--------------------------------------------------------------------------
    def skill_window
    SceneManager.scene.skill_window
    end
    #--------------------------------------------------------------------------
    # * New method: item_window
    #--------------------------------------------------------------------------
    def item_window
    SceneManager.scene.item_window
    end
    #--------------------------------------------------------------------------
    # * New method: shift_input
    #--------------------------------------------------------------------------
    def shift_input
    battler = @input_battlers.last
    battler.actor? ? setup_action(battler) : setup_no_selection(battler)
    end
    #--------------------------------------------------------------------------
    # * New method: setup_action
    #--------------------------------------------------------------------------
    def setup_action(battler)
    return if scene_changing?
    return if SceneManager.scene.windows_active? && battler.inputable?
    return if battler.guard? && VE_ATB_REVERSE
    battler.inputable? ? setup_selection(battler) : setup_no_selection(battler)
    end
    #--------------------------------------------------------------------------
    # * New method: setup_selection
    #--------------------------------------------------------------------------
    def setup_selection(battler)
    @actor_index = battler.index
    battler.make_actions
    SceneManager.scene.start_actor_command_selection
    VE_ATB_SOUND.play if VE_ATB_SOUND
    end
    #--------------------------------------------------------------------------
    # * New method: setup_no_selection
    #--------------------------------------------------------------------------
    def setup_no_selection(battler)
    battler.turn_count += 1 if !battler.actor? && !battler.cast_action?
    battler.make_actions
    battler.setup_cast_action if battler.cast_action?
    @input_battlers.delete(battler)
    @active_members.push(battler)
    turn_start
    end
    #--------------------------------------------------------------------------
    # * New method: add_actor
    #--------------------------------------------------------------------------
    def add_actor(battler)
    return unless input_battlers?(battler)
    @input_battlers.delete(battler)
    @active_members.push(battler)
    end
    #--------------------------------------------------------------------------
    # * New method: active_battler?
    #--------------------------------------------------------------------------
    def active_battler?(battler)
    @active_members.include?(battler) || @action_battlers.include?(battler) ||
    @input_battlers.include?(battler) || battler.current_actor? ||
    active?(battler)
    end
    #--------------------------------------------------------------------------
    # * New method: input_battlers?
    #--------------------------------------------------------------------------
    def input_battlers?(battler)
    @input_battlers.include?(battler)
    end
    #--------------------------------------------------------------------------
    # * New method: all_battle_members
    #--------------------------------------------------------------------------
    def all_battle_members
    $game_party.members + $game_troop.members
    end
    #--------------------------------------------------------------------------
    # * New method: all_dead_members
    #--------------------------------------------------------------------------
    def all_dead_members
    $game_party.dead_members + $game_troop.dead_members
    end
    #--------------------------------------------------------------------------
    # * New method: delete_input
    #--------------------------------------------------------------------------
    def delete_input(battler)
    @input_battlers.delete(battler)
    end
    #--------------------------------------------------------------------------
    # * New method: clear_battler
    #--------------------------------------------------------------------------
    def clear_battler(battler)
    @input_battlers.delete(battler)
    @active_members.delete(battler)
    end
    #--------------------------------------------------------------------------
    # * New method: escaping?
    #--------------------------------------------------------------------------
    def escaping?
    @key_escaping
    end
    #--------------------------------------------------------------------------
    # * New method: party_escaping?
    #--------------------------------------------------------------------------
    def party_escaping?
    @party_escaping
    end
    #--------------------------------------------------------------------------
    # * New method: active?
    #--------------------------------------------------------------------------
    def active?(battler)
    $imported[:ve_animated_battle] && battler.poses.active?
    end
    #--------------------------------------------------------------------------
    # * New method: setup_atb_turn_speed
    #--------------------------------------------------------------------------
    def setup_atb_turn_speed
    case VE_ATB_TURN_COUNT
    when :battlers then all_dead_members.size
    when :actions then VE_ATB_ACTION_COUNT
    when :time then VE_ATB_TIME_COUNT
    end
    end
    #--------------------------------------------------------------------------
    # * New method: clear_dead_atb
    #--------------------------------------------------------------------------
    def clear_dead_atb
    all_dead_members.each do |battler|
    next unless active_battler?(battler)
    battler.atb = 0
    @active_members.delete(battler)
    @input_battlers.delete(battler)
    @action_battlers.delete(battler)
    end
    end
    #--------------------------------------------------------------------------
    # * New method: increase_atb_turn_count
    #--------------------------------------------------------------------------
    def increase_atb_turn_count(type)
    @atb_turn_count += $game_system.atb_speed if VE_ATB_TURN_COUNT == type
    end
    #--------------------------------------------------------------------------
    # * New method: setup_escape
    #--------------------------------------------------------------------------
    def setup_escape
    $game_party.members.each {|battler| delete_input(battler) }
    @party_escaping = true
    end
    #--------------------------------------------------------------------------
    # * New method: undo_escape
    #--------------------------------------------------------------------------
    def undo_escape
    @party_escaping = false
    end
    #--------------------------------------------------------------------------
    # * New method: turn_phase
    #--------------------------------------------------------------------------
    def turn_phase
    @phase = :turn
    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 :wait_mode
    attr_accessor :atb_speed
    #--------------------------------------------------------------------------
    # * Alias method: initialize
    #--------------------------------------------------------------------------
    alias :initialize_ve_active_time_battle :initialize
    def initialize
    initialize_ve_active_time_battle
    @wait_mode = VE_ATB_WAIT_MODE
    @atb_speed = VE_ATB_SPEED
    end
    end

    #================================================= =============================
    # ** Game_Action
    #------------------------------------------------------------------------------
    # This class handles battle actions. This class is used within the
    # Game_Battler class.
    #================================================= =============================

    class Game_Action
    #--------------------------------------------------------------------------
    # * Alias method: prepare
    #--------------------------------------------------------------------------
    alias repare_ve_active_time_battle repare
    def prepare
    subject.atb = item ? subject.atb * item.atb_cost : 0
    if item && item.castable? && !subject.cast_action? &&
    !subject.confusion? && !forcing
    subject.cast_action = self.clone
    subject.skip_actions
    subject.reset_pose if $imported[:ve_animated_battle]
    else
    subject.cast_action = nil if !forcing
    prepare_ve_active_time_battle
    end
    end
    end

    #================================================= =============================
    # ** Game_BattlerBase
    #------------------------------------------------------------------------------
    # This class handles battlers. It's used as a superclass of the Game_Battler
    # classes.
    #================================================= =============================

    class Game_BattlerBase
    #--------------------------------------------------------------------------
    # * Alias method: inputable?
    #--------------------------------------------------------------------------
    alias :inputable_ve_active_time_battle? :inputable?
    def inputable?
    inputable_ve_active_time_battle? && atb_full? && input? && !cast_action?
    end
    #--------------------------------------------------------------------------
    # * Alias method: clear_states
    #--------------------------------------------------------------------------
    alias :clear_states_ve_active_time_battle :clear_states
    def clear_states
    clear_states_ve_active_time_battle
    @state_timing = {}
    end
    #--------------------------------------------------------------------------
    # * Alias method: erase_state
    #--------------------------------------------------------------------------
    alias :erase_state_ve_active_time_battle :erase_state
    def erase_state(state_id)
    erase_state_ve_active_time_battle(state_id)
    @state_timing.delete(state_id)
    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 :cast_action
    #--------------------------------------------------------------------------
    # * Overwite method: on_action_end
    #--------------------------------------------------------------------------
    def on_action_end
    @result.clear
    regenerate_all if VE_ATB_REGEN_TRIGGER == :action
    @result.clear if VE_ATB_REGEN_TRIGGER == :action
    remove_states_auto(1)
    update_buff_turns
    remove_buffs_auto
    end
    #--------------------------------------------------------------------------
    # * Overwite method: on_turn_end
    #--------------------------------------------------------------------------
    def on_turn_end
    @result.clear
    remove_states_auto(2)
    end
    #--------------------------------------------------------------------------
    # * Alias method: remove_states_auto
    #--------------------------------------------------------------------------
    alias :remove_states_auto_ve_active_time_battle :remove_states_auto
    def remove_states_auto(timing)
    update_state_auto(timing)
    remove_states_auto_ve_active_time_battle(timing)
    end
    #--------------------------------------------------------------------------
    # * Alias method: item_user_effect
    #--------------------------------------------------------------------------
    alias :item_user_effect_ve_active_time_battle :item_user_effect
    def item_user_effect(user, item)
    item_user_effect_ve_active_time_battle(user, item)
    setup_cast_cancel(user, item)
    setup_atb_delay(user, item)
    end
    #--------------------------------------------------------------------------
    # * Alias method: reset_state_counts
    #--------------------------------------------------------------------------
    alias :reset_state_counts_ve_active_time_battle :reset_state_counts
    def reset_state_counts(state_id)
    reset_state_counts_ve_active_time_battle(state_id)
    state = $data_states[state_id]
    @state_timing[state_id] = state.timed_trigger if state.timed_trigger
    end
    #--------------------------------------------------------------------------
    # * New method: max_atb
    #--------------------------------------------------------------------------
    def max_atb
    @max_atb ||= 1000
    end
    #--------------------------------------------------------------------------
    # * New method: atb
    #--------------------------------------------------------------------------
    def atb
    @atb ||= 0
    end
    #--------------------------------------------------------------------------
    # * New method: atb=
    #--------------------------------------------------------------------------
    def atb=(n)
    @atb = [[n, 0].max, max_atb].min
    end
    #--------------------------------------------------------------------------
    # * New method: atb_freeze
    #--------------------------------------------------------------------------
    def atb_freeze
    @atb_freeze
    end
    #--------------------------------------------------------------------------
    # * New method: regen_timing
    #--------------------------------------------------------------------------
    def regen_timing
    @regen_timing ||= 0
    end
    #--------------------------------------------------------------------------
    # * New method: regen_timing=
    #--------------------------------------------------------------------------
    def regen_timing=(n)
    @regen_timing = [[n, 0].max, VE_ATB_REGEN_TIMING].min
    end
    #--------------------------------------------------------------------------
    # * New method: regen_timing_full?
    #--------------------------------------------------------------------------
    def regen_timing_full?
    regen_timing == VE_ATB_REGEN_TIMING
    end
    #--------------------------------------------------------------------------
    # * New method: atb_freeze=
    #--------------------------------------------------------------------------
    def atb_freeze=(n)
    @atb_freeze = n
    end
    #--------------------------------------------------------------------------
    # * New method: atb_full?
    #--------------------------------------------------------------------------
    def atb_full?
    @atb == max_atb
    end
    #--------------------------------------------------------------------------
    # * New method: atb_rate
    #--------------------------------------------------------------------------
    def atb_rate
    atb.to_f / max_atb
    end
    #--------------------------------------------------------------------------
    # * New method: ready?
    #--------------------------------------------------------------------------
    def ready?
    movable? && atb_full? && !active_battler?
    end
    #--------------------------------------------------------------------------
    # * New method: cast_action?
    #--------------------------------------------------------------------------
    def cast_action?
    cast_action ? true : false
    end
    #--------------------------------------------------------------------------
    # * New method: preset_atb
    #--------------------------------------------------------------------------
    def preset_atb
    self.atb = max_atb * VE_ATB_START_RATE * rand / 100
    end
    #--------------------------------------------------------------------------
    # * New method: total_agi
    #--------------------------------------------------------------------------
    def total_agi
    SceneManager.scene.all_battle_members.inject(0.0) {|r, obj| r += obj.agi }
    end
    #--------------------------------------------------------------------------
    # * New method: atb_update
    #--------------------------------------------------------------------------
    def atb_update
    update_atb_freeze if atb_freeze?
    return if atb_wait?
    self.atb_freeze = nil
    self.atb += update_atb
    self.atb = max_atb if VE_ATB_REVERSE && !cast_action?
    end
    #--------------------------------------------------------------------------
    # * New method: atb_freeze?
    #--------------------------------------------------------------------------
    def atb_freeze?
    !movable?
    end
    #--------------------------------------------------------------------------
    # * New method: update_atb
    #--------------------------------------------------------------------------
    def update_atb
    speed = cast_action? ? cast_speed : agi
    20.0 * $game_system.atb_speed * atb_speed_mod(speed) * speed_modifier
    end
    #--------------------------------------------------------------------------
    # * New method: atb_wait?
    #--------------------------------------------------------------------------
    def atb_wait?
    atb_full? || atb_freeze? || pause_damage? || current_actor? ||
    (actor? && BattleManager.escaping?)
    end
    #--------------------------------------------------------------------------
    # * New method: update_atb_freeze
    #--------------------------------------------------------------------------
    def update_atb_freeze
    self.cast_action = nil
    self.atb_freeze ||= self.atb
    self.atb_freeze += update_atb
    atb_freeze_result unless @atb_freeze < max_atb
    end
    #--------------------------------------------------------------------------
    # * New method: atb_freeze_result
    #--------------------------------------------------------------------------
    def atb_freeze_result
    @result.clear
    remove_states_auto(1)
    regenerate_all if VE_ATB_REGEN_TRIGGER == :action
    self.atb_freeze = 0
    end
    #--------------------------------------------------------------------------
    # * New method: pause_damage?
    #--------------------------------------------------------------------------
    def pause_damage?
    VE_ATB_DAMAGE_WAIT && $imported[:ve_animated_battle] && poses.damage_pose?
    end
    #--------------------------------------------------------------------------
    # * New method: cast_speed
    #--------------------------------------------------------------------------
    def cast_speed
    return agi if !cast_action
    speed = cast_action.item.cast_speed
    speed[:spd] * send(make_symbol(speed[:stat])) / 100.0
    end
    #--------------------------------------------------------------------------
    # * New method: atb_speed_mod
    #--------------------------------------------------------------------------
    def atb_speed_mod(speed)
    (speed + [VE_speed_modifier, 0].max) / total_agi
    end
    #--------------------------------------------------------------------------
    # * New method: setup_cast_action
    #--------------------------------------------------------------------------
    def setup_cast_action
    @actions = [cast_action]
    end
    #--------------------------------------------------------------------------
    # * New method: setup_cast_cancel
    #--------------------------------------------------------------------------
    def setup_cast_cancel(user, item)
    rate = item.cast_cancel
    rate += user.cast_cancel if item.physical?
    rate *= cast_protection
    execute_cast_cancel if rand < rate && cast_action?
    end
    #--------------------------------------------------------------------------
    # * New method: setup_atb_delay
    #--------------------------------------------------------------------------
    def setup_atb_delay(user, item)
    rate = item.atb_delay[:rate]
    rate += user.atb_delay[:rate] if item.physical?
    rate *= delay_protection
    execute_atb_delay(user, item) if rand < rate
    end
    #--------------------------------------------------------------------------
    # * New method: execute_cast_cancel
    #--------------------------------------------------------------------------
    def execute_cast_cancel
    skip_actions
    self.atb = 0
    self.cast_action = nil
    end
    #--------------------------------------------------------------------------
    # * New method: execute_atb_delay
    #--------------------------------------------------------------------------
    def execute_atb_delay(user, item)
    rate = item.atb_delay[:delay]
    rate += user.atb_delay[:delay] if item.physical?
    self.atb -= max_atb * rate
    end
    #--------------------------------------------------------------------------
    # * New method: cast_cancel
    #--------------------------------------------------------------------------
    def cast_cancel
    regexp = /<CAST CANCEL: (\d+)%?>/i
    get_all_notes.scan(regexp).inject(0.0) {|r| r += ($1.to_f / 100) }
    end
    #--------------------------------------------------------------------------
    # * New method: atb_delay
    #--------------------------------------------------------------------------
    def atb_delay
    result = {}
    notes = get_all_notes.dup
    regexp = /<ATB DELAY: (\d+)%?, *(\d+)%?>/i
    result[:rate] = notes.scan(regexp).inject(0.0) {|r| r += ($1.to_f / 100) }
    result[:delay] = notes.scan(regexp).inject(0.0) {|r| r += ($1.to_f / 100) }
    result
    end
    #--------------------------------------------------------------------------
    # * New method: cast_protection
    #--------------------------------------------------------------------------
    def cast_protection
    regexp = /<CAST PROTECTION: (\d+)%?>/i
    get_all_notes.scan(regexp).inject(1.0) {|r| r *= 1 - ($1.to_f / 100) }
    end
    #--------------------------------------------------------------------------
    # * New method: delay_protection
    #--------------------------------------------------------------------------
    def delay_protection
    regexp = /<DELAY PROTECTION: (\d+)%?>/i
    get_all_notes.scan(regexp).inject(1.0) {|r| r *= 1 - ($1.to_f / 100) }
    end
    #--------------------------------------------------------------------------
    # * New method: update_state_auto
    #--------------------------------------------------------------------------
    def update_state_auto(timing)
    states.each do |state|
    if @state_turns[state.id] > 0 && state.auto_removal_timing == timing
    @state_turns[state.id] -= 1
    end
    end
    end
    #--------------------------------------------------------------------------
    # * New method: on_timing
    #--------------------------------------------------------------------------
    def on_timing
    timing_regen
    remove_timing_states
    end
    #--------------------------------------------------------------------------
    # * New method: timing_regen
    #--------------------------------------------------------------------------
    def timing_regen
    return unless VE_ATB_REGEN_TRIGGER == :timing
    self.regen_timing += $game_system.atb_speed if regen?
    @result.clear if regen_timing_full?
    regenerate_all if regen_timing_full?
    @regen_timing = 0 if regen_timing_full? || !regen?
    end
    #--------------------------------------------------------------------------
    # * New method: remove_timing_states
    #--------------------------------------------------------------------------
    def remove_timing_states
    states.each do |state|
    next if state.auto_removal_timing != 3
    next if state.guard_state? && !VE_ATB_REVERSE
    @state_timing[state.id] -= $game_system.atb_speed
    if @state_turns[state.id] > 0 && @state_timing[state.id] <= 0
    @state_turns[state.id] -= 1
    @state_timing[state.id] = state.timed_trigger
    end
    remove_state(state.id) if @state_turns[state.id] == 0
    end
    end
    #--------------------------------------------------------------------------
    # * New method: regen?
    #--------------------------------------------------------------------------
    def regen?
    hrg != 0 || mrg != 0 || trg != 0
    end
    #--------------------------------------------------------------------------
    # * Overwite method: on_action_end
    #--------------------------------------------------------------------------
    def on_action_start
    make_actions
    remove_guard_state
    end
    #--------------------------------------------------------------------------
    # * Overwite method: remove_guard_state
    #--------------------------------------------------------------------------
    def remove_guard_state
    return if VE_ATB_REVERSE
    states.each do |state|
    next unless state.guard_state?
    remove_state(state.id)
    @damaged = true
    end
    end
    #--------------------------------------------------------------------------
    # * New method: skip_actions
    #--------------------------------------------------------------------------
    def skip_actions
    clear_actions
    @actions = [Game_Action.new(self)]
    end
    #--------------------------------------------------------------------------
    # * New method: active_battler?
    #--------------------------------------------------------------------------
    def active_battler?
    BattleManager.active_battler?(self)
    end
    #--------------------------------------------------------------------------
    # * New method: input?
    #--------------------------------------------------------------------------
    def input?
    BattleManager.input_battlers?(self)
    end
    #--------------------------------------------------------------------------
    # * New method: current_actor?
    #--------------------------------------------------------------------------
    def current_actor?
    SceneManager.scene_is?(Scene_Battle) && SceneManager.scene.subject == self
    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
    #--------------------------------------------------------------------------
    # * New method: speed_modifier
    #--------------------------------------------------------------------------
    def speed_modifier
    list = [self.actor] + [self.class] + states + equips
    list.compact.inject(1.0) {|r, obj| r *= obj.atb_speed }
    end
    end

    #================================================= =============================
    # ** Game_Enemy
    #------------------------------------------------------------------------------
    # This class handles enemy characters. It's used within the Game_Troop class
    # ($game_troop).
    #================================================= =============================

    class Game_Enemy < Game_Battler
    #--------------------------------------------------------------------------
    # * Public Instance Variables
    #--------------------------------------------------------------------------
    attr_accessor :turn_count
    #--------------------------------------------------------------------------
    # * Overwrite method: conditions_met_turns?
    #--------------------------------------------------------------------------
    def conditions_met_turns?(param1, param2)
    n = @turn_count
    if param2 == 0
    n == param1
    else
    n > 0 && n >= param1 && n % param2 == param1 % param2
    end
    end
    #--------------------------------------------------------------------------
    # * Alias method: initialize
    #--------------------------------------------------------------------------
    alias :initialize_ve_active_time_battle :initialize
    def initialize(index, enemy_id)
    initialize_ve_active_time_battle(index, enemy_id)
    @turn_count = 0
    end
    #--------------------------------------------------------------------------
    # * New method: speed_modifier
    #--------------------------------------------------------------------------
    def speed_modifier
    enemy.atb_speed * states.inject(1.0) {|r, state| r *= state.atb_speed }
    end
    end

    #================================================= =============================
    # ** Spriteset_Battle
    #------------------------------------------------------------------------------
    # This class brings together battle screen sprites. It's used within the
    # Scene_Battle class.
    #================================================= =============================

    class Spriteset_Battle
    #--------------------------------------------------------------------------
    # * Alias method: update_actors
    #--------------------------------------------------------------------------
    alias :update_actors_ve_active_time_battle :update_actors
    def update_actors
    uptate_actors_atb
    update_actors_ve_active_time_battle
    end
    #--------------------------------------------------------------------------
    # * New method: uptate_actors_atb
    #--------------------------------------------------------------------------
    def uptate_actors_atb
    return if @atb_actors == $game_party.members
    $game_party.members.each do |actor|
    actor.preset_atb if @atb_actors && !@atb_actors.include?(actor)
    end
    @atb_actors = $game_party.members.dup
    end
    end

    #================================================= =============================
    # ** Window_Base
    #------------------------------------------------------------------------------
    # This is a superclass of all windows in the game.
    #================================================= =============================

    class Window_Base < Window
    #--------------------------------------------------------------------------
    # * Public Instance Variables
    #--------------------------------------------------------------------------
    attr_accessor :hidden
    end

    #================================================= =============================
    # ** Window_BattleLog
    #------------------------------------------------------------------------------
    # This window shows the battle progress. Do not show the window frame.
    #================================================= =============================

    class Window_BattleLog < Window_Selectable
    #--------------------------------------------------------------------------
    # * Alias method: last_text
    #--------------------------------------------------------------------------
    alias :last_text_ve_active_time_battle :last_text
    def last_text
    last_text_ve_active_time_battle ? last_text_ve_active_time_battle : ""
    end
    end

    #================================================= =============================
    # ** Window_ActorCommand
    #------------------------------------------------------------------------------
    # This window is used to select actor commands, such as "Attack" or "Skill".
    #================================================= =============================

    class Window_ActorCommand < Window_Command
    #--------------------------------------------------------------------------
    # * Alias method: make_command_list
    #--------------------------------------------------------------------------
    alias :make_command_list_ve_active_time_battle :make_command_list
    def make_command_list
    make_command_list_ve_active_time_battle
    add_escape_command if VE_ATB_ESCAPE_TYPE == :command
    end
    #--------------------------------------------------------------------------
    # * New method: add_escape_command
    #--------------------------------------------------------------------------
    def add_escape_command
    add_command(Vocab::escape, :escape, BattleManager.can_escape?)
    end
    end

    #================================================= =============================
    # ** Window_BattleStatus
    #------------------------------------------------------------------------------
    # Esta janela exibe as condições de todos membros do grupo na tela de batalha.
    #================================================= =============================

    class Window_BattleStatus < Window_Selectable
    #--------------------------------------------------------------------------
    # * Overwrite method: window_width
    #--------------------------------------------------------------------------
    def window_width
    Graphics.width - ($data_system.opt_display_tp ? 0 : 128)
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: draw_basic_area
    #--------------------------------------------------------------------------
    def draw_basic_area(rect, actor)
    width = $data_system.opt_display_tp ? 180 : 104
    draw_actor_name(actor, rect.x + 0, rect.y, 100)
    draw_actor_icons(actor, rect.x + 104, rect.y, [rect.width - width, 24].max)
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: draw_gauge_area_with_tp
    #--------------------------------------------------------------------------
    def draw_gauge_area_with_tp(rect, actor)
    draw_actor_hp(actor, rect.x - 82, rect.y, 72)
    draw_actor_mp(actor, rect.x + 0, rect.y, 64)
    draw_actor_tp(actor, rect.x + 74, rect.y, 64)
    update_atb
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: draw_gauge_area_without_tp
    #--------------------------------------------------------------------------
    def draw_gauge_area_without_tp(rect, actor)
    draw_actor_hp(actor, rect.x + 0, rect.y, 72)
    draw_actor_mp(actor, rect.x + 82, rect.y, 64)
    update_atb
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: update
    #--------------------------------------------------------------------------
    def update
    super
    update_atb
    end
    #--------------------------------------------------------------------------
    # * New method: update_atb
    #--------------------------------------------------------------------------
    def update_atb
    @count ||= 0
    @count += 1
    return if @count % 2 != 0
    update_atb_bars
    end
    #--------------------------------------------------------------------------
    # * New method: update_atb_bars
    #--------------------------------------------------------------------------
    def update_atb_bars
    tp_adjust = $data_system.opt_display_tp ? 148 : 156
    item_max.times do |i|
    actor = $game_party.battle_members[i]
    rect = gauge_area_rect(i)
    rect.x += tp_adjust
    contents.clear_rect(rect)
    draw_actor_atb(actor, rect.x, rect.y, 64)
    end
    end
    #--------------------------------------------------------------------------
    # * New method: draw_actor_atb
    #--------------------------------------------------------------------------
    def draw_actor_atb(actor, x, y, width = 124)
    color1 = setup_atb_color1(actor)
    color2 = setup_atb_color2(actor)
    draw_gauge(x, y, width, actor.atb_rate, color1, color2)
    change_color(system_color)
    draw_text(x, y, 30, line_height, Vocab::VE_ATB_Name)
    end
    #--------------------------------------------------------------------------
    # * New method: setup_atb_color1
    #--------------------------------------------------------------------------
    def setup_atb_color1(actor)
    return text_color(2) if actor.cast_action?
    return text_color(6) if BattleManager.party_escaping?
    return text_color(5)
    end
    #--------------------------------------------------------------------------
    # * New method: setup_atb_color2
    #--------------------------------------------------------------------------
    def setup_atb_color2(actor)
    return text_color(10) if actor.cast_action?
    return text_color(14) if BattleManager.party_escaping?
    return text_color(13)
    end
    end

    #================================================= =============================
    # ** Scene_Battle
    #------------------------------------------------------------------------------
    # This class performs battle screen processing.
    #================================================= =============================

    class Scene_Battle < Scene_Base
    #--------------------------------------------------------------------------
    # * Public Instance Variables
    #--------------------------------------------------------------------------
    attr_reader :log_window
    attr_reader :item_window
    attr_reader :skill_window
    #--------------------------------------------------------------------------
    # * Overwrite method: update_info_viewport
    #--------------------------------------------------------------------------
    def update_all_windows
    update_active_windows
    super
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: update_info_viewport
    #--------------------------------------------------------------------------
    def update_info_viewport
    if VE_MOVE_STATUS_WINDOW
    @move_info_wait = 4 if @moved_info != windows_active?
    @move_info_wait -= 1
    move_info_viewport(0) if @party_command_window.active
    move_info_viewport(right_status_window) if right_info_viewport
    move_info_viewport(center_status_window) if center_info_viewport
    @moved_info = windows_active?
    else
    move_info_viewport(128)
    end
    update_close_command_window
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: turn_start
    #--------------------------------------------------------------------------
    def turn_start
    BattleManager.add_actor(BattleManager.actor)
    @close_command_wait = 2
    @close_command_window = true
    @status_window.unselect
    BattleManager.turn_start
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: start_party_command_selection
    #--------------------------------------------------------------------------
    def start_party_command_selection
    end
    #--------------------------------------------------------------------------
    # * Overwrite method: turn_end
    #--------------------------------------------------------------------------
    def turn_end
    end
    #--------------------------------------------------------------------------
    # * Alias method: battle_start
    #--------------------------------------------------------------------------
    alias :battle_start_ve_active_time_battle :battle_start
    def battle_start
    battle_start_ve_active_time_battle
    battle_start_open_window
    end
    #--------------------------------------------------------------------------
    # * Alias method: create_all_windows
    #--------------------------------------------------------------------------
    alias :create_all_windows_ve_active_time_battle :create_all_windows
    def create_all_windows
    create_all_windows_ve_active_time_battle
    create_escape_window
    @close_command_wait = 0
    @move_info_wait = 4
    end
    #--------------------------------------------------------------------------
    # * Alias method: reate_party_command_window
    #--------------------------------------------------------------------------
    alias :create_party_command_window_ve_active_time_battle :create_party_command_window
    def create_party_command_window
    create_party_command_window_ve_active_time_battle
    unless VE_MOVE_STATUS_WINDOW
    @party_command_window.x = @party_command_window.width
    end
    @info_viewport.ox = center_status_window
    end
    #--------------------------------------------------------------------------
    # * Alias method: create_actor_command_window
    #--------------------------------------------------------------------------
    alias :create_command_window_ve_active_time_battle :create_actor_command_window
    def create_actor_command_window
    create_command_window_ve_active_time_battle
    @actor_command_window.set_handler(:escape, method(:command_escape))
    if !VE_MOVE_STATUS_WINDOW
    @actor_command_window.x = @actor_command_window.width
    elsif $data_system.opt_display_tp
    @actor_command_window.x = Graphics.width + 128
    end
    end
    #--------------------------------------------------------------------------
    # * Alias method: update
    #--------------------------------------------------------------------------
    alias :update_ve_active_time_battle :update
    def update
    result = update_ve_active_time_battle
    BattleManager.update_atb unless result
    result
    end
    #--------------------------------------------------------------------------
    # * Alias method: update_basic
    #--------------------------------------------------------------------------
    alias :update_basic_ve_active_time_battle :update_basic
    def update_basic
    update_basic_ve_active_time_battle
    update_escape_window if VE_ATB_ESCAPE_TYPE == :key
    end
    #--------------------------------------------------------------------------
    # * Alias method: update_for_wait
    #--------------------------------------------------------------------------
    alias :update_for_wait_ve_active_time_battle :update_for_wait
    def update_for_wait
    update_for_wait_ve_active_time_battle
    BattleManager.update_atb if BattleManager.in_turn? && !wait_action?
    end
    #--------------------------------------------------------------------------
    # * Alias method: wait_for_message
    #--------------------------------------------------------------------------
    alias :wait_for_message_ve_active_time_battle :wait_for_message
    def wait_for_message
    wait_for_message_ve_active_time_battle
    open_windows
    end
    #--------------------------------------------------------------------------
    # * Atualização da mensagem aberta
    #--------------------------------------------------------------------------
    alias :update_message_open_ve_active_time_battle :update_message_open
    def update_message_open
    close_windows
    update_message_open_ve_active_time_battle
    end
    #--------------------------------------------------------------------------
    # * Alias method: start_actor_command_selection
    #--------------------------------------------------------------------------
    alias :start_actor_command_selection_ve_active_time_batt le :start_actor_command_selection
    def start_actor_command_selection
    start_actor_command_selection_ve_active_time_battl e
    @close_command_window = false
    end
    #--------------------------------------------------------------------------
    # * Alias method: process_action_end
    #--------------------------------------------------------------------------
    alias rocess_action_end_ve_active_time_battle rocess_action_end
    def process_action_end
    return if $imported[:ve_animated_battle] && @subject.poses.active?
    BattleManager.increase_atb_turn_count(:battlers)
    BattleManager.increase_atb_turn_count(:actions)
    process_action_end_ve_active_time_battle
    end
    #--------------------------------------------------------------------------
    # * Alias method: command_fight
    #--------------------------------------------------------------------------
    alias :command_fight_end_ve_active_time_battle :command_fight
    def command_fight
    command_fight_end_ve_active_time_battle
    @party_command_window.close
    BattleManager.undo_escape
    end
    #--------------------------------------------------------------------------
    # * Alias method: command_escape
    #--------------------------------------------------------------------------
    alias :command_escape_end_ve_active_time_battle :command_escape
    def command_escape
    if VE_ATB_ESCAPE_TYPE == :command
    BattleManager.actor.atb = 0
    command_escape_end_ve_active_time_battle
    battle_start_open_window
    else
    @party_command_window.close
    BattleManager.setup_escape
    end
    end
    #--------------------------------------------------------------------------
    # * Alias method: prior_command
    #--------------------------------------------------------------------------
    alias rior_command_ve_active_time_battle rior_command
    def prior_command
    prior_command_ve_active_time_battle
    open_party_command_selection if !BattleManager.actor.prior_command
    end
    #--------------------------------------------------------------------------
    # * Alias method: on_enemy_ok
    #--------------------------------------------------------------------------
    alias n_enemy_ok_ve_active_time_battle n_enemy_ok
    def on_enemy_ok
    return if !@enemy_window.enemy
    on_enemy_ok_ve_active_time_battle
    end
    #--------------------------------------------------------------------------
    # * Alias method: refresh_status
    #--------------------------------------------------------------------------
    alias :refresh_status_ve_active_time_battle :refresh_status
    def refresh_status
    refresh_status_ve_active_time_battle
    @skill_window.refresh if @skill_window.active
    @item_window.refresh if @item_window.active
    end
    #--------------------------------------------------------------------------
    # * New method: update_close_command_window
    #--------------------------------------------------------------------------
    def update_close_command_window
    @close_command_wait -= 1
    if @close_command_wait == 0 && @close_command_window
    @actor_command_window.close
    @close_command_window = false
    end
    end
    #--------------------------------------------------------------------------
    # * New method: update_active_windows
    #--------------------------------------------------------------------------
    def update_active_windows
    @enemy_window.hide if @enemy_window.active && @enemy_window.item_max == 0
    @actor_window.hide if @actor_window.active && @actor_window.item_max == 0
    close_command_windows
    end
    #--------------------------------------------------------------------------
    # * New method: close_command_windows
    #--------------------------------------------------------------------------
    def close_command_windows
    return if !BattleManager.actor || BattleManager.actor.inputable?
    on_enemy_cancel if @enemy_window.active
    on_actor_cancel if @actor_window.active
    on_skill_cancel if @skill_window.active
    on_item_cancel if @item_window.active
    @actor_command_window.close.deactivate
    @skill_window.deactivate
    @item_window.deactivate
    @actor_window.deactivate
    @enemy_window.deactivate
    BattleManager.clear_actor
    next_command
    end
    #--------------------------------------------------------------------------
    # * New method: create_escape_window
    #--------------------------------------------------------------------------
    def create_escape_window
    @escape_window = Window_Help.new(1)
    @escape_window.openness = 0
    end
    #--------------------------------------------------------------------------
    # * New method: update_escape_window
    #--------------------------------------------------------------------------
    def update_escape_window
    escaping = BattleManager.escaping?
    open_escape_window if escaping && @escape_window.openness == 0
    @escape_window.close if !escaping && @escape_window.openness != 0
    end
    #--------------------------------------------------------------------------
    # * New method: open_escape_window
    #--------------------------------------------------------------------------
    def open_escape_window
    return if BattleManager.can_escape? && !VE_ATB_ESCAPE_TEXT
    txt = BattleManager.can_escape? ? Vocab::VE_Escaping : Vocab::VE_CantEscape
    @escape_window.set_text(txt)
    @escape_window.open
    end
    #--------------------------------------------------------------------------
    # * New method: on_turn_end
    #--------------------------------------------------------------------------
    def on_turn_end
    end
    #--------------------------------------------------------------------------
    # * New method: close_windows
    #--------------------------------------------------------------------------
    def close_windows
    if $game_message.busy? && !@status_window.close?
    command_windows.each {|window| window.hidden ||= window.open? }
    @help_window.close
    @item_window.close
    @skill_window.close
    @actor_window.close
    @enemy_window.close
    end
    end
    #--------------------------------------------------------------------------
    # * New method: open_windows
    #--------------------------------------------------------------------------
    def open_windows
    command_windows.each do |window|
    window.open if window.hidden
    window.hidden = false
    end
    end
    #--------------------------------------------------------------------------
    # * New method: command_windows
    #--------------------------------------------------------------------------
    def command_windows
    [@party_command_window, @actor_command_window, @help_window, @skill_window,
    @item_window, @actor_window, @enemy_window, @status_window]
    end
    #--------------------------------------------------------------------------
    # * New method: battle_start_open_window
    #--------------------------------------------------------------------------
    def battle_start_open_window
    unless scene_changing?
    refresh_status
    @status_window.unselect
    @status_window.open
    end
    end
    #--------------------------------------------------------------------------
    # * New method: open_party_command_selection
    #--------------------------------------------------------------------------
    def open_party_command_selection
    return if scene_changing? || VE_ATB_ESCAPE_TYPE != arty
    BattleManager.delete_input(BattleManager.actor)
    refresh_status
    @status_window.unselect
    @status_window.open
    @actor_command_window.close.deactivate
    @party_command_window.setup
    end
    #--------------------------------------------------------------------------
    # * New method: wait_action?
    #--------------------------------------------------------------------------
    def wait_action?
    VE_ATB_WAIT_ACTION
    end
    #--------------------------------------------------------------------------
    # * New method: full_wait?
    #--------------------------------------------------------------------------
    def full_wait?
    $game_system.wait_mode == :full_wait && windows_active?(true)
    end
    #--------------------------------------------------------------------------
    # * New method: semi_wait?
    #--------------------------------------------------------------------------
    def semi_wait?
    $game_system.wait_mode == :semi_wait && windows_active?(false)
    end
    #--------------------------------------------------------------------------
    # * New method: party_window?
    #--------------------------------------------------------------------------
    def party_window?
    @party_command_window.active
    end
    #--------------------------------------------------------------------------
    # * New method: windows_active?
    #--------------------------------------------------------------------------
    def windows_active?(command = true)
    (command && @actor_command_window.active) || @skill_window.active ||
    @item_window.active || @actor_window.active || @enemy_window.active
    end
    #--------------------------------------------------------------------------
    # * New method: turn_ending
    #--------------------------------------------------------------------------
    def turn_ending
    BattleManager.turn_end
    process_event
    BattleManager.turn_phase
    end
    #--------------------------------------------------------------------------
    # * New method: right_status_window
    #--------------------------------------------------------------------------
    def right_status_window
    256 - (Graphics.width - @status_window.width)
    end
    #--------------------------------------------------------------------------
    # * New method: center_status_window
    #--------------------------------------------------------------------------
    def center_status_window
    128 - (Graphics.width - @status_window.width) / 2
    end
    #--------------------------------------------------------------------------
    # * New method: right_info_viewport
    #--------------------------------------------------------------------------
    def right_info_viewport
    !@party_command_window.active && windows_active? && @move_info_wait < 0
    end
    #--------------------------------------------------------------------------
    # * New method: center_info_viewport
    #--------------------------------------------------------------------------
    def center_info_viewport
    !@party_command_window.active && !windows_active? && @move_info_wait < 0
    end
    end

    Помогите мне разобраться, как избваться от ошибки и что я делаю не так?
    Последний раз редактировалось rockman765; 30.12.2013 в 12:48.

  2. #2

    По умолчанию

    Из описания ничего не понял. В каком порядке что устанавливалось, какие вообще в проекте скрипты, что за ошибка также не указано.
    Приложите сразу проект, так будет легче разобраться.

    В указанном коде стоит пометка, что требуется скрипт "Victor Engine - Basic Module" версии 1.32 или выше. Он есть в проекте?


    Dropbox — бесплатное хранилище файлов с прямыми ссылками.

    Humble Bundle — игры, подборки и наборы со скидками.

  3. #3
    Новичок Аватар для rockman765
    Информация о пользователе
    Регистрация
    30.12.2013
    Адрес
    Забайкалье
    Сообщений
    27
    Репутация: 1 Добавить или отнять репутацию

    По умолчанию

    В общем скрипты все стандартные стоят. Ничего в самих скриптах не менял. Установил сначала скрипт Ace Battle System в вкладку "Дополнения". Basic Module у меня тоже стоит. Там же. Скрипты все как по описанию совместимы с VX Ace. Пробовал без них, но вылазит всё равно таже ошибка. Что я написал выше. Ошибка в линии 827 скрипта Ace Battle System. Неужели там всё ядро надо ставить? Тоесть скрипт Ace Core Engine?

  4. #4

    По умолчанию

    Выложите скриншот экрана со скриптами.
    Возможно вы ошиблись в порядке установки скриптов или ставите скрипты от разных авторов.

  5. #5
    Новичок Аватар для rockman765
    Информация о пользователе
    Регистрация
    30.12.2013
    Адрес
    Забайкалье
    Сообщений
    27
    Репутация: 1 Добавить или отнять репутацию

    По умолчанию

    Блин, ребята вот же я нуб. Я забыл анимационный фикс поставить, который всё поправил. Проблема решилась, но всё равно спасибо что откликнулись.
    У меня совсем голова кругом идёт. Тяжело тащить проект в одну каску. Хорошо что с системой битв я пока разобрался. Хотел вообще поставить систему как в FFXIII, но я не нашел скрипты под Ace.
    Теперь ломаю голову над сюжетом и пишу саундтрек одновременно. Хорошо хоть праздники впереди. Всех с наступающим!

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

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

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

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

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

Ваши права

  • Вы не можете создавать новые темы
  • Вы не можете отвечать в темах
  • Вы не можете прикреплять вложения
  • Вы не можете редактировать свои сообщения
  •  
Проблема с работой скриптка &quot;Ace Battle System&quot;