循环状态动画脚本 - 求改错

congtangtang

各位大神，

我找到一个理论上很不错的脚本，它的功能是用来播放循环状态动画的，比如，我在敌人身上放个毒气，再放个黑暗，那么这两种状态的动画就会在敌人身上循环播放，一次毒气，一次黑暗，直到效果消失或者敌人死亡为止。

这套脚本需要两个脚本才能使用，一个是基础配置脚本，一个是循环动画脚本。

可是，第二个循环动画脚本当中有个BUG，在624行，是个METHOD定义的错误，我完全不知道该怎么修改，有没有懂脚本的大神能帮着看一眼？


这是VICTOR ENGINE 基础配置脚本
#==============================================================================
# ** Victor Engine - Basic Module
#------------------------------------------------------------------------------
# Author : Victor Sant
#
# Version History:
#  v 1.00 - 2011.12.19 > First release
#  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.01 > Compatibility with Custom Slip Effect v 1.01
#  v 1.29 - 2012.11.03 > Fixed returning value division by 0 error.
#  v 1.30 - 2012.12.13 > Compatibility with State Graphics
#  v 1.31 - 2012.12.16 > Compatibility with Active Time Battle
#  v 1.32 - 2012.12.24 > Compatibility with Active Time Battle v 1.01
#  v 1.33 - 2012.12.30 > Compatibility with Leap Attack
#  v 1.34 - 2013.01.07 > Compatibility with Critical Hit Effects v 1.01
#  v 1.35 - 2013.02.13 > Compatibility with Cooperation Skills
#------------------------------------------------------------------------------
#   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
#
#   class Game_Battler < Game_BattlerBase
#     def item_effect_recover_hp(user, item, effect)
#     def item_effect_recover_mp(user, item, effect)
#     def item_effect_gain_tp
#
# * 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://victorenginescripts.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.35

