Victor Engine - Fog and Overlay

8/19/2019 Victor Engine - Fog and Overlay

1/15

#==============================================================================# ** Victor Engine - Fog and Overlay#------------------------------------------------------------------------------# Author : Victor Sant## Version History:# v 1.00 - 2011.12.19 > First release# v 1.01 - 2011.12.30 > Faster Regular Expressions# v 1.02 - 2012.01.02 > Fixed fog dispose when changing maps# v 1.03 - 2012.01.04 > Fixed load fail when fog ON# v 1.04 - 2012.01.10 > Fixed fog movement y bug# v 1.05 - 2012.01.14 > Fixed the positive sign on some Regular Expressions# v 1.06 - 2012.01.15 > Fixed the Regular Expressions problem with "" and # v 1.07 - 2012.01.15 > Fixed fog position in maps with loop# v 1.08 - 2012.05.21 > Compatibility with Map Turn Battle# v 1.09 - 2012.05.24 > Fixed initial fog position# v 1.10 - 2012.07.02 > Fixed initial fog position with Map Turn Battle# v 1.11 - 2012.08.02 > Compatibility with Basic Module 1.27# v 1.12 - 2012.12.13 > Fixed fog movement during battles#------------------------------------------------------------------------------# This script allows to add varied of effects and overlays to the maps.# Differently from pictures the fog follows the map movement instead of the# screen (this behavior can be changed). You can add various fogs and/or# overlays to the map.

#------------------------------------------------------------------------------# Compatibility# Requires the script 'Victor Engine - Basic Module' v 1.27 or higher## * Alias methods# class Game_Screen# def initialize# def clear# def update## class Game_Map# def setup(map_id)# def scroll_down(distance)

# def scroll_left(distance)# def scroll_right(distance)# def scroll_up(distance)## class Spriteset_Map# def initialize# def dispose# def update## class Game_Interpreter# def comment_call##------------------------------------------------------------------------------

# Instructions:# To instal the script, open you script editor and paste this script on# a new section bellow the Materials section. This script must also# be bellow the script 'Victor Engine - Basic'# The images must be placed on the folder "Graphics/Fogs". Create a folder# named "Fogs" on the Graphics folder.##------------------------------------------------------------------------------# Maps and Comment calls note tags:# Tags to be used on the Maps note box in the database or in events


2/15

# comment box, works like a script call## # settings# # Create a fog effect on the map, add the following values to the info# the ID and name must be added, other values are optional.# id: x : fog ID# name: "x" : fog graphic filename ("filename")# opacity: x : fog opacity (0-255)# move: x : fog screen movement (32 = fog follows the map)# zoom: x : fog zoom (100 = default size)# hue: x : fog hue (0-360)# blend: x : fog blend type (0: normal, 1: add, 2: subtract)# depth: x : fog Z axis (300 = default value)## # This tag allows to change the fog opacity gradually# id : fog ID# o : new opacity (0-255)# d : wait until complete change (60 frames = 1 second)## # This tag adds fog continuous movement

# id : fog ID# x : horizontal movement, can be positive or negative# y : vertical movement, can be positive or negative## # This tag allows to change the fog opacity gradually# id : fog ID# r : red tone (0-255, can be negative)# g : green tone (0-255, can be negative)# b : blue tone (0-255, can be negative)# y : gray tone (0-255)# d : wait until complete change (60 frames = 1 second)#

#------------------------------------------------------------------------------# Additional instructions:## Map note tags commands are called right when enters the map, comment calls# are called during the event process.##==============================================================================

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

module Victor_Engine #-------------------------------------------------------------------------- # * Set fogs visibility on battle # When true, fogs are visible on battle #-------------------------------------------------------------------------- VE_BATTLE_FOGS = true #-------------------------------------------------------------------------- # * required # This method checks for the existance of the basic module and other


3/15

# VE scripts required for this script to work, don't edit this #-------------------------------------------------------------------------- def self.required(name, req, version, type = nil) if !$imported[:ve_basic_module] msg = "The script '%s' requires the script\n" msg += "'VE - Basic Module' v%s or higher above it to work properly\n" msg += "Go to http://victorscripts.wordpress.com/ to download this script." msgbox(sprintf(msg, self.script_name(name), version)) exit else self.required_script(name, req, version, type) end end #-------------------------------------------------------------------------- # * script_name # Get the script name base on the imported value, don't edit this #-------------------------------------------------------------------------- def self.script_name(name, ext = "VE") name = name.to_s.gsub("_", " ").upcase.split name.collect! {|char| char == ext ? "#{char} -" : char.capitalize } name.join(" ") endend

