Код:
#==============================================================================
# ** Victor Engine - Basic Module
#------------------------------------------------------------------------------
# Author : Victor Sant
#
# Version History:
# v 1.00 - 2011.12.19 > First relase
# v 1.01 - 2011.12.21 > Added Event Troop notes
# v 1.02 - 2011.12.22 > Added character frames value
# v 1.03 - 2011.12.30 > Added Actor and Enemy notes
# v 1.04 - 2012.01.01 > Added party average level and map actors
# v 1.05 - 2012.01.04 > Compatibility with Characters Scripts
# v 1.06 - 2012.01.07 > Compatibility with Fog and Light Effect
# > Added new Sprite Character functions
# v 1.07 - 2012.01.11 > Compatibility with Control Text and Codes
# v 1.08 - 2012.01.13 > Compatibility with Trait Control
# v 1.09 - 2012.01.15 > Fixed the Regular Expressions problem with "" and “”
# v 1.10 - 2012.01.18 > Compatibility with Automatic Battlers
# v 1.11 - 2012.01.26 > Compatibility with Followers Options
# Compatibility with Animated Battle beta
# v 1.12 - 2012.02.08 > Compatibility with Animated Battle
# v 1.13 - 2012.02.18 > Fix for non RTP dependant encrypted projects
# v 1.14 - 2012.03.11 > Better version handling and required messages
# v 1.15 - 2012.03.11 > Added level variable for enemies (to avoid crashes)
# v 1.16 - 2012.03.21 > Compatibility with Follower Control
# v 1.17 - 2012.03.22 > Compatibility with Follower Control new method
# v 1.18 - 2012.03.22 > Added Battler Types tag support
# v 1.19 - 2012.05.20 > Compatibility with Map Turn Battle
# v 1.20 - 2012.05.21 > Fix for older RMVXa versions
# v 1.21 - 2012.05.29 > Compatibility with Pixel Movement
# v 1.22 - 2012.07.02 > Compatibility with Terrain States
# v 1.23 - 2012.07.03 > Fix for Pixel Movement
# v 1.24 - 2012.07.17 > Compatibility with Critical Hit Effects
# v 1.25 - 2012.07.24 > Compatibility with Moving Plaforms
# v 1.26 - 2012.07.30 > Compatibility with Automatic Battlers
# v 1.27 - 2012.08.01 > Compatibility with Custom Slip Effect
# v 1.28 - 2012.08.03 > Compatibility with Custom Slip Effect v 1.01
#------------------------------------------------------------------------------
# This is the basic script for the system from Victory Engine and is
# required to use the scripts from the engine. This script offer some new
# functions to be used within many scripts of the engine.
#------------------------------------------------------------------------------
# Compatibility
# Required for the Victor Engine
#
# * Overwrite methods
# class << Cache
# def self.character(filename)
#
# class Sprite_Character < Sprite_Base
# def set_character_bitmap
#
# * Alias methods
# class Game_Interpreter
# def command_108
#
# class Window_Base < Window
# def convert_escape_characters(text)
#
#------------------------------------------------------------------------------
# Instructions:
# To instal the script, open you script editor and paste this script on
# a new section bellow the Materials section.
#
#------------------------------------------------------------------------------
# New functions
#
# * Random number between two vales
# rand_between(min, max)
# min : min value
# max : max value
# Can be called from any class, this method return an random value between
# two specific numbers
#
# * Random array value
# <Array>.random
# <Array>.random!
# Returns a random object from the array, the method .random! is destructive,
# removing the value returned from the array.
#
# * Sum of the numeric values of a array
# <Array>.sum
# Returns the sum of all numeric values
#
# * Average of all numeric values from the array
# <Array>.average(float = false)
# float : float flag
# Returns the average of all numeric values, if floa is true, the value
# returned is a float, otherwise it's a integer.
#
# * Note for events
# <Event>.note
# By default, events doesn't have note boxes. This command allows to use
# comments as note boxes, following the same format as the ones on the
# database. Returns all comments on the active page of the event.
#
# * Comment calls
# <Event>.comment_call
# Another function for comment boxes, by default, they have absolutely no
# effect in game when called. But this method allows to make the comment
# box to behave like an script call, but with the versatility of the
# note boxes. Remember that the commands will only take effect if there
# is scripts to respond to the comment code.
#
#==============================================================================
#==============================================================================
# ** Victor Engine
#------------------------------------------------------------------------------
# Setting module for the Victor Engine
#==============================================================================
module Victor_Engine
#--------------------------------------------------------------------------
# * New method: required_script
#--------------------------------------------------------------------------
def self.required_script(name, req, version, type = 0)
if type != :bellow && (!$imported[req] || $imported[req] < version)
msg = "The script '%s' requires the script\n"
case type
when :above
msg += "'%s' v%s or higher above it to work properly\n"
else
msg += "'%s' v%s or higher to work properly\n"
end
msg += "Go to http://victorscripts.wordpress.com/ to download this script."
self.exit_message(msg, name, req, version)
elsif type == :bellow && $imported[req]
msg = "The script '%s' requires the script\n"
msg += "'%s' to be put bellow it\n"
msg += "move the scripts to the proper position"
self.exit_message(msg, name, req, version)
end
end
#--------------------------------------------------------------------------
# * New method: exit_message
#--------------------------------------------------------------------------
def self.exit_message(message, name, req, version)
name = self.script_name(name)
req = self.script_name(req)
msgbox(sprintf(message, name, req, version))
exit
end
#--------------------------------------------------------------------------
# * New method: script_name
#--------------------------------------------------------------------------
def self.script_name(name, ext = "VE")
name = name.to_s.gsub("_", " ").upcase.split
name.collect! {|char| char == ext ? "#{char} -" : char.capitalize }
name.join(" ")
end
end
$imported ||= {}
$imported[:ve_basic_module] = 1.28
#==============================================================================
# ** Object
#------------------------------------------------------------------------------
# This class is the superclass of all other classes.
#==============================================================================
class Object
#--------------------------------------------------------------------------
# * Include setting module
#--------------------------------------------------------------------------
include Victor_Engine
#-------------------------------------------------------------------------
# * New method: rand_between
#-------------------------------------------------------------------------
def rand_between(min, max)
min + rand(max - min + 1)
end
#--------------------------------------------------------------------------
# * New method: numeric?
#--------------------------------------------------------------------------
def numeric?
return false
end
#--------------------------------------------------------------------------
# * New method: string?
#--------------------------------------------------------------------------
def string?
return false
end
#--------------------------------------------------------------------------
# * New method: array?
#--------------------------------------------------------------------------
def array?
return false
end
#--------------------------------------------------------------------------
# * New method: float?
#--------------------------------------------------------------------------
def float?
return false
end
#--------------------------------------------------------------------------
# * New method: item?
#--------------------------------------------------------------------------
def item?
return false
end
#--------------------------------------------------------------------------
# * New method: skill?
#--------------------------------------------------------------------------
def skill?
return false
end
#--------------------------------------------------------------------------
# * New method: file_exist?
#--------------------------------------------------------------------------
def file_exist?(path, filename)
$file_list ||= {}
$file_list[path + filename] ||= file_test(path, filename)
$file_list[path + filename]
end
#--------------------------------------------------------------------------
# * New method: get_file_list
#--------------------------------------------------------------------------
def file_test(path, filename)
bitmap = Cache.load_bitmap(path, filename) rescue nil
bitmap ? true : false
end
#--------------------------------------------------------------------------
# * New method: character_exist?
#--------------------------------------------------------------------------
def character_exist?(filename)
file_exist?("Graphics/Characters/", filename)
end
#--------------------------------------------------------------------------
# * New method: battler_exist?
#--------------------------------------------------------------------------
def battler_exist?(filename)
file_exist?("Graphics/Battlers/", filename)
end
#--------------------------------------------------------------------------
# * New method: get_filename
#--------------------------------------------------------------------------
def get_filename
"[\"'“‘]([^\"'”‘”’]+)[\"'”’]"
end
#--------------------------------------------------------------------------
# * New method: get_all_values
#--------------------------------------------------------------------------
def get_all_values(value1, value2 = nil)
value2 = value1 unless value2
/<#{value1}>((?:[^<]|<[^\/])*)<\/#{value2}>/im
end
#--------------------------------------------------------------------------
# * New method: make_symbol
#--------------------------------------------------------------------------
def make_symbol(string)
string.downcase.gsub(" ", "_").to_sym
end
#--------------------------------------------------------------------------
# * New method: make_string
#--------------------------------------------------------------------------
def make_string(symbol)
symbol.to_s.gsub("_", " ").upcase
end
#--------------------------------------------------------------------------
# * New method: returing_value
#--------------------------------------------------------------------------
def returing_value(i, x)
i % (x * 2) >= x ? (x * 2) - i % (x * 2) : i % (x * 2)
end
#--------------------------------------------------------------------------
# New method: in_rect?
#--------------------------------------------------------------------------
def in_rect?(w, h, x1, y1, x2, y2, fx = 0)
aw, ah, ax, ay, bx, by = setup_area(w, h, x1, y1, x2, y2, fx)
bx > ax - aw && bx < ax + aw && by > ay - ah && by < ay + ah
end
#--------------------------------------------------------------------------
# New method: in_radius?
#--------------------------------------------------------------------------
def in_radius?(w, h, x1, y1, x2, y2, fx = 0)
aw, ah, ax, ay, bx, by = setup_area(w, h, x1, y1, x2, y2, fx)
((bx - ax) ** 2 / aw ** 2) + ((by - ay) ** 2 / ah ** 2) <= 1
end
#--------------------------------------------------------------------------
# New method: setup_area
#--------------------------------------------------------------------------
def setup_area(w, h, x1, y1, x2, y2, fx)
aw = w
ah = h * aw
ax = x1
ay = y1
bx = x2
by = y2
bx += fx / 4 if ax > bx
bx -= fx / 4 if ax < bx
[aw, ah, ax, ay, bx, by]
end
end
#==============================================================================
# ** String
#------------------------------------------------------------------------------
# The string class. Can handle character sequences of arbitrary lengths.
#==============================================================================
class String
#--------------------------------------------------------------------------
# * New method: string?
#--------------------------------------------------------------------------
def string?
return true
end
end
#==============================================================================
# ** Numeric
#------------------------------------------------------------------------------
# This is the abstract class for numbers.
#==============================================================================
class Numeric
#--------------------------------------------------------------------------
# * New method: numeric?
#--------------------------------------------------------------------------
def numeric?
return true
end
#--------------------------------------------------------------------------
# * New method: ceil?
#--------------------------------------------------------------------------
def ceil?
return false
end
end
#==============================================================================
# ** Float
#------------------------------------------------------------------------------
# This is the abstract class for the floating point values.
#==============================================================================
class Float
#--------------------------------------------------------------------------
# * New method: float?
#--------------------------------------------------------------------------
def float?
return true
end
#--------------------------------------------------------------------------
# * New method: ceil?
#--------------------------------------------------------------------------
def ceil?
self != self.ceil
end
end
#==============================================================================
# ** Array
#------------------------------------------------------------------------------
# This class store arbitrary Ruby objects.
#==============================================================================
class Array
#--------------------------------------------------------------------------
# * New method: array?
#--------------------------------------------------------------------------
def array?
return true
end
#-------------------------------------------------------------------------
# * New method: random
#-------------------------------------------------------------------------
def random
self[rand(size)]
end
#-------------------------------------------------------------------------
# * New method: random!
#-------------------------------------------------------------------------
def random!
self.delete_at(rand(size))
end
#---------------------------------------------------------------------------
# * New method: sum
#---------------------------------------------------------------------------
def sum
self.inject(0) {|r, n| r += (n.numeric? ? n : 0)}
end
#---------------------------------------------------------------------------
# * New method: average
#---------------------------------------------------------------------------
def average(float = false)
self.sum / [(float ? size.to_f : size.to_i), 1].max
end
#---------------------------------------------------------------------------
# * New method: next_item
#---------------------------------------------------------------------------
def next_item
item = self.shift
self.push(item)
item
end
#---------------------------------------------------------------------------
# * New method: previous_item
#---------------------------------------------------------------------------
def previous_item
item = self.pop
self.unshift(item)
item
end
end
#==============================================================================
# ** RPG::Troop::Page
#------------------------------------------------------------------------------
# This is the data class for battle events (pages).
#==============================================================================
class RPG::Troop::Page
#--------------------------------------------------------------------------
# * New method: note
#--------------------------------------------------------------------------
def note
return "" if !@list || @list.size <= 0
comment_list = []
@list.each do |item|
next unless item && (item.code == 108 || item.code == 408)
comment_list.push(item.parameters[0])
end
comment_list.join("\r\n")
end
end
#==============================================================================
# ** RPG::UsableItem
#------------------------------------------------------------------------------
# This is the superclass for skills and items.
#==============================================================================
class RPG::UsableItem < RPG::BaseItem
#--------------------------------------------------------------------------
# * New method: for_all_targets?
#--------------------------------------------------------------------------
def for_all_targets?
return false
end
end
#==============================================================================
# ** RPG::Skill
#------------------------------------------------------------------------------
# This is the data class for skills.
#==============================================================================
class RPG::Skill < RPG::UsableItem
#--------------------------------------------------------------------------
# * New method: item?
#--------------------------------------------------------------------------
def item?
return false
end
#--------------------------------------------------------------------------
# * New method: skill?
#--------------------------------------------------------------------------
def skill?
return true
end
#--------------------------------------------------------------------------
# * New method: type_set
#--------------------------------------------------------------------------
def type_set
[stype_id]
end
end
#==============================================================================
# ** RPG::Item
#------------------------------------------------------------------------------
# This is the data class for items.
#==============================================================================
class RPG::Item < RPG::UsableItem
#--------------------------------------------------------------------------
# * New method: item?
#--------------------------------------------------------------------------
def item?
return true
end
#--------------------------------------------------------------------------
# * New method: skill?
#--------------------------------------------------------------------------
def skill?
return false
end
#--------------------------------------------------------------------------
# * New method: type_set
#--------------------------------------------------------------------------
def type_set
[itype_id]
end
end
#==============================================================================
# ** Cache
#------------------------------------------------------------------------------
# This module loads each of graphics, creates a Bitmap object, and retains it.
# To speed up load times and conserve memory, this module holds the created
# Bitmap object in the internal hash, allowing the program to return
# preexisting objects when the same bitmap is requested again.
#==============================================================================
class << Cache
#--------------------------------------------------------------------------
# * Overwrite method: character
#--------------------------------------------------------------------------
def character(filename, hue = 0)
load_bitmap("Graphics/Characters/", filename, hue)
end
#--------------------------------------------------------------------------
# * New method: cache
#--------------------------------------------------------------------------
def cache
@cache
end
end
#==============================================================================
# ** Game_BattlerBase
#------------------------------------------------------------------------------
# This class handles battlers. It's used as a superclass of the Game_Battler
# classes.
#==============================================================================
class Game_BattlerBase
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :buffs
#--------------------------------------------------------------------------
# * New method: get_cond
#--------------------------------------------------------------------------
def get_cond(text)
case text.upcase
when "HIGHER" then ">"
when "LOWER" then "<"
when "EQUAL" then "=="
when "DIFFERENT" then "!="
else "!="
end
end
#--------------------------------------------------------------------------
# * New method: get_param
#--------------------------------------------------------------------------
def get_param(text)
case text.upcase
when "MAXHP" then self.mhp
when "MAXMP" then self.mmp
when "MAXTP" then self.max_tp
else eval("self.#{text.downcase}")
end
end
#--------------------------------------------------------------------------
# * New method: get_param_id
#--------------------------------------------------------------------------
def get_param_id(text)
case text.upcase
when "MAXHP", "HP" then 0
when "MAXMP", "MP" then 1
when "ATK" then 2
when "DEF" then 3
when "MAT" then 4
when "MDF" then 5
when "AGI" then 6
when "LUK" then 7
end
end
#--------------------------------------------------------------------------
# * New method: type
#--------------------------------------------------------------------------
def type
list = []
get_all_notes.scan(/<BATTLER TYPE: ((?:\w+ *,? *)+)>/i) do
$1.scan(/(\d+)/i) { list.push(make_symbol($1)) }
end
list.uniq
end
#--------------------------------------------------------------------------
# * New method: danger?
#--------------------------------------------------------------------------
def danger?
hp < mhp * 25 / 100
end
#--------------------------------------------------------------------------
# * New method: sprite
#--------------------------------------------------------------------------
def sprite
valid = SceneManager.scene_is?(Scene_Battle) && SceneManager.scene.spriteset
valid ? SceneManager.scene.spriteset.sprite(self) : nil
end
#--------------------------------------------------------------------------
# * New method:
#--------------------------------------------------------------------------
def element_set(item)
element_set = [item.damage.element_id]
element_set += atk_elements if item.damage.element_id < 0
element_set.compact
end
#--------------------------------------------------------------------------
# * New method: add_state_normal
#--------------------------------------------------------------------------
def add_state_normal(state_id, rate = 1, user = self)
chance = rate
chance *= state_rate(state_id)
chance *= luk_effect_rate(user)
add_state(state_id) if rand < state_rate(state_id)
end
#--------------------------------------------------------------------------
# * New method: damaged?
#--------------------------------------------------------------------------
def damaged?
@result.hp_damage != 0 || @result.mp_damage != 0 || @result.tp_damage != 0
end
#--------------------------------------------------------------------------
# * New method: mtp
#--------------------------------------------------------------------------
def mtp
return 100
end
end
#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
# This class deals with battlers. It's used as a superclass of the Game_Actor
# and Game_Enemy classes.
#==============================================================================
class Game_Battler < Game_BattlerBase
#--------------------------------------------------------------------------
# * New method: cri_rate
#--------------------------------------------------------------------------
def cri_rate(user, item)
user.cri
end
#--------------------------------------------------------------------------
# * New method: cri_eva
#--------------------------------------------------------------------------
def cri_eva(user, item)
cev
end
#--------------------------------------------------------------------------
# * New method: setup_critical
#--------------------------------------------------------------------------
def setup_critical(user, item)
cri_rate(user, item) * (1 - cri_eva(user, item))
end
end
#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
# This class handles enemy characters. It's used within the Game_Troop class
# ($game_troop).
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# * New method: note
#--------------------------------------------------------------------------
def note
enemy ? enemy.note : ""
end
#--------------------------------------------------------------------------
# * New method: get_all_notes
#--------------------------------------------------------------------------
def get_all_notes(*args)
notes = ""
notes += note if !args.include?(:self)
states.compact.each {|state| notes += state.note } if !args.include?(:state)
notes
end
#--------------------------------------------------------------------------
# * New method: get_all_objects
#--------------------------------------------------------------------------
def get_all_objects(*args)
result = []
result += [self] if !args.include?(:self)
result += states.compact if !args.include?(:state)
result
end
#--------------------------------------------------------------------------
# * New method: level
#--------------------------------------------------------------------------
def level
return 1
end
#--------------------------------------------------------------------------
# * New method: skill_learn?
#--------------------------------------------------------------------------
def skill_learn?(skill)
skill.skill? && skills.include?(skill)
end
#--------------------------------------------------------------------------
# * New method: skills
#--------------------------------------------------------------------------
def skills
enemy.actions.collect {|action| $data_skills[action.skill_id] }
end
end
#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
# This class handles actors. It's used within the Game_Actors class
# ($game_actors) and referenced by the Game_Party class ($game_party).
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# * New method: note
#--------------------------------------------------------------------------
def note
actor ? actor.note : ""
end
#--------------------------------------------------------------------------
# * New method: hue
#--------------------------------------------------------------------------
def hue
@hue ? @hue : 0
end
#--------------------------------------------------------------------------
# * New method: get_all_notes
#--------------------------------------------------------------------------
def get_all_notes(*args)
notes = ""
notes += note if !args.include?(:self)
notes += self.class.note if !args.include?(:class)
equips.compact.each {|equip| notes += equip.note } if !args.include?(:equip)
states.compact.each {|state| notes += state.note } if !args.include?(:state)
notes
end
#--------------------------------------------------------------------------
# * New method: get_all_objects
#--------------------------------------------------------------------------
def get_all_objects(*args)
result = []
result += [self] if !args.include?(:self)
result += [self.class] if !args.include?(:self)
result += equips.compact if !args.include?(:equip)
result += states.compact if !args.include?(:state)
result
end
#--------------------------------------------------------------------------
# * New method: in_active_party?
#--------------------------------------------------------------------------
def in_active_party?
$game_party.battle_members.include?(self)
end
#--------------------------------------------------------------------------
# * New method: in_reserve_party?
#--------------------------------------------------------------------------
def in_reserve_party?
$game_party.reserve_members.include?(self)
end
#--------------------------------------------------------------------------
# * New method: in_party?
#--------------------------------------------------------------------------
def in_party?
$game_party.all_members.include?(self)
end
#--------------------------------------------------------------------------
# * New method: map_animation
#--------------------------------------------------------------------------
def map_animation(id)
$game_map.actors.each do |member|
member.animation_id = id if member.actor == self
end
end
#--------------------------------------------------------------------------
# * New method: on_damage_floor
#--------------------------------------------------------------------------
def on_damage_floor?
$game_player.on_damage_floor?
end
end
#==============================================================================
# ** Game_Unit
#------------------------------------------------------------------------------
# This class handles units. It's used as a superclass of the Game_Party and
# Game_Troop classes.
#==============================================================================
class Game_Unit
#--------------------------------------------------------------------------
# * New method: refresh
#--------------------------------------------------------------------------
def refresh
members.each {|member| member.refresh }
end
end
#==============================================================================
# ** Game_Party
#------------------------------------------------------------------------------
# This class handles the party. It includes information on amount of gold
# and items. The instance of this class is referenced by $game_party.
#==============================================================================
class Game_Party < Game_Unit
#--------------------------------------------------------------------------
# * New method: average_level
#--------------------------------------------------------------------------
def average_level
battle_members.collect {|actor| actor.level }.average
end
#--------------------------------------------------------------------------
# * New method: reserve_members
#--------------------------------------------------------------------------
def reserve_members
all_members - battle_members
end
end
#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
# This class handles maps. It includes scrolling and passage determination
# functions. The instance of this class is referenced by $game_map.
#==============================================================================
class Game_Map
#--------------------------------------------------------------------------
# * New method: event_list
#--------------------------------------------------------------------------
def event_list
events.values
end
#--------------------------------------------------------------------------
# * New method: note
#--------------------------------------------------------------------------
def note
@map ? @map.note : ""
end
#--------------------------------------------------------------------------
# * New method: vehicles
#--------------------------------------------------------------------------
def vehicles
@vehicles
end
#--------------------------------------------------------------------------
# * New method: map_events
#--------------------------------------------------------------------------
def map_events
@map.events
end
#--------------------------------------------------------------------------
# * New method: actors
#--------------------------------------------------------------------------
def actors
[$game_player] + $game_player.followers.visible_followers
end
end
#==============================================================================
# ** Game_CharacterBase
#------------------------------------------------------------------------------
# This class deals with characters. Common to all characters, stores basic
# data, such as coordinates and graphics. It's used as a superclass of the
# Game_Character class.
#==============================================================================
class Game_CharacterBase
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :move_speed
attr_accessor :move_frequency
#--------------------------------------------------------------------------
# * New method: player?
#--------------------------------------------------------------------------
def player?
return false
end
#--------------------------------------------------------------------------
# * New method: event?
#--------------------------------------------------------------------------
def event?
return false
end
#--------------------------------------------------------------------------
# * New method: follower?
#--------------------------------------------------------------------------
def follower?
return false
end
#--------------------------------------------------------------------------
# * New method: vehicle?
#--------------------------------------------------------------------------
def vehicle?
return false
end
#--------------------------------------------------------------------------
# * New method: frames
#--------------------------------------------------------------------------
def frames
return 3
end
#--------------------------------------------------------------------------
# * New method: hue
#--------------------------------------------------------------------------
def hue
@hue ? @hue : 0
end
end
#==============================================================================
# ** Game_Character
#------------------------------------------------------------------------------
# This class deals with characters. It's used as a superclass of the
# Game_Player and Game_Event classes.
#==============================================================================
class Game_Character < Game_CharacterBase
#--------------------------------------------------------------------------
# * New method: move_toward_position
#--------------------------------------------------------------------------
def move_toward_position(x, y)
sx = distance_x_from(x)
sy = distance_y_from(y)
if sx.abs > sy.abs
move_straight(sx > 0 ? 4 : 6)
move_straight(sy > 0 ? 8 : 2) if !@move_succeed && sy != 0
elsif sy != 0
move_straight(sy > 0 ? 8 : 2)
move_straight(sx > 0 ? 4 : 6) if !@move_succeed && sx != 0
end
end
#--------------------------------------------------------------------------
# * New method: move_toward_position
#--------------------------------------------------------------------------
def turn_toward_position(x, y)
sx = distance_x_from(x)
sy = distance_y_from(y)
if sx.abs > sy.abs
set_direction(sx > 0 ? 4 : 6)
elsif sy != 0
set_direction(sy > 0 ? 8 : 2)
end
end
end
#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
# This class handles the player.
# The instance of this class is referenced by $game_map.
#==============================================================================
class Game_Player < Game_Character
#--------------------------------------------------------------------------
# * New method: player?
#--------------------------------------------------------------------------
def player?
return true
end
#--------------------------------------------------------------------------
# * New method: perform_transfer
#--------------------------------------------------------------------------
def new_map_id
@new_map_id
end
#--------------------------------------------------------------------------
# * New method: hue
#--------------------------------------------------------------------------
def hue
actor ? actor.hue : 0
end
end
#==============================================================================
# ** Game_Follower
#------------------------------------------------------------------------------
# This class handles the followers. Followers are the actors of the party
# that follows the leader in a line. It's used within the Game_Followers class.
#==============================================================================
class Game_Follower < Game_Character
#--------------------------------------------------------------------------
# * New method: follower?
#--------------------------------------------------------------------------
def follower?
return true
end
#--------------------------------------------------------------------------
# * New method: index
#--------------------------------------------------------------------------
def index
@member_index
end
#--------------------------------------------------------------------------
# * New method: gathering?
#--------------------------------------------------------------------------
def gathering?
$game_player.followers.gathering? && !gather?
end
end
#==============================================================================
# ** Game_Followers
#------------------------------------------------------------------------------
# This class handles the followers. It's a wrapper for the built-in class
# "Array." It's used within the Game_Player class.
#==============================================================================
class Game_Followers
#--------------------------------------------------------------------------
# * New method: get_actor
#--------------------------------------------------------------------------
def get_actor(id)
list = [$game_player] + visible_followers
list.select {|follower| follower.actor && follower.actor.id == id }.first
end
#--------------------------------------------------------------------------
# * Method fix: visble_folloers
#--------------------------------------------------------------------------
unless method_defined?(:visible_followers)
def visible_followers; visible_folloers; end
end
end
#==============================================================================
# ** Game_Vehicle
#------------------------------------------------------------------------------
# This class handles vehicles. It's used within the Game_Map class. If there
# are no vehicles on the current map, the coordinates is set to (-1,-1).
#==============================================================================
class Game_Vehicle < Game_Character
#--------------------------------------------------------------------------
# * New method: vehicle?
#--------------------------------------------------------------------------
def vehicle?
return true
end
#--------------------------------------------------------------------------
# * New method: map_id
#--------------------------------------------------------------------------
def map_id
@map_id
end
#--------------------------------------------------------------------------
# * New method: type
#--------------------------------------------------------------------------
def type
@type
end
#--------------------------------------------------------------------------
# * New method: aerial?
#--------------------------------------------------------------------------
def aerial?
type == :airship
end
#--------------------------------------------------------------------------
# * New method: above?
#--------------------------------------------------------------------------
def above?
aerial?
end
end
#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
# This class deals with events. It handles functions including event page
# switching via condition determinants, and running parallel process events.
# It's used within the Game_Map class.
#==============================================================================
class Game_Event < Game_Character
#--------------------------------------------------------------------------
# * New method: name
#--------------------------------------------------------------------------
def name
@event.name
end
#--------------------------------------------------------------------------
# * New method: event?
#--------------------------------------------------------------------------
def event?
return true
end
#--------------------------------------------------------------------------
# * New method: erased?
#--------------------------------------------------------------------------
def erased?
@erased
end
#--------------------------------------------------------------------------
# * New method: note
#--------------------------------------------------------------------------
def note
return "" if !@page || !@page.list || @page.list.size <= 0
return @notes if @notes && @page.list == @note_page
@note_page = @page.list.dup
comment_list = []
@page.list.each do |item|
next unless item && (item.code == 108 || item.code == 408)
comment_list.push(item.parameters[0])
end
@notes = comment_list.join("\r\n")
@notes
end
end
#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
# An interpreter for executing event commands. This class is used within the
# Game_Map, Game_Troop, and Game_Event classes.
#==============================================================================
class Game_Interpreter
#--------------------------------------------------------------------------
# * Alias method: command_108
#--------------------------------------------------------------------------
alias :command_108_ve_basic_module :command_108
def command_108
command_108_ve_basic_module
comment_call
end
#--------------------------------------------------------------------------
# * New method: comment_call
#--------------------------------------------------------------------------
def comment_call
end
#--------------------------------------------------------------------------
# * New method: note
#--------------------------------------------------------------------------
def note
@comments ? @comments.join("\r\n") : ""
end
end
#==============================================================================
# ** Sprite_Character
#------------------------------------------------------------------------------
# This sprite is used to display characters. It observes a instance of the
# Game_Character class and automatically changes sprite conditions.
#==============================================================================
class Sprite_Character < Sprite_Base
#--------------------------------------------------------------------------
# * Overwrite method: set_character_bitmap
#--------------------------------------------------------------------------
def set_character_bitmap
update_character_info
set_bitmap
set_bitmap_position
end
#--------------------------------------------------------------------------
# * New method: center_y
#--------------------------------------------------------------------------
def actor?
@character.is_a?(Game_Player) || @character.is_a?(Game_Follower)
end
#--------------------------------------------------------------------------
# * New method: center_y
#--------------------------------------------------------------------------
def actor
actor? ? @character.actor : nil
end
#--------------------------------------------------------------------------
# * New method: update_character_info
#--------------------------------------------------------------------------
def update_character_info
end
#--------------------------------------------------------------------------
# * New method: hue
#--------------------------------------------------------------------------
def hue
@character.hue
end
#--------------------------------------------------------------------------
# * New method: set_bitmap
#--------------------------------------------------------------------------
def set_bitmap
self.bitmap = Cache.character(set_bitmap_name, hue)
end
#--------------------------------------------------------------------------
# * New method: set_bitmap_name
#--------------------------------------------------------------------------
def set_bitmap_name
@character_name
end
#--------------------------------------------------------------------------
# * New method: set_bitmap_position
#--------------------------------------------------------------------------
def set_bitmap_position
sign = get_sign
if sign && sign.include?('$')
@cw = bitmap.width / @character.frames
@ch = bitmap.height / 4
else
@cw = bitmap.width / (@character.frames * 4)
@ch = bitmap.height / 8
end
self.ox = @cw / 2
self.oy = @ch
end
#--------------------------------------------------------------------------
# * New method: get_sign
#--------------------------------------------------------------------------
def get_sign
@character_name[/^[\!\$]./]
end
end
#==============================================================================
# ** Sprite_Battler
#------------------------------------------------------------------------------
# This sprite is used to display battlers. It observes a instance of the
# Game_Battler class and automatically changes sprite conditions.
#==============================================================================
class Sprite_Battler < Sprite_Base
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :dmg_mirror
#--------------------------------------------------------------------------
# * New method: center_x
#--------------------------------------------------------------------------
def center_x
self.ox
end
#--------------------------------------------------------------------------
# * New method: center_y
#--------------------------------------------------------------------------
def center_y
self.oy / 2
end
end
#==============================================================================
# ** Spriteset_Battle
#------------------------------------------------------------------------------
# This class brings together battle screen sprites. It's used within the
# Scene_Battle class.
#==============================================================================
class Spriteset_Battle
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :viewport1
#--------------------------------------------------------------------------
# * New method: sprite
#--------------------------------------------------------------------------
def sprite(subject)
battler_sprites.compact.select {|sprite| sprite.battler == subject }.first
end
end
#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
# This is a superclass of all windows in the game.
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# * Alias method: convert_escape_characters
#--------------------------------------------------------------------------
alias :convert_escape_ve_basic_module :convert_escape_characters
def convert_escape_characters(text)
result = text.to_s.clone
result = text_replace(result)
result = convert_escape_ve_basic_module(text)
result
end
#--------------------------------------------------------------------------
# * New method: text_replace
#--------------------------------------------------------------------------
def text_replace(result)
result.gsub!(/\r/) { "" }
result.gsub!(/\\/) { "\e" }
result
end
end
#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#==============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :subject
attr_reader :spriteset
end
#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
# This class performs map screen processing.
#==============================================================================
class Scene_Map < Scene_Base
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :spriteset
end
скрипт
Код:
#================================================= =============================
# ** Victor Engine - Map Turn Battle
#------------------------------------------------------------------------------
# Author : Victor Sant
#
# Version History:
# v 1.00 - 2012.07.20 > First relase
# v 1.01 - 2012.07.21 > Compatibility with Fog and Overlay and Light Effects
# > Fixed Map Pictures not showing during battle
# v 1.02 - 2012.05.29 > Compatibility with Pixel Movement
# v 1.03 - 2012.07.24 > Compatibility with Basic Module 1.25
# v 1.04 - 2012.08.02 > Compatibility with Basic Module 1.27
# v 1.05 - 2012.08.03 > Compatibility with Anti Lag
#------------------------------------------------------------------------------
# This script is an add-on for the 'Victor Engine - Animated Battle', it
# allows to make battles to occur the current map, instead of using a
# transition to another scene, like int the game Chrono Trigger. It doesn't
# make any change on the turn mechanic of the battle and anything else.
#------------------------------------------------------------------------------
# Compatibility
# Requires the script 'Victor Engine - Basic Module' v 1.27 or higher
# Requires the script 'Victor Engine - Animated Battle' v 1.05 or higher
# Requires the script 'Victor Engine - Actors Battlers' v 1.06 or higher
# If used with 'Victor Engine - Light Effects' place this bellow it.
# If used with 'Victor Engine - Pixel Movement' place this bellow it.
#
# * Alias methods
# class << BattleManager
# def process_escape_pose
# def battle_end(result)
#
# class Game_Party < Game_Unit
# def initialize
#
# class Game_Player < Game_Character
# def update_scroll(last_real_x, last_real_y)
# def add_move_update(dir)
#
# class Game_Follower < Game_Character
# def initialize(member_index, preceding_character)
# def chase_preceding_character
# def add_move_update(dir)
#
# class Scene_Map < Scene_Base
# def pre_battle_scene
# def perform_battle_transition
# def perform_transition
#
# class Scene_Battle < Scene_Base
# def create_spriteset
# def perform_transition
# def pre_terminate
#
# class Game_Interpreter
# def comment_call
#
#
# class Game_Follower < Game_Character
#
#------------------------------------------------------------------------------
# Instructions:
# To instal the script, open you script editor and paste this script on
# a new section bellow the Materials section. This script must also
# be bellow the script 'Victor Engine - Basic' and the script
#
#------------------------------------------------------------------------------
# Comment calls note tags:
# Tags to be used in events comment box, works like a script call.
#
# <call map battle>
# start: [x, y]; end: [x, y]; escape: [x, y]; defeat: [x, y];
# actors: [x, y], [x, y], [x, y];
# enemies: [event, enemy, switch], [event, enemy];
# can escape; can lose; skip return;
# </call map battle>
# This call is used to call battles on maps, using the normal event battle
# call will end on a normal battle with transition.
# start: [x, y];
# position of the screen at the battle start
# end: [x, y];
# position of the party at battle end, in case of victory
# escape: [x, y];
# position of the party at battle end, in case of escape
# defeat: [x, y];
# position of the party at battle end, in case of defeat (only if the
# battle is set up to continue after defeat)
# actors: [x, y], [x, y], [x, y];
# position of each actor during the battle, you must add a value [x, y]
# for every actor in the party, so always add an ammount equal the
# max number of party members to avoid errors.
# enemies: [event, enemy, switch], [event, enemy];
# enemies info
# event is the Event ID of the event that represents the enemye
# enemy is the Enemy ID on the database.
# switch is an opitional value that represents the switch that will
# be turned on when the enemy dies, it can be a numeric value, or the
# the letters A, B, C or D. If numeric, it turn on a switch, if it's a
# letter, it turn on the switch local with that letter. If omited
# it don't turn on any switch using an erase event instead.
# can escape;
# optional value that must be added to allow escaping from battles
# can lose;
# optional value that must be added to avoid game over after a defeat
# skip return;
# optional value that makes the actors not return to their positions
# after the battle end, can be used for after battle cutscenes, remember
# that you must make a call manually to gather the party before allowing
# the player to control them.
#
#------------------------------------------------------------------------------
# Additional instructions:
# All the positions are *MAP COORDINATES*, so to know the positions just
# check the tile position on the editor.
#
# If using sprites, you need to have 5 different graphics for them:
# The default and one for each direction.
# You must add an extra sufix on them for each direction they're facing:
# [up] [left] [right] [down]
#
# So if you have a battler named "Actor" and use VE_SPRITE_SUFIX = "[anim]"
# you will need the files to be named like this:
# Actor[anim][up]
# Actor[anim][left]
# Actor[anim][right]
# Actor[anim][down]
#
# Charsets battlers don't need any extra setup.
#
# When using the script 'Victor Engine - Animated Battle' the lights do NOT
# follow the actors and enemies during battles, even if there was a light on
# the event/actor on the map.
#
#------------------------------------------------------------------------------
# Example call:
#
# <call map battle>
# start: [12, 15]; end: [12, 15]; escape: [12, 21];
# actors: [7, 14], [14, 17], [17, 14], [10, 17];
# enemies: [1, 1, A], [2, 1, A], [3, 1, A];
# can escape;
# </call map battle>
#
# This call will make the screen center at the coodinate x:12 y:15 of the
# map, the battle end position will be the same, for escape the position
# is the coordinate x:12, y:21
#
# The actor will be placed on the following positions: first actor on
# x:7, y:14; second actor on x:14, y:17, third actor on x:17, y:14;
# and the last actor on x:10, y:17
#
# The events ID 1, 2 and 3 will become enemies. They will become the enemy
# ID 1, and will turn on the switch local A for each event.
#
# The battle can be escaped.
#
#================================================= =============================
#================================================= =============================
# ** Victor Engine
#------------------------------------------------------------------------------
# Setting module for the Victor Engine
#================================================= =============================
module Victor_Engine
#--------------------------------------------------------------------------
# * Change the behavior of default template to work with 4 directions
# sprites
#--------------------------------------------------------------------------
VE_DEFAULT_ACTION = "
# Pose displayed when idle
<action: idle, loop>
pose: self, row idle, all frames, wait 8, sufix [direction];
wait: 32;
</action>
# Pose displayed when incapacited
<action: dead, loop>
pose: self, row dead, all frames, wait 8, sufix [direction];
wait: 32;
</action>
# Pose displayed when hp is low
<action: danger, loop>
pose: self, row danger, all frames, wait 8, sufix [direction];
wait: 32;
</action>
# Pose displayed when guarding
<action: guard, loop>
pose: self, row guard, all frames, wait 12, sufix [direction];
wait: 48;
</action>
# Pose displayed during the battle start
<action: intro, reset>
pose: self, row intro, all frames, wait 16, sufix [direction];
wait: 64;
</action>
# Pose displayed during battle victory
<action: victory>
pose: self, row intro, all frames, wait 16, sufix [direction], revert;
wait: 64;
pose: self, row victory, all frames, wait 16, sufix [direction];
wait: 64;
</action>
# Pose displayed while waiting to perfom actions
<action: ready, loop>
pose: self, row ready, frame 1, sufix [direction];
wait: 32;
</action>
# Pose displayed while waiting to perfom item actions
<action: item cast, loop>
pose: self, row itemcast, frame 1, sufix [direction];
wait: 32;
</action>
# Pose displayed while waiting to perfom skill actions
<action: skill cast, loop>
pose: self, row skillcast, frame 1, sufix [direction];
wait: 32;
</action>
# Pose displayed while waiting to perfom magic actions
<action: magic cast, loop>
pose: self, row magiccast, frame 1, sufix [direction];
wait: 32;
</action>
# Pose displayed before inputing commands
<action: command, reset>
</action>
# Pose displayed after inputing commands
<action: input, reset>
</action>
# Pose displayed when cancel inputing commands
<action: cancel, reset>
</action>
# Pose displayed when recive damage
<action: hurt, reset>
pose: self, row hurt, all frames, wait 4, sufix [direction];
wait: 16
</action>
# Pose displayed when evading attacks
<action: evade, reset>
pose: self, row evade, all frames, wait 4, sufix [direction];
wait: 16;
</action>
# Pose displayed when a attack miss
<action: miss, reset>
</action>
# Pose displayed when reviving
<action: revive, reset>
</action>
# Pose displayed when dying
<action: die, reset>
</action>
# Make the target inactive (important, avoid change)
<action: inactive>
inactive;
</action>
# Set action advance
<action: advance, reset>
action: self, move to target;
wait: action;
</action>
# Movement to target
<action: move to target, reset>
wait: animation;
move: self, move to;
direction: targets;
jump: self, move, height 7;
pose: self, row advance, all frames, wait 4, sufix [direction];
wait: movement;
</action>
# Step foward movement
<action: step foward, reset>
wait: animation;
move: self, step foward, speed 6;
pose: self, row advance, all frames, wait 4, sufix [direction];
wait: movement;
</action>
# Step backward movement
<action: step backward, reset>
wait: animation;
move: self, step backward, speed 6;
pose: self, row retreat, all frames, wait 4, invert, sufix [direction];
wait: movement;
</action>
# Return to original spot
<action: retreat, reset>
move: self, retreat;
pose: self, row retreat, all frames, wait 4, invert, sufix [direction];
jump: self, move, height 7;
wait: movement;
direction: default;
</action>
# Move outside of the screen
<action: escape, reset>
move: self, escape;
pose: self, row retreat, all frames, wait 4, invert, sufix [direction];
wait: movement;
</action>
# Pose used for Defend command
<action: defend, reset>
pose: self, row guard, all frames, wait 8, sufix [direction];
wait: 4;
anim: targets, effect;
wait: 4;
effect: 100%;
wait: 20;
</action>
# Pose for physical attacks
<action: attack, reset>
pose: self, row attack, all frames, wait 4, sufix [direction];
wait: 4;
anim: targets, effect;
wait: 8;
effect: 100%;
wait: 20;
</action>
# Pose for physical attack with two weapons
<action: dual attack, reset>
pose: self, row attack, all frames, wait 4, sufix [direction];
wait: 4;
anim: targets, weapon 1;
wait: 8;
effect: 75%, weapon 1;
wait: 4;
wait: animation;
pose: self, row skill, all frames, wait 4, sufix [direction];
wait: 8;
anim: targets, weapon 2;
wait: 4;
effect: 75%, weapon 2;
wait: 20;
</action>
# Pose for using actions without type
<action: use, reset>
wait: animation;
pose: self, row item, all frames, wait 4, sufix [direction];
wait: 4;
anim: targets, effect;
wait: 4;
effect: 100%;
wait: 20;
</action>
# Pose for item use
<action: item, reset>
wait: animation;
pose: self, row direction, all frames, wait 4, sufix [direction];
wait: 4;
anim: targets, effect;
wait: 4;
effect: 100%;
wait: 20;
</action>
# Pose for magical skill use
<action: magic, reset>
wait: animation;
pose: self, row magic, all frames, wait 4, sufix [direction];
wait: 4;
anim: targets, effect;
wait: 8;
effect: 100%;
wait: 20;
</action>
# Pose for physical skill use
<action: skill, reset>
pose: self, row attack, all frames, wait 4, sufix [direction];
wait: 4;
anim: targets, effect;
wait: 8;
effect: 100%;
wait: 20;
</action>
# Pose for counter attack activation (important, avoid change)
<action: counter on, reset>
counter: self, on;
wait: counter;
</action>
# Pose for counter attack deactivation (important, avoid change)
<action: counter off, reset>
counter: targets, off;
</action>
# Pose for magic reflection
<action: reflection, reset>
wait: animation;
wait: 4;
anim: self, effect;
wait: 8;
effect: 100%;
wait: animation;
</action>
# Pose for substitution activation (important, avoid change)
<action: substitution on, reset>
move: self, substitution, teleport;
wait: movement;
</action>
# Pose for substitution deactivation
<action: substitution off, reset>
move: self, retreat, speed 15;
</action>
# Pose for the skill 'Dual Attack'
<action: double attack, reset>
pose: self, row attack, all frames, wait 4, sufix [direction];
wait: 4;
anim: targets, weapon 1;
wait: 8;
effect: 75%;
wait: 4;
wait: animation;
pose: self, row skill, all frames, wait 4, sufix [direction];
wait: 8;
anim: targets, weapon 1;
wait: 4;
effect: 75%;
wait: 20;
</action>
# Pose for the skills 'Life Drain' and 'Manda Drain'
<action: drain, reset>
wait: animation;
pose: self, row magic, all frames, wait 4, sufix [direction];
wait: 4;
anim: targets, effect;
wait: 8;
effect: 100%;
wait: 20;
action: targets, user drain;
wait: action;
</action>
# Pose for the targets of the skills 'Life Drain' and 'Manda Drain'
<action: user drain, reset>
throw: self, icon 187, return, revert, init y -12, end y -12;
wait: throw;
drain: self;
wait: animation;
</action>
# Pose for the sample skill 'Throw Weapon'
<action: throw weapon, reset>
pose: self, row attack, all frames, wait 4, sufix [direction];
action: targets, target throw;
wait: action;
</action>
# Pose for the targets of the sample skill 'Throw Weapon'
<action: target throw, reset>
throw: self, weapon 1, arc 12, spin +45, init y -12, end y -12;
wait: throw;
throw: self, weapon 1, arc 12, spin +45, return, revert, init y -12, end y -12;
anim: self, weapon 1;
effect: self, 100%;
wait: throw;
wait: animation;
</action>
# Pose for the sample skill 'Lightning Strike'
<action: lightning strike, 5 times>
direction: targets;
pose: self, row attack, frame 1, all frames, wait 2, sufix [direction];
move: self, x -48, speed 50;
anim: targets, effect;
effect: 20%;
</action>
# Pose for the sample skill 'Tempest'
<action: tempest, reset>
wait: animation;
pose: self, row magic, all frames, wait 4, sufix [direction];
wait: 4;
tone: black, high priority, duration 20;
wait: tone;
movie: name 'Tempest', white, high priority;
tone: clear, high priority, duration 20;
wait: 15;
anim: targets, effect;
flash: screen, duration 10;
effect: 100%;
wait: 20;
</action>
# Pose for the sample skill 'Meteor'
<action: meteor, reset>
wait: animation;
pose: self, row magic, all frames, wait 4, sufix [direction];
wait: 4;
tone: black, high priority, duration 20;
wait: tone;
movie: name 'Meteor';
tone: clear, high priority, duration 20;
anim: targets, effect;
wait: 20;
effect: 100%;
wait: 20;
</action>
# Pose for 'Bow' type weapons
<action: bow, reset>
direction: targets;
pose: self, row attack, all frames, wait 4, sufix [direction];
action: targets, arrow;
wait: action;
</action>
# Pose for the targets of 'Bow' attack
<action: arrow, reset>
throw: self, image 'Arrow', arc 10, angle 45, init x -6, init y -12;
wait: throw;
anim: self, weapon 1;
effect: self, 100%;
wait: animation;
</action>
# Pose for the skill 'Aura Blade'
<action: aura blade, reset>
pose: self, row magic, all frames, wait 2, sufix [direction];
anim: id 81;
wait: animation;
pose: self, row advance, all frames, wait 2, sufix [direction];
move: move to;
wait: movement;
jump: height 16;
wait: 12;
pose: self, row attack, frame 1, sufix [direction];
freeze: duration 40;
anim: self, id 66;
wait: self, freeze;
wait: 4;
pose: self, row attack, all frames, wait 2, sufix [direction];
wait: 4;
anim: targets, effect;
flash: screen, duration 8;
wait: 8;
effect: 75%, weapon 1;
flash: screen, duration 8;
wait: 4;
</action>
# Movement to target for the skill 'Aura Blade'
<action: aura blade move to, reset>
pose: self, row magic, all frames, wait 2, sufix [direction];
anim: id 81;
wait: animation;
</action>
"
#--------------------------------------------------------------------------
# * required
# This method checks for the existance of the basic module and other
# VE scripts required for this script to work, don't edit this
#--------------------------------------------------------------------------
def self.required(name, req, version, type = nil)
if !$imported[:ve_basic_module]
msg = "The script '%s' requires the script\n"
msg += "'VE - Basic Module' v%s or higher above it to work properly\n"
msg += "Go to http://victorscripts.wordpress.com/ to download this script."
msgbox(sprintf(msg, self.script_name(name), version))
exit
else
self.required_script(name, req, version, type)
end
end
#--------------------------------------------------------------------------
# * script_name
# Get the script name base on the imported value
#--------------------------------------------------------------------------
def self.script_name(name, ext = "VE")
name = name.to_s.gsub("_", " ").upcase.split
name.collect! {|char| char == ext ? "#{char} -" : char.capitalize }
name.join(" ")
end
end
$imported ||= {}
$imported[:ve_map_battle] = 1.05
Victor_Engine.required(:ve_map_battle, :ve_basic_module, 1.27, :above)
Victor_Engine.required(:ve_map_battle, :ve_animated_battle, 1.05, :above)
Victor_Engine.required(:ve_map_battle, :ve_actor_battlers, 1.06, :above)
#================================================= =============================
# ** BattleManager
#------------------------------------------------------------------------------
# This module handles the battle processing
#================================================= =============================
class << BattleManager
#--------------------------------------------------------------------------
# * Alias method: process_escape_pose
#--------------------------------------------------------------------------
alias :process_escape_pose_ve_map_battle :process_escape_pose
def process_escape_pose
if $game_party.map_battle
SceneManager.scene.wait(5)
SceneManager.scene.close_window
Graphics.freeze
else
process_escape_pose_ve_map_battle
end
end
#--------------------------------------------------------------------------
# * Alias method: battle_end
#--------------------------------------------------------------------------
alias :battle_end_ve_map_battle :battle_end
def battle_end(result)
battle_end_ve_map_battle(result)
map_battle = $game_party.map_battle
if map_battle
$game_system.intro_fade = $game_temp.old_intro_fade
$game_battle_fogs = $game_temp.old_battle_fog
map_battle[:result] = :end if result == 0 && map_battle
map_battle[:result] = :escape if result == 1 && map_battle
map_battle[:result] = :defeat if result == 2 && map_battle
end
end
#--------------------------------------------------------------------------
# * New method: setup_map_battle
#--------------------------------------------------------------------------
def setup_map_battle
init_members
$game_troop.setup_map_battle($game_party.map_battl e)
@can_escape = $game_party.map_battle[:can_run]
@can_lose = $game_party.map_battle[:can_lose]
$game_temp.old_intro_fade = $game_system.intro_fade
$game_temp.old_battle_fog = $game_battle_fogs
$game_battle_fogs = true
$game_system.intro_fade = false
make_escape_ratio
end
end
#================================================= =============================
# ** Game_Temp
#------------------------------------------------------------------------------
# This class handles temporary data that is not included with save data.
# The instance of this class is referenced by $game_temp.
#================================================= =============================
class Game_Temp
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :old_intro_fade
attr_accessor :old_battle_fog
attr_accessor :old_custom_positions
attr_accessor :old_custom_formation
attr_accessor :old_position_adjust
end
#================================================= =============================
# ** Game_Map
#------------------------------------------------------------------------------
# This class handles maps. It includes scrolling and passage determination
# functions. The instance of this class is referenced by $game_map.
#================================================= =============================
class Game_Map
#--------------------------------------------------------------------------
# * New method: finished_movement?
#--------------------------------------------------------------------------
def finished_movement?
actors.all? {|actor| actor.finished_movement? }
end
end
#================================================= =============================
# ** Game_Party
#------------------------------------------------------------------------------
# This class handles the party. It includes information on amount of gold
# and items. The instance of this class is referenced by $game_party.
#================================================= =============================
class Game_Party < Game_Unit
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :map_battle
#--------------------------------------------------------------------------
# * Alias method: initialize
#--------------------------------------------------------------------------
alias :initialize_ve_map_battle :initialize
def initialize
initialize_ve_map_battle
@map_battle = nil
end
end
#================================================= =============================
# ** Game_Troop
#------------------------------------------------------------------------------
# This class handles enemy groups and battle-related data. Also performs
# battle events. The instance of this class is referenced by $game_troop.
#================================================= =============================
class Game_Troop < Game_Unit
#--------------------------------------------------------------------------
# * New method: setup_map_battle
#--------------------------------------------------------------------------
def setup_map_battle(value)
clear
@troop_id = value[:troop_id]
@enemies = []
value[:enemies].each do |info|
next if !$data_enemies[info[:id]] || erased_event(info)
enemy = Game_Enemy.new(@enemies.size, info[:id])
event = $game_map.events[info[:event]]
enemy.screen_x = event.screen_x
enemy.screen_y = event.screen_y
enemy.switch = info[:switch]
enemy.event_id = info[:event]
@enemies.push(enemy)
end
init_screen_tone
make_unique_names
end
#--------------------------------------------------------------------------
# * New method: erased_event
#--------------------------------------------------------------------------
def erased_event(info)
if info[:switch].string?
$game_self_switches[[$game_map.map_id, info[:event], info[:switch]]]
elsif info[:switch].numeric?
$game_switches[info[:switch]]
else
$game_map.events[info[:event]].erased?
end
end
end
#================================================= =============================
# ** Game_Enemy
#------------------------------------------------------------------------------
# This class handles enemy characters. It's used within the Game_Troop class
# ($game_troop).
#================================================= =============================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :switch
attr_accessor :event_id
#--------------------------------------------------------------------------
# * New method: setup_dead_event
#--------------------------------------------------------------------------
def setup_dead_event
return if !dead?
if switch.string?
$game_self_switches[[$game_map.map_id, event_id, switch]] = true
elsif switch.numeric?
$game_switches[switch] = true
else
$game_map.events[event_id].erase
end
end
end
#================================================= =============================
# ** Game_CharacterBase
#------------------------------------------------------------------------------
# This class deals with characters. Common to all characters, stores basic
# data, such as coordinates and graphics. It's used as a superclass of the
# Game_Character class.
#================================================= =============================
class Game_CharacterBase
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :battle_positions
#--------------------------------------------------------------------------
# * New method: finished_movement?
#--------------------------------------------------------------------------
def finished_movement?
@battle_positions[:x].ceil == @x.ceil &&
@battle_positions[:y].ceil == @y.ceil && !moving?
end
#--------------------------------------------------------------------------
# * New method: move_to_position
#--------------------------------------------------------------------------
def move_to_position
return if moving? || finished_movement?
position = @battle_positions
move_toward_position(position[:x], position[:y])
end
#--------------------------------------------------------------------------
# * New method: turn_to_position
#--------------------------------------------------------------------------
def turn_to_position
return if moving? || !finished_movement?
position = $game_party.map_battle[:start]
turn_toward_position(position[:x], position[:y])
end
end
#================================================= =============================
# ** Game_Player
#------------------------------------------------------------------------------
# This class handles the player.
# The instance of this class is referenced by $game_map.
#================================================= =============================
class Game_Player < Game_Character
#--------------------------------------------------------------------------
# * Alias method: update_scroll
#--------------------------------------------------------------------------
alias :update_scroll_ve_map_battle :update_scroll
def update_scroll(last_real_x, last_real_y)
return if @battle_positions
update_scroll_ve_map_battle(last_real_x, last_real_y)
end
#--------------------------------------------------------------------------
# * Alias method: add_move_update
#--------------------------------------------------------------------------
alias :add_move_update_ve_map_battle :add_move_update if $imported[:ve_followers_options]
def add_move_update(dir)
return if @battle_positions
add_move_update_ve_map_battle(dir)
end
#--------------------------------------------------------------------------
# *
#--------------------------------------------------------------------------
alias :step_times_ve_map_battle :step_times if $imported[:ve_pixel_movement]
def step_times
$game_party.map_battle ? super : step_times_ve_map_battle
end
#--------------------------------------------------------------------------
# * New method: update_battle_scroll
#--------------------------------------------------------------------------
def update_battle_scroll(type)
position = get_screen_postion($game_party.map_battle[type])
ax1 = $game_map.display_x
ay1 = $game_map.display_y
ax2 = $game_map.round_x(position[:x])
ay2 = $game_map.round_y(position[:y])
$game_map.scroll_down (1.0 / 16) if ay2 > ay1
$game_map.scroll_left (1.0 / 16) if ax2 < ax1
$game_map.scroll_right(1.0 / 16) if ax2 > ax1
$game_map.scroll_up (1.0 / 16) if ay2 < ay1
end
#--------------------------------------------------------------------------
# * New method: get_screen_postion
#--------------------------------------------------------------------------
def get_screen_postion(position)
max_x = ($game_map.width - $game_map.screen_tile_x)
max_y = ($game_map.height - $game_map.screen_tile_y)
pos_x = [0, [position[:x] - center_x, max_x].min].max
pos_y = [0, [position[:y] - center_y, max_y].min].max
{x: pos_x, y: pos_y}
end
end
#================================================= =============================
# ** Game_Follower
#------------------------------------------------------------------------------
# This class handles the followers. Followers are the actors of the party
# that follows the leader in a line. It's used within the Game_Followers class.
#================================================= =============================
class Game_Follower < Game_Character
#--------------------------------------------------------------------------
# * Alias method: chase_preceding_character
#--------------------------------------------------------------------------
alias :chase_preceding_character_ve_map_battle :chase_preceding_character
def chase_preceding_character
return if @battle_positions
chase_preceding_character_ve_map_battle
end
#--------------------------------------------------------------------------
# * Alias method: add_move_update
#--------------------------------------------------------------------------
alias :add_move_update_ve_map_battle :add_move_update if $imported[:ve_followers_options]
def add_move_update(dir)
return if @battle_positions
add_move_update_ve_map_battle(dir)
end
#--------------------------------------------------------------------------
# * Alias method: step_times
#--------------------------------------------------------------------------
alias :step_times_ve_map_battle :step_times if $imported[:ve_pixel_movement]
def step_times
$game_party.map_battle ? super : step_times_ve_map_battle
end
end
#================================================= =============================
# ** Game_Event
#------------------------------------------------------------------------------
# This class deals with events. It handles functions including event page
# switching via condition determinants, and running parallel process events.
# It's used within the Game_Map class.
#================================================= =============================
class Game_Event < Game_Character
#--------------------------------------------------------------------------
# * New method: is_in_battle?
#--------------------------------------------------------------------------
def is_in_battle?
list = $game_party.map_battle[:enemies].collect {|event| event[:event] }
list.include?(@id)
end
end
#================================================= =============================
# ** Game_Interpreter
#------------------------------------------------------------------------------
# An interpreter for executing event commands. This class is used within the
# Game_Map, Game_Troop, and Game_Event classes.
#================================================= =============================
class Game_Interpreter
#--------------------------------------------------------------------------
# * Alias method: comment_call
#--------------------------------------------------------------------------
alias :comment_call_ve_map_battle :comment_call
def comment_call
call_map_battle_comments
comment_call_ve_map_battle
end
#--------------------------------------------------------------------------
# * New method: call_map_battle_comments
#--------------------------------------------------------------------------
def call_map_battle_comments
regexp = get_all_values("CALL MAP BATTLE")
if note =~ regexp
info = $1.dup
value = {}
value[:can_run] = info =~ /CAN ESCAPE/i ? true : false
value[:can_lose] = info =~ /CAN LOSE/i ? true : false
value[:skip] = info =~ /SKIP RETURN/i ? true : false
value[:troop_id] = info =~ /TROOP: (\d+)/i ? $1.to_i : 1
value[:start] = get_position('START' , info)
value[:end] = get_position('END' , info)
value[:escape] = get_position('ESCAPE', info)
value[:defeat] = get_position('DEFEAT', info)
value[:enemies] = setup_enemies(info)
return if no_available_enemies(value)
setup_actors(info)
$game_party.map_battle = value
SceneManager.call(Scene_Battle)
end
end
#--------------------------------------------------------------------------
# * New method: get_position
#--------------------------------------------------------------------------
def get_position(value, info)
regexp = /#{value}: *\[(\d+), *(\d+)\]/i
info =~ regexp ? {x: $1.to_i, y: $2.to_i} : {x: 0, y: 0}
end
#--------------------------------------------------------------------------
# * New method: setup_actors
#--------------------------------------------------------------------------
def setup_actors(info)
list = get_actor_info(info)
$game_map.actors.each_with_index do |actor, index|
actor.battle_positions = {x: list[index][:x], y: list[index][:y]}
actor.clear_move if actor.follower? && $imported[:ve_followers_options]
end
end
#--------------------------------------------------------------------------
# * New method: get_actor_info
#--------------------------------------------------------------------------
def get_actor_info(info)
value = info =~ /ACTORS: ((?: *\[\d+, *\d+\],?)*)/i ? $1 : ""
value.scan(/\[(\d+) *, *(\d+)\]/i).collect {|x, y| {x: x.to_i, y: y.to_i} }
end
#--------------------------------------------------------------------------
# * New method: setup_enemies
#--------------------------------------------------------------------------
def setup_enemies(info)
regexp = /ENEMIES: ((?: *\[\d+ *, *\d+(?: *, *\w+)?\],*)*)/i
value = info =~ regexp ? $1 : ""
value.scan(/\[(\d+) *, *(\d+)(?: *, *(\w+))?\]/i).collect do |x, y, z|
result = ["A","B","C","D"].include?(z.upcase) ? z.upcase : z.to_i
{event: x.to_i, id: y.to_i, switch: result}
end
end
#--------------------------------------------------------------------------
# * New method: no_available_enemies
#--------------------------------------------------------------------------
def no_available_enemies(info)
info[:enemies].all? {|enemy| erased_event(enemy) }
end
#--------------------------------------------------------------------------
# * New method: erased_event
#--------------------------------------------------------------------------
def erased_event(info)
if info[:switch].string?
$game_self_switches[[$game_map.map_id, info[:event], info[:switch]]]
elsif info[:switch].numeric?
$game_switches[info[:switch]]
else
$game_map.events[info[:event]].erased?
end
end
end
#================================================= =============================
# ** Scene_Map
#------------------------------------------------------------------------------
# This class performs the map screen processing.
#================================================= =============================
class Scene_Map < Scene_Base
#--------------------------------------------------------------------------
# * Alias method: pre_battle_scene
#--------------------------------------------------------------------------
alias :pre_battle_scene_ve_map_battle :pre_battle_scene
def pre_battle_scene
if $game_party.map_battle
prepare_map_battle
Graphics.freeze
@spriteset.dispose_characters
BattleManager.save_bgm_and_bgs
BattleManager.play_battle_bgm
else
pre_battle_scene_ve_map_battle
end
end
#--------------------------------------------------------------------------
# * Alias method: perform_battle_transition
#--------------------------------------------------------------------------
alias :perform_battle_transition_ve_map_battle :perform_battle_transition
def perform_battle_transition
perform_battle_transition_ve_map_battle if !$game_party.map_battle
end
#--------------------------------------------------------------------------
# * Alias method: perform_transition
#--------------------------------------------------------------------------
alias :perform_transition_ve_map_battle :perform_transition
def perform_transition
if $game_party.map_battle
Graphics.transition(0)
end_map_battle
else
perform_transition_ve_map_battle
end
end
#--------------------------------------------------------------------------
# * New method: prepare_map_battle
#--------------------------------------------------------------------------
def prepare_map_battle
setup_battle_position
Graphics.update
end
#--------------------------------------------------------------------------
# * New method: setup_battle_position
#--------------------------------------------------------------------------
def setup_battle_position
update_screen_position(:start)
upate_battle_position
setup_actors_position
BattleManager.setup_map_battle
end
#--------------------------------------------------------------------------
# * New method: update_screen_position
#--------------------------------------------------------------------------
def update_screen_position(type)
while !$game_map.finished_movement? ||
display_position != start_position(type)
upate_battle_position
update_actor_position
$game_player.update_battle_scroll(type)
end
$game_map.actors.each {|actor| actor.straighten }
$game_map.actors.each {|actor| actor.turn_to_position }
end
#--------------------------------------------------------------------------
# * New method: display_position
#--------------------------------------------------------------------------
def display_position
{x: $game_map.display_x, y: $game_map.display_y}
end
#--------------------------------------------------------------------------
# * New method: start_position
#--------------------------------------------------------------------------
def start_position(type)
position = $game_player.get_screen_postion($game_party.map_ba ttle[type])
{x: position[:x], y: position[:y]}
end
#--------------------------------------------------------------------------
# * New method: update_actor_position
#--------------------------------------------------------------------------
def update_actor_position
$game_map.actors.each {|actor| actor.move_to_position }
$game_map.actors.each {|actor| actor.turn_to_position }
end
#--------------------------------------------------------------------------
# * New method: upate_battle_position
#--------------------------------------------------------------------------
def upate_battle_position
update_basic
$game_map.update(false)
$game_player.update
$game_timer.update
@spriteset.update
end
#--------------------------------------------------------------------------
# * New method: setup_actors_position
#--------------------------------------------------------------------------
def setup_actors_position
$game_temp.old_custom_positions = $game_custom_positions.dup
$game_temp.old_custom_formation = $game_custom_formation
$game_custom_formation = :custom
$game_map.actors.each do |character|
index = character.actor.index + 1
$game_custom_positions[index][:x] = character.screen_x
$game_custom_positions[index][:y] = character.screen_y
end
end
#--------------------------------------------------------------------------
# * New method: end_map_battle
#--------------------------------------------------------------------------
def end_map_battle
unless $game_party.map_battle[:skip]
setup_return_position($game_party.map_battle[:result])
update_screen_position($game_party.map_battle[:result])
upate_battle_position
end
clear_battle_valies
end
#--------------------------------------------------------------------------
# * New method: setup_return_position
#--------------------------------------------------------------------------
def setup_return_position(result)
position = $game_party.map_battle[result]
$game_map.actors.each do |actor|
actor.battle_positions = {x: position[:x], y: position[:y]}
end
end
#--------------------------------------------------------------------------
# * New method: clear_battle_valies
#--------------------------------------------------------------------------
def clear_battle_valies
$game_party.map_battle = nil
$game_map.actors.each {|actor| actor.battle_positions = nil }
end
end
#================================================= =============================
# ** Scene_Battle
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#================================================= =============================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# * Alias method: create_spriteset
#--------------------------------------------------------------------------
alias :create_spriteset_ve_map_battle :create_spriteset
def create_spriteset
if $game_party.map_battle
@spriteset = Spriteset_MapBattle.new
setup_spriteset
else
create_spriteset_ve_map_battle
end
end
#--------------------------------------------------------------------------
# * Alias method: perform_transition
#--------------------------------------------------------------------------
alias :perform_transition_ve_map_battle :perform_transition
def perform_transition
if $game_party.map_battle
Graphics.transition(0)
else
perform_transition_ve_map_battle
end
end
#--------------------------------------------------------------------------
# * Alias method: pre_terminate
#--------------------------------------------------------------------------
alias :pre_terminate_ve_map_battle :pre_terminate
def pre_terminate
if $game_party.map_battle && SceneManager.scene_is?(Scene_Map)
clear_enemies
super
else
pre_terminate_ve_map_battle
end
end
#--------------------------------------------------------------------------
# * New method: clear_enemies
#--------------------------------------------------------------------------
def clear_enemies
$game_troop.members.each {|enemy| enemy.setup_dead_event }
end
end
#================================================= =============================
# ** Spriteset_MapBattle
#------------------------------------------------------------------------------
# This class brings together battle screen sprites and Map sprites.
# It's used within the Scene_Battle class.
#================================================= =============================
class Spriteset_MapBattle < Spriteset_Battle
#--------------------------------------------------------------------------
# * initialize
#--------------------------------------------------------------------------
def initialize
super
create_characters
create_tilemap
create_parallax
create_characters
create_shadow
create_weather
update
end
#--------------------------------------------------------------------------
# * dispose
#--------------------------------------------------------------------------
def dispose
super
dispose_tilemap
dispose_parallax
dispose_characters
dispose_shadow
dispose_weather
end
#--------------------------------------------------------------------------
# * update
#--------------------------------------------------------------------------
def update
super
update_tileset if @tileset
update_tilemap if @tilemap
update_parallax if @parallax
update_characters if @character_sprites
update_shadow if @shadow_sprite
update_weather if @weather
end
#--------------------------------------------------------------------------
# * create_battleback1
#--------------------------------------------------------------------------
def create_battleback1
end
#--------------------------------------------------------------------------
# * create_battleback2
#--------------------------------------------------------------------------
def create_battleback2
end
#--------------------------------------------------------------------------
# * dispose_battleback1
#--------------------------------------------------------------------------
def dispose_battleback1
end
#--------------------------------------------------------------------------
# * dispose_battleback2
#--------------------------------------------------------------------------
def dispose_battleback2
end
#--------------------------------------------------------------------------
# * update_battleback1
#--------------------------------------------------------------------------
def update_battleback1
end
#--------------------------------------------------------------------------
# * update_battleback2
#--------------------------------------------------------------------------
def update_battleback2
end
#--------------------------------------------------------------------------
# * create_tilemap
#--------------------------------------------------------------------------
def create_tilemap
@tilemap = Tilemap.new(@viewport1)
@tilemap.map_data = $game_map.data
load_tileset
end
#--------------------------------------------------------------------------
# * load_tileset
#--------------------------------------------------------------------------
def load_tileset
@tileset = $game_map.tileset
@tileset.tileset_names.each_with_index do |name, i|
@tilemap.bitmaps[i] = Cache.tileset(name)
end
@tilemap.flags = @tileset.flags
end
#--------------------------------------------------------------------------
# * create_parallax
#--------------------------------------------------------------------------
def create_parallax
@parallax = Plane.new(@viewport1)
@parallax.z = -100
end
#--------------------------------------------------------------------------
# * create_characters
#--------------------------------------------------------------------------
def create_characters
@character_sprites = []
$game_map.events.values.each do |event|
next if event.is_in_battle?
@character_sprites.push(Sprite_Character.new(@view port1, event))
end
$game_map.vehicles.each do |vehicle|
@character_sprites.push(Sprite_Character.new(@view port1, vehicle))
end
@map_id = $game_map.map_id
refresh_characters_sprites if $imported[:ve_anti_lag]
end
#--------------------------------------------------------------------------
# * create_shadow
#--------------------------------------------------------------------------
def create_shadow
@shadow_sprite = Sprite.new(@viewport1)
@shadow_sprite.bitmap = Cache.system("Shadow")
@shadow_sprite.ox = @shadow_sprite.bitmap.width / 2
@shadow_sprite.oy = @shadow_sprite.bitmap.height
@shadow_sprite.z = 180
end
#--------------------------------------------------------------------------
# * create_weather
#--------------------------------------------------------------------------
def create_weather
@weather = Spriteset_Weather.new(@viewport2)
end
#--------------------------------------------------------------------------
# * dispose_tilemap
#--------------------------------------------------------------------------
def dispose_tilemap
@tilemap.dispose
end
#--------------------------------------------------------------------------
# * dispose_parallax
#--------------------------------------------------------------------------
def dispose_parallax
@parallax.bitmap.dispose if @parallax.bitmap
@parallax.dispose
end
#--------------------------------------------------------------------------
# * dispose_characters
#--------------------------------------------------------------------------
def dispose_characters
@character_sprites.each {|sprite| sprite.dispose }
end
#--------------------------------------------------------------------------
# * dispose_shadow
#--------------------------------------------------------------------------
def dispose_shadow
@shadow_sprite.dispose
end
#--------------------------------------------------------------------------
# * dispose_weather
#--------------------------------------------------------------------------
def dispose_weather
@weather.dispose
end
#--------------------------------------------------------------------------
# * refresh_characters
#--------------------------------------------------------------------------
def refresh_characters
dispose_characters
create_characters
end
#--------------------------------------------------------------------------
# * refresh_characters_sprites
#--------------------------------------------------------------------------
def refresh_characters_sprites
@screen_sprites = []
@character_sprites.each do |sprite|
@screen_sprites.push(sprite) if sprite.character.on_buffer_area?
end
end
#--------------------------------------------------------------------------
# * refresh_sprites
#--------------------------------------------------------------------------
def refresh_sprites
refresh_characters_sprites
$game_map.refresh_event_list
$game_map.refresh_screen_position
end
#--------------------------------------------------------------------------
# * update_tileset
#--------------------------------------------------------------------------
def update_tileset
if @tileset != $game_map.tileset
load_tileset
refresh_characters
end
end
#--------------------------------------------------------------------------
# * update_tilemap
#--------------------------------------------------------------------------
def update_tilemap
@tilemap.map_data = $game_map.data
@tilemap.ox = $game_map.display_x * 32
@tilemap.oy = $game_map.display_y * 32
@tilemap.update
end
#--------------------------------------------------------------------------
# * update_parallax
#--------------------------------------------------------------------------
def update_parallax
if @parallax_name != $game_map.parallax_name
@parallax_name = $game_map.parallax_name
@parallax.bitmap.dispose if @parallax.bitmap
@parallax.bitmap = Cache.parallax(@parallax_name)
Graphics.frame_reset
end
@parallax.ox = $game_map.parallax_ox(@parallax.bitmap)
@parallax.oy = $game_map.parallax_oy(@parallax.bitmap)
end
#--------------------------------------------------------------------------
# * update_characters
#--------------------------------------------------------------------------
def update_characters
refresh_characters if @map_id != $game_map.map_id
refresh_sprites if $imported[:ve_anti_lag] && $game_map.screen_moved?
if $imported[:ve_anti_lag]
@screen_sprites.each {|sprite| sprite.update }
else
@character_sprites.each {|sprite| sprite.update }
end
end
#--------------------------------------------------------------------------
# * update_shadow
#--------------------------------------------------------------------------
def update_shadow
airship = $game_map.airship
@shadow_sprite.x = airship.screen_x
@shadow_sprite.y = airship.screen_y + airship.altitude
@shadow_sprite.opacity = airship.altitude * 8
@shadow_sprite.update
end
#--------------------------------------------------------------------------
# * update_weather
#--------------------------------------------------------------------------
def update_weather
@weather.type = $game_map.screen.weather_type
@weather.power = $game_map.screen.weather_power
@weather.ox = $game_map.display_x * 32
@weather.oy = $game_map.display_y * 32
@weather.update
end
#--------------------------------------------------------------------------
# * update_pictures
#--------------------------------------------------------------------------
def update_pictures
$game_map.screen.pictures.each do |pic|
@picture_sprites[pic.number] ||= Sprite_Picture.new(@viewport2, pic)
@picture_sprites[pic.number].update
end
end
end
#================================================= =============================
# ** VE - Map Battle X VE - Light Effects
#------------------------------------------------------------------------------
# Compatibility Patch for VE - Map Battle and VE - Light Effects
#================================================= =============================
if $imported[:ve_light_effects]
#================================================= =============================
# ** Spriteset_MapBattle
#------------------------------------------------------------------------------
# This class brings together battle screen sprites and Map sprites.
# It's used within the Scene_Battle class.
#================================================= =============================
class Spriteset_MapBattle < Spriteset_Battle
#--------------------------------------------------------------------------
# * Alias method: initialize
#--------------------------------------------------------------------------
alias :initialize_ve_map_battle :initialize
def initialize
initialize_ve_map_battle
2.times { update_light(true) }
end
#--------------------------------------------------------------------------
# * Alias method: update
#--------------------------------------------------------------------------
alias :update_ve_map_battle :update
def update
update_ve_map_battle
update_light
end
#--------------------------------------------------------------------------
# * Alias method: dispose
#--------------------------------------------------------------------------
alias :dispose_ve_map_battle :dispose
def dispose
dispose_ve_map_battle
dispose_light unless SceneManager.scene_is?(Scene_Map)
end
#--------------------------------------------------------------------------
# * New method: update_light
#--------------------------------------------------------------------------
def update_light(forced = false)
return unless Graphics.frame_count % 2 == 0 || forced
update_shade
update_effects
end
#--------------------------------------------------------------------------
# * New method: dispose_light
#--------------------------------------------------------------------------
def dispose_light
if @light_effect
@light_effect.dispose
@light_effect = nil
@screen_shade = nil
end
end
#--------------------------------------------------------------------------
# * New method: update_shade
#--------------------------------------------------------------------------
def update_shade
if !@light_effect && $game_map.screen.shade.visible
refresh_lights
elsif $game_map.screen.shade.visible && @light_effect
@light_effect.update
elsif @light_effect && !$game_map.screen.shade.visible
dispose_light
end
end
#--------------------------------------------------------------------------
# * New method: refresh_lights
#--------------------------------------------------------------------------
def refresh_lights
@light_effect.dispose if @light_effect
@screen_shade = $game_map.screen.shade
@light_effect = Sprite_Light.new(@screen_shade, @viewport2)
$game_map.event_list.each {|ev| ev.refresh_lights }
@light_effect.update
end
#--------------------------------------------------------------------------
# * New method: update_effects
#--------------------------------------------------------------------------
def update_effects
return if !@light_effect || $game_map.screen.lights.empty?
$game_map.screen.lights.keys.each {|key| create_light(key) }
$game_map.screen.remove_light.clear
end
#--------------------------------------------------------------------------
# * New method: create_light
#--------------------------------------------------------------------------
def create_light(key)
effect = @light_effect.lights[key]
return if remove_light(key)
return if effect && effect.light == $game_map.screen.lights[key]
@light_effect.create_light($game_map.screen.lights[key])
end
#--------------------------------------------------------------------------
# * New method: remove_light
#--------------------------------------------------------------------------
def remove_light(key)
return false if !$game_map.screen.remove_light.include?(key)
@light_effect.remove_light(key)
$game_map.screen.lights.delete(key)
return true
end
end
end
Социальные закладки