#==============================================================================
# ** 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: symbol?
  #--------------------------------------------------------------------------
  def symbol?
    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: face_exist?
  #--------------------------------------------------------------------------
  def face_exist?(filename)
    file_exist?("Graphics/Faces/", 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: returning_value
  #--------------------------------------------------------------------------
  def returning_value(i, x)
    y = [x * 2, 1].max
    i % y  >= x ? (x * 2) - i % y : i % y
  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
  #--------------------------------------------------------------------------
  # * 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: get_param_text
  #--------------------------------------------------------------------------
  def get_param_text(id)
    case id
    when 0 then "HP"
    when 1 then "MP"
    when 2 then "ATK"
    when 3 then "DEF"
    when 4 then "MAT"
    when 5 then "MDF"
    when 6 then "AGI"
    when 7 then "LUK"
    end
  end
  #--------------------------------------------------------------------------
  # * New method: get_xparam_id
  #--------------------------------------------------------------------------
  def get_xparam_id(text)
    case text.upcase
    when "HIT" then 0
    when "EVA" then 1
    when "CRI" then 2
    when "CEV" then 3
    when "MEV" then 4
    when "MRF" then 5
    when "CNT" then 6
    when "HRG" then 7
    when "MRG" then 8
    when "TRG" then 9
    end
  end
  #--------------------------------------------------------------------------
  # * New method: get_xparam_text
  #--------------------------------------------------------------------------
  def get_xparam_text(id)
    case id
    when 0 then "HIT"
    when 1 then "EVA"
    when 2 then "CRI"
    when 3 then "CEV"
    when 4 then "MEV"
    when 5 then "MRF"
    when 6 then "CNT"
    when 7 then "HRG"
    when 8 then "MRG"
    when 9 then "TRG"
    end
  end
  #--------------------------------------------------------------------------
  # * New method: get_sparam_id
  #--------------------------------------------------------------------------
  def get_sparam_id(text)
    case text.upcase
    when "TGR" then 0
    when "GRD" then 1
    when "REC" then 2
    when "PHA" then 3
    when "MCR" then 4
    when "TCR" then 5
    when "PDR" then 6
    when "MDR" then 7
    when "FDR" then 8
    when "EXR" then 9
    end
  end
  #--------------------------------------------------------------------------
  # * New method: get_sparam_text
  #--------------------------------------------------------------------------
  def get_sparam_text(id)
    case id
    when 0 then "TGR"
    when 1 then "GRD"
    when 2 then "REC"
    when 3 then "PHA"
    when 4 then "MCR"
    when 5 then "TCR"
    when 6 then "PDR"
    when 7 then "MDR"
    when 8 then "FDR"
    when 9 then "EXR"
    end
  end
  #--------------------------------------------------------------------------
  # * 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
end

#==============================================================================
# ** String
#------------------------------------------------------------------------------
#  The string class. Can handle character sequences of arbitrary lengths.
#==============================================================================

class String
  #--------------------------------------------------------------------------
  # * New method: string?
  #--------------------------------------------------------------------------
  def string?
    return true
  end
end

#==============================================================================
# ** String
#------------------------------------------------------------------------------
#  The class that represents symbols.
#==============================================================================

class Symbol
  #--------------------------------------------------------------------------
  # * New method: symbol?
  #--------------------------------------------------------------------------
  def symbol?
    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
  #--------------------------------------------------------------------------
  # * New method: to_ceil
  #--------------------------------------------------------------------------
  def to_ceil
    self > 0 ? self.abs.ceil : -self.abs.ceil
  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
  #--------------------------------------------------------------------------
  # * New method: element_set
  #--------------------------------------------------------------------------
  def element_set
    [damage.element_id]
  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

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

class << BattleManager
  #--------------------------------------------------------------------------
  # * New method: all_battle_members
  #--------------------------------------------------------------------------
  def all_battle_members
    $game_party.members + $game_troop.members
  end
  #--------------------------------------------------------------------------
  # * New method: all_dead_members
  #--------------------------------------------------------------------------
  def all_dead_members
    $game_party.dead_members + $game_troop.dead_members
  end
  #--------------------------------------------------------------------------
  # * New method: all_movable_members
  #--------------------------------------------------------------------------
  def all_movable_members
    $game_party.movable_members + $game_troop.movable_members
  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_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: 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: element_set
  #--------------------------------------------------------------------------
  def element_set(item)
    element_set  = item.element_set
    element_set += atk_elements if item.damage.element_id < 0
    element_set.delete(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 < chance
  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
  #--------------------------------------------------------------------------
  # * Overwrite method: item_effect_recover_hp
  #--------------------------------------------------------------------------
  def item_effect_recover_hp(user, item, effect)
    value = item_value_recover_hp(user, item, effect).to_i
    @result.hp_damage -= value
    @result.success    = true
    self.hp += value
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: item_effect_recover_mp
  #--------------------------------------------------------------------------
  def item_effect_recover_mp(user, item, effect)
    value = item_value_recover_mp(user, item, effect).to_i
    @result.mp_damage -= value
    @result.success    = true if value != 0
    self.mp += value
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: item_effect_gain_tp
  #--------------------------------------------------------------------------
  def item_effect_gain_tp(user, item, effect)
    value    = item_value_recover_tp(user, item, effect)
    self.tp += value
  end
  #--------------------------------------------------------------------------
  # * New method: item_value_recover_hp
  #--------------------------------------------------------------------------
  def item_value_recover_hp(user, item, effect)
    value  = (mhp * effect.value1 + effect.value2) * rec
    value *= user.pha if item.is_a?(RPG::Item)
    value
  end
  #--------------------------------------------------------------------------
  # * New method: item_value_recover_mp
  #--------------------------------------------------------------------------
  def item_value_recover_mp(user, item, effect)
    value  = (mmp * effect.value1 + effect.value2) * rec
    value *= user.pha if item.is_a?(RPG::Item)
    value
  end
  #--------------------------------------------------------------------------
  # * New method: item_value_recover_tp
  #--------------------------------------------------------------------------
  def item_value_recover_tp(user, item, effect)
    effect.value1.to_i
  end
  #--------------------------------------------------------------------------
  # * 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: id
  #--------------------------------------------------------------------------
  def id
    @enemy_id
  end
  #--------------------------------------------------------------------------
  # * 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 | added_skills).sort.collect {|id| $data_skills[id] }
  end
  #--------------------------------------------------------------------------
  # * New method: enemy_actions
  #--------------------------------------------------------------------------
  def enemy_actions
    enemy.actions.collect {|action| 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?(:class)
    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 || [email protected] || @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

#==============================================================================
# ** Game_Animation
#------------------------------------------------------------------------------
#  Classe that handles Animation data
#==============================================================================

class Game_Animation
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :ox
  attr_accessor :oy
  attr_accessor :rate
  attr_accessor :zoom
  attr_accessor :loop
  attr_accessor :type
  attr_accessor :map_x
  attr_accessor :map_y
  attr_accessor :mirror
  attr_accessor :follow
  attr_accessor :height
  attr_accessor :bitmap1
  attr_accessor :bitmap2
  attr_accessor :sprites
  attr_accessor :duration
  attr_accessor :direction
  attr_accessor :duplicated
  #--------------------------------------------------------------------------
  # * New method: initialize
  #--------------------------------------------------------------------------
  def initialize(animation, mirror, user = nil)
    @animation = animation
    @rate      = animation.name =~ /<RATE: ([+-]?\d+)>/i ? [$1.to_i, 1].max : 4
    @zoom      = animation.name =~ /<ZOOM: (\d+)%?>/i ? $1.to_i / 100.0 : 1.0
    @follow    = animation.name =~ /<FOLLOW>/i ? true : false
    @mirror    = mirror
    @duration  = frame_max * @rate
    @direction = user.anim_direction if user
    @sprites   = []
    bellow     = animation.name =~ /<BELLOW>/i
    above      = animation.name =~ /<ABOVE>/i
    @height    = bellow ? -1 : above ? 300 : 1
  end
  #--------------------------------------------------------------------------
  # * New method: data
  #--------------------------------------------------------------------------  
  def data
    @animation
  end
  #--------------------------------------------------------------------------
  # * New method: id
  #--------------------------------------------------------------------------  
  def id
    @animation.id
  end
  #--------------------------------------------------------------------------
  # * New method: name
  #--------------------------------------------------------------------------  
  def name
    @animation.name
  end
  #--------------------------------------------------------------------------
  # * New method: frame_max
  #--------------------------------------------------------------------------
  def frame_max
    @animation.frame_max
  end
  #--------------------------------------------------------------------------
  # * New method: position
  #--------------------------------------------------------------------------
  def position
    @animation.position
  end
  #--------------------------------------------------------------------------
  # * New method: animation1_name
  #--------------------------------------------------------------------------
  def animation1_name
    @animation.animation1_name
  end
  #--------------------------------------------------------------------------
  # * New method: animation2_name
  #--------------------------------------------------------------------------
  def animation2_name
    @animation.animation2_name
  end
  #--------------------------------------------------------------------------
  # * New method: animation1_hue
  #--------------------------------------------------------------------------
  def animation1_hue
    @animation.animation1_hue
  end
  #--------------------------------------------------------------------------
  # * New method: animation2_hue
  #--------------------------------------------------------------------------
  def animation2_hue
    @animation.animation2_hue
  end
  #--------------------------------------------------------------------------
  # * New method: frames
  #--------------------------------------------------------------------------
  def frames
    @animation.frames
  end
  #--------------------------------------------------------------------------
  # * New method: timings
  #--------------------------------------------------------------------------
  def timings
    @animation.timings
  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













这是循环动画脚本，624行会出错，method定义有问题
#==============================================================================
# ** Victor Engine - Loop Animation
#------------------------------------------------------------------------------
# Author : Victor Sant
#
# Version History:
#  v 1.00 - 2012.01.01 > First relase
#  v 1.01 - 2012.01.07 > Fixed Bug with Comment Call
#                      > Reordered the Regular Expression to fix a mismatch
#  v 1.02 - 2012.01.15 > Compatibility with Target Arrow
#  v 1.03 - 2012.03.11 > Compatibility with Animation Setting
#  v 1.04 - 2013.02.13 > Compatibility with Basic Module 1.35
#------------------------------------------------------------------------------
#  This script allows to display looping and cycling animations, the
# animation loops indefinitely, and if there's more than one they cycles
# between them. They're used to display status effects or can be called to
# display some visual effect.
#------------------------------------------------------------------------------
# Compatibility
#   Requires the script 'Victor Engine - Basic Module' v 1.35 or higher
#
# * Alias methods (Default)
#   class Game_Battler < Game_BattlerBase
#     def initialize
#
#   class Game_Enemy < Game_Battler
#     def initialize
#
#   class Game_CharacterBase
#     def initialize
#
#   class Sprite_Base < Sprite
#     def initialize(viewport = nil)
#     def dispose
#     def update
#
#   class Sprite_Character < Sprite_Base
#     def initialize(viewport, character = nil)
#     def setup_new_effect
#
#   class Sprite_Battler < Sprite_Base
#     def initialize(viewport, battler = nil)
#     def setup_new_effect
#
# * 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 scripts 'Victor Engine - Basic'
#
#------------------------------------------------------------------------------
# Comment calls note tags:
#  Tags to be used in events comment box, works like a script call.
#
#  <event loop animation i: x>
#   Display a loop animation on the event.
#     i : event ID
#     x : loop animation ID
#
#  <event loop animation type i: x, y>
#   Set the loop animation type for events, have effect only when used together
#   with <event loop animation i: x>, otherwise have no effect, this tag is
#   opitional
#     i : event ID
#     x : loop animation ID
#     y : loop animation type
#
#  <event loop animation loop i: x, y>
#   Set the loop animation loop numbers for events, have effect only when used
#   together with <event loop animation i: x>, otherwise have no effect,
#   this tag is opitional
#     i : event ID
#     x : loop animation ID
#     y : loop animation loop times
#
#  <actor loop animation i: x>
#   Display a loop animation on the actors, can be used in battles.
#     i : actor index
#     x : loop animation ID
#
#  <actor loop animation type i: x, y>
#   Set the loop animation type for actors, have effect only when used together
#   with <actor loop animation i: x>, otherwise have no effect, this tag
#  is opitional
#     i : actor index
#     x : loop animation ID
#     y : loop animation type
#
#  <actor loop animation loop i: x, y>
#   Set the loop animation loop numbers for actors, have effect only when used
#   together with <actor loop animation i: x>, otherwise have no effect,
#   this tag is opitional
#     i : actor index
#     x : loop animation ID
#     y : loop animation loop times
#
#  <vehicle loop animation i: x>
#   Display a loop animation on the vehicles, can be used in battles.
#   this tag is opitional
#     i : vehicle type name
#     x : loop animation ID
#
#  <vehicle loop animation type i: x, y>
#   Set the loop animation type for vehicles, have effect only when used
#   together with <vehicle loop animation i: x>, otherwise have no effect,
#   this tag is opitional
#     i : vehicle type name
#     x : loop animation ID
#     y : loop animation type
#
#  <vehicle loop animation loop i: x, y>
#   Set the loop animation loop numbers for vehicles, have effect only when
#   used together with <vehicle loop animation i: x>, otherwise have no
#   effect, this tag is opitional
#     i : vehicle type name
#     x : loop animation ID
#     y : loop animation loop times
#
#------------------------------------------------------------------------------
# Comment boxes note tags:
#   Tags to be used on events Comment boxes. They're different from the
#   comment call, they're called always the even refresh.
#
#  <loop animation: i>
#   Display a loop animation on the event.
#     i : loop animation ID
#
#  <loop animation type: x, y>
#   Set the loop animation type, have effect only when used together with
#   <self loop animation id: x>, otherwise have no effect, this tag is opitional
#     x : loop animation ID
#     y : loop animation type
#
#  <loop animation loop: x, y>
#   Set the loop animation loop numbers, have effect only when used
#   together with <self loop animation id: x>, otherwise have no effect,
#   this tag is opitional
#     x : loop animation ID
#     y : loop animation loop times
#
#------------------------------------------------------------------------------
# Enemies note tags:
#   Tags to be used on the Enemies note box in the database
#
#  <loop animation: i>
#   Display a loop animation on the enemy.
#     i : loop animation ID
#
#  <loop animation type: x, y>
#   Set the loop animation type, have effect only when used together with
#   <loop animation id: x>, otherwise have no effect, this tag is opitional
#     x : loop animation ID
#     y : loop animation type
#
#  <loop animation loop: x, y>
#   Set the loop animation loop numbers, have effect only when used together
#   with <loop animation id: x>, otherwise have no effect, this tag is opitional
#     x : loop animation ID
#     y : loop animation loop times
#
#------------------------------------------------------------------------------
# States note tags:
#   Tags to be used on the States note box in the database
#
#  <loop animation: i>
#   Display a loop animation on the target of the state during battles
#     i : loop animation ID
#
#  <loop animation type: x, y>
#   Set the loop animation type, have effect only when used together with
#   <loop animation: x>, otherwise have no effect, this tag is opitional
#     x : loop animation ID
#     y : loop animation type
#
#  <loop animation loop: x, y>
#   Set the loop animation loop numbers, have effect only when used together
#   with <loop animation: x>, otherwise have no effect, this tag is opitional
#     x : loop animation ID
#     y : loop animation loop times
#
#  <map loop animation: i>
#   Display a loop animation on the target of the state on the map
#     i : loop animation ID
#
#  <map loop animation type: x, y>
#   Set the loop animation type, have effect only when used together with
#   <map loop animation: x>, otherwise have no effect, this tag is opitional
#     x : loop animation ID
#     y : loop animation type
#
#  <map loop animation loop: x, y>
#   Set the loop animation loop numbers, have effect only when used together
#   with <map loop animation: x>, otherwise have no effect, this tag is
#   opitional
#     x : loop animation ID
#     y : loop animation loop times
#
#------------------------------------------------------------------------------
# Additional instructions:
#
#  The animation type is a identifier to decide the animation cycle. Loop
#  animations only cycle thought animations of the same type. If two or more
#  animations from different types are displayed on the same target.
#  all animations from the different types will be displayed at same time.
#  Avoid overdoing with this because it may cause FPS drop.
#
#==============================================================================

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

module Victor_Engine
  #--------------------------------------------------------------------------
  # * 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://victorenginescripts.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_loop_animation] = 1.04
Victor_Engine.required(:ve_loop_animation, :ve_basic_module, 1.35, :above)

#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
#  This class deals with battlers. It's used as a superclass of the Game_Actor
# and Game_Enemy classes.
#==============================================================================

class Game_Battler < Game_BattlerBase
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :add_animation
  attr_reader   :remove_animation
  #--------------------------------------------------------------------------
  # * Alias method: initialize
  #--------------------------------------------------------------------------
  alias :initialize_ve_loop_animation :initialize
  def initialize
    initialize_ve_loop_animation
    clear_add_loop_animation
  end
  #--------------------------------------------------------------------------
  # * New method: add_loop_animation
  #--------------------------------------------------------------------------
  def add_loop_animation(anim, type, loop = 1)
    @add_animation = {anim: anim, type: type, loop: loop}
  end
  #--------------------------------------------------------------------------
  # * New method: remove_loop_animation
  #--------------------------------------------------------------------------
  def remove_loop_animation(anim, type)
    @remove_animation = {anim: anim, type: type}
  end
  #--------------------------------------------------------------------------
  # * New method: clear_add_loop_animation
  #--------------------------------------------------------------------------
  def clear_add_loop_animation
    @add_animation = nil
  end
  #--------------------------------------------------------------------------
  # * New method: clear_remove_loop_animation
  #--------------------------------------------------------------------------
  def clear_remove_loop_animation
    @remove_animation = nil
  end
end


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

class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # * Alias method: initialize
  #--------------------------------------------------------------------------
  alias :initialize_ge_ve_loop_animation :initialize
  def initialize(index, enemy_id)
    initialize_ge_ve_loop_animation(index, enemy_id)
    refresh_loop_animations
  end
  #--------------------------------------------------------------------------
  # * New method: refresh_loop_animations
  #--------------------------------------------------------------------------
  def refresh_loop_animations
    note.scan(/<LOOP ANIMATION: (\d+)>/i) do
      id   = $1
      type = note =~ /<LOOP ANIMATION TYPE: #{id},\s*(\d+)>/i ? $1 : 0
      loop = note =~ /<LOOP ANIMATION LOOP: #{id},\s*(\d+)>/i ? $1 : 1
      add_loop_animation(id.to_i, type.to_i, loop.to_i)
    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_reader   :add_animation
  attr_reader   :remove_animation
  #--------------------------------------------------------------------------
  # * Alias method: initialize
  #--------------------------------------------------------------------------
  alias :initialize_ve_loop_animation :initialize
  def initialize
    initialize_ve_loop_animation
    clear_add_loop_animation
  end
  #--------------------------------------------------------------------------
  # * New method: add_loop_animation
  #--------------------------------------------------------------------------
  def add_loop_animation(anim, type, loop = 1)
    @add_animation = {anim: anim, type: type, loop: loop}
  end
  #--------------------------------------------------------------------------
  # * New method: remove_loop_animation
  #--------------------------------------------------------------------------
  def remove_loop_animation(anim, type)
    @remove_animation = {anim: anim, type: type}
  end
  #--------------------------------------------------------------------------
  # * New method: clear_add_loop_animation
  #--------------------------------------------------------------------------
  def clear_add_loop_animation
    @add_animation = nil
  end
  #--------------------------------------------------------------------------
  # * New method: clear_remove_loop_animation
  #--------------------------------------------------------------------------
  def clear_remove_loop_animation
    @remove_animation = nil
  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
  #--------------------------------------------------------------------------
  # * Alias method: clear_starting_flag
  #--------------------------------------------------------------------------
  alias :clear_starting_flag_ve_loop_animation :clear_starting_flag
  def clear_starting_flag
    clear_starting_flag_ve_loop_animation
    refresh_loop_animations if @page
  end
  #--------------------------------------------------------------------------
  # * New method: refresh_loop_animations
  #--------------------------------------------------------------------------
  def refresh_loop_animations
    note.scan(/<LOOP ANIMATION ID: (\d+)>/i) do
      id   = $1
      type = note =~ /<LOOP ANIMATION TYPE: #{id},\s*(\d+)>/i ? $1 : 0
      loop = note =~ /<LOOP ANIMATION LOOP: #{id},\s*(\d+)>/i ? $1 : 1
      add_loop_animation(id.to_i, type.to_i, loop.to_i)
    end
  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_loop_animation :comment_call
  def comment_call
    call_event_loop_anim
    call_actor_loop_anim
    call_vehicle_loop_anim
    call_enemy_loop_anim
    comment_call_ve_loop_animation
  end
  #--------------------------------------------------------------------------
  # * New method: call_event_loop_anim
  #--------------------------------------------------------------------------
  def call_event_loop_anim
    note.scan(/<EVENT LOOP ANIMATION (\d+): (\d+)>/i) do |i, id|
      event = $game_map.events[i.to_i]
      regexp = "EVENT LOOP ANIMATION"
      type   = note =~ /<#{regexp} TYPE #{i}: #{id},\s*(\d+)>/i ? $1 : 1
      loop   = note =~ /<#{regexp} LOOP #{i}: #{id},\s*(\d+)>/i ? $1 : 1
      event.add_loop_animation(id.to_i, type.to_i, loop.to_i)
    end
  end
  #--------------------------------------------------------------------------
  # * New method: call_actor_loop_anim
  #--------------------------------------------------------------------------
  def call_actor_loop_anim
    note.scan(/<ACTOR LOOP ANIMATION (\d+): (\d+)>/i) do |i, id|
      if $game_party.in_battle
        actor = $game_party.battle_members[i.to_i]
      else
        actor = $game_map.actors[i.to_i]
      end
      regexp = "ACTOR LOOP ANIMATION"
      type   = note =~ /<#{regexp} TYPE #{i}: #{id},\s*(\d+)>/i ? $1 : 1
      loop   = note =~ /<#{regexp} LOOP #{i}: #{id},\s*(\d+)>/i ? $1 : 1
      actor.add_loop_animation(id.to_i, type.to_i, loop.to_i)
    end
  end
  #--------------------------------------------------------------------------
  # * New method: call_vehicle_loop_anim
  #--------------------------------------------------------------------------
  def call_vehicle_loop_anim
    note.scan(/<VEHICLE LOOP ANIMATION (\w+): (\d+)>/i) do |i, id|
      vehicle = $game_map.vehicle(eval(":#{i}"))
      regexp = "VEHICLE LOOP ANIMATION"
      type   = note =~ /<#{regexp} TYPE #{i}: #{id},\s*(\d+)>/i ? $1 : 1
      loop   = note =~ /<#{regexp} LOOP #{i}: #{id},\s*(\d+)>/i ? $1 : 1
      vehicle.add_loop_animation(id.to_i, type.to_i, loop.to_i)
    end
  end
  #--------------------------------------------------------------------------
  # * New method: call_enemy_loop_anim
  #--------------------------------------------------------------------------
  def call_enemy_loop_anim
    return if !$game_party.in_battle
    note.scan(/<ENEMY LOOP ANIMATION (\d+): (\d+)>/i) do |i, id|
      enemy = $game_troop.members[i.to_i]
      regexp = "ENEMY LOOP ANIMATION"
      type   = note =~ /<#{regexp} TYPE #{i}: #{id},\s*(\d+)>/i ? $1 : 1
      loop   = note =~ /<#{regexp} LOOP #{i}: #{id},\s*(\d+)>/i ? $1 : 1
      enemy.add_loop_animation(id.to_i, type.to_i, loop.to_i)
    end
  end  
end

#==============================================================================
# ** Sprite_Base
#------------------------------------------------------------------------------
#  A sprite class with animation display processing added.
#==============================================================================

class Sprite_Base < Sprite
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :loop_anim
  #--------------------------------------------------------------------------
  # * Class Variables
  #--------------------------------------------------------------------------
  @@loop_ani_checker = []
  #--------------------------------------------------------------------------
  # * Alias method: initialize
  #--------------------------------------------------------------------------
  alias :initialize_ve_loop_animation :initialize
  def initialize(viewport = nil)
    initialize_ve_loop_animation(viewport)
    @loop_animation = {}
    @loop_list = {}
  end
  #--------------------------------------------------------------------------
  # * Alias method: dispose
  #--------------------------------------------------------------------------
  alias :dispose_ve_loop_animation :dispose
  def dispose
    dispose_ve_loop_animation
    end_all_loop_anim
  end
  #--------------------------------------------------------------------------
  # * Alias method: update
  #--------------------------------------------------------------------------
  alias :update_ve_loop_animation :update
  def update
    dispose_removed_loop_anim
    update_ve_loop_animation
    setup_loop_anim
    update_all_loop_anim
    end_all_loop_anim if any_loop_anim? && !sprite_visible
  end
  #--------------------------------------------------------------------------
  # * New method: user
  #--------------------------------------------------------------------------
  def user
    @battler ? @battler : @character
  end
  #--------------------------------------------------------------------------
  # * New method: setup_loop_anim
  #--------------------------------------------------------------------------
  def setup_loop_anim
    @loop_list.keys.each do |type|
      if !loop_anim?(type) && @loop_list[type].size > 0
        create_loop_anim(type)
      elsif @loop_list[type].empty?
        @loop_list.delete(type)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * New method: create_loop_anim
  #--------------------------------------------------------------------------
  def create_loop_anim(type)
    return if !@loop_list[type]
    item = @loop_list[type].next_item
    anim = $data_animations[item.first]
    start_loop_anim(anim, type)
    @loop_animation[type].loop = item.last - 1
  end
  #--------------------------------------------------------------------------
  # * New method: any_loop_anim?
  #--------------------------------------------------------------------------
  def any_loop_anim?
    @loop_animation && @loop_animation.values.size > 0
  end
  #--------------------------------------------------------------------------
  # * New method: loop_anim?
  #--------------------------------------------------------------------------
  def loop_anim?(type)
    @loop_animation[type]
  end
  #--------------------------------------------------------------------------
  # * New method: start_loop_anim
  #--------------------------------------------------------------------------
  def start_loop_anim(animation, type, mirror = false)
    return if @loop_animation[type] && animation == @loop_animation[type].data
    dispose_loop_anim(type) if @loop_animation[type]
    @loop_animation[type] = Game_Animation.new(animation, mirror)
    if @loop_animation[type]
      load_loop_anim_bitmap(type)
      make_loop_anim_sprites(type)
      set_loop_anim_origin(type)
    end
  end
  #--------------------------------------------------------------------------
  # * New method: load_loop_anim_bitmap
  #--------------------------------------------------------------------------
  def load_loop_anim_bitmap(type)
    animation  = @loop_animation[type]
    anim1_name = animation.animation1_name
    anim1_hue  = animation.animation1_hue
    anim2_name = animation.animation2_name
    anim2_hue  = animation.animation2_hue
    animation.bitmap1 = Cache.animation(anim1_name, anim1_hue)
    animation.bitmap2 = Cache.animation(anim2_name, anim2_hue)
    if @@_reference_count.include?(animation.bitmap1)
      @@_reference_count[animation.bitmap1] += 1
    else
      @@_reference_count[animation.bitmap1] = 1
    end
    if @@_reference_count.include?(animation.bitmap2)
      @@_reference_count[animation.bitmap2] += 1
    else
      @@_reference_count[animation.bitmap2] = 1
    end
    Graphics.frame_reset
  end
  #--------------------------------------------------------------------------
  # * New method: make_loop_anim_sprites
  #--------------------------------------------------------------------------
  def make_loop_anim_sprites(type)
    animation = @loop_animation[type]
    animation.duplicated = @@loop_ani_checker.include?(animation.data)
    if @use_sprite && !(animation.duplicated  && animation.position == 3)
      16.times do
        sprite = ::Sprite.new(viewport)
        sprite.visible = false
        animation.sprites.push(sprite)
      end
    end
    @@loop_ani_checker.push(animation.data) if !animation.duplicated
  end
  #--------------------------------------------------------------------------
  # * New method: set_loop_anim_origin
  #--------------------------------------------------------------------------
  def set_loop_anim_origin(type)
    animation = @loop_animation[type]
    if animation.position == 3
      update_animation_screen(animation)
    else
      update_animation_origin(animation)
    end
    animation.map_x = charset? ? $game_map.display_x : 0
    animation.map_y = charset? ? $game_map.display_y : 0
  end
  #--------------------------------------------------------------------------
  # * New method: update_animation_screen
  #--------------------------------------------------------------------------
  def update_animation_screen(animation)
    if viewport == nil
      animation.ox = Graphics.width  / 2
      animation.oy = Graphics.height / 2
    else
      animation.ox = viewport.rect.width  / 2
      animation.oy = viewport.rect.height / 2
    end
  end
  #--------------------------------------------------------------------------
  # * New method: update_animation_origin
  #--------------------------------------------------------------------------
  def update_animation_origin(animation)
    animation.ox  = x - ox + width  / 2
    animation.oy  = y - oy + height / 2
    animation.oy -= height / 2 if animation.position == 0
    animation.oy += height / 2 if animation.position == 2
  end
  #--------------------------------------------------------------------------
  # * New method: dispose_loop_anim
  #--------------------------------------------------------------------------
  def dispose_loop_anim(type)
    animation = @loop_animation[type]
    if animation.bitmap1
      @@_reference_count[animation.bitmap1] -= 1
      animation.bitmap1.dispose if @@_reference_count[animation.bitmap1] == 0
    end
    if animation.bitmap2
      @@_reference_count[animation.bitmap2] -= 1
      animation.bitmap2.dispose if @@_reference_count[animation.bitmap2] == 0
    end
    animation.sprites.each {|sprite| sprite.dispose } if animation.sprites
    @loop_animation.delete(type)
  end
  #--------------------------------------------------------------------------
  # * New method: update_all_loop_anim
  #--------------------------------------------------------------------------
  def update_all_loop_anim
    @loop_animation.keys.each {|type| update_loop_anim(type) }
  end
  #--------------------------------------------------------------------------
  # * New method: update_loop_anim
  #--------------------------------------------------------------------------
  def update_loop_anim(type)
    animation = @loop_animation[type]
    animation.duration -= 1
    update_animation_origin(animation)
    if animation.duration > 0
      update_loop_frames(animation)
    elsif animation.duration <= 0 && animation.loop > 0
      animation.loop -= 1
      animation.duration = animation.frame_max * animation.rate + 1
    elsif @loop_list.empty?
      end_all_loop_anim
    else
      create_loop_anim(type)
      animation          = @loop_animation[type]
      animation.duration = animation.frame_max * animation.rate
      update_loop_frames(animation)
    end
  end
  #--------------------------------------------------------------------------
  # * New method: update_loop_frames
  #--------------------------------------------------------------------------
  def update_loop_frames(animation)
    frame = (animation.duration + animation.rate - 1) / animation.rate
    index = animation.frame_max - frame
    animation_set_sprites(animation, animation.frames[index])
    @ani_duplicated = animation.duplicated
    @ani_rate       = animation.rate
    if animation.duration % animation.rate == 1
      @@loop_ani_checker.delete(animation.data)
      animation.timings.each do |timing|
        animation_process_timing(timing) if timing.frame == index
      end
    end
  end
  #--------------------------------------------------------------------------
  # * New method: dispose_removed_loop_anim
  #--------------------------------------------------------------------------  
  def dispose_removed_loop_anim
    @loop_animation.keys.each do |type|
      id = @loop_animation[type].id
      if @loop_list[type] && !@loop_list[type].include?(id)
        @loop_list[type].delete(id)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * New method: end_all_loop_anim
  #--------------------------------------------------------------------------
  def end_all_loop_anim
    @loop_animation.keys.each {|type| dispose_loop_anim(type) }
    @loop_list = {}
  end
  #--------------------------------------------------------------------------
  # * New method: end_all_loop_anim
  #--------------------------------------------------------------------------
  def end_loop_anim(type)
    return unless @loop_animation.keys.include?(type)
    dispose_loop_anim(type)
    @loop_list.delete(type)
  end
  #--------------------------------------------------------------------------
  # * New method: loop_anim_set_sprites
  #--------------------------------------------------------------------------
  def loop_anim_set_sprites(animation, frame)
    cell_data = frame.cell_data
    animation.sprites.each_with_index do |sprite, i|
      next unless sprite
      pattern = cell_data[i, 0]
      if !pattern || pattern < 0
        sprite.visible = false
        next
      end
      if animation.duration % animation.rate == 0
        setup_loop_pattern(animation, pattern, sprite)
      end
      setup_loop_position(animation, cell_data, sprite, i)
    end
  end
  #--------------------------------------------------------------------------
  # * New method: setup_loop_pattern
  #--------------------------------------------------------------------------
  def setup_loop_pattern(animation, pattern, sprite)
    sprite.bitmap  = pattern < 100 ? animation.bitmap1 : animation.bitmap2
    sprite.visible = true
    sprite.src_rect.set(pattern % 5 * 192, pattern % 100 / 5 * 192, 192, 192)
  end
  #--------------------------------------------------------------------------
  # * New method: setup_loop_position
  #--------------------------------------------------------------------------
  def setup_loop_position(animation, cell_data, sprite, i)
    if $imported[:ve_animation_setting]
      setup_sprite_position(animation, cell_data, sprite, i)
    else
      if animation.mirror
        sprite.x = animation.ox - cell_data[i, 1] * animation.zoom
        sprite.y = animation.oy + cell_data[i, 2] * animation.zoom
        sprite.angle  = 360 - cell_data[i, 4]
        sprite.mirror = cell_data[i, 5] == 0
      else
        sprite.x = animation.ox + cell_data[i, 1] * animation.zoom
        sprite.y = animation.oy + cell_data[i, 2] * animation.zoom
        sprite.angle  = cell_data[i, 4]
        sprite.mirror = cell_data[i, 5] == 1
      end
      sprite.z  = self.z + 300 + i
      sprite.ox = 96
      sprite.oy = 96
      sprite.zoom_x     = cell_data[i, 3] / 100.0
      sprite.zoom_y     = cell_data[i, 3] / 100.0
      sprite.opacity    = cell_data[i, 6] * self.opacity / 255.0
      sprite.blend_type = cell_data[i, 7]
    end
  end
  #--------------------------------------------------------------------------
  # * New method: add_loop_animation
  #--------------------------------------------------------------------------
  def add_loop_animation(animation)
    if animation
      type = animation[:type]
      anim = animation[:anim]
      loop = animation[:loop]
      @loop_list[type] ||= []
      @loop_list[type].push([anim, loop])
      @loop_list[type].uniq!
    end
  end
  #--------------------------------------------------------------------------
  # * New method: remove_loop_animation
  #--------------------------------------------------------------------------
  def remove_loop_animation(animation)
    if animation
      type = animation[:type]
      data = animation[:anim]
      if @loop_list[type]
        @loop_list[type].delete_if {|anim| anim.first == data }
      end
      @loop_list.delete(type) if @loop_list[type] && @loop_list[type].empty?
    end
  end
  #--------------------------------------------------------------------------
  # * New method: remove_state_animations
  #--------------------------------------------------------------------------
  def remove_state_animations(new_states, old_states, map)
    regex = "#{map}\s*LOOP ANIMATION"
    old_states.each do |state|
      next if new_states.include?(state)
      if state.note =~ /<#{regex}: (\d+)>/i
        id   = $1.to_i
        type = state.note =~ /<#{regex} TYPE: #{id},\s*(\d+)>/i ? $1.to_i : ""
        anim = {anim: id, type: eval(":state#{type}")}
        remove_loop_animation(anim)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * New method: add_state_animation
  #--------------------------------------------------------------------------
  def add_state_animation(new_states, old_states, map)
    regex = "#{map}\s*LOOP ANIMATION"
    new_states.each do |state|
      next if old_states.include?(state)
      if state.note =~ /<#{regex}: (\d+)>/i
        id   = $1.to_i
        type = state.note =~ /<#{regex} TYPE: #{id},\s*(\d+)>/i ? $1.to_i : ""
        loop = state.note =~ /<#{regex} LOOP: #{id},\s*(\d+)>/i ? $1.to_i : 1
        anim = {anim: id, type: eval(":state#{type}"), loop: loop}
        add_loop_animation(anim)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * New method: sprite_visible
  #--------------------------------------------------------------------------
  def sprite_visible
    self.visible && self.opacity > 0
  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
  #--------------------------------------------------------------------------
  # * Alias method: initialize
  #--------------------------------------------------------------------------
  alias :initialize_sc_ve_loop_animation :initialize
  def initialize(viewport, character = nil)
    @actor_states = []
    initialize_sc_ve_loop_animation(viewport, character)
  end
  #--------------------------------------------------------------------------
  # * Alias method: setup_new_effect
  #--------------------------------------------------------------------------
  alias :setup_new_effect_ve_loop_animation :setup_new_effect
  def setup_new_effect
    setup_new_effect_ve_loop_animation
    setup_new_loop_animation
    setup_remove_loop_animation
    setup_states_loop_animation
  end
  #--------------------------------------------------------------------------
  # * New method: setup_new_loop_animation
  #--------------------------------------------------------------------------
  def setup_new_loop_animation
    add_loop_animation(@character.add_animation)
    @character.clear_add_loop_animation
  end
  #--------------------------------------------------------------------------
  # * New method: setup_remove_loop_animation
  #--------------------------------------------------------------------------
  def setup_remove_loop_animation
    remove_loop_animation(@character.remove_animation)
    @character.clear_remove_loop_animation
  end
  #--------------------------------------------------------------------------
  # * New method: setup_states_loop_animation
  #--------------------------------------------------------------------------
  def setup_states_loop_animation
    return unless actor
    if @actor_states != actor.states
      remove_state_animations(actor.states, @actor_states, "MAP")
      add_state_animation(actor.states, @actor_states, "MAP")
      @actor_states = actor.states.dup
    end
  end
  #--------------------------------------------------------------------------
  # * New method: sprite_visible
  #--------------------------------------------------------------------------
  def sprite_visible
    self.visible && (self.opacity > 0 || @effect_type == :blink)
  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
  #--------------------------------------------------------------------------
  # * Alias method: initialize
  #--------------------------------------------------------------------------
  alias :initialize_sb_ve_loop_animation  :initialize
  def initialize(viewport, battler = nil)
    @battler_states = []
    initialize_sb_ve_loop_animation(viewport, battler)
  end
  #--------------------------------------------------------------------------
  # * Alias method: setup_new_effect
  #--------------------------------------------------------------------------
  alias :setup_new_effect_ve_loop_animation :setup_new_effect
  def setup_new_effect
    setup_new_effect_ve_loop_animation
    setup_new_loop_animation
    setup_remove_loop_animation
    setup_states_loop_animation
  end
  #--------------------------------------------------------------------------
  # * New method: setup_new_loop_animation
  #--------------------------------------------------------------------------
  def setup_new_loop_animation
    add_loop_animation(@battler.add_animation)
    @battler.clear_add_loop_animation
  end
  #--------------------------------------------------------------------------
  # * New method: setup_remove_loop_animation
  #--------------------------------------------------------------------------
  def setup_remove_loop_animation
    remove_loop_animation(@battler.remove_animation)
    @battler.clear_remove_loop_animation
  end
  #--------------------------------------------------------------------------
  # * New method: setup_states_loop_animation
  #--------------------------------------------------------------------------
  def setup_states_loop_animation
    if @battler_states != @battler.states
      remove_state_animations(@battler.states, @battler_states, "")
      add_state_animation(@battler.states, @battler_states, "")
      @battler_states = @battler.states.dup
    end
  end
  #--------------------------------------------------------------------------
  # * New method: sprite_visible
  #--------------------------------------------------------------------------
  def sprite_visible
    @battler_visible && (self.opacity > 0 || @effect_type == :blink)
  end
end

hfz521999

{:2_284:}虽然不懂脚本，但是还是顶一下~~真心心目你们这些会脚本的大神~~~{:2_249:}