$imported ||= {}$imported[:ve_fog_and_overlay] = 1.12Victor_Engine.required(:ve_fog_and_overlay, :ve_basic_module, 1.27, :above)

#==============================================================================# ** 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.#==============================================================================

module Cache #-------------------------------------------------------------------------- # * New method: fogs #-------------------------------------------------------------------------- def self.fogs(filename) self.load_bitmap('Graphics/Fogs/', filename) endend

#==============================================================================# ** DataManager#------------------------------------------------------------------------------

# This module handles the game and database objects used in game.# Almost all global variables are initialized on this module#==============================================================================

class


4/15


5/15

#-------------------------------------------------------------------------- alias :clear_ve_fog_and_overlay :clear def clear clear_ve_fog_and_overlay clear_fogs end #-------------------------------------------------------------------------- # * Alias method: update #-------------------------------------------------------------------------- alias :update_ve_fog_and_overlay :update def update update_ve_fog_and_overlay update_fogs end #-------------------------------------------------------------------------- # * New method: fogs #-------------------------------------------------------------------------- def fogs @fogs ||= Game_Fogs.new end #-------------------------------------------------------------------------- # * New method: clear_fogs #-------------------------------------------------------------------------- def clear_fogs

fogs.each {|fog| fog.erase } end #-------------------------------------------------------------------------- # * New method: update_fogs #-------------------------------------------------------------------------- def update_fogs fogs.each {|fog| fog.update } end #-------------------------------------------------------------------------- # * New method: create_fog #-------------------------------------------------------------------------- def create_fog(*args) fogs[args.first].show(*args)

end #-------------------------------------------------------------------------- # * New method: set_fog_move #-------------------------------------------------------------------------- def set_fog_move(id, sx, sy) fogs[id].start_movement(sx, sy) end #-------------------------------------------------------------------------- # * New method: set_fog_tone #-------------------------------------------------------------------------- def set_fog_tone(id, red, green, blue, gray, duration = 0) tone = Tone.new(red, green, blue, gray) fogs[id].start_tone_change(tone, duration)

end #-------------------------------------------------------------------------- # * New method: set_fog_opacity #-------------------------------------------------------------------------- def set_fog_opacity(id, opacity, duration = 0) fogs[id].start_opacity_change(opacity, duration) endend

#==============================================================================


6/15

# ** 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 #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :fog_x attr_accessor :fog_y #-------------------------------------------------------------------------- # * Alias method: setup #-------------------------------------------------------------------------- alias :setup_ve_fog_and_overlay :setup def setup(map_id) setup_ve_fog_and_overlay(map_id) setup_fogs_effect end #-------------------------------------------------------------------------- # * Alias method: scroll_down #-------------------------------------------------------------------------- alias :scroll_down_ve_fog_and_overlay :scroll_down

def scroll_down(distance) last_y = @display_y scroll_down_ve_fog_and_overlay(distance) @fog_y += loop_vertical? ? distance : @display_y - last_y end #-------------------------------------------------------------------------- # * Alias method: scroll_left #-------------------------------------------------------------------------- alias :scroll_left_ve_fog_and_overlay :scroll_left def scroll_left(distance) last_x = @display_x scroll_left_ve_fog_and_overlay(distance) @fog_x += loop_horizontal? ? -distance : @display_x - last_x

end #-------------------------------------------------------------------------- # * Alias method: scroll_right #-------------------------------------------------------------------------- alias :scroll_right_ve_fog_and_overlay :scroll_right def scroll_right(distance) last_x = @display_x scroll_right_ve_fog_and_overlay(distance) @fog_x += loop_horizontal? ? distance : @display_x - last_x end #-------------------------------------------------------------------------- # * Alias method: scroll_up #--------------------------------------------------------------------------

alias :scroll_up_ve_fog_and_overlay :scroll_up def scroll_up(distance) last_y = @display_y scroll_up_ve_fog_and_overlay(distance) @fog_y += loop_vertical? ? -distance : @display_y - last_y end #-------------------------------------------------------------------------- # * New method: setup_fogs_effect #-------------------------------------------------------------------------- def setup_fogs_effect


