Страница 1 из 3 123 ПоследняяПоследняя
Показано с 1 по 10 из 28

Тема: Victor Engine - Map Turn Battle

  1. #1
    Хранитель Аватар для Темный
    Информация о пользователе
    Регистрация
    13.05.2011
    Сообщений
    2,449
    Записей в дневнике
    20
    Репутация: 50 Добавить или отнять репутацию

    По умолчанию Victor Engine - Map Turn Battle

    Данная боевка проходит прямо на карте по типу "Хроно Тигер" Бои проходят пошагово.
    Для использования этой боевой системы требуется дополнительные скрипты. вот их список!
    Victor Engine – Basic Module http://victorscripts.wordpress.com/r.../basic-module/
    Victor Engine – Animated Battle http://victorscripts.wordpress.com/r...imated-battle/
    Victor Engine – Actor Battlers http://victorscripts.wordpress.com/r...tors-battlers/
    чтоб увидить как выглядит боевка щелк на видео.
    Основной модуль
    Код:
    #==============================================================================
    # ** Victor Engine - Basic Module
    #------------------------------------------------------------------------------
    # Author : Victor Sant
    #
    # Version History:
    #  v 1.00 - 2011.12.19 > First relase
    #  v 1.01 - 2011.12.21 > Added Event Troop notes
    #  v 1.02 - 2011.12.22 > Added character frames value
    #  v 1.03 - 2011.12.30 > Added Actor and Enemy notes
    #  v 1.04 - 2012.01.01 > Added party average level and map actors
    #  v 1.05 - 2012.01.04 > Compatibility with Characters Scripts
    #  v 1.06 - 2012.01.07 > Compatibility with Fog and Light Effect
    #                      > Added new Sprite Character functions
    #  v 1.07 - 2012.01.11 > Compatibility with Control Text and Codes
    #  v 1.08 - 2012.01.13 > Compatibility with Trait Control
    #  v 1.09 - 2012.01.15 > Fixed the Regular Expressions problem with "" and “”
    #  v 1.10 - 2012.01.18 > Compatibility with Automatic Battlers
    #  v 1.11 - 2012.01.26 > Compatibility with Followers Options
    #                        Compatibility with Animated Battle beta
    #  v 1.12 - 2012.02.08 > Compatibility with Animated Battle
    #  v 1.13 - 2012.02.18 > Fix for non RTP dependant encrypted projects
    #  v 1.14 - 2012.03.11 > Better version handling and required messages
    #  v 1.15 - 2012.03.11 > Added level variable for enemies (to avoid crashes)
    #  v 1.16 - 2012.03.21 > Compatibility with Follower Control
    #  v 1.17 - 2012.03.22 > Compatibility with Follower Control new method
    #  v 1.18 - 2012.03.22 > Added Battler Types tag support 
    #  v 1.19 - 2012.05.20 > Compatibility with Map Turn Battle
    #  v 1.20 - 2012.05.21 > Fix for older RMVXa versions
    #  v 1.21 - 2012.05.29 > Compatibility with Pixel Movement
    #  v 1.22 - 2012.07.02 > Compatibility with Terrain States
    #  v 1.23 - 2012.07.03 > Fix for Pixel Movement
    #  v 1.24 - 2012.07.17 > Compatibility with Critical Hit Effects
    #  v 1.25 - 2012.07.24 > Compatibility with Moving Plaforms
    #  v 1.26 - 2012.07.30 > Compatibility with Automatic Battlers
    #  v 1.27 - 2012.08.01 > Compatibility with Custom Slip Effect
    #  v 1.28 - 2012.08.03 > Compatibility with Custom Slip Effect v 1.01
    #------------------------------------------------------------------------------
    #   This is the basic script for the system from Victory Engine and is
    # required to use the scripts from the engine. This script offer some new
    # functions to be used within many scripts of the engine.
    #------------------------------------------------------------------------------
    # Compatibility
    #   Required for the Victor Engine
    # 
    # * Overwrite methods
    #   class << Cache
    #     def self.character(filename)
    #
    #   class Sprite_Character < Sprite_Base
    #     def set_character_bitmap
    #
    # * Alias methods
    #   class Game_Interpreter
    #     def command_108
    #
    #   class Window_Base < Window
    #     def convert_escape_characters(text)
    #
    #------------------------------------------------------------------------------
    # Instructions:
    #  To instal the script, open you script editor and paste this script on
    #  a new section bellow the Materials section.
    #
    #------------------------------------------------------------------------------
    # New functions
    #
    # * Random number between two vales
    #   rand_between(min, max)
    #    min : min value
    #    max : max value
    #   Can be called from any class, this method return an random value between
    #   two specific numbers
    #
    # * Random array value
    #   <Array>.random
    #   <Array>.random!
    #   Returns a random object from the array, the method .random! is destructive,
    #   removing the value returned from the array.
    #
    # * Sum of the numeric values of a array
    #   <Array>.sum
    #   Returns the sum of all numeric values
    #
    # * Average of all numeric values from the array
    #   <Array>.average(float = false)
    #    float : float flag
    #   Returns the average of all numeric values, if floa is true, the value
    #   returned is a float, otherwise it's a integer.
    #
    # * Note for events
    #   <Event>.note
    #   By default, events doesn't have note boxes. This command allows to use
    #   comments as note boxes, following the same format as the ones on the
    #   database. Returns all comments on the active page of the event.
    #
    # * Comment calls
    #   <Event>.comment_call
    #   Another function for comment boxes, by default, they have absolutely no
    #   effect in game when called. But this method allows to make the comment
    #   box to behave like an script call, but with the versatility of the
    #   note boxes. Remember that the commands will only take effect if there
    #   is scripts to respond to the comment code.
    #
    #==============================================================================
    
    #==============================================================================
    # ** Victor Engine
    #------------------------------------------------------------------------------
    #   Setting module for the Victor Engine
    #==============================================================================
    
    module Victor_Engine
      #--------------------------------------------------------------------------
      # * New method: required_script
      #--------------------------------------------------------------------------
      def self.required_script(name, req, version, type = 0)
        if type != :bellow && (!$imported[req] || $imported[req] < version)
          msg = "The script '%s' requires the script\n"
          case type
          when :above
            msg += "'%s' v%s or higher above it to work properly\n"
          else
            msg += "'%s' v%s or higher to work properly\n"
          end
          msg += "Go to http://victorscripts.wordpress.com/ to download this script."
          self.exit_message(msg, name, req, version)
        elsif type == :bellow && $imported[req]
          msg =  "The script '%s' requires the script\n"
          msg += "'%s' to be put bellow it\n"
          msg += "move the scripts to the proper position"
          self.exit_message(msg, name, req, version)
        end
      end
      #--------------------------------------------------------------------------
      # * New method: exit_message
      #--------------------------------------------------------------------------
      def self.exit_message(message, name, req, version)
        name = self.script_name(name)
        req  = self.script_name(req)
        msgbox(sprintf(message, name, req, version))
        exit
      end
      #--------------------------------------------------------------------------
      # * New method: script_name
      #--------------------------------------------------------------------------
      def self.script_name(name, ext = "VE")
        name = name.to_s.gsub("_", " ").upcase.split
        name.collect! {|char| char == ext ? "#{char} -" : char.capitalize }
        name.join(" ")
      end
    end
    
    $imported ||= {}
    $imported[:ve_basic_module] = 1.28
    
    #==============================================================================
    # ** Object
    #------------------------------------------------------------------------------
    #  This class is the superclass of all other classes.
    #==============================================================================
    
    class Object
      #--------------------------------------------------------------------------
      # * Include setting module
      #--------------------------------------------------------------------------
      include Victor_Engine
      #-------------------------------------------------------------------------
      # * New method: rand_between
      #-------------------------------------------------------------------------
      def rand_between(min, max)
        min + rand(max - min + 1)
      end
      #--------------------------------------------------------------------------
      # * New method: numeric?
      #--------------------------------------------------------------------------
      def numeric?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: string?
      #--------------------------------------------------------------------------
      def string?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: array?
      #--------------------------------------------------------------------------
      def array?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: float?
      #--------------------------------------------------------------------------
      def float?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: item?
      #--------------------------------------------------------------------------
      def item?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: skill?
      #--------------------------------------------------------------------------
      def skill?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: file_exist?
      #--------------------------------------------------------------------------
      def file_exist?(path, filename)
        $file_list ||= {}
        $file_list[path + filename] ||= file_test(path, filename)
        $file_list[path + filename]
      end
      #--------------------------------------------------------------------------
      # * New method: get_file_list
      #--------------------------------------------------------------------------
      def file_test(path, filename)
        bitmap = Cache.load_bitmap(path, filename) rescue nil
        bitmap ? true : false
      end
      #--------------------------------------------------------------------------
      # * New method: character_exist?
      #--------------------------------------------------------------------------
      def character_exist?(filename)
        file_exist?("Graphics/Characters/", filename)
      end
      #--------------------------------------------------------------------------
      # * New method: battler_exist?
      #--------------------------------------------------------------------------
      def battler_exist?(filename)
        file_exist?("Graphics/Battlers/", filename)
      end
      #--------------------------------------------------------------------------
      # * New method: get_filename
      #--------------------------------------------------------------------------
      def get_filename
        "[\"'“‘]([^\"'”‘”’]+)[\"'”’]"
      end
      #--------------------------------------------------------------------------
      # * New method: get_all_values
      #--------------------------------------------------------------------------
      def get_all_values(value1, value2 = nil)
        value2 = value1 unless value2
        /<#{value1}>((?:[^<]|<[^\/])*)<\/#{value2}>/im
      end
      #--------------------------------------------------------------------------
      # * New method: make_symbol
      #--------------------------------------------------------------------------
      def make_symbol(string)
        string.downcase.gsub(" ", "_").to_sym
      end
      #--------------------------------------------------------------------------
      # * New method: make_string
      #--------------------------------------------------------------------------
      def make_string(symbol)
        symbol.to_s.gsub("_", " ").upcase
      end
      #--------------------------------------------------------------------------
      # * New method: returing_value
      #--------------------------------------------------------------------------
      def returing_value(i, x)
        i % (x * 2) >= x ? (x * 2) - i % (x * 2) : i % (x * 2)
      end
      #--------------------------------------------------------------------------
      # New method: in_rect?
      #--------------------------------------------------------------------------
      def in_rect?(w, h, x1, y1, x2, y2, fx = 0)
        aw, ah, ax, ay, bx, by = setup_area(w, h, x1, y1, x2, y2, fx)
        bx > ax - aw && bx < ax + aw && by > ay - ah && by < ay + ah
      end
      #--------------------------------------------------------------------------
      # New method: in_radius?
      #--------------------------------------------------------------------------
      def in_radius?(w, h, x1, y1, x2, y2, fx = 0)
        aw, ah, ax, ay, bx, by = setup_area(w, h, x1, y1, x2, y2, fx)
        ((bx - ax) ** 2 / aw ** 2) + ((by - ay) ** 2 / ah ** 2) <= 1
      end
      #--------------------------------------------------------------------------
      # New method: setup_area
      #--------------------------------------------------------------------------
      def setup_area(w, h, x1, y1, x2, y2, fx)
        aw = w
        ah = h * aw
        ax = x1
        ay = y1
        bx = x2
        by = y2
        bx += fx / 4 if ax > bx
        bx -= fx / 4 if ax < bx
        [aw, ah, ax, ay, bx, by]
      end
    end
    
    #==============================================================================
    # ** String
    #------------------------------------------------------------------------------
    # The string class. Can handle character sequences of arbitrary lengths. 
    #==============================================================================
    
    class String
      #--------------------------------------------------------------------------
      # * New method: string?
      #--------------------------------------------------------------------------
      def string?
        return true
      end
    end
    
    #==============================================================================
    # ** Numeric
    #------------------------------------------------------------------------------
    #  This is the abstract class for numbers.
    #==============================================================================
    
    class Numeric
      #--------------------------------------------------------------------------
      # * New method: numeric?
      #--------------------------------------------------------------------------
      def numeric?
        return true
      end
      #--------------------------------------------------------------------------
      # * New method: ceil?
      #--------------------------------------------------------------------------
      def ceil?
        return false
      end
    end
    
    #==============================================================================
    # ** Float
    #------------------------------------------------------------------------------
    #  This is the abstract class for the floating point values.
    #==============================================================================
    
    class Float
      #--------------------------------------------------------------------------
      # * New method: float?
      #--------------------------------------------------------------------------
      def float?
        return true
      end
      #--------------------------------------------------------------------------
      # * New method: ceil?
      #--------------------------------------------------------------------------
      def ceil?
        self != self.ceil
      end
    end
    
    #============================================================================== 
    # ** Array     
    #------------------------------------------------------------------------------
    #  This class store arbitrary Ruby objects.
    #==============================================================================
    
    class Array
      #--------------------------------------------------------------------------
      # * New method: array?
      #--------------------------------------------------------------------------
      def array?
        return true
      end
      #-------------------------------------------------------------------------
      # * New method: random
      #-------------------------------------------------------------------------
      def random
        self[rand(size)]
      end
      #-------------------------------------------------------------------------
      # * New method: random!
      #-------------------------------------------------------------------------
      def random!
        self.delete_at(rand(size))
      end
      #---------------------------------------------------------------------------
      # * New method: sum
      #---------------------------------------------------------------------------
      def sum
        self.inject(0) {|r, n| r += (n.numeric? ? n : 0)} 
      end
      #---------------------------------------------------------------------------
      # * New method: average
      #---------------------------------------------------------------------------
      def average(float = false)
        self.sum / [(float ? size.to_f : size.to_i), 1].max
      end
      #---------------------------------------------------------------------------
      # * New method: next_item
      #---------------------------------------------------------------------------
      def next_item
        item = self.shift
        self.push(item)
        item
      end
      #---------------------------------------------------------------------------
      # * New method: previous_item
      #---------------------------------------------------------------------------
      def previous_item
        item = self.pop
        self.unshift(item)
        item
      end
    end
    
    #==============================================================================
    # ** RPG::Troop::Page
    #------------------------------------------------------------------------------
    #  This is the data class for battle events (pages).
    #==============================================================================
    
    class RPG::Troop::Page
      #--------------------------------------------------------------------------
      # * New method: note
      #--------------------------------------------------------------------------
      def note
        return "" if !@list || @list.size <= 0
        comment_list = []
        @list.each do |item|
          next unless item && (item.code == 108 || item.code == 408)
          comment_list.push(item.parameters[0])
        end
        comment_list.join("\r\n")
      end
    end
    
    #==============================================================================
    # ** RPG::UsableItem
    #------------------------------------------------------------------------------
    #  This is the superclass for skills and items.
    #==============================================================================
    
    class RPG::UsableItem < RPG::BaseItem
      #--------------------------------------------------------------------------
      # * New method: for_all_targets?
      #--------------------------------------------------------------------------
      def for_all_targets?
        return false
      end
    end
    
    #==============================================================================
    # ** RPG::Skill
    #------------------------------------------------------------------------------
    #  This is the data class for skills.
    #==============================================================================
    
    class RPG::Skill < RPG::UsableItem
      #--------------------------------------------------------------------------
      # * New method: item?
      #--------------------------------------------------------------------------
      def item?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: skill?
      #--------------------------------------------------------------------------
      def skill?
        return true
      end
      #--------------------------------------------------------------------------
      # * New method: type_set
      #--------------------------------------------------------------------------
      def type_set
        [stype_id]
      end  
    end
    
    #==============================================================================
    # ** RPG::Item
    #------------------------------------------------------------------------------
    #  This is the data class for items.
    #==============================================================================
    
    class RPG::Item < RPG::UsableItem
      #--------------------------------------------------------------------------
      # * New method: item?
      #--------------------------------------------------------------------------
      def item?
        return true
      end 
      #--------------------------------------------------------------------------
      # * New method: skill?
      #--------------------------------------------------------------------------
      def skill?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: type_set
      #--------------------------------------------------------------------------
      def type_set
        [itype_id]
      end  
    end
    
    #==============================================================================
    # ** Cache
    #------------------------------------------------------------------------------
    #  This module loads each of graphics, creates a Bitmap object, and retains it.
    # To speed up load times and conserve memory, this module holds the created
    # Bitmap object in the internal hash, allowing the program to return
    # preexisting objects when the same bitmap is requested again.
    #==============================================================================
    
    class << Cache
      #--------------------------------------------------------------------------
      # * Overwrite method: character
      #--------------------------------------------------------------------------
      def character(filename, hue = 0)
        load_bitmap("Graphics/Characters/", filename, hue)
      end
      #--------------------------------------------------------------------------
      # * New method: cache
      #--------------------------------------------------------------------------
      def cache
        @cache
      end
    end
    
    #==============================================================================
    # ** Game_BattlerBase
    #------------------------------------------------------------------------------
    #  This class handles battlers. It's used as a superclass of the Game_Battler
    # classes.
    #==============================================================================
    
    class Game_BattlerBase
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_reader   :buffs
      #--------------------------------------------------------------------------
      # * New method: get_cond
      #--------------------------------------------------------------------------
      def get_cond(text)
        case text.upcase
        when "HIGHER"    then ">"
        when "LOWER"     then "<"
        when "EQUAL"     then "=="
        when "DIFFERENT" then "!="
        else "!="
        end
      end
      #--------------------------------------------------------------------------
      # * New method: get_param
      #--------------------------------------------------------------------------
      def get_param(text)
        case text.upcase
        when "MAXHP" then self.mhp
        when "MAXMP" then self.mmp
        when "MAXTP" then self.max_tp
        else eval("self.#{text.downcase}")
        end
      end
      #--------------------------------------------------------------------------
      # * New method: get_param_id
      #--------------------------------------------------------------------------
      def get_param_id(text)
        case text.upcase
        when "MAXHP", "HP" then 0
        when "MAXMP", "MP" then 1
        when "ATK" then 2
        when "DEF" then 3
        when "MAT" then 4
        when "MDF" then 5
        when "AGI" then 6
        when "LUK" then 7
        end
      end
      #--------------------------------------------------------------------------
      # * New method: type
      #--------------------------------------------------------------------------
      def type
        list = []
        get_all_notes.scan(/<BATTLER TYPE: ((?:\w+ *,? *)+)>/i) do
          $1.scan(/(\d+)/i) { list.push(make_symbol($1)) }
        end
        list.uniq
      end
      #--------------------------------------------------------------------------
      # * New method: danger?
      #--------------------------------------------------------------------------
      def danger?
        hp < mhp * 25 / 100
      end
      #--------------------------------------------------------------------------
      # * New method: sprite
      #--------------------------------------------------------------------------
      def sprite
        valid = SceneManager.scene_is?(Scene_Battle) && SceneManager.scene.spriteset
        valid ? SceneManager.scene.spriteset.sprite(self) : nil
      end
      #--------------------------------------------------------------------------
      # * New method: 
      #--------------------------------------------------------------------------
      def element_set(item)
        element_set  = [item.damage.element_id]
        element_set += atk_elements if item.damage.element_id < 0
        element_set.compact
      end
      #--------------------------------------------------------------------------
      # * New method: add_state_normal
      #--------------------------------------------------------------------------
      def add_state_normal(state_id, rate = 1, user = self)
        chance  = rate
        chance *= state_rate(state_id)
        chance *= luk_effect_rate(user)
        add_state(state_id) if rand < state_rate(state_id)
      end
      #--------------------------------------------------------------------------
      # * New method: damaged?
      #--------------------------------------------------------------------------
      def damaged?
        @result.hp_damage != 0 || @result.mp_damage != 0 || @result.tp_damage != 0
      end
      #--------------------------------------------------------------------------
      # * New method: mtp
      #--------------------------------------------------------------------------
      def mtp
        return 100
      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
      #--------------------------------------------------------------------------
      # * New method: cri_rate
      #--------------------------------------------------------------------------
      def cri_rate(user, item)
        user.cri
      end
      #--------------------------------------------------------------------------
      # * New method: cri_eva
      #--------------------------------------------------------------------------
      def cri_eva(user, item)
        cev
      end
      #--------------------------------------------------------------------------
      # * New method: setup_critical
      #--------------------------------------------------------------------------
      def setup_critical(user, item)
        cri_rate(user, item) * (1 - cri_eva(user, item))
      end
    end
    
    #==============================================================================
    # ** Game_Enemy
    #------------------------------------------------------------------------------
    #  This class handles enemy characters. It's used within the Game_Troop class
    # ($game_troop).
    #==============================================================================
    
    class Game_Enemy < Game_Battler
      #--------------------------------------------------------------------------
      # * New method: note
      #--------------------------------------------------------------------------
      def note
        enemy ? enemy.note : ""
      end
      #--------------------------------------------------------------------------
      # * New method: get_all_notes
      #--------------------------------------------------------------------------
      def get_all_notes(*args)
        notes  = ""
        notes += note if !args.include?(:self)
        states.compact.each {|state| notes += state.note } if !args.include?(:state)
        notes
      end
      #--------------------------------------------------------------------------
      # * New method: get_all_objects
      #--------------------------------------------------------------------------
      def get_all_objects(*args)
        result = []
        result += [self] if !args.include?(:self)
        result += states.compact if !args.include?(:state)
        result
      end
      #--------------------------------------------------------------------------
      # * New method: level
      #--------------------------------------------------------------------------
      def level
        return 1
      end
      #--------------------------------------------------------------------------
      # * New method: skill_learn?
      #--------------------------------------------------------------------------
      def skill_learn?(skill)
        skill.skill? && skills.include?(skill)
      end
      #--------------------------------------------------------------------------
      # * New method: skills
      #--------------------------------------------------------------------------
      def skills
        enemy.actions.collect {|action| $data_skills[action.skill_id] }
      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: note
      #--------------------------------------------------------------------------
      def note
        actor ? actor.note : ""
      end
      #--------------------------------------------------------------------------
      # * New method: hue
      #--------------------------------------------------------------------------
      def hue
        @hue ? @hue : 0
      end
      #--------------------------------------------------------------------------
      # * New method: get_all_notes
      #--------------------------------------------------------------------------
      def get_all_notes(*args)
        notes = ""
        notes += note if !args.include?(:self)
        notes += self.class.note if !args.include?(:class)
        equips.compact.each {|equip| notes += equip.note } if !args.include?(:equip)
        states.compact.each {|state| notes += state.note } if !args.include?(:state)
        notes
      end
      #--------------------------------------------------------------------------
      # * New method: get_all_objects
      #--------------------------------------------------------------------------
      def get_all_objects(*args)
        result = []
        result += [self] if !args.include?(:self)
        result += [self.class]   if !args.include?(:self)
        result += equips.compact if !args.include?(:equip)
        result += states.compact if !args.include?(:state)
        result
      end
      #--------------------------------------------------------------------------
      # * New method: in_active_party?
      #--------------------------------------------------------------------------
      def in_active_party?
        $game_party.battle_members.include?(self)
      end
      #--------------------------------------------------------------------------
      # * New method: in_reserve_party?
      #--------------------------------------------------------------------------
      def in_reserve_party?
        $game_party.reserve_members.include?(self)
      end
      #--------------------------------------------------------------------------
      # * New method: in_party?
      #--------------------------------------------------------------------------
      def in_party?
        $game_party.all_members.include?(self)
      end
      #--------------------------------------------------------------------------
      # * New method: map_animation
      #--------------------------------------------------------------------------
      def map_animation(id)
        $game_map.actors.each do |member|
          member.animation_id = id if member.actor == self
        end
      end
      #--------------------------------------------------------------------------
      # * New method: on_damage_floor
      #--------------------------------------------------------------------------
      def on_damage_floor?
        $game_player.on_damage_floor?
      end
    end
    
    #==============================================================================
    # ** Game_Unit
    #------------------------------------------------------------------------------
    #  This class handles units. It's used as a superclass of the Game_Party and
    # Game_Troop classes.
    #==============================================================================
    
    class Game_Unit
      #--------------------------------------------------------------------------
      # * New method: refresh
      #--------------------------------------------------------------------------
      def refresh
        members.each {|member| member.refresh }
      end
    end
    
    #==============================================================================
    # ** Game_Party
    #------------------------------------------------------------------------------
    #  This class handles the party. It includes information on amount of gold 
    # and items. The instance of this class is referenced by $game_party.
    #==============================================================================
    
    class Game_Party < Game_Unit
      #--------------------------------------------------------------------------
      # * New method: average_level
      #--------------------------------------------------------------------------
      def average_level
        battle_members.collect {|actor| actor.level }.average
      end
      #--------------------------------------------------------------------------
      # * New method: reserve_members
      #--------------------------------------------------------------------------
      def reserve_members
        all_members - battle_members
      end
    end
    
    #==============================================================================
    # ** Game_Map
    #------------------------------------------------------------------------------
    #  This class handles maps. It includes scrolling and passage determination
    # functions. The instance of this class is referenced by $game_map.
    #==============================================================================
    
    class Game_Map
      #--------------------------------------------------------------------------
      # * New method: event_list
      #--------------------------------------------------------------------------
      def event_list
        events.values
      end
      #--------------------------------------------------------------------------
      # * New method: note
      #--------------------------------------------------------------------------
      def note
        @map ? @map.note : ""
      end
      #--------------------------------------------------------------------------
      # * New method: vehicles
      #--------------------------------------------------------------------------
      def vehicles
        @vehicles
      end
      #--------------------------------------------------------------------------
      # * New method: map_events
      #--------------------------------------------------------------------------
      def map_events
        @map.events
      end
      #--------------------------------------------------------------------------
      # * New method: actors
      #--------------------------------------------------------------------------
      def actors
        [$game_player] + $game_player.followers.visible_followers
      end
    end
    
    #==============================================================================
    # ** Game_CharacterBase
    #------------------------------------------------------------------------------
    #  This class deals with characters. Common to all characters, stores basic
    # data, such as coordinates and graphics. It's used as a superclass of the
    # Game_Character class.
    #==============================================================================
    
    class Game_CharacterBase
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_accessor :move_speed
      attr_accessor :move_frequency
      #--------------------------------------------------------------------------
      # * New method: player?
      #--------------------------------------------------------------------------
      def player?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: event?
      #--------------------------------------------------------------------------
      def event?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: follower?
      #--------------------------------------------------------------------------
      def follower?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: vehicle?
      #--------------------------------------------------------------------------
      def vehicle?
        return false
      end
      #--------------------------------------------------------------------------
      # * New method: frames
      #--------------------------------------------------------------------------
      def frames
        return 3
      end
      #--------------------------------------------------------------------------
      # * New method: hue
      #--------------------------------------------------------------------------
      def hue
        @hue ? @hue : 0
      end
    end
    
    #==============================================================================
    # ** Game_Character
    #------------------------------------------------------------------------------
    #  This class deals with characters. It's used as a superclass of the
    # Game_Player and Game_Event classes.
    #==============================================================================
    
    class Game_Character < Game_CharacterBase
      #--------------------------------------------------------------------------
      # * New method: move_toward_position
      #--------------------------------------------------------------------------
      def move_toward_position(x, y)
        sx = distance_x_from(x)
        sy = distance_y_from(y)
        if sx.abs > sy.abs
          move_straight(sx > 0 ? 4 : 6)
          move_straight(sy > 0 ? 8 : 2) if !@move_succeed && sy != 0
        elsif sy != 0
          move_straight(sy > 0 ? 8 : 2)
          move_straight(sx > 0 ? 4 : 6) if !@move_succeed && sx != 0
        end
      end
      #--------------------------------------------------------------------------
      # * New method: move_toward_position
      #--------------------------------------------------------------------------
      def turn_toward_position(x, y)
        sx = distance_x_from(x)
        sy = distance_y_from(y)
        if sx.abs > sy.abs
          set_direction(sx > 0 ? 4 : 6)
        elsif sy != 0
          set_direction(sy > 0 ? 8 : 2)
        end
      end
    end
    
    #==============================================================================
    # ** Game_Player
    #------------------------------------------------------------------------------
    #  This class handles the player.
    # The instance of this class is referenced by $game_map.
    #==============================================================================
    
    class Game_Player < Game_Character
      #--------------------------------------------------------------------------
      # * New method: player?
      #--------------------------------------------------------------------------
      def player?
        return true
      end
      #--------------------------------------------------------------------------
      # * New method: perform_transfer
      #--------------------------------------------------------------------------
      def new_map_id
        @new_map_id
      end
      #--------------------------------------------------------------------------
      # * New method: hue
      #--------------------------------------------------------------------------
      def hue
        actor ? actor.hue : 0
      end
    end
    
    #==============================================================================
    # ** Game_Follower
    #------------------------------------------------------------------------------
    #  This class handles the followers. Followers are the actors of the party
    # that follows the leader in a line. It's used within the Game_Followers class.
    #==============================================================================
    
    class Game_Follower < Game_Character
      #--------------------------------------------------------------------------
      # * New method: follower?
      #--------------------------------------------------------------------------
      def follower?
        return true
      end
      #--------------------------------------------------------------------------
      # * New method: index
      #--------------------------------------------------------------------------
      def index
        @member_index
      end
      #--------------------------------------------------------------------------
      # * New method: gathering?
      #--------------------------------------------------------------------------
      def gathering?
        $game_player.followers.gathering? && !gather?
      end
    end
    
    #==============================================================================
    # ** Game_Followers
    #------------------------------------------------------------------------------
    #  This class handles the followers. It's a wrapper for the built-in class
    # "Array." It's used within the Game_Player class.
    #==============================================================================
    
    class Game_Followers
      #--------------------------------------------------------------------------
      # * New method: get_actor
      #--------------------------------------------------------------------------
      def get_actor(id)
        list = [$game_player] + visible_followers
        list.select {|follower| follower.actor && follower.actor.id == id }.first
      end
      #--------------------------------------------------------------------------
      # * Method fix: visble_folloers
      #--------------------------------------------------------------------------
      unless method_defined?(:visible_followers)
        def visible_followers; visible_folloers; end
      end
    end
    
    #==============================================================================
    # ** Game_Vehicle
    #------------------------------------------------------------------------------
    #  This class handles vehicles. It's used within the Game_Map class. If there
    # are no vehicles on the current map, the coordinates is set to (-1,-1).
    #==============================================================================
    
    class Game_Vehicle < Game_Character
      #--------------------------------------------------------------------------
      # * New method: vehicle?
      #--------------------------------------------------------------------------
      def vehicle?
        return true
      end
      #--------------------------------------------------------------------------
      # * New method: map_id
      #--------------------------------------------------------------------------
      def map_id
        @map_id 
      end
      #--------------------------------------------------------------------------
      # * New method: type
      #--------------------------------------------------------------------------
      def type
        @type
      end
      #--------------------------------------------------------------------------
      # * New method: aerial?
      #--------------------------------------------------------------------------
      def aerial?
        type == :airship
      end 
      #--------------------------------------------------------------------------
      # * New method: above?
      #--------------------------------------------------------------------------
      def above?
        aerial?
      end
    end
    
    #==============================================================================
    # ** Game_Event
    #------------------------------------------------------------------------------
    #  This class deals with events. It handles functions including event page 
    # switching via condition determinants, and running parallel process events.
    # It's used within the Game_Map class.
    #==============================================================================
    
    class Game_Event < Game_Character
      #--------------------------------------------------------------------------
      # * New method: name
      #--------------------------------------------------------------------------
      def name
        @event.name
      end
      #--------------------------------------------------------------------------
      # * New method: event?
      #--------------------------------------------------------------------------
      def event?
        return true
      end
      #--------------------------------------------------------------------------
      # * New method: erased?
      #--------------------------------------------------------------------------
      def erased?
        @erased
      end
      #--------------------------------------------------------------------------
      # * New method: note
      #--------------------------------------------------------------------------
      def note
        return ""     if !@page || !@page.list || @page.list.size <= 0
        return @notes if @notes && @page.list == @note_page
        @note_page = @page.list.dup
        comment_list = []
        @page.list.each do |item|
          next unless item && (item.code == 108 || item.code == 408)
          comment_list.push(item.parameters[0])
        end
        @notes = comment_list.join("\r\n")
        @notes
      end  
    end
    
    #==============================================================================
    # ** Game_Interpreter
    #------------------------------------------------------------------------------
    #  An interpreter for executing event commands. This class is used within the
    # Game_Map, Game_Troop, and Game_Event classes.
    #==============================================================================
    
    class Game_Interpreter
      #--------------------------------------------------------------------------
      # * Alias method: command_108
      #--------------------------------------------------------------------------
      alias :command_108_ve_basic_module :command_108
      def command_108
        command_108_ve_basic_module
        comment_call
      end
      #--------------------------------------------------------------------------
      # * New method: comment_call
      #--------------------------------------------------------------------------
      def comment_call
      end
      #--------------------------------------------------------------------------
      # * New method: note
      #--------------------------------------------------------------------------
      def note
        @comments ? @comments.join("\r\n") : ""
      end
    end
    
    #==============================================================================
    # ** Sprite_Character
    #------------------------------------------------------------------------------
    #  This sprite is used to display characters. It observes a instance of the
    # Game_Character class and automatically changes sprite conditions.
    #==============================================================================
    
    class Sprite_Character < Sprite_Base
      #--------------------------------------------------------------------------
      # * Overwrite method: set_character_bitmap
      #--------------------------------------------------------------------------
      def set_character_bitmap
        update_character_info
        set_bitmap
        set_bitmap_position
      end
      #--------------------------------------------------------------------------
      # * New method: center_y
      #--------------------------------------------------------------------------
      def actor?
        @character.is_a?(Game_Player) || @character.is_a?(Game_Follower)
      end
      #--------------------------------------------------------------------------
      # * New method: center_y
      #--------------------------------------------------------------------------
      def actor
        actor? ? @character.actor : nil
      end
      #--------------------------------------------------------------------------
      # * New method: update_character_info
      #--------------------------------------------------------------------------
      def update_character_info
      end
      #--------------------------------------------------------------------------
      # * New method: hue
      #--------------------------------------------------------------------------
      def hue
        @character.hue
      end
      #--------------------------------------------------------------------------
      # * New method: set_bitmap
      #--------------------------------------------------------------------------
      def set_bitmap
        self.bitmap = Cache.character(set_bitmap_name, hue)
      end
      #--------------------------------------------------------------------------
      # * New method: set_bitmap_name
      #--------------------------------------------------------------------------
      def set_bitmap_name
        @character_name
      end
      #--------------------------------------------------------------------------
      # * New method: set_bitmap_position
      #--------------------------------------------------------------------------
      def set_bitmap_position
        sign = get_sign
        if sign && sign.include?('$')
          @cw = bitmap.width / @character.frames
          @ch = bitmap.height / 4
        else
          @cw = bitmap.width / (@character.frames * 4)
          @ch = bitmap.height / 8
        end
        self.ox = @cw / 2
        self.oy = @ch
      end
      #--------------------------------------------------------------------------
      # * New method: get_sign
      #--------------------------------------------------------------------------
      def get_sign
        @character_name[/^[\!\$]./]
      end
    end
    
    #==============================================================================
    # ** Sprite_Battler
    #------------------------------------------------------------------------------
    #  This sprite is used to display battlers. It observes a instance of the
    # Game_Battler class and automatically changes sprite conditions.
    #==============================================================================
    
    class Sprite_Battler < Sprite_Base
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_accessor :dmg_mirror
      #--------------------------------------------------------------------------
      # * New method: center_x
      #--------------------------------------------------------------------------
      def center_x
        self.ox
      end
      #--------------------------------------------------------------------------
      # * New method: center_y
      #--------------------------------------------------------------------------
      def center_y
        self.oy / 2
      end
    end
    
    #==============================================================================
    # ** Spriteset_Battle
    #------------------------------------------------------------------------------
    #  This class brings together battle screen sprites. It's used within the
    # Scene_Battle class.
    #==============================================================================
    
    class Spriteset_Battle
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_reader   :viewport1
      #--------------------------------------------------------------------------
      # * New method: sprite
      #--------------------------------------------------------------------------
      def sprite(subject)
        battler_sprites.compact.select {|sprite| sprite.battler == subject }.first
      end
    end
    
    #==============================================================================
    # ** Window_Base
    #------------------------------------------------------------------------------
    #  This is a superclass of all windows in the game.
    #==============================================================================
    
    class Window_Base < Window
      #--------------------------------------------------------------------------
      # * Alias method: convert_escape_characters
      #--------------------------------------------------------------------------
      alias :convert_escape_ve_basic_module :convert_escape_characters
      def convert_escape_characters(text)
        result = text.to_s.clone
        result = text_replace(result)
        result = convert_escape_ve_basic_module(text)
        result
      end
      #--------------------------------------------------------------------------
      # * New method: text_replace
      #--------------------------------------------------------------------------
      def text_replace(result)
        result.gsub!(/\r/) { "" }
        result.gsub!(/\\/) { "\e" }
        result
      end
    end
    
    #==============================================================================
    # ** Scene_Battle
    #------------------------------------------------------------------------------
    #  This class performs battle screen processing.
    #==============================================================================
    
    class Scene_Battle < Scene_Base
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_reader   :subject
      attr_reader   :spriteset
    end
    
    #==============================================================================
    # ** Scene_Battle
    #------------------------------------------------------------------------------
    #  This class performs map screen processing.
    #==============================================================================
    
    class Scene_Map < Scene_Base
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_reader   :spriteset
    end
    скрипт VictorEngine AnimatedBattle.txt

    Код:
    #==============================================================================
    # ** Victor Engine - Actors Battlers
    #------------------------------------------------------------------------------
    # Author : Victor Sant
    #
    # Version History:
    #  v 1.00 - 2011.12.19 > First relase
    #  v 1.01 - 2011.12.30 > Faster Regular Expressions
    #  v 1.02 - 2012.01.15 > Compatibility with Target Arrow
    #  v 1.03 - 2012.01.28 > Compatibility with Animated Battle
    #  v 1.04 - 2012.03.11 > Added position distance settings
    #  v 1.05 - 2012.03.17 > Fixed battle test glitch
    #  v 1.06 - 2012.05.20 > Compatibility with Map Turn Battle
    #------------------------------------------------------------------------------
    #  This script adds visible battler graphics for the party actors actors
    # during combat. With the visible battlers, new options will be available
    # like setting actor's battlers positions and attack animations.
    #------------------------------------------------------------------------------
    # Compatibility
    #   Requires the script 'Victor Engine - Basic Module' v 1.11 or higher.
    #   If used with 'Victor Engine - Animated Battle' place this bellow it.
    # 
    # * Overwrite methods (Default)
    #   class Spriteset_Battle
    #      def create_actors
    #     def update_actors
    #
    #   class Scene_Battle < Scene_Base
    #     def show_attack_animation(targets)
    #
    # * Alias methods (Default)
    #   class << DataManager
    #     def setup_new_game
    #     def create_game_objects
    #     def make_save_contents
    #     def extract_save_contents(contents)
    #
    #   class Game_Actor < Game_Battler
    #     def setup(actor_id)
    #
    # * Alias methods (Basic Module)
    #   class Game_Interpreter
    #     def comment_call
    #
    #------------------------------------------------------------------------------
    # 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'
    #
    #------------------------------------------------------------------------------
    # Comment calls note tags:
    #  Tags to be used in events comment box, works like a script call.
    #  
    #  <battler name id: x>
    #   This tag allows to change the actor battler graphic.
    #    id : actor ID
    #    x  : battler graphic filename
    #
    #  <battler hue id: x>
    #   This tag allows to change the actor battler graphic.
    #    id : actor ID
    #    x  : battler graphic hue (0-360)
    #
    #  <battler position i: x, y>
    #   This tag allows to change the battler position during combat.
    #   only valid if VE_BATTLE_FORMATION = :custom
    #     i : position index
    #     x : new coorditante X
    #     y : new coorditante X
    #
    #------------------------------------------------------------------------------
    # Actors note tags:
    #   Tags to be used on the Actors note box in the database
    #
    #  <battler name: x>
    #   This tag allows to set the initial battler graphic filename for the actor.
    #    x : battler graphic filename
    #
    #  <battler hue: x>
    #   This tag allows to set the initial battler graphic hur for the actor.
    #    x : battler graphic hue (0-360)
    #
    #------------------------------------------------------------------------------
    # Enemies note tags:
    #   Tags to be used on the Enemies note box in the database
    #
    #  <attack animation: x>
    #   This tag allows to set the normal attack animation for the enemy
    #    x : animation ID
    #  
    #==============================================================================
    
    #==============================================================================
    # ** Victor Engine
    #------------------------------------------------------------------------------
    #   Setting module for the Victor Engine
    #==============================================================================
    
    module Victor_Engine
      #--------------------------------------------------------------------------
      # * Set the battle formation
      #    Choose here how the actors battlers will be placed on the combat.
      #    :front  : horizontal placement
      #    :side   : vertical placement
      #    :iso    : isometric placement
      #    :custom : custom placement
      #--------------------------------------------------------------------------
      VE_BATTLE_FORMATION = :side
      #--------------------------------------------------------------------------
      # * Set battler centralization
      #    When true, battlers are centralized automatically.
      #    Not valid if VE_BATTLE_FORMATION = :custom
      #--------------------------------------------------------------------------
      VE_BATTLE_CENTRALIZE = true
      #--------------------------------------------------------------------------
      # * Set battlers custom positions
      #    Only if VE_BATTLE_FORMATION = :custom, allows to set the position of
      #    all party actors, don't forget to add values for all positions
      #    available if using a party bigger than the default.
      #--------------------------------------------------------------------------
      VE_CUSTOM_POSITION = {
      # Position
        1 => {x: 100, y: 240}, # Position for the first actor.
        2 => {x: 320, y: 100}, # Position for the second actor.
        3 => {x: 500, y: 240}, # Position for the thrid actor.
        4 => {x: 320, y: 270}, # Position for the fourth actor.
      } # Don't remove
      #--------------------------------------------------------------------------
      # * Actors battlers position adjust
      #    Used to adjust the position of all actors battlers.
      #--------------------------------------------------------------------------
      VE_POSITION_ADJUST = {x: 0, y: 0}
      #--------------------------------------------------------------------------
      # * Actors battlers position adjust
      #    Used to adjust the position of all actors battlers.
      #--------------------------------------------------------------------------
      VE_DISTANCE_ADJUST = {x: 48, y: 32}
      #--------------------------------------------------------------------------
      # * required
      #   This method checks for the existance of the basic module and other
      #   VE scripts required for this script to work, don't edit this
      #--------------------------------------------------------------------------
      def self.required(name, req, version, type = nil)
        if !$imported[:ve_basic_module]
          msg = "The script '%s' requires the script\n"
          msg += "'VE - Basic Module' v%s or higher above it to work properly\n"
          msg += "Go to http://victorscripts.wordpress.com/ to download this script."
          msgbox(sprintf(msg, self.script_name(name), version))
          exit
        else
          self.required_script(name, req, version, type)
        end
      end
      #--------------------------------------------------------------------------
      # * script_name
      #   Get the script name base on the imported value, don't edit this
      #--------------------------------------------------------------------------
      def self.script_name(name, ext = "VE")
        name = name.to_s.gsub("_", " ").upcase.split
        name.collect! {|char| char == ext ? "#{char} -" : char.capitalize }
        name.join(" ")
      end
    end
    
    $imported ||= {}
    $imported[:ve_actor_battlers] = 1.06
    Victor_Engine.required(:ve_actor_battlers, :ve_basic_module, 1.11, :above)
    Victor_Engine.required(:ve_actor_battlers, :ve_map_battle, 1.00, :bellow)
    
    #==============================================================================
    # ** DataManager
    #------------------------------------------------------------------------------
    #  This module handles the game and database objects used in game.
    # Almost all global variables are initialized on this module
    #==============================================================================
    
    class << DataManager
      #--------------------------------------------------------------------------
      # * Alias method: setup_new_game
      #--------------------------------------------------------------------------
      alias :setup_new_game_ve_actor_battlers :setup_new_game
      def setup_new_game
        setup_new_game_ve_actor_battlers
        $game_custom_positions = VE_CUSTOM_POSITION.dup
        $game_custom_formation = VE_BATTLE_FORMATION
        $game_position_adjust  = VE_POSITION_ADJUST.dup
      end
      #--------------------------------------------------------------------------
      # * Alias method: setup_battle_test
      #--------------------------------------------------------------------------
      alias :setup_battle_test_ve_actor_battlers :setup_battle_test
      def setup_battle_test
        setup_battle_test_ve_actor_battlers
        $game_custom_positions = VE_CUSTOM_POSITION.dup
        $game_custom_formation = VE_BATTLE_FORMATION
        $game_position_adjust  = VE_POSITION_ADJUST.dup
      end
      #--------------------------------------------------------------------------
      # * Alias method: create_game_objects
      #--------------------------------------------------------------------------
      alias :create_game_objects_ve_actor_battlers :create_game_objects
      def create_game_objects
        create_game_objects_ve_actor_battlers
        $game_custom_positions = {}
        $game_custom_formation = VE_BATTLE_FORMATION
        $game_position_adjust  = VE_POSITION_ADJUST.dup
      end
      #--------------------------------------------------------------------------
      # * Alias method: make_save_contents
      #--------------------------------------------------------------------------
      alias :make_save_contents_ve_actor_battlers  :make_save_contents
      def make_save_contents
        contents = make_save_contents_ve_actor_battlers
        contents[:positions_ve]  = $game_custom_positions
        contents[:formation_ve]  = $game_custom_formation
        contents[:pos_adjust_ve] = $game_position_adjust
        contents
      end
      #--------------------------------------------------------------------------
      # * Alias method: extract_save_contents
      #--------------------------------------------------------------------------
      alias :extract_save_contents_ve_actor_battlers :extract_save_contents
      def extract_save_contents(contents)
        extract_save_contents_ve_actor_battlers(contents)
        $game_custom_positions = contents[:positions_ve]
        $game_custom_formation = contents[:formation_ve]
        $game_position_adjust  = contents[:pos_adjust_ve]
      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
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_accessor :screen_x                 # Coordenada X na tela
      attr_accessor :screen_y                 # Coordenada Y na tela
      #--------------------------------------------------------------------------
      # * Alias method: setup
      #--------------------------------------------------------------------------
      alias :setup_ve_actor_battlers :setup
      def setup(actor_id)
        setup_ve_actor_battlers(actor_id)
        @battler_name = actor_battler_name
        @battler_hue  = actor_battler_hue
      end
      #--------------------------------------------------------------------------
      # * Overwrite method: use_sprite?
      #--------------------------------------------------------------------------
      def use_sprite?
        return true
      end
      #--------------------------------------------------------------------------
      # * Overwrite method: screen_z
      #--------------------------------------------------------------------------
      def screen_z
        return 100
      end
      #--------------------------------------------------------------------------
      # * New method: actor_battler_name
      #--------------------------------------------------------------------------
      def actor_battler_name
        actor.note =~ /<BATTLER NAME: ([^><]*)>/i ? $1.to_s : ""
      end
      #--------------------------------------------------------------------------
      # * New method: actor_battler_hue
      #--------------------------------------------------------------------------
      def actor_battler_hue
        actor.note =~ /<BATTLER HUE: (\d+)>/i ? $1.to_i : 0
      end
      #--------------------------------------------------------------------------
      # * New method: battler_name
      #--------------------------------------------------------------------------
      def battler_name=(name)
        @battler_name = name if name.is_a?(String)
      end
      #--------------------------------------------------------------------------
      # * New method: battler_hue
      #--------------------------------------------------------------------------
      def battler_hue=(hue)
        @battler_hue = hue if hue.numeric?
      end
      #--------------------------------------------------------------------------
      # * New method: screen_x
      #--------------------------------------------------------------------------
      def screen_x
        setup_x
      end
      #--------------------------------------------------------------------------
      # * New method: screen_y
      #--------------------------------------------------------------------------
      def screen_y
        setup_y
      end
      #--------------------------------------------------------------------------
      # * New method: setup_x
      #--------------------------------------------------------------------------
      def setup_x
        case $game_custom_formation
        when :front  then position = get_frontal_x
        when :side   then position = get_sideview_x
        when :iso    then position = get_isometric_x
        when :custom then position = $game_custom_positions[index + 1][:x]
        end
        position + $game_position_adjust[:x]
      end
      #--------------------------------------------------------------------------
      # * New method: setup_y
      #--------------------------------------------------------------------------
      def setup_y
        case $game_custom_formation
        when :front  then position = get_frontal_y
        when :side   then position = get_sideview_y
        when :iso    then position = get_isometric_y
        when :custom then position = $game_custom_positions[index + 1][:y]
        end
        position + $game_position_adjust[:y]
      end
      #--------------------------------------------------------------------------
      # * New method: get_frontal_x
      #--------------------------------------------------------------------------
      def get_frontal_x
        if VE_BATTLE_CENTRALIZE
          size = $game_party.battle_members.size
          position = (index + 1) * Graphics.width / (size + 1)
        else
          size = $game_party.max_battle_members
          position = index * Graphics.width / size + 64
        end
        position
      end
      #--------------------------------------------------------------------------
      # * New method: get_frontal_y
      #--------------------------------------------------------------------------
      def get_frontal_y
        Graphics.height - 16
      end
      #--------------------------------------------------------------------------
      # * New method: get_sideview_x
      #--------------------------------------------------------------------------
      def get_sideview_x
        if VE_BATTLE_CENTRALIZE
          size = $game_party.max_battle_members
          x    = dist[:x] / 8
          position = -index * (index * x - x * size) + Graphics.width - 160
        else
          position = index * dist[:x] + Graphics.width - 192
        end
        position
      end
      #--------------------------------------------------------------------------
      # * New method: get_sideview_y
      #--------------------------------------------------------------------------
      def get_sideview_y
        if VE_BATTLE_CENTRALIZE
          size   = $game_party.battle_members.size
          height = Graphics.height
          position = (index - size) * dist[:y] + size * dist[:y] / 2 + height - 160
        else
          position = index * dist[:y] +  Graphics.height - 192
        end
        position
      end
      #--------------------------------------------------------------------------
      # * New method: get_isometric_x
      #--------------------------------------------------------------------------
      def get_isometric_x
        if VE_BATTLE_CENTRALIZE
          position = -index * (index * dist[:x] - 32) + Graphics.width - 160
        else
          position = index * dist[:x] +  Graphics.width - 192
        end
        position
      end
      #--------------------------------------------------------------------------
      # * New method: get_isometric_y
      #--------------------------------------------------------------------------
      def get_isometric_y
        if VE_BATTLE_CENTRALIZE
          position = index * (dist[:y] - index * 6) + Graphics.height - 160
        else
          position = Graphics.height - 96 - index * dist[:y]
        end
        position
      end
      #--------------------------------------------------------------------------
      # * New method: dist
      #--------------------------------------------------------------------------
      def dist
        VE_DISTANCE_ADJUST
      end
    end
    
    #==============================================================================
    # ** Game_Enemy
    #------------------------------------------------------------------------------
    #  This class handles enemy characters. It's used within the Game_Troop class
    # ($game_troop).
    #==============================================================================
    
    class Game_Enemy < Game_Battler
      #--------------------------------------------------------------------------
      # * New method: atk_animation_id1
      #--------------------------------------------------------------------------
      def atk_animation_id1
        enemy.note =~ /<ATTACK ANIM(?:ATION): (\d+)>/i ? $1.to_i : 1
      end
      #--------------------------------------------------------------------------
      # * New method: atk_animation_id2
      #--------------------------------------------------------------------------
      def atk_animation_id2
        return 0
      end
    end
    
    #==============================================================================
    # ** Game_Interpreter
    #------------------------------------------------------------------------------
    #  An interpreter for executing event commands. This class is used within the
    # Game_Map, Game_Troop, and Game_Event classes.
    #==============================================================================
    
    class Game_Interpreter
      #--------------------------------------------------------------------------
      # * Alias method: comment_call
      #--------------------------------------------------------------------------
      alias :comment_call_ve_actor_battlers :comment_call
      def comment_call
        change_battler_name
        change_battler_hue
        change_position
        comment_call_ve_actor_battlers
      end
      #--------------------------------------------------------------------------
      # * New method: change_battler_name
      #--------------------------------------------------------------------------
      def change_battler_name
        note.scan(/<BATTLER NAME (\d+): ([^><]*)>/i) do |id, name|
          $game_actors[id.to_i].battler_name = name
        end
      end
      #--------------------------------------------------------------------------
      # * New method: change_battler_hue
      #--------------------------------------------------------------------------
      def change_battler_hue
        note.scan(/<BATTLER HUE (\d+): (\d+)>/i) do |id, hue|
          $game_actors[id.to_i].battler_hue = hue
        end
      end
      #--------------------------------------------------------------------------
      # * New method: change_position
      #--------------------------------------------------------------------------
      def change_position
        regexp = /<BATTLER POSITION (\d+): (\d+) *, *(\d+)>/i
        note.scan(regexp) do |i, x, y|
          $game_custom_positions[i.to_i][:x] = x.to_i
          $game_custom_positions[i.to_i][:y] = y.to_i
        end
      end
    end
    
    #==============================================================================
    # ** Spriteset_Battle
    #------------------------------------------------------------------------------
    #  This class brings together battle screen sprites. It's used within the
    # Scene_Battle class.
    #==============================================================================
    
    class Spriteset_Battle
      #--------------------------------------------------------------------------
      # * Overwrite method: create_actors
      #--------------------------------------------------------------------------
      def create_actors
        @actor_sprites = $game_party.battle_members.reverse.collect do |actor|
          Sprite_Battler.new(@viewport1, actor)
        end
        @actors_party = $game_party.battle_members.dup
      end
      #--------------------------------------------------------------------------
      # * Overwrite method: update_actors
      #--------------------------------------------------------------------------
      def update_actors
        update_party if $game_party.battle_members != @actors_party
        @actor_sprites.each {|sprite| sprite.update }
      end
      #--------------------------------------------------------------------------
      # * New method: update_party
      #--------------------------------------------------------------------------
      def update_party
        @actor_sprites.each_index do |i|
          next if $game_party.battle_members.include?(@actor_sprites[i].battler)
          @actor_sprites[i].dispose
          @actor_sprites[i] = nil
        end
        $game_party.battle_members.collect do |actor|
          next if @actors_party.include?(actor)
          @actor_sprites.push(Sprite_Battler.new(@viewport1, actor))
        end
        @actor_sprites.compact!
        @actors_party = $game_party.battle_members.dup
        $game_party.battle_members.each do |actor|
          old_position = [actor.screen_x, actor.screen_y]
          actor.setup_position
          if old_position != [actor.screen_x, actor.screen_y]
            sprite(actor).start_effect(:appear) 
          end
        end
      end
    end
    
    #==============================================================================
    # ** Scene_Battle
    #------------------------------------------------------------------------------
    #  This class performs battle screen processing.
    #==============================================================================
    
    class Scene_Battle < Scene_Base
      #--------------------------------------------------------------------------
      # * Overwrite method: show_attack_animation
      #--------------------------------------------------------------------------
      def show_attack_animation(targets)
        show_normal_animation(targets, @subject.atk_animation_id1, false)
        show_normal_animation(targets, @subject.atk_animation_id2, true)
      end
    end
    Код:
    #=================================================  =============================
    # ** Victor Engine - Map Turn Battle
    #------------------------------------------------------------------------------
    # Author : Victor Sant
    #
    # Version History:
    #  v 1.00 - 2012.07.20 > First relase
    #  v 1.01 - 2012.07.21 > Compatibility with Fog and Overlay and Light Effects
    #                      > Fixed Map Pictures not showing during battle
    #  v 1.02 - 2012.05.29 > Compatibility with Pixel Movement
    #  v 1.03 - 2012.07.24 > Compatibility with Basic Module 1.25
    #  v 1.04 - 2012.08.02 > Compatibility with Basic Module 1.27
    #  v 1.05 - 2012.08.03 > Compatibility with Anti Lag
    #------------------------------------------------------------------------------
    #  This script is an add-on for the 'Victor Engine - Animated Battle', it
    # allows to make battles to occur the current map, instead of using a
    # transition to another scene, like int the game Chrono Trigger. It doesn't
    # make any change on the turn mechanic of the battle and anything else.
    #------------------------------------------------------------------------------
    # Compatibility
    #   Requires the script 'Victor Engine - Basic Module' v 1.27 or higher
    #   Requires the script 'Victor Engine - Animated Battle' v 1.05 or higher
    #   Requires the script 'Victor Engine - Actors Battlers' v 1.06 or higher
    #   If used with 'Victor Engine - Light Effects' place this bellow it.
    #   If used with 'Victor Engine - Pixel Movement' place this bellow it.
    #
    # * Alias methods 
    #   class << BattleManager
    #     def process_escape_pose
    #     def battle_end(result)
    #
    #   class Game_Party < Game_Unit
    #     def initialize
    #
    #   class Game_Player < Game_Character
    #     def update_scroll(last_real_x, last_real_y)
    #     def add_move_update(dir)
    #
    #   class Game_Follower < Game_Character
    #     def initialize(member_index, preceding_character)
    #     def chase_preceding_character
    #     def add_move_update(dir)
    #
    #   class Scene_Map < Scene_Base
    #     def pre_battle_scene
    #     def perform_battle_transition
    #     def perform_transition
    #
    #   class Scene_Battle < Scene_Base
    #     def create_spriteset
    #     def perform_transition
    #     def pre_terminate
    #
    #   class Game_Interpreter
    #     def comment_call
    #
    #
    #   class Game_Follower < Game_Character
    #
    #------------------------------------------------------------------------------
    # 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' and the script
    # 
    #------------------------------------------------------------------------------
    # Comment calls note tags:
    #  Tags to be used in events comment box, works like a script call.
    #
    #  <call map battle>
    #  start: [x, y]; end: [x, y]; escape: [x, y]; defeat: [x, y];
    #  actors: [x, y], [x, y], [x, y];
    #  enemies: [event, enemy, switch],  [event, enemy];
    #  can escape; can lose; skip return;
    #  </call map battle>
    #   This call is used to call battles on maps, using the normal event battle
    #   call will end on a normal battle with transition.
    #     start: [x, y];
    #       position of the screen at the battle start
    #     end: [x, y];
    #        position of the party at battle end, in case of victory
    #     escape: [x, y];
    #        position of the party at battle end, in case of escape
    #     defeat: [x, y];
    #        position of the party at battle end, in case of defeat (only if the
    #        battle is set up to continue after defeat)
    #     actors: [x, y], [x, y], [x, y];
    #        position of each actor during the battle, you must add a value [x, y]
    #        for every actor in the party, so always add an ammount equal the
    #        max number of party members to avoid errors.
    #     enemies: [event, enemy, switch], [event, enemy];
    #        enemies info
    #        event is the Event ID of the event that represents the enemye
    #        enemy is the Enemy ID on the database.
    #        switch is an opitional value that represents the switch that will
    #         be turned on when the enemy dies, it can be a numeric value, or the
    #         the letters A, B, C or D. If numeric, it turn on a switch, if it's a
    #         letter, it turn on the switch local with that letter. If omited
    #         it don't turn on any switch using an erase event instead.
    #     can escape;
    #        optional value that must be added to allow escaping from battles
    #     can lose;
    #        optional value that must be added to avoid game over after a defeat
    #     skip return;
    #        optional value that makes the actors not return to their positions
    #        after the battle end, can be used for after battle cutscenes, remember
    #        that you must make a call manually to gather the party before allowing
    #        the player to control them.
    #
    #------------------------------------------------------------------------------
    # Additional instructions:
    #   All the positions are *MAP COORDINATES*, so to know the positions just
    #   check the tile position on the editor.
    #
    #   If using sprites, you need to have 5 different graphics for them:
    #   The default and one for each direction.
    #   You must add an extra sufix on them for each direction they're facing:
    #   [up] [left] [right] [down]
    #
    #   So if you have a battler named "Actor" and use VE_SPRITE_SUFIX = "[anim]"
    #   you will need the files to be named like this:
    #   Actor[anim][up]
    #   Actor[anim][left]
    #   Actor[anim][right]
    #   Actor[anim][down]
    #   
    #   Charsets battlers don't need any extra setup.
    #
    #   When using the script 'Victor Engine - Animated Battle' the lights do NOT
    #   follow the actors and enemies during battles, even if there was a light on
    #   the event/actor on the map.
    #
    #------------------------------------------------------------------------------
    #  Example call:
    #
    #   <call map battle>
    #   start: [12, 15]; end: [12, 15]; escape: [12, 21];
    #   actors: [7, 14], [14, 17], [17, 14], [10, 17];
    #   enemies: [1, 1, A],  [2, 1, A],  [3, 1, A];
    #   can escape;
    #   </call map battle>
    # 
    #    This call will make the screen center at the coodinate x:12 y:15 of the
    #    map, the battle end position will be the same, for escape the position
    #    is the coordinate x:12, y:21
    #
    #    The actor will be placed on the following positions: first actor on
    #    x:7, y:14; second actor on x:14, y:17, third actor on x:17, y:14;
    #    and the last actor on x:10, y:17
    #
    #    The events ID 1, 2 and 3 will become enemies. They will become the enemy
    #    ID 1, and will turn on the switch local A for each event.
    #
    #    The battle can be escaped.
    #
    #=================================================  =============================
    
    #=================================================  =============================
    # ** Victor Engine
    #------------------------------------------------------------------------------
    #   Setting module for the Victor Engine
    #=================================================  =============================
    
    module Victor_Engine
      #--------------------------------------------------------------------------
      # * Change the behavior of default template to work with 4 directions
      #   sprites
      #--------------------------------------------------------------------------
      VE_DEFAULT_ACTION = "
      
        # Pose displayed when idle
        <action: idle, loop>
        pose: self, row idle, all frames, wait 8, sufix [direction];
        wait: 32;
        </action>
      
        # Pose displayed when incapacited
        <action: dead, loop>
        pose: self, row dead, all frames, wait 8, sufix [direction];
        wait: 32;
        </action>
      
        # Pose displayed when hp is low
        <action: danger, loop>
        pose: self, row danger, all frames, wait 8, sufix [direction];
        wait: 32;
        </action>
      
        # Pose displayed when guarding
        <action: guard, loop>
        pose: self, row guard, all frames, wait 12, sufix [direction];
        wait: 48;
        </action>
      
        # Pose displayed during the battle start
        <action: intro, reset>
        pose: self, row intro, all frames, wait 16, sufix [direction];
        wait: 64;
        </action>
      
        # Pose displayed during battle victory
        <action: victory>
        pose: self, row intro, all frames, wait 16, sufix [direction], revert;
        wait: 64;
        pose: self, row victory, all frames, wait 16, sufix [direction];
        wait: 64;
        </action>
      
        # Pose displayed while waiting to perfom actions
        <action: ready, loop>
        pose: self, row ready, frame 1, sufix [direction];
        wait: 32;
        </action>
        
        # Pose displayed while waiting to perfom item actions
        <action: item cast, loop>
        pose: self, row itemcast, frame 1, sufix [direction];
        wait: 32;
        </action>
        
        # Pose displayed while waiting to perfom skill actions
        <action: skill cast, loop>
        pose: self, row skillcast, frame 1, sufix [direction];
        wait: 32;
        </action>
        
        # Pose displayed while waiting to perfom magic actions
        <action: magic cast, loop>
        pose: self, row magiccast, frame 1, sufix [direction];
        wait: 32;
        </action>
        
        # Pose displayed before inputing commands
        <action: command, reset>
        </action>
        
        # Pose displayed after inputing commands
        <action: input, reset>
        </action>
        
        # Pose displayed when cancel inputing commands
        <action: cancel, reset>
        </action>
        
        # Pose displayed when recive damage
        <action: hurt, reset>
        pose: self, row hurt, all frames, wait 4, sufix [direction];
        wait: 16
        </action>
      
        # Pose displayed when evading attacks
        <action: evade, reset>
        pose: self, row evade, all frames, wait 4, sufix [direction];
        wait: 16;
        </action>
      
        # Pose displayed when a attack miss
        <action: miss, reset>
        </action>
      
        # Pose displayed when reviving
        <action: revive, reset>
        </action>
      
        # Pose displayed when dying
        <action: die, reset>
        </action>
      
        # Make the target inactive (important, avoid change)
        <action: inactive>
        inactive;
        </action>
      
        # Set action advance
        <action: advance, reset>
        action: self, move to target;
        wait: action;
        </action>
        
        # Movement to target
        <action: move to target, reset>
        wait: animation;
        move: self, move to;
        direction: targets;
        jump: self, move, height 7;
        pose: self, row advance, all frames, wait 4, sufix [direction];
        wait: movement;
        </action>
        
        # Step foward movement
        <action: step foward, reset>
        wait: animation;
        move: self, step foward, speed 6;
        pose: self, row advance, all frames, wait 4, sufix [direction];
        wait: movement;
        </action>
        
        # Step backward movement
        <action: step backward, reset>
        wait: animation;
        move: self, step backward, speed 6;
        pose: self, row retreat, all frames, wait 4, invert, sufix [direction];
        wait: movement;
        </action>
    
        # Return to original spot
        <action: retreat, reset>
        move: self, retreat;
        pose: self, row retreat, all frames, wait 4, invert, sufix [direction];
        jump: self, move, height 7;
        wait: movement;
        direction: default;
        </action>
        
        # Move outside of the screen
        <action: escape, reset>
        move: self, escape;
        pose: self, row retreat, all frames, wait 4, invert, sufix [direction];
        wait: movement;
        </action>
        
        # Pose used for Defend command
        <action: defend, reset>
        pose: self, row guard, all frames, wait 8, sufix [direction];
        wait: 4;
        anim: targets, effect;
        wait: 4;
        effect: 100%;
        wait: 20;
        </action>
        
        # Pose for physical attacks
        <action: attack, reset>
        pose: self, row attack, all frames, wait 4, sufix [direction];
        wait: 4;
        anim: targets, effect;
        wait: 8;
        effect: 100%;
        wait: 20;
        </action>
        
        # Pose for physical attack with two weapons
        <action: dual attack, reset>
        pose: self, row attack, all frames, wait 4, sufix [direction];
        wait: 4;
        anim: targets, weapon 1;
        wait: 8;
        effect: 75%, weapon 1;
        wait: 4;
        wait: animation;
        pose: self, row skill, all frames, wait 4, sufix [direction];
        wait: 8;
        anim: targets, weapon 2;
        wait: 4;
        effect: 75%, weapon 2;
        wait: 20;
        </action>
            
        # Pose for using actions without type
        <action: use, reset>
        wait: animation;
        pose: self, row item, all frames, wait 4, sufix [direction];
        wait: 4;
        anim: targets, effect;
        wait: 4;
        effect: 100%;
        wait: 20;
        </action>
        
        # Pose for item use
        <action: item, reset>
        wait: animation;
        pose: self, row direction, all frames, wait 4, sufix [direction];
        wait: 4;
        anim: targets, effect;
        wait: 4;
        effect: 100%;
        wait: 20;
        </action>
        
        # Pose for magical skill use
        <action: magic, reset>
        wait: animation;
        pose: self, row magic, all frames, wait 4, sufix [direction];
        wait: 4;
        anim: targets, effect;
        wait: 8;
        effect: 100%;
        wait: 20;
        </action>
        
        # Pose for physical skill use
        <action: skill, reset>
        pose: self, row attack, all frames, wait 4, sufix [direction];
        wait: 4;
        anim: targets, effect;
        wait: 8;
        effect: 100%;
        wait: 20;
        </action>
        
        # Pose for counter attack activation (important, avoid change)
        <action: counter on, reset>
        counter: self, on;
        wait: counter;
        </action>
        
        # Pose for counter attack deactivation (important, avoid change)
        <action: counter off, reset>
        counter: targets, off;
        </action>
        
        # Pose for magic reflection
        <action: reflection, reset>
        wait: animation;
        wait: 4;
        anim: self, effect;
        wait: 8;
        effect: 100%;
        wait: animation;
        </action>
        
        # Pose for substitution activation (important, avoid change)
        <action: substitution on, reset>
        move: self, substitution, teleport;
        wait: movement;
        </action>
        
        # Pose for substitution deactivation
        <action: substitution off, reset>
        move: self, retreat, speed 15;
        </action>
        
        # Pose for the skill 'Dual Attack'
        <action: double attack, reset>
        pose: self, row attack, all frames, wait 4, sufix [direction];
        wait: 4;
        anim: targets, weapon 1;
        wait: 8;
        effect: 75%;
        wait: 4;
        wait: animation;
        pose: self, row skill, all frames, wait 4, sufix [direction];
        wait: 8;
        anim: targets, weapon 1;
        wait: 4;
        effect: 75%;
        wait: 20;
        </action>
        
        # Pose for the skills 'Life Drain' and 'Manda Drain'
        <action: drain, reset>
        wait: animation;
        pose: self, row magic, all frames, wait 4, sufix [direction];
        wait: 4;
        anim: targets, effect;
        wait: 8;
        effect: 100%;
        wait: 20;
        action: targets, user drain;
        wait: action;
        </action>
    
        # Pose for the targets of the skills 'Life Drain' and 'Manda Drain'
        <action: user drain, reset>
        throw: self, icon 187, return, revert, init y -12, end y -12;
        wait: throw;
        drain: self;
        wait: animation;
        </action>    
        
        # Pose for the sample skill 'Throw Weapon'
        <action: throw weapon, reset>
        pose: self, row attack, all frames, wait 4, sufix [direction];
        action: targets, target throw;
        wait: action;
        </action>
        
        # Pose for the targets of the sample skill 'Throw Weapon'
        <action: target throw, reset>
        throw: self, weapon 1, arc 12, spin +45, init y -12, end y -12;
        wait: throw;
        throw: self, weapon 1, arc 12, spin +45, return, revert, init y -12, end y -12;
        anim: self, weapon 1;
        effect: self, 100%;
        wait: throw;
        wait: animation;
        </action>
        
        # Pose for the sample skill 'Lightning Strike'
        <action: lightning strike, 5 times>
        direction: targets;
        pose: self, row attack, frame 1, all frames, wait 2, sufix [direction];
        move: self, x -48, speed 50;
        anim: targets, effect;
        effect: 20%;
        </action>
        
        # Pose for the sample skill 'Tempest'
        <action: tempest, reset>
        wait: animation;
        pose: self, row magic, all frames, wait 4, sufix [direction];
        wait: 4;
        tone: black, high priority, duration 20;
        wait: tone;
        movie: name 'Tempest', white, high priority;
        tone: clear, high priority, duration 20;
        wait: 15;
        anim: targets, effect;
        flash: screen, duration 10; 
        effect: 100%;
        wait: 20;
        </action>
        
        # Pose for the sample skill 'Meteor'
        <action: meteor, reset>
        wait: animation;
        pose: self, row magic, all frames, wait 4, sufix [direction];
        wait: 4;
        tone: black, high priority, duration 20;
        wait: tone;
        movie: name 'Meteor';
        tone: clear, high priority, duration 20;
        anim: targets, effect;
        wait: 20;
        effect: 100%;
        wait: 20;
        </action>
        
        # Pose for 'Bow' type weapons
        <action: bow, reset>
        direction: targets;
        pose: self, row attack, all frames, wait 4, sufix [direction];
        action: targets, arrow;
        wait: action;
        </action>
        
        # Pose for the targets of 'Bow' attack
        <action: arrow, reset>
        throw: self, image 'Arrow', arc 10, angle 45, init x -6, init y -12;
        wait: throw;
        anim: self, weapon 1;
        effect: self, 100%;
        wait: animation;
        </action>
    
        # Pose for the skill 'Aura Blade'
        <action: aura blade, reset>
        pose: self, row magic, all frames, wait 2, sufix [direction];
        anim: id 81;
        wait: animation;
        pose: self, row advance, all frames, wait 2, sufix [direction];
        move: move to;
        wait: movement;
        jump: height 16;
        wait: 12;
        pose: self, row attack, frame 1, sufix [direction];
        freeze: duration 40;
        anim: self, id 66;
        wait: self, freeze;
        wait: 4;
        pose: self, row attack, all frames, wait 2, sufix [direction];
        wait: 4;
        anim: targets, effect;
        flash: screen, duration 8;
        wait: 8;
        effect: 75%, weapon 1;
        flash: screen, duration 8;
        wait: 4;
        </action>
        
        # Movement to target for the skill 'Aura Blade'
        <action: aura blade move to, reset>
        pose: self, row magic, all frames, wait 2, sufix [direction];
        anim: id 81;
        wait: animation;
        </action>
    
        "
      #--------------------------------------------------------------------------
      # * required
      #   This method checks for the existance of the basic module and other
      #   VE scripts required for this script to work, don't edit this
      #--------------------------------------------------------------------------
      def self.required(name, req, version, type = nil)
        if !$imported[:ve_basic_module]
          msg = "The script '%s' requires the script\n"
          msg += "'VE - Basic Module' v%s or higher above it to work properly\n"
          msg += "Go to http://victorscripts.wordpress.com/ to download this script."
          msgbox(sprintf(msg, self.script_name(name), version))
          exit
        else
          self.required_script(name, req, version, type)
        end
      end
      #--------------------------------------------------------------------------
      # * script_name
      #   Get the script name base on the imported value
      #--------------------------------------------------------------------------
      def self.script_name(name, ext = "VE")
        name = name.to_s.gsub("_", " ").upcase.split
        name.collect! {|char| char == ext ? "#{char} -" : char.capitalize }
        name.join(" ")
      end
    end
    
    $imported ||= {}
    $imported[:ve_map_battle] = 1.05
    Victor_Engine.required(:ve_map_battle, :ve_basic_module, 1.27, :above)
    Victor_Engine.required(:ve_map_battle, :ve_animated_battle, 1.05, :above)
    Victor_Engine.required(:ve_map_battle, :ve_actor_battlers, 1.06, :above)
    
    #=================================================  =============================
    # ** BattleManager
    #------------------------------------------------------------------------------
    #  This module handles the battle processing
    #=================================================  =============================
    
    class << BattleManager
      #--------------------------------------------------------------------------
      # * Alias method: process_escape_pose
      #--------------------------------------------------------------------------
      alias :process_escape_pose_ve_map_battle :process_escape_pose
      def process_escape_pose
        if $game_party.map_battle
          SceneManager.scene.wait(5)
          SceneManager.scene.close_window
          Graphics.freeze
        else
          process_escape_pose_ve_map_battle
        end
      end
      #--------------------------------------------------------------------------
      # * Alias method: battle_end
      #--------------------------------------------------------------------------
      alias :battle_end_ve_map_battle :battle_end
      def battle_end(result)
        battle_end_ve_map_battle(result)
        map_battle = $game_party.map_battle
        if map_battle
          $game_system.intro_fade = $game_temp.old_intro_fade
          $game_battle_fogs       = $game_temp.old_battle_fog
          map_battle[:result] = :end    if result == 0 && map_battle
          map_battle[:result] = :escape if result == 1 && map_battle
          map_battle[:result] = :defeat if result == 2 && map_battle
        end
      end
      #--------------------------------------------------------------------------
      # * New method: setup_map_battle
      #--------------------------------------------------------------------------
      def setup_map_battle
        init_members
        $game_troop.setup_map_battle($game_party.map_battl  e)
        @can_escape = $game_party.map_battle[:can_run]
        @can_lose   = $game_party.map_battle[:can_lose]
        $game_temp.old_intro_fade = $game_system.intro_fade
        $game_temp.old_battle_fog = $game_battle_fogs
        $game_battle_fogs         = true
        $game_system.intro_fade   = false
        make_escape_ratio
      end
    end
    
    #=================================================  =============================
    # ** Game_Temp
    #------------------------------------------------------------------------------
    #  This class handles temporary data that is not included with save data.
    # The instance of this class is referenced by $game_temp.
    #=================================================  =============================
    
    class Game_Temp
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_accessor :old_intro_fade
      attr_accessor :old_battle_fog
      attr_accessor :old_custom_positions
      attr_accessor :old_custom_formation
      attr_accessor :old_position_adjust
    end
    
    #=================================================  =============================
    # ** Game_Map
    #------------------------------------------------------------------------------
    #  This class handles maps. It includes scrolling and passage determination
    # functions. The instance of this class is referenced by $game_map.
    #=================================================  =============================
    
    class Game_Map
      #--------------------------------------------------------------------------
      # * New method: finished_movement?
      #--------------------------------------------------------------------------
      def finished_movement?
        actors.all? {|actor| actor.finished_movement? }
      end  
    end
    
    #=================================================  =============================
    # ** Game_Party
    #------------------------------------------------------------------------------
    #  This class handles the party. It includes information on amount of gold 
    # and items. The instance of this class is referenced by $game_party.
    #=================================================  =============================
    
    class Game_Party < Game_Unit
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_accessor :map_battle
      #--------------------------------------------------------------------------
      # * Alias method: initialize
      #--------------------------------------------------------------------------
      alias :initialize_ve_map_battle :initialize
      def initialize
        initialize_ve_map_battle
        @map_battle = nil
      end
    end
    
    #=================================================  =============================
    # ** Game_Troop
    #------------------------------------------------------------------------------
    #  This class handles enemy groups and battle-related data. Also performs
    # battle events. The instance of this class is referenced by $game_troop.
    #=================================================  =============================
    
    class Game_Troop < Game_Unit
      #--------------------------------------------------------------------------
      # * New method: setup_map_battle
      #--------------------------------------------------------------------------
      def setup_map_battle(value)
        clear
        @troop_id = value[:troop_id]
        @enemies  = []
        value[:enemies].each do |info|
          next if !$data_enemies[info[:id]] || erased_event(info)
          enemy = Game_Enemy.new(@enemies.size, info[:id])
          event = $game_map.events[info[:event]]
          enemy.screen_x = event.screen_x
          enemy.screen_y = event.screen_y
          enemy.switch   = info[:switch]
          enemy.event_id = info[:event]
          @enemies.push(enemy)
        end
        init_screen_tone
        make_unique_names
      end
      #--------------------------------------------------------------------------
      # * New method: erased_event
      #--------------------------------------------------------------------------
      def erased_event(info)
        if info[:switch].string?
          $game_self_switches[[$game_map.map_id, info[:event], info[:switch]]]
        elsif info[:switch].numeric?
          $game_switches[info[:switch]]
        else
          $game_map.events[info[:event]].erased?
        end
      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 :switch
      attr_accessor :event_id
      #--------------------------------------------------------------------------
      # * New method: setup_dead_event
      #--------------------------------------------------------------------------
      def setup_dead_event
        return if !dead?
        if switch.string?
          $game_self_switches[[$game_map.map_id, event_id, switch]] = true
        elsif switch.numeric?
          $game_switches[switch] = true
        else
          $game_map.events[event_id].erase
        end
      end
    end
    
    #=================================================  =============================
    # ** Game_CharacterBase
    #------------------------------------------------------------------------------
    #  This class deals with characters. Common to all characters, stores basic
    # data, such as coordinates and graphics. It's used as a superclass of the
    # Game_Character class.
    #=================================================  =============================
    
    class Game_CharacterBase
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_accessor :battle_positions
      #--------------------------------------------------------------------------
      # * New method: finished_movement?
      #--------------------------------------------------------------------------
      def finished_movement?
        @battle_positions[:x].ceil == @x.ceil &&
        @battle_positions[:y].ceil == @y.ceil && !moving?
      end
      #--------------------------------------------------------------------------
      # * New method: move_to_position
      #--------------------------------------------------------------------------
      def move_to_position
        return if moving? || finished_movement?
        position = @battle_positions
        move_toward_position(position[:x], position[:y])
      end
      #--------------------------------------------------------------------------
      # * New method: turn_to_position
      #--------------------------------------------------------------------------
      def turn_to_position
        return if moving? || !finished_movement?
        position = $game_party.map_battle[:start]
        turn_toward_position(position[:x], position[:y])
      end
    end
    
    #=================================================  =============================
    # ** Game_Player
    #------------------------------------------------------------------------------
    #  This class handles the player.
    # The instance of this class is referenced by $game_map.
    #=================================================  =============================
    
    class Game_Player < Game_Character
      #--------------------------------------------------------------------------
      # * Alias method: update_scroll
      #--------------------------------------------------------------------------
      alias :update_scroll_ve_map_battle :update_scroll
      def update_scroll(last_real_x, last_real_y)
        return if @battle_positions
        update_scroll_ve_map_battle(last_real_x, last_real_y)
      end
      #--------------------------------------------------------------------------
      # * Alias method: add_move_update
      #--------------------------------------------------------------------------
      alias :add_move_update_ve_map_battle :add_move_update if $imported[:ve_followers_options]
      def add_move_update(dir)
        return if @battle_positions
        add_move_update_ve_map_battle(dir)
      end
      #--------------------------------------------------------------------------
      # *
      #--------------------------------------------------------------------------
      alias :step_times_ve_map_battle :step_times if $imported[:ve_pixel_movement]
      def step_times
        $game_party.map_battle ? super : step_times_ve_map_battle
      end
      #--------------------------------------------------------------------------
      # * New method: update_battle_scroll
      #--------------------------------------------------------------------------
      def update_battle_scroll(type)
        position = get_screen_postion($game_party.map_battle[type])
        ax1 = $game_map.display_x
        ay1 = $game_map.display_y
        ax2 = $game_map.round_x(position[:x])
        ay2 = $game_map.round_y(position[:y])
        $game_map.scroll_down (1.0 / 16) if ay2 > ay1
        $game_map.scroll_left (1.0 / 16) if ax2 < ax1
        $game_map.scroll_right(1.0 / 16) if ax2 > ax1
        $game_map.scroll_up   (1.0 / 16) if ay2 < ay1
      end
      #--------------------------------------------------------------------------
      # * New method: get_screen_postion
      #--------------------------------------------------------------------------
      def get_screen_postion(position)
        max_x = ($game_map.width  - $game_map.screen_tile_x)
        max_y = ($game_map.height - $game_map.screen_tile_y)
        pos_x = [0, [position[:x] - center_x, max_x].min].max
        pos_y = [0, [position[:y] - center_y, max_y].min].max
        {x: pos_x, y: pos_y}
      end
    end
    
    #=================================================  =============================
    # ** Game_Follower
    #------------------------------------------------------------------------------
    #  This class handles the followers. Followers are the actors of the party
    # that follows the leader in a line. It's used within the Game_Followers class.
    #=================================================  =============================
    
    class Game_Follower < Game_Character
      #--------------------------------------------------------------------------
      # * Alias method: chase_preceding_character
      #--------------------------------------------------------------------------
      alias :chase_preceding_character_ve_map_battle :chase_preceding_character
      def chase_preceding_character
        return if @battle_positions
        chase_preceding_character_ve_map_battle
      end
      #--------------------------------------------------------------------------
      # * Alias method: add_move_update
      #--------------------------------------------------------------------------
      alias :add_move_update_ve_map_battle :add_move_update if $imported[:ve_followers_options]
      def add_move_update(dir)
        return if @battle_positions
        add_move_update_ve_map_battle(dir)
      end
      #--------------------------------------------------------------------------
      # * Alias method: step_times
      #--------------------------------------------------------------------------
      alias :step_times_ve_map_battle :step_times if $imported[:ve_pixel_movement]
      def step_times
        $game_party.map_battle ? super : step_times_ve_map_battle
      end
    end
    
    #=================================================  =============================
    # ** Game_Event
    #------------------------------------------------------------------------------
    #  This class deals with events. It handles functions including event page 
    # switching via condition determinants, and running parallel process events.
    # It's used within the Game_Map class.
    #=================================================  =============================
    
    class Game_Event < Game_Character
      #--------------------------------------------------------------------------
      # * New method: is_in_battle?
      #--------------------------------------------------------------------------
      def is_in_battle?
        list = $game_party.map_battle[:enemies].collect {|event| event[:event] }
        list.include?(@id)
      end
    end
    
    #=================================================  =============================
    # ** Game_Interpreter
    #------------------------------------------------------------------------------
    #  An interpreter for executing event commands. This class is used within the
    # Game_Map, Game_Troop, and Game_Event classes.
    #=================================================  =============================
    
    class Game_Interpreter
      #--------------------------------------------------------------------------
      # * Alias method: comment_call
      #--------------------------------------------------------------------------
      alias :comment_call_ve_map_battle :comment_call
      def comment_call
        call_map_battle_comments
        comment_call_ve_map_battle
      end
      #--------------------------------------------------------------------------
      # * New method: call_map_battle_comments
      #--------------------------------------------------------------------------
      def call_map_battle_comments
        regexp = get_all_values("CALL MAP BATTLE")
        if note =~ regexp
          info  = $1.dup
          value = {}
          value[:can_run]  = info =~ /CAN ESCAPE/i   ? true : false
          value[:can_lose] = info =~ /CAN LOSE/i     ? true : false
          value[:skip]     = info =~ /SKIP RETURN/i  ? true : false
          value[:troop_id] = info =~ /TROOP: (\d+)/i ? $1.to_i : 1
          value[:start]    = get_position('START' , info)
          value[:end]      = get_position('END'   , info)
          value[:escape]   = get_position('ESCAPE', info)
          value[:defeat]   = get_position('DEFEAT', info)
          value[:enemies]  = setup_enemies(info)
          return if no_available_enemies(value)
          setup_actors(info)
          $game_party.map_battle = value
          SceneManager.call(Scene_Battle)
        end
      end
      #--------------------------------------------------------------------------
      # * New method: get_position
      #--------------------------------------------------------------------------
      def get_position(value, info)
        regexp = /#{value}: *\[(\d+), *(\d+)\]/i
        info   =~ regexp ? {x: $1.to_i, y: $2.to_i} : {x: 0, y: 0}
      end
      #--------------------------------------------------------------------------
      # * New method: setup_actors
      #--------------------------------------------------------------------------
      def setup_actors(info)
        list = get_actor_info(info)  
        $game_map.actors.each_with_index do |actor, index|
          actor.battle_positions = {x: list[index][:x], y: list[index][:y]}
          actor.clear_move if actor.follower? && $imported[:ve_followers_options]
        end
      end
      #--------------------------------------------------------------------------
      # * New method: get_actor_info
      #--------------------------------------------------------------------------
      def get_actor_info(info)
        value = info =~ /ACTORS: ((?: *\[\d+, *\d+\],?)*)/i ? $1 : ""
        value.scan(/\[(\d+) *, *(\d+)\]/i).collect {|x, y| {x: x.to_i, y: y.to_i} }
      end
      #--------------------------------------------------------------------------
      # * New method: setup_enemies
      #--------------------------------------------------------------------------
      def setup_enemies(info)
        regexp = /ENEMIES: ((?: *\[\d+ *, *\d+(?: *, *\w+)?\],*)*)/i 
        value  = info =~ regexp ? $1 : ""
        value.scan(/\[(\d+) *, *(\d+)(?: *, *(\w+))?\]/i).collect do |x, y, z| 
          result = ["A","B","C","D"].include?(z.upcase) ? z.upcase : z.to_i
          {event: x.to_i, id: y.to_i, switch: result} 
        end
      end
      #--------------------------------------------------------------------------
      # * New method: no_available_enemies
      #--------------------------------------------------------------------------
      def no_available_enemies(info)
        info[:enemies].all? {|enemy| erased_event(enemy) }
      end
      #--------------------------------------------------------------------------
      # * New method: erased_event
      #--------------------------------------------------------------------------
      def erased_event(info)
        if info[:switch].string?
          $game_self_switches[[$game_map.map_id, info[:event], info[:switch]]]
        elsif info[:switch].numeric?
          $game_switches[info[:switch]]
        else
          $game_map.events[info[:event]].erased?
        end
      end
    end
    
    #=================================================  =============================
    # ** Scene_Map
    #------------------------------------------------------------------------------
    #  This class performs the map screen processing.
    #=================================================  =============================
    
    class Scene_Map < Scene_Base
      #--------------------------------------------------------------------------
      # * Alias method: pre_battle_scene
      #--------------------------------------------------------------------------
      alias :pre_battle_scene_ve_map_battle :pre_battle_scene
      def pre_battle_scene
        if $game_party.map_battle
          prepare_map_battle
          Graphics.freeze
          @spriteset.dispose_characters
          BattleManager.save_bgm_and_bgs
          BattleManager.play_battle_bgm
        else
          pre_battle_scene_ve_map_battle
        end
      end
      #--------------------------------------------------------------------------
      # * Alias method: perform_battle_transition
      #--------------------------------------------------------------------------
      alias :perform_battle_transition_ve_map_battle :perform_battle_transition
      def perform_battle_transition
        perform_battle_transition_ve_map_battle if !$game_party.map_battle
      end
      #--------------------------------------------------------------------------
      # * Alias method: perform_transition
      #--------------------------------------------------------------------------
      alias :perform_transition_ve_map_battle :perform_transition
      def perform_transition
        if $game_party.map_battle
          Graphics.transition(0)
          end_map_battle
        else
          perform_transition_ve_map_battle
        end
      end
      #--------------------------------------------------------------------------
      # * New method: prepare_map_battle
      #--------------------------------------------------------------------------
      def prepare_map_battle
        setup_battle_position
        Graphics.update
      end
      #--------------------------------------------------------------------------
      # * New method: setup_battle_position
      #--------------------------------------------------------------------------
      def setup_battle_position
        update_screen_position(:start)
        upate_battle_position
        setup_actors_position
        BattleManager.setup_map_battle
      end
      #--------------------------------------------------------------------------
      # * New method: update_screen_position
      #--------------------------------------------------------------------------
      def update_screen_position(type)
        while !$game_map.finished_movement? || 
               display_position != start_position(type)
          upate_battle_position
          update_actor_position
          $game_player.update_battle_scroll(type)
        end
        $game_map.actors.each {|actor| actor.straighten }
        $game_map.actors.each {|actor| actor.turn_to_position }
      end
      #--------------------------------------------------------------------------
      # * New method: display_position
      #--------------------------------------------------------------------------
      def display_position
        {x: $game_map.display_x, y:  $game_map.display_y}
      end
      #--------------------------------------------------------------------------
      # * New method: start_position
      #--------------------------------------------------------------------------
      def start_position(type)
        position = $game_player.get_screen_postion($game_party.map_ba  ttle[type])
        {x: position[:x], y: position[:y]}
      end
      #--------------------------------------------------------------------------
      # * New method: update_actor_position
      #--------------------------------------------------------------------------
      def update_actor_position
        $game_map.actors.each {|actor| actor.move_to_position }
        $game_map.actors.each {|actor| actor.turn_to_position }
      end
      #--------------------------------------------------------------------------
      # * New method: upate_battle_position
      #--------------------------------------------------------------------------
      def upate_battle_position
        update_basic
        $game_map.update(false)
        $game_player.update
        $game_timer.update
        @spriteset.update
      end
      #--------------------------------------------------------------------------
      # * New method: setup_actors_position
      #--------------------------------------------------------------------------
      def setup_actors_position
        $game_temp.old_custom_positions = $game_custom_positions.dup
        $game_temp.old_custom_formation = $game_custom_formation
        $game_custom_formation = :custom
        $game_map.actors.each do |character|
          index = character.actor.index + 1
          $game_custom_positions[index][:x] = character.screen_x
          $game_custom_positions[index][:y] = character.screen_y
        end
      end
      #--------------------------------------------------------------------------
      # * New method: end_map_battle
      #--------------------------------------------------------------------------
      def end_map_battle
        unless $game_party.map_battle[:skip]
          setup_return_position($game_party.map_battle[:result])
          update_screen_position($game_party.map_battle[:result])
          upate_battle_position
        end
        clear_battle_valies
      end
      #--------------------------------------------------------------------------
      # * New method: setup_return_position
      #--------------------------------------------------------------------------
      def setup_return_position(result)
        position = $game_party.map_battle[result]
        $game_map.actors.each do |actor|
          actor.battle_positions = {x: position[:x], y: position[:y]}
        end
      end
      #--------------------------------------------------------------------------
      # * New method: clear_battle_valies
      #--------------------------------------------------------------------------
      def clear_battle_valies
        $game_party.map_battle = nil
        $game_map.actors.each {|actor| actor.battle_positions = nil }
      end
    end
    
    #=================================================  =============================
    # ** Scene_Battle
    #------------------------------------------------------------------------------
    #  This class performs battle screen processing.
    #=================================================  =============================
    
    class Scene_Battle < Scene_Base
      #--------------------------------------------------------------------------
      # * Alias method: create_spriteset
      #--------------------------------------------------------------------------
      alias :create_spriteset_ve_map_battle :create_spriteset
      def create_spriteset
        if $game_party.map_battle
          @spriteset = Spriteset_MapBattle.new
          setup_spriteset
        else
          create_spriteset_ve_map_battle
        end
      end
      #--------------------------------------------------------------------------
      # * Alias method: perform_transition
      #--------------------------------------------------------------------------
      alias :perform_transition_ve_map_battle :perform_transition
      def perform_transition
        if $game_party.map_battle
          Graphics.transition(0)
        else
          perform_transition_ve_map_battle
        end
      end
      #--------------------------------------------------------------------------
      # * Alias method: pre_terminate
      #--------------------------------------------------------------------------
      alias :pre_terminate_ve_map_battle :pre_terminate
      def pre_terminate
        if $game_party.map_battle && SceneManager.scene_is?(Scene_Map)
          clear_enemies
          super
        else
          pre_terminate_ve_map_battle
        end
      end
      #--------------------------------------------------------------------------
      # * New method: clear_enemies
      #--------------------------------------------------------------------------
      def clear_enemies
        $game_troop.members.each {|enemy| enemy.setup_dead_event }
      end
    end
    
    #=================================================  =============================
    # ** Spriteset_MapBattle
    #------------------------------------------------------------------------------
    #  This class brings together battle screen sprites and Map sprites. 
    # It's used within the Scene_Battle class.
    #=================================================  =============================
    
    class Spriteset_MapBattle < Spriteset_Battle
      #--------------------------------------------------------------------------
      # * initialize
      #--------------------------------------------------------------------------
      def initialize
        super
        create_characters
        create_tilemap
        create_parallax
        create_characters
        create_shadow
        create_weather
        update
      end
      #--------------------------------------------------------------------------
      # * dispose
      #--------------------------------------------------------------------------
      def dispose
        super
        dispose_tilemap
        dispose_parallax
        dispose_characters
        dispose_shadow
        dispose_weather
      end
      #--------------------------------------------------------------------------
      # * update
      #--------------------------------------------------------------------------
      def update
        super
        update_tileset    if @tileset
        update_tilemap    if @tilemap
        update_parallax   if @parallax
        update_characters if @character_sprites
        update_shadow     if @shadow_sprite
        update_weather    if @weather
      end
      #--------------------------------------------------------------------------
      # * create_battleback1
      #--------------------------------------------------------------------------
      def create_battleback1
      end
      #--------------------------------------------------------------------------
      # * create_battleback2
      #--------------------------------------------------------------------------
      def create_battleback2
      end
      #--------------------------------------------------------------------------
      # * dispose_battleback1
      #--------------------------------------------------------------------------
      def dispose_battleback1
      end
      #--------------------------------------------------------------------------
      # * dispose_battleback2
      #--------------------------------------------------------------------------
      def dispose_battleback2
      end
      #--------------------------------------------------------------------------
      # * update_battleback1
      #--------------------------------------------------------------------------
      def update_battleback1
      end
      #--------------------------------------------------------------------------
      # * update_battleback2
      #--------------------------------------------------------------------------
      def update_battleback2
      end  
      #--------------------------------------------------------------------------
      # * create_tilemap
      #--------------------------------------------------------------------------
      def create_tilemap
        @tilemap = Tilemap.new(@viewport1)
        @tilemap.map_data = $game_map.data
        load_tileset
      end
      #--------------------------------------------------------------------------
      # * load_tileset
      #--------------------------------------------------------------------------
      def load_tileset
        @tileset = $game_map.tileset
        @tileset.tileset_names.each_with_index do |name, i|
          @tilemap.bitmaps[i] = Cache.tileset(name)
        end
        @tilemap.flags = @tileset.flags
      end
      #--------------------------------------------------------------------------
      # * create_parallax
      #--------------------------------------------------------------------------
      def create_parallax
        @parallax = Plane.new(@viewport1)
        @parallax.z = -100
      end
      #--------------------------------------------------------------------------
      # * create_characters
      #--------------------------------------------------------------------------
      def create_characters
        @character_sprites = []
        $game_map.events.values.each do |event|
          next if event.is_in_battle?
          @character_sprites.push(Sprite_Character.new(@view  port1, event))
        end
        $game_map.vehicles.each do |vehicle|
          @character_sprites.push(Sprite_Character.new(@view  port1, vehicle))
        end
        @map_id = $game_map.map_id
        refresh_characters_sprites if $imported[:ve_anti_lag]
      end
      #--------------------------------------------------------------------------
      # * create_shadow
      #--------------------------------------------------------------------------
      def create_shadow
        @shadow_sprite = Sprite.new(@viewport1)
        @shadow_sprite.bitmap = Cache.system("Shadow")
        @shadow_sprite.ox = @shadow_sprite.bitmap.width / 2
        @shadow_sprite.oy = @shadow_sprite.bitmap.height
        @shadow_sprite.z = 180
      end
      #--------------------------------------------------------------------------
      # * create_weather
      #--------------------------------------------------------------------------
      def create_weather
        @weather = Spriteset_Weather.new(@viewport2)
      end
      #--------------------------------------------------------------------------
      # * dispose_tilemap
      #--------------------------------------------------------------------------
      def dispose_tilemap
        @tilemap.dispose
      end
      #--------------------------------------------------------------------------
      # * dispose_parallax
      #--------------------------------------------------------------------------
      def dispose_parallax
        @parallax.bitmap.dispose if @parallax.bitmap
        @parallax.dispose
      end
      #--------------------------------------------------------------------------
      # * dispose_characters
      #--------------------------------------------------------------------------
      def dispose_characters
        @character_sprites.each {|sprite| sprite.dispose }
      end
      #--------------------------------------------------------------------------
      # * dispose_shadow
      #--------------------------------------------------------------------------
      def dispose_shadow
        @shadow_sprite.dispose
      end
      #--------------------------------------------------------------------------
      # * dispose_weather
      #--------------------------------------------------------------------------
      def dispose_weather
        @weather.dispose
      end
      #--------------------------------------------------------------------------
      # * refresh_characters
      #--------------------------------------------------------------------------
      def refresh_characters
        dispose_characters
        create_characters
      end
      #--------------------------------------------------------------------------
      # * refresh_characters_sprites
      #--------------------------------------------------------------------------
      def refresh_characters_sprites
        @screen_sprites = []
        @character_sprites.each do |sprite|
          @screen_sprites.push(sprite) if sprite.character.on_buffer_area?
        end
      end
      #--------------------------------------------------------------------------
      # * refresh_sprites
      #--------------------------------------------------------------------------
      def refresh_sprites
        refresh_characters_sprites
        $game_map.refresh_event_list
        $game_map.refresh_screen_position
      end
      #--------------------------------------------------------------------------
      # * update_tileset
      #--------------------------------------------------------------------------
      def update_tileset
        if @tileset != $game_map.tileset
          load_tileset
          refresh_characters
        end
      end
      #--------------------------------------------------------------------------
      # * update_tilemap
      #--------------------------------------------------------------------------
      def update_tilemap
        @tilemap.map_data = $game_map.data
        @tilemap.ox = $game_map.display_x * 32
        @tilemap.oy = $game_map.display_y * 32
        @tilemap.update
      end
      #--------------------------------------------------------------------------
      # * update_parallax
      #--------------------------------------------------------------------------
      def update_parallax
        if @parallax_name != $game_map.parallax_name
          @parallax_name = $game_map.parallax_name
          @parallax.bitmap.dispose if @parallax.bitmap
          @parallax.bitmap = Cache.parallax(@parallax_name)
          Graphics.frame_reset
        end
        @parallax.ox = $game_map.parallax_ox(@parallax.bitmap)
        @parallax.oy = $game_map.parallax_oy(@parallax.bitmap)
      end
      #--------------------------------------------------------------------------
      # * update_characters
      #--------------------------------------------------------------------------
      def update_characters
        refresh_characters if @map_id != $game_map.map_id
        refresh_sprites    if $imported[:ve_anti_lag] && $game_map.screen_moved?
        if $imported[:ve_anti_lag]
          @screen_sprites.each {|sprite| sprite.update }
        else
          @character_sprites.each {|sprite| sprite.update }
        end
      end
      #--------------------------------------------------------------------------
      # * update_shadow
      #--------------------------------------------------------------------------
      def update_shadow
        airship = $game_map.airship
        @shadow_sprite.x = airship.screen_x
        @shadow_sprite.y = airship.screen_y + airship.altitude
        @shadow_sprite.opacity = airship.altitude * 8
        @shadow_sprite.update
      end
      #--------------------------------------------------------------------------
      # * update_weather
      #--------------------------------------------------------------------------
      def update_weather
        @weather.type  = $game_map.screen.weather_type
        @weather.power = $game_map.screen.weather_power
        @weather.ox = $game_map.display_x * 32
        @weather.oy = $game_map.display_y * 32
        @weather.update
      end
      #--------------------------------------------------------------------------
      # * update_pictures
      #--------------------------------------------------------------------------
      def update_pictures
        $game_map.screen.pictures.each do |pic|
          @picture_sprites[pic.number] ||= Sprite_Picture.new(@viewport2, pic)
          @picture_sprites[pic.number].update
        end
      end
    end
    
    #=================================================  =============================
    # ** VE - Map Battle X VE - Light Effects
    #------------------------------------------------------------------------------
    #  Compatibility Patch for VE - Map Battle and VE - Light Effects
    #=================================================  =============================
    
    if $imported[:ve_light_effects]
      #=================================================  =============================
      # ** Spriteset_MapBattle
      #------------------------------------------------------------------------------
      #  This class brings together battle screen sprites and Map sprites. 
      # It's used within the Scene_Battle class.
      #=================================================  =============================
    
      class Spriteset_MapBattle < Spriteset_Battle
        #--------------------------------------------------------------------------
        # * Alias method: initialize
        #--------------------------------------------------------------------------
        alias :initialize_ve_map_battle :initialize
        def initialize
          initialize_ve_map_battle
          2.times { update_light(true) }
        end
        #--------------------------------------------------------------------------
        # * Alias method: update
        #--------------------------------------------------------------------------
        alias :update_ve_map_battle :update
        def update
          update_ve_map_battle
          update_light
        end
        #--------------------------------------------------------------------------
        # * Alias method: dispose
        #--------------------------------------------------------------------------
        alias :dispose_ve_map_battle :dispose
        def dispose
          dispose_ve_map_battle
          dispose_light unless SceneManager.scene_is?(Scene_Map)
        end
        #--------------------------------------------------------------------------
        # * New method: update_light
        #--------------------------------------------------------------------------
        def update_light(forced = false)
          return unless Graphics.frame_count % 2 == 0 || forced
          update_shade
          update_effects
        end
        #--------------------------------------------------------------------------
        # * New method: dispose_light
        #--------------------------------------------------------------------------
        def dispose_light
          if @light_effect
            @light_effect.dispose
            @light_effect = nil
            @screen_shade = nil
          end
        end
        #--------------------------------------------------------------------------
        # * New method: update_shade
        #--------------------------------------------------------------------------
        def update_shade
          if !@light_effect && $game_map.screen.shade.visible
            refresh_lights
          elsif $game_map.screen.shade.visible && @light_effect
            @light_effect.update
          elsif @light_effect && !$game_map.screen.shade.visible
            dispose_light
          end
        end
        #--------------------------------------------------------------------------
        # * New method: refresh_lights
        #--------------------------------------------------------------------------
        def refresh_lights
          @light_effect.dispose if @light_effect
          @screen_shade = $game_map.screen.shade
          @light_effect = Sprite_Light.new(@screen_shade, @viewport2)
          $game_map.event_list.each {|ev| ev.refresh_lights }
          @light_effect.update
        end  
        #--------------------------------------------------------------------------
        # * New method: update_effects
        #--------------------------------------------------------------------------
        def update_effects
          return if !@light_effect || $game_map.screen.lights.empty?
          $game_map.screen.lights.keys.each {|key| create_light(key) }
          $game_map.screen.remove_light.clear
        end
        #--------------------------------------------------------------------------
        # * New method: create_light
        #--------------------------------------------------------------------------
        def create_light(key)
          effect = @light_effect.lights[key]
          return if remove_light(key)
          return if effect && effect.light == $game_map.screen.lights[key]
          @light_effect.create_light($game_map.screen.lights[key])
        end
        #--------------------------------------------------------------------------
        # * New method: remove_light
        #--------------------------------------------------------------------------
        def remove_light(key)
          return false if !$game_map.screen.remove_light.include?(key) 
          @light_effect.remove_light(key)
          $game_map.screen.lights.delete(key)
          return true
        end
      end
    end
    Последний раз редактировалось Темный; 09.10.2012 в 03:14.



  2. #2
    Бывалый Аватар для Soliд
    Информация о пользователе
    Регистрация
    24.04.2011
    Адрес
    Далеко за горами
    Сообщений
    907
    Записей в дневнике
    5
    Репутация: 32 Добавить или отнять репутацию

    По умолчанию

    Как-то ты очень "прозрачно" описал скрипт..."боевка прям на карте"...и все?неужели нельзя добавить что-то от себя, правильно оформить тему, отдать должное автору скрипта в конце-то концов?

  3. #3
    Хранитель Аватар для Темный
    Информация о пользователе
    Регистрация
    13.05.2011
    Сообщений
    2,449
    Записей в дневнике
    20
    Репутация: 50 Добавить или отнять репутацию

    По умолчанию

    По мойму видео говорит само за себя если не полениться его включить.
    Тема оформлена правильно или ты теперь модератор темы скриптов а?)



  4. #4
    Маститый Аватар для The Joker
    Информация о пользователе
    Регистрация
    16.06.2008
    Сообщений
    1,209
    Записей в дневнике
    11
    Репутация: 29 Добавить или отнять репутацию

    По умолчанию

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

    Темный, обрати, пожалуйста, внимание на вот эту тему: Правила составления темы со скриптом. Твой вклад в развитие форума весом, но не упорядочен. Приведи тему, пожалуйста, в порядок, и впредь пользуйся правилами оформления и не создавай темы, вроде "Еще три японских скрипта" и тому подобное.

    Сам скрипт впринципе не плох, но я не стану использовать ни Victor Engine, ни Yanflee Engine... Как-то нет у меня к ним доверия, да и это вызовет (у меня, по крайней мере) проблемы с внедрением иных скриптов, которые затрагивают их системы.
    Damaged

  5. #5
    Хранитель Аватар для Темный
    Информация о пользователе
    Регистрация
    13.05.2011
    Сообщений
    2,449
    Записей в дневнике
    20
    Репутация: 50 Добавить или отнять репутацию

    По умолчанию

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



  6. #6
    Маститый Аватар для The Joker
    Информация о пользователе
    Регистрация
    16.06.2008
    Сообщений
    1,209
    Записей в дневнике
    11
    Репутация: 29 Добавить или отнять репутацию

    По умолчанию

    Темный, ну че ты как маленький, ей-богу? Тут блин с новичками бьешься-бьешься за порядок и чистоту, и тут на те! Блин, ну попросил, вежливо, раз пять сказал пожалуйста, нет жешь надо теперь блин стать в гордую позу оскорбленного самурая... И всего-то попросили - тупо переписать немного первый пост. СЛОЖНО ТАК ЧТО ЛИ БЛИН ?!?
    Damaged

  7. #7
    Хранитель Аватар для Темный
    Информация о пользователе
    Регистрация
    13.05.2011
    Сообщений
    2,449
    Записей в дневнике
    20
    Репутация: 50 Добавить или отнять репутацию

    По умолчанию

    да за чем на фиг не чего не кому не надо. не кто даже вниманя не обратил что я этот пост постил
    ночью когда глаза закрывались. вобще тему удалю. Правильно сказано не делай не чего все равно не оценят!
    Последний раз редактировалось Темный; 14.08.2012 в 15:14.



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

    По умолчанию

    Нормально оформлено, что ты к нему прицепился. Если было бы вот скрипт и ссылка, тогда можно было наезжать.

  9. #9
    Маститый Аватар для The Joker
    Информация о пользователе
    Регистрация
    16.06.2008
    Сообщений
    1,209
    Записей в дневнике
    11
    Репутация: 29 Добавить или отнять репутацию

    По умолчанию

    Вот теперь оформлено отлично. Я бы и слова не брякнул, если так все было сначала.
    Damaged

  10. #10
    Хранитель Аватар для Темный
    Информация о пользователе
    Регистрация
    13.05.2011
    Сообщений
    2,449
    Записей в дневнике
    20
    Репутация: 50 Добавить или отнять репутацию

    По умолчанию

    тема закрыта! смотри пост выше!



Страница 1 из 3 123 ПоследняяПоследняя

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

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

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

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

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

Ваши права

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