7/15

@fog_x = 0 @fog_y = 0 create_fog(note) set_fog_opacity(note) set_fog_move(note) set_fog_tone(note) end #-------------------------------------------------------------------------- # * New method: create_fog #-------------------------------------------------------------------------- def create_fog(note) regexp = get_all_values("FOG EFFECT") note.scan(regexp) { setup_fog($1) } end #-------------------------------------------------------------------------- # * New method: set_fog_opacity #-------------------------------------------------------------------------- def set_fog_opacity(note) regexp = //i note.scan(regexp) do |id, o, d| @screen.set_fog_opacity(id.to_i, o.to_i, d.to_i) end end #--------------------------------------------------------------------------

# * New method: set_fog_move #-------------------------------------------------------------------------- def set_fog_move(note) regexp = //i note.scan(regexp) do |id, sx, sy| @screen.set_fog_move(id.to_i, sx.to_i, sy.to_i) end end #-------------------------------------------------------------------------- # * New method: set_fog_tone #-------------------------------------------------------------------------- def set_fog_tone(note) values = "(\\d+) *, *(\\d+) *, *(\\d+) *, *(\\d+)(?: *, *(\\d+))?"

regexp = //i note.scan(regexp) do |i, r, g, b, a, d| info = [i.to_i, r.to_i, g.to_i, b.to_i, a.to_i, d ? d.to_i : 0] @screen.set_fog_tone(*info) end end #-------------------------------------------------------------------------- # * New method: setup_fog #-------------------------------------------------------------------------- def setup_fog(info) id = info =~ /ID: (\d+)/i ? $1.to_i : 0 name = info =~ /NAME: #{get_filename}/i ? $1.dup : "" op = info =~ /OPACITY: (\d+)/i ? $1.to_i : 192

move = info =~ /MOVE: (\d+)/i ? $1.to_i : 32 zoom = info =~ /ZOOM: (\d+)/i ? $1.to_f : 100.0 hue = info =~ /HUE: (\d+)/i ? $1.to_i : 0 blend = info =~ /BLEND: (\d+)/i ? $1.to_i : 0 depth = info =~ /DEPTH: ([+-]?\d+)/i ? $1.to_i : 300 @screen.create_fog(id, name, op, move, zoom, hue, blend, depth) endend

#==============================================================================


8/15

# ** 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_fog_and_overlay :comment_call def comment_call call_create_fog_effect comment_call_ve_fog_and_overlay end #-------------------------------------------------------------------------- # * New method: call_create_fog_effect #-------------------------------------------------------------------------- def call_create_fog_effect $game_map.create_fog(note) $game_map.set_fog_opacity(note) $game_map.set_fog_move(note) $game_map.set_fog_tone(note) end

end

#==============================================================================# ** Spriteset_Map#------------------------------------------------------------------------------# Esta classe reune os sprites da tela de mapa e tilesets. Esta classe é# usada internamente pela classe Scene_Map.#==============================================================================

class Spriteset_Map #-------------------------------------------------------------------------- # * Alias method: initialize #--------------------------------------------------------------------------

alias :initialize_ve_fog_and_overlay :initialize def initialize create_fogs initialize_ve_fog_and_overlay end #-------------------------------------------------------------------------- # * Alias method: dispose #-------------------------------------------------------------------------- alias :dispose_ve_fog_and_overlay :dispose def dispose dispose_ve_fog_and_overlay dispose_fogs end

#-------------------------------------------------------------------------- # * Alias method: update #-------------------------------------------------------------------------- alias :update_ve_fog_and_overlay :update def update update_ve_fog_and_overlay update_fogs end #-------------------------------------------------------------------------- # * New method: create_fogs


9/15

#-------------------------------------------------------------------------- def create_fogs @fog_sprites = [] end #-------------------------------------------------------------------------- # * New method: dispose_fogs #-------------------------------------------------------------------------- def dispose_fogs if @fog_sprites @fog_sprites.compact.each {|sprite| sprite.dispose } @fog_sprites.clear end end #-------------------------------------------------------------------------- # * New method: update_fogs #-------------------------------------------------------------------------- def update_fogs $game_map.screen.fogs.each do |fog| @fog_sprites[fog.id] ||= Sprite_Fog.new(@viewport1, fog) @fog_sprites[fog.id].update end endend

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

class Spriteset_Battle #-------------------------------------------------------------------------- # * Alias method: initialize #-------------------------------------------------------------------------- alias :initialize_ve_fog_and_overlay :initialize def initialize

create_fogs if $game_battle_fogs initialize_ve_fog_and_overlay end #-------------------------------------------------------------------------- # * Alias method: dispose #-------------------------------------------------------------------------- alias :dispose_ve_fog_and_overlay :dispose def dispose dispose_fogs if $game_battle_fogs dispose_ve_fog_and_overlay end #-------------------------------------------------------------------------- # * Alias method: update

#-------------------------------------------------------------------------- alias :update_ve_fog_and_overlay :update def update update_fogs if $game_battle_fogs update_ve_fog_and_overlay end #-------------------------------------------------------------------------- # * New method: create_fogs #-------------------------------------------------------------------------- def create_fogs


10/15

@fog_sprites = [] end #-------------------------------------------------------------------------- # * New method: dispose_fogs #-------------------------------------------------------------------------- def dispose_fogs if @fog_sprite $game_map.screen.fogs.clear @fog_sprites.compact.each {|sprite| sprite.dispose } @fog_sprites.clear end end #-------------------------------------------------------------------------- # * New method: update_fogs #-------------------------------------------------------------------------- def update_fogs $game_map.screen.update_fogs $game_map.screen.fogs.each do |fog| @fog_sprites[fog.id] ||= Sprite_Fog.new(@viewport1, fog) @fog_sprites[fog.id].update end endend

#==============================================================================# ** Scene_Map#------------------------------------------------------------------------------# This class performs the map screen processing.#==============================================================================

class Scene_Map #-------------------------------------------------------------------------- # * Alias method: pre_transfer #-------------------------------------------------------------------------- alias :pre_transfer_ve_fog_and_overlay :pre_transfer def pre_transfer pre_transfer_ve_fog_and_overlay

if $game_player.new_map_id != $game_map.map_id @spriteset.dispose_fogs $game_map.screen.clear_fogs $game_map.screen.fogs.clear end endend

#==============================================================================# ** Game_Fog#------------------------------------------------------------------------------# This class handles fog data. This class is used within the Game_Fogs class.#==============================================================================

class Game_Fog #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_reader :id attr_reader :name attr_reader :hue attr_reader :sx attr_reader :sy


11/15

attr_reader :ox attr_reader :oy attr_reader :depth attr_reader :move attr_reader :zoom_x attr_reader :zoom_y attr_reader :opacity attr_reader :blend_type attr_reader :tone #-------------------------------------------------------------------------- # * initialize #-------------------------------------------------------------------------- def initialize(id) @id = id init_basic init_target init_tone end #-------------------------------------------------------------------------- # * init_basic #-------------------------------------------------------------------------- def init_basic @name = "" @depth = 300

@zoom_x = 1.0 @zoom_y = 1.0 @move = 32 @opacity = 255.0 @blend_type = 1 @sx = 0 @sy = 0 @ox = 0 @oy = 0 @hue = 0 @opacity_duration = 0 @tone_duration = 0 end

#-------------------------------------------------------------------------- # * init_target #-------------------------------------------------------------------------- def init_target @target_x = @x @target_y = @y @target_zoom_x = @zoom_x @target_zoom_y = @zoom_y @target_opacity = @opacity end #-------------------------------------------------------------------------- # * init_tone #--------------------------------------------------------------------------

def init_tone @tone = Tone.new @tone_target = Tone.new @tone_duration = 0 end #-------------------------------------------------------------------------- # * show #-------------------------------------------------------------------------- def show(id, name, opacity, move, zoom, hue, blend, depth) @id = id


12/15

@name = name @move = move @zoom_x = zoom.to_f @zoom_y = zoom.to_f @depth = depth @opacity = opacity.to_f @blend_type = blend @ox = 0 @oy = 0 init_target init_tone end #-------------------------------------------------------------------------- # * start_movement #-------------------------------------------------------------------------- def start_movement(sx, sy) @sx = sx @sy = sy end #-------------------------------------------------------------------------- # * start_tone_change #-------------------------------------------------------------------------- def start_tone_change(tone, duration) @tone_target = tone.clone

@tone_duration = [duration.to_i, 0].max @tone = @tone_target.clone if @tone_duration == 0 end #-------------------------------------------------------------------------- # * start_opacity_change #-------------------------------------------------------------------------- def start_opacity_change(opacity, duration) @opacity_target = opacity @opacity_duration = [duration.to_i, 0].max @opacity = @opacity_target if @opacity_duration == 0 end #-------------------------------------------------------------------------- # * erase

#-------------------------------------------------------------------------- def erase @name = "" end #-------------------------------------------------------------------------- # * update #-------------------------------------------------------------------------- def update update_move update_tone update_opacity end #--------------------------------------------------------------------------

# * update_move #-------------------------------------------------------------------------- def update_move @ox -= @sx / 16.0 @oy -= @sy / 16.0 end #-------------------------------------------------------------------------- # * update_opacity #-------------------------------------------------------------------------- def update_opacity


13/15

return if @opacity_duration == 0 d = @opacity_duration @opacity = (@opacity * (d - 1) + @opacity_target) / d @opacity_duration -= 1 end #-------------------------------------------------------------------------- # * update_tone #-------------------------------------------------------------------------- def update_tone return if @tone_duration == 0 d = @tone_duration @tone.red = (@tone.red * (d - 1) + @tone_target.red) / d @tone.green = (@tone.green * (d - 1) + @tone_target.green) / d @tone.blue = (@tone.blue * (d - 1) + @tone_target.blue) / d @tone.gray = (@tone.gray * (d - 1) + @tone_target.gray) / d @tone_duration -= 1 endend

#==============================================================================# ** Game_Fogs#------------------------------------------------------------------------------# This class handles fogs. This class is used within the Game_Screen class.#==============================================================================

class Game_Fogs #-------------------------------------------------------------------------- # * initialize #-------------------------------------------------------------------------- def initialize @data = [] end #-------------------------------------------------------------------------- # * [] #-------------------------------------------------------------------------- def [](number) @data[number] ||= Game_Fog.new(number)

end #-------------------------------------------------------------------------- # * each #-------------------------------------------------------------------------- def each @data.compact.each {|fog| yield fog } if block_given? end #-------------------------------------------------------------------------- # * clear #-------------------------------------------------------------------------- def clear @data.clear end

end

#==============================================================================# ** Sprite_Fog#------------------------------------------------------------------------------# This sprite is used to display fgos. It observes a instance of the# Game_Fog class and automatically changes sprite conditions.#==============================================================================

class Sprite_Fog < Plane


14/15

#-------------------------------------------------------------------------- # * initialize #-------------------------------------------------------------------------- def initialize(viewport, fog) super(viewport) @fog = fog @x = 0 @y = 0 $game_map.fog_x = 0 $game_map.fog_y = 0 @initi_ox = $game_map.display_x * 32 @initi_oy = $game_map.display_y * 32 update end #-------------------------------------------------------------------------- # * dispose #-------------------------------------------------------------------------- def dispose bitmap.dispose if bitmap super end #-------------------------------------------------------------------------- # * update #--------------------------------------------------------------------------

def update update_bitmap update_position update_zoom update_other end #-------------------------------------------------------------------------- # * update bitmap #-------------------------------------------------------------------------- def update_bitmap if @fog_name != @fog.name self.bitmap = Cache.fogs(@fog.name) @fog_name = @fog.name.dup

end end #-------------------------------------------------------------------------- # * update_position #-------------------------------------------------------------------------- def update_position self.ox = $game_map.fog_x * @fog.move + @fog.ox + @initi_ox self.oy = $game_map.fog_y * @fog.move + @fog.oy + @initi_oy self.z = @fog.depth end #-------------------------------------------------------------------------- # * update_zoom #--------------------------------------------------------------------------

def update_zoom self.zoom_x = @fog.zoom_x / 100.0 self.zoom_y = @fog.zoom_y / 100.0 end #-------------------------------------------------------------------------- # * update_other #-------------------------------------------------------------------------- def update_other self.opacity = @fog.opacity self.blend_type = @fog.blend_type


15/15

self.tone.set(@fog.tone) endend

Victor Engine - Fog and Overlay

Documents

Transcript of Victor Engine - Fog and Overlay