#===============================================================
=
==============
# ▼ Map Effect Pack 1
# |-By Noor Xp
# |-For RPG Maker VX
# |-Version 1.0
# |-2009-March-30
#==============================================================================
# Script Option
#==============================================================================
module NXP
ENABLE_SHADOW = true
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
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :screen # map screen state
attr_reader :interpreter # map event interpreter
attr_reader :display_x # display X coordinate * 256
attr_reader :display_y # display Y coordinate * 256
attr_reader :parallax_name # parallax background filename
attr_reader :passages # passage table
attr_reader :events # events
attr_reader :vehicles # vehicle
attr_accessor :need_refresh # refresh request flag
attr_accessor :fog_name # fog file name
attr_accessor :fog_ox # fog x-coordinate starting point
attr_accessor :fog_oy # fog y-coordinate starting point
attr_accessor :fog_sx # fog x-coordinate starting point
attr_accessor :fog_sy # fog y-coordinate starting point
attr_accessor :opserv
attr_accessor :opacity
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
@screen = Game_Screen.new
@interpreter = Game_Interpreter.new(0, true)
@map_id = 0
@display_x = 0
@display_y = 0
create_vehicles
end
#--------------------------------------------------------------------------
# * Setup
# map_id : map ID
#--------------------------------------------------------------------------
def setup(map_id)
@map_id = map_id
@map = load_data(sprintf("Data/Map%03d.rvdata", @map_id))
@display_x = 0
@display_y = 0
@passages = $data_system.passages
referesh_vehicles
setup_events
setup_scroll
setup_parallax
@need_refresh = false
@fog_name = ""
@fog_ox = 0
@fog_oy = 0
@fog_sx = 0
@fog_sy = 0
@opserv = true
@opacity = 0
end
#--------------------------------------------------------------------------
# * Create Vehicles
#--------------------------------------------------------------------------
def create_vehicles
@vehicles = []
@vehicles[0] = Game_Vehicle.new(0) # Boat
@vehicles[1] = Game_Vehicle.new(1) # Ship
@vehicles[2] = Game_Vehicle.new(2) # Airship
end
#--------------------------------------------------------------------------
# * Refresh Vehicles
#--------------------------------------------------------------------------
def referesh_vehicles
for vehicle in @vehicles
vehicle.refresh
end
end
#--------------------------------------------------------------------------
# * Get Boat
#--------------------------------------------------------------------------
def boat
return @vehicles[0]
end
#--------------------------------------------------------------------------
# * Get Ship
#--------------------------------------------------------------------------
def ship
return @vehicles[1]
end
#--------------------------------------------------------------------------
# * Get Airship
#--------------------------------------------------------------------------
def airship
return @vehicles[2]
end
#--------------------------------------------------------------------------
# * Event Setup
#--------------------------------------------------------------------------
def setup_events
@events = {} # Map event
for i in @map.events.keys
@events[i] = Game_Event.new(@map_id, @map.events[i])
end
@common_events = {} # Common event
for i in 1...$data_common_events.size
@common_events[i] = Game_CommonEvent.new(i)
end
end
#--------------------------------------------------------------------------
# * Scroll Setup
#--------------------------------------------------------------------------
def setup_scroll
@scroll_direction = 2
@scroll_rest = 0
@scroll_speed = 4
@margin_x = (width - 17) * 256 / 2 # Screen non-display width /2
@margin_y = (height - 13) * 256 / 2 # Screen non-display height /2
end
#--------------------------------------------------------------------------
# * Parallax Background Setup
#--------------------------------------------------------------------------
def setup_parallax
@parallax_name = @map.parallax_name
@parallax_loop_x = @map.parallax_loop_x
@parallax_loop_y = @map.parallax_loop_y
@parallax_sx = @map.parallax_sx
@parallax_sy = @map.parallax_sy
@parallax_x = 0
@parallax_y = 0
end
#--------------------------------------------------------------------------
# * Set Display Position
# x : New display X coordinate (*256)
# y : New display Y coordinate (*256)
#--------------------------------------------------------------------------
def set_display_pos(x, y)
@display_x = (x + @map.width * 256) % (@map.width * 256)
@display_y = (y + @map.height * 256) % (@map.height * 256)
@parallax_x = x
@parallax_y = y
end
#--------------------------------------------------------------------------
# * Calculate X coordinate for parallax display
# bitmap : Parallax bitmap
#--------------------------------------------------------------------------
def calc_parallax_x(bitmap)
if bitmap == nil
return 0
elsif @parallax_loop_x
return @parallax_x / 16
elsif loop_horizontal?
return 0
else
w1 = bitmap.width - 544
w2 = @map.width * 32 - 544
if w1 <= 0 or w2 <= 0
return 0
else
return @parallax_x * w1 / w2 / 8
end
end
end
#--------------------------------------------------------------------------
# * Calculate Y coordinate for parallax display
# bitmap : Parallax bitmap
#--------------------------------------------------------------------------
def calc_parallax_y(bitmap)
if bitmap == nil
return 0
elsif @parallax_loop_y
return @parallax_y / 16
elsif loop_vertical?
return 0
else
h1 = bitmap.height - 416
h2 = @map.height * 32 - 416
if h1 <= 0 or h2 <= 0
return 0
else
return @parallax_y * h1 / h2 / 8
end
end
end
#--------------------------------------------------------------------------
# * Get Map ID
#--------------------------------------------------------------------------
def map_id
return @map_id
end
#--------------------------------------------------------------------------
# * Get Width
#--------------------------------------------------------------------------
def width
return @map.width
end
#--------------------------------------------------------------------------
# * Get Height
#--------------------------------------------------------------------------
def height
return @map.height
end
#--------------------------------------------------------------------------
# * Loop Horizontally?
#--------------------------------------------------------------------------
def loop_horizontal?
return (@map.scroll_type == 2 or @map.scroll_type == 3)
end
#--------------------------------------------------------------------------
# * Loop Vertically?
#--------------------------------------------------------------------------
def loop_vertical?
return (@map.scroll_type == 1 or @map.scroll_type == 3)
end
#--------------------------------------------------------------------------
# * Get Whether Dash is Disabled
#--------------------------------------------------------------------------
def disable_dash?
return @map.disable_dashing
end
#--------------------------------------------------------------------------
# * Get Encounter List
#--------------------------------------------------------------------------
def encounter_list
return @map.encounter_list
end
#--------------------------------------------------------------------------
# * Get Encounter Steps
#--------------------------------------------------------------------------
def encounter_step
return @map.encounter_step
end
#--------------------------------------------------------------------------
# * Get Map Data
#--------------------------------------------------------------------------
def data
return @map.data
end
#--------------------------------------------------------------------------
# * Calculate X coordinate, minus display coordinate
# x : x-coordinate
#--------------------------------------------------------------------------
def adjust_x(x)
if loop_horizontal? and x < @display_x - @margin_x
return x - @display_x + @map.width * 256
else
return x - @display_x
end
end
#--------------------------------------------------------------------------
# * Calculate Y coordinate, minus display coordinate
# y : y-coordinate
#--------------------------------------------------------------------------
def adjust_y(y)
if loop_vertical? and y < @display_y - @margin_y
return y - @display_y + @map.height * 256
else
return y - @display_y
end
end
#--------------------------------------------------------------------------
# * Calculate X coordinate after loop adjustment
# x : x-coordinate
#--------------------------------------------------------------------------
def round_x(x)
if loop_horizontal?
return (x + width) % width
else
return x
end
end
#--------------------------------------------------------------------------
# * Calculate Y coordinate after loop adjustment
# y : y-coordinate
#--------------------------------------------------------------------------
def round_y(y)
if loop_vertical?
return (y + height) % height
else
return y
end
end
#--------------------------------------------------------------------------
# * Calculate X coordinate one square in a particular direction
# x : x-coordinate
# direction : direction (2,4,6,8)
#--------------------------------------------------------------------------
def x_with_direction(x, direction)
return round_x(x + (direction == 6 ? 1 : direction == 4 ? -1 : 0))
end
#--------------------------------------------------------------------------
# * Calculate Y coordinate one square in a particular direction
# y : y-coordinate
# direction : direction (2,4,6,8)
#--------------------------------------------------------------------------
def y_with_direction(y, direction)
return round_y(y + (direction == 2 ? 1 : direction == 8 ? -1 : 0))
end
#--------------------------------------------------------------------------
# * Get array of event at designated coordinates
# x : x-coordinate
# y : y-coordinate
#--------------------------------------------------------------------------
def events_xy(x, y)
result = []
for event in $game_map.events.values
result.push(event) if event.pos?(x, y)
end
return result
end
#--------------------------------------------------------------------------
# * Automatically Switch BGM and BGS
#--------------------------------------------------------------------------
def autoplay
@map.bgm.play if @map.autoplay_bgm
@map.bgs.play if @map.autoplay_bgs
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
if @map_id > 0
for event in @events.values
event.refresh
end
for common_event in @common_events.values
common_event.refresh
end
end
@need_refresh = false
end
#--------------------------------------------------------------------------
# * Scroll Down
# distance : scroll distance
#--------------------------------------------------------------------------
def scroll_down(distance)
if loop_vertical?
@display_y += distance
@display_y %= @map.height * 256
@parallax_y += distance
else
last_y = @display_y
@display_y = [@display_y + distance, (height - 13) * 256].min
@parallax_y += @display_y - last_y
end
end
#--------------------------------------------------------------------------
# * Scroll Left
# distance : scroll distance
#--------------------------------------------------------------------------
def scroll_left(distance)
if loop_horizontal?
@display_x += @map.width * 256 - distance
@display_x %= @map.width * 256
@parallax_x -= distance
else
last_x = @display_x
@display_x = [@display_x - distance, 0].max
@parallax_x += @display_x - last_x
end
end
#--------------------------------------------------------------------------
# * Scroll Right
# distance : scroll distance
#--------------------------------------------------------------------------
def scroll_right(distance)
if loop_horizontal?
@display_x += distance
@display_x %= @map.width * 256
@parallax_x += distance
else
last_x = @display_x
@display_x = [@display_x + distance, (width - 17) * 256].min
@parallax_x += @display_x - last_x
end
end
#--------------------------------------------------------------------------
# * Scroll Up
# distance : scroll distance
#--------------------------------------------------------------------------
def scroll_up(distance)
if loop_vertical?
@display_y += @map.height * 256 - distance
@display_y %= @map.height * 256
@parallax_y -= distance
else
last_y = @display_y
@display_y = [@display_y - distance, 0].max
@parallax_y += @display_y - last_y
end
end
#--------------------------------------------------------------------------
# * Determine Valid Coordinates
# x : x-coordinate
# y : y-coordinate
#--------------------------------------------------------------------------
def valid?(x, y)
return (x >= 0 and x < width and y >= 0 and y < height)
end
#--------------------------------------------------------------------------
# * Determine if Passable
# x : x coordinate
# y : y coordinate
# flag : The impassable bit to be looked up
# (normally 0x01, only changed for vehicles)
#--------------------------------------------------------------------------
def passable?(x, y, flag = 0x01)
for event in events_xy(x, y) # events with matching coordinates
next if event.tile_id == 0 # graphics are not tiled
next if event.priority_type > 0 # not [Below characters]
next if event.through # pass-through state
pass = @passages[event.tile_id] # get passable attribute
next if pass & 0x10 == 0x10 # *: Does not affect passage
return true if pass & flag == 0x00 # o: Passable
return false if pass & flag == flag # x: Impassable
end
for i in [2, 1, 0] # in order from on top of layer
tile_id = @map.data[x, y, i] # get tile ID
return false if tile_id == nil # failed to get tile: Impassable
pass = @passages[tile_id] # get passable attribute
next if pass & 0x10 == 0x10 # *: Does not affect passage
return true if pass & flag == 0x00 # o: Passable
return false if pass & flag == flag # x: Impassable
end
return false # Impassable
end
#--------------------------------------------------------------------------
# * Determine if Boat is Passable
# x : x-coordinate
# y : y-coordinate
#--------------------------------------------------------------------------
def boat_passable?(x, y)
return passable?(x, y, 0x02)
end
#--------------------------------------------------------------------------
# * Determine if Ship is Passable
# x : x-coordinate
# y : y-coordinate
#--------------------------------------------------------------------------
def ship_passable?(x, y)
return passable?(x, y, 0x04)
end
#--------------------------------------------------------------------------
# * Determine if Airship can Land
# x : x-coordinate
# y : y-coordinate
#--------------------------------------------------------------------------
def airship_land_ok?(x, y)
return passable?(x, y, 0x08)
end
#--------------------------------------------------------------------------
# * Determine bush
# x : x-coordinate
# y : y-coordinate
#--------------------------------------------------------------------------
def bush?(x, y)
return false unless valid?(x, y)
return @passages[@map.data[x, y, 1]] & 0x40 == 0x40
end
#--------------------------------------------------------------------------
# * Determine Counter
# x : x-coordinate
# y : y-coordinate
#--------------------------------------------------------------------------
def counter?(x, y)
return false unless valid?(x, y)
return @passages[@map.data[x, y, 0]] & 0x80 == 0x80
end
#--------------------------------------------------------------------------
# * Start Scroll
# direction : scroll direction
# distance : scroll distance
# speed : scroll speed
#--------------------------------------------------------------------------
def start_scroll(direction, distance, speed)
@scroll_direction = direction
@scroll_rest = distance * 256
@scroll_speed = speed
end
#--------------------------------------------------------------------------
# * Determine if Scrolling
#--------------------------------------------------------------------------
def scrolling?
return @scroll_rest > 0
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
refresh if $game_map.need_refresh
update_scroll
update_events
update_vehicles
update_parallax
@fog_ox -= @fog_sx / 8.0
@fog_oy -= @fog_sy / 8.0
@screen.update
end
#--------------------------------------------------------------------------
# * Update Scroll
#--------------------------------------------------------------------------
def update_scroll
if @scroll_rest > 0 # If scrolling
distance = 2 ** @scroll_speed # Convert to distance
case @scroll_direction
when 2 # Down
scroll_down(distance)
when 4 # Left
scroll_left(distance)
when 6 # Right
scroll_right(distance)
when 8 # Up
scroll_up(distance)
end
@scroll_rest -= distance # Subtract scrolled distance
end
end
#--------------------------------------------------------------------------
# * Update Events
#--------------------------------------------------------------------------
def update_events
for event in @events.values
event.update
end
for common_event in @common_events.values
common_event.update
end
end
#--------------------------------------------------------------------------
# * Update Vehicles
#--------------------------------------------------------------------------
def update_vehicles
for vehicle in @vehicles
vehicle.update
end
end
#--------------------------------------------------------------------------
# * Update Parallax
#--------------------------------------------------------------------------
def update_parallax
@parallax_x += @parallax_sx * 4 if @parallax_loop_x
@parallax_y += @parallax_sy * 4 if @parallax_loop_y
end
end
#==============================================================================
# ** Spriteset_Weather
#------------------------------------------------------------------------------
# Weather effect (rain, storm, snow) class. This class is used within the
# Spriteset_Map class.
#==============================================================================

class Spriteset_Weather
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :type
attr_reader :max
attr_reader x
attr_reader y
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize(viewport = nil)
@type = 0
@max = 0
@ox = 0
@oy = 0
@rain_bitmap = Cache.system("rain.png")
@storm_bitmap = Cache.system("wind#{rand(2)}")
@snow_bitmap = Cache.system("snow#{rand(2)}")
@snow_counter = 0
@sprites = []
for i in 1..300
sprite = Sprite.new(viewport)
sprite.visible = false
sprite.opacity = 0
@sprites.push(sprite)
end
end
#--------------------------------------------------------------------------
# * Dispose
#--------------------------------------------------------------------------
def dispose
for sprite in @sprites
sprite.dispose
end
@rain_bitmap.dispose
@storm_bitmap.dispose
@snow_bitmap.dispose
end
#--------------------------------------------------------------------------
# * Set weather type
# type : new weather type
#--------------------------------------------------------------------------
def type=(type)
return if @type == type
@type = type
case @type
when 1
bitmap = @rain_bitmap
when 2
bitmap = @storm_bitmap
when 3
bitmap = @snow_bitmap
else
bitmap = nil
end
for i in 0...@sprites.size
sprite = @sprites[i]
sprite.visible = (i <= @max)
sprite.bitmap = bitmap
end
end
#--------------------------------------------------------------------------
# * Set starting point X coordinate
# ox : starting point X coordinate
#--------------------------------------------------------------------------
def ox=(ox)
return if @ox == ox;
@ox = ox
for sprite in @sprites
sprite.ox = @ox
end
end
#--------------------------------------------------------------------------
# * Set starting point Y coordinate
# oy : starting point Y coordinate
#--------------------------------------------------------------------------
def oy=(oy)
return if @oy == oy;
@oy = oy
for sprite in @sprites
sprite.oy = @oy
end
end
#--------------------------------------------------------------------------
# * Set maximum number of sprites
# max : maximum number of sprites
#--------------------------------------------------------------------------
def max=(max)
return if @max == max;
@max = [[max, 0].max, 300].min
for i in 1..300
sprite = @sprites[i]
sprite.visible = (i <= @max) if sprite != nil
end
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
return if @type == 0
for i in 1..@max
sprite = @sprites[i]
if sprite == nil
break
end
if @type == 1
sprite.x -= 2
sprite.y += 9
sprite.opacity -= 5
sprite.blend_type = 1
end
if @type == 2
@snow_counter = (@snow_counter+1) % 40
if @snow_counter > 10 and @snow_counter < 20
sprite.x -= 9
elsif @snow_counter > 20 and @snow_counter < 30
sprite.x -= 10
elsif @snow_counter > 30
sprite.x -= 12
end
#sprite.y += 16
sprite.opacity -= 0.9
sprite.blend_type = 0
end
if @type == 3
if Graphics.frame_count % 2 == 0
@snow_counter = (@snow_counter+1) % 8
if @snow_counter > 4
sprite.x -= 0.7
elsif @snow_counter < 4
sprite.x += 1.7
sprite.y += 0.7
end
sprite.y +=2
sprite.opacity -= 1
sprite.blend_type = 1
end
end
x = sprite.x - @ox
y = sprite.y - @oy
if sprite.opacity < 45 or x < -10 or x > 600 or y < -100 or y > 480
if @type == 3
sprite.bitmap = Cache.system("snow#{rand(2)}")
sprite.opacity = 255
end
if @type == 2
sprite.x = (500 + rand(44)) - 100 + @ox
sprite.y = rand(600) - 200 + @oy
sprite.bitmap = Cache.system("wind#{rand(2)}")
sprite.opacity = 100
else
sprite.x = rand(800) - 100 + @ox
sprite.y = rand(600) - 200 + @oy
end
if @type == 1
sprite.opacity = 180
end
end
end
end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
# This class brings together map screen sprites, tilemaps, etc. It's used
# within the Scene_Map class.
#==============================================================================

class Spriteset_Map
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
create_viewports
create_tilemap
create_parallax
if NXP::ENABLE_SHADOW
create_playershadow
end
create_characters
create_shadow
create_weather
create_pictures
create_timer
create_fog
update
end
#--------------------------------------------------------------------------
# * Create Viewport
#--------------------------------------------------------------------------
def create_viewports
@viewport1 = Viewport.new(0, 0, 544, 416)
@viewport2 = Viewport.new(0, 0, 544, 416)
@viewport3 = Viewport.new(0, 0, 544, 416)
@viewport2.z = 50
@viewport3.z = 100
end
#--------------------------------------------------------------------------
# * Create Tilemap
#--------------------------------------------------------------------------
def create_tilemap
@tilemap = Tilemap.new(@viewport1)
@tilemap.bitmaps[0] = Cache.system("TileA1")
@tilemap.bitmaps[1] = Cache.system("TileA2")
@tilemap.bitmaps[2] = Cache.system("TileA3")
@tilemap.bitmaps[3] = Cache.system("TileA4")
@tilemap.bitmaps[4] = Cache.system("TileA5")
@tilemap.bitmaps[5] = Cache.system("TileB")
@tilemap.bitmaps[6] = Cache.system("TileC")
@tilemap.bitmaps[7] = Cache.system("TileD")
@tilemap.bitmaps[8] = Cache.system("TileE")
@tilemap.map_data = $game_map.data
@tilemap.passages = $game_map.passages
end
#--------------------------------------------------------------------------
# * Create Fog
#--------------------------------------------------------------------------
def create_fog
@fog = Plane.new(@viewport1)
@fog.opacity = $game_map.opacity
@fog.z = 3000
end
#--------------------------------------------------------------------------
# * Create Parallax
#--------------------------------------------------------------------------
def create_parallax
@parallax = Plane.new(@viewport1)
@parallax.z = -100
end
#--------------------------------------------------------------------------
# * Create Character Sprite
#--------------------------------------------------------------------------
def create_characters
@character_sprites = []
for i in $game_map.events.keys.sort
sprite = Sprite_Character.new(@viewport1, $game_map.events[i])
@character_sprites.push(sprite)
end
for vehicle in $game_map.vehicles
sprite = Sprite_Character.new(@viewport1, vehicle)
@character_sprites.push(sprite)
end
@character_sprites.push(Sprite_Character.new(@viewport1, $game_player))
end
#--------------------------------------------------------------------------
# * Create Airship Shadow Sprite
#--------------------------------------------------------------------------
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 Airship Shadow Sprite
#--------------------------------------------------------------------------
def create_playershadow
@shadow_psprite = Sprite.new(@viewport1)
@shadow_psprite.bitmap = Cache.system("Shadow")
@shadow_psprite.ox = @shadow_psprite.bitmap.width / 2
@shadow_psprite.oy = @shadow_psprite.bitmap.height
@shadow_psprite.opacity = 160
end
#--------------------------------------------------------------------------
# * Create Weather
#--------------------------------------------------------------------------
def create_weather
@weather = Spriteset_Weather.new(@viewport2)
end
#--------------------------------------------------------------------------
# * Create Picture Sprite
#--------------------------------------------------------------------------
def create_pictures
@picture_sprites = []
for i in 1..20
@picture_sprites.push(Sprite_Picture.new(@viewport2,
$game_map.screen.pictures[i]))
end
end
#--------------------------------------------------------------------------
# * Create Timer Sprite
#--------------------------------------------------------------------------
def create_timer
@timer_sprite = Sprite_Timer.new(@viewport2)
end
#--------------------------------------------------------------------------
# * Dispose
#--------------------------------------------------------------------------
def dispose
dispose_tilemap
dispose_parallax
dispose_characters
dispose_shadow
dispose_weather
dispose_pictures
dispose_timer
dispose_viewports
if NXP::ENABLE_SHADOW
dispose_playershadow
end
@fog.dispose
end
#--------------------------------------------------------------------------
# * Dispose of Tilemap
#--------------------------------------------------------------------------
def dispose_tilemap
@tilemap.dispose
end
#--------------------------------------------------------------------------
# * Dispose of Parallax
#--------------------------------------------------------------------------
def dispose_parallax
@parallax.dispose
end
#--------------------------------------------------------------------------
# * Dispose of Character Sprite
#--------------------------------------------------------------------------
def dispose_characters
for sprite in @character_sprites
sprite.dispose
end
end
#--------------------------------------------------------------------------
# * Dispose of Airship Shadow Sprite
#--------------------------------------------------------------------------
def dispose_shadow
@shadow_sprite.dispose
end
#--------------------------------------------------------------------------
# * Dispose of Airship Shadow Sprite
#--------------------------------------------------------------------------
def dispose_playershadow
@shadow_psprite.dispose
end
#--------------------------------------------------------------------------
# * Dispose of Weather
#--------------------------------------------------------------------------
def dispose_weather
@weather.dispose
end
#--------------------------------------------------------------------------
# * Dispose of Picture Sprite
#--------------------------------------------------------------------------
def dispose_pictures
for sprite in @picture_sprites
sprite.dispose
end
end
#--------------------------------------------------------------------------
# * Dispose of Timer Sprite
#--------------------------------------------------------------------------
def dispose_timer
@timer_sprite.dispose
end
#--------------------------------------------------------------------------
# * Dispose of Viewport
#--------------------------------------------------------------------------
def dispose_viewports
@viewport1.dispose
@viewport2.dispose
@viewport3.dispose
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
update_tilemap
update_parallax
update_characters
update_shadow
update_weather
update_pictures
update_timer
update_viewports
if NXP::ENABLE_SHADOW
update_playershadow
end
update_fog
end
#--------------------------------------------------------------------------
# * Update Tilemap
#--------------------------------------------------------------------------
def update_tilemap
@tilemap.ox = $game_map.display_x / 8
@tilemap.oy = $game_map.display_y / 8
@tilemap.update
end
#--------------------------------------------------------------------------
# * Update Parallax
#--------------------------------------------------------------------------
def update_parallax
if @parallax_name != $game_map.parallax_name
@parallax_name = $game_map.parallax_name
if @parallax.bitmap != nil
@parallax.bitmap.dispose
@parallax.bitmap = nil
end
if @parallax_name != ""
@parallax.bitmap = Cache.parallax(@parallax_name)
end
Graphics.frame_reset
end
@parallax.ox = $game_map.calc_parallax_x(@parallax.bitmap)
@parallax.oy = $game_map.calc_parallax_y(@parallax.bitmap)
end
#--------------------------------------------------------------------------
# * Update Character Sprite
#--------------------------------------------------------------------------
def update_characters
for sprite in @character_sprites
sprite.update
end
end
#--------------------------------------------------------------------------
# * Update Airship Shadow Sprite
#--------------------------------------------------------------------------
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 Airship Shadow Sprite
#--------------------------------------------------------------------------
def update_playershadow
@shadow_psprite.x = $game_player.screen_x
@shadow_psprite.y = $game_player.screen_y + 5
@shadow_psprite.opacity = 160
@shadow_psprite.update
end
#--------------------------------------------------------------------------
# * Update Fog
#--------------------------------------------------------------------------
def update_fog
if @fog_name != $game_map.fog_name
@fog_name = $game_map.fog_name
if @fog.bitmap != nil
@fog.bitmap.dispose
@fog.bitmap = nil
end
if @fog_name != ""
@fog.bitmap = Cache.system(@fog_name)
end
Graphics.frame_reset
end
if $game_map.opserv
@fog.ox = $game_map.display_x / 6 + $game_map.fog_ox
@fog.oy = $game_map.display_y / 6 + $game_map.fog_oy
@fog.opacity = $game_map.opacity
@fog.blend_type = 0
else
@fog.ox = $game_map.display_x / 8 + $game_map.fog_ox
@fog.oy = $game_map.display_y / 8 + $game_map.fog_oy
@fog.opacity = $game_map.opacity
@fog.blend_type = 1
end
@fog.opacity = $game_map.opacity
end
#--------------------------------------------------------------------------
# * Update Weather
#--------------------------------------------------------------------------
def update_weather
@weather.type = $game_map.screen.weather_type
@weather.max = $game_map.screen.weather_max
@weather.ox = $game_map.display_x / 8
@weather.oy = $game_map.display_y / 8
@weather.update
end
#--------------------------------------------------------------------------
# *Update Picture Sprite
#--------------------------------------------------------------------------
def update_pictures
for sprite in @picture_sprites
sprite.update
end
end
#--------------------------------------------------------------------------
# * Update Timer Sprite
#--------------------------------------------------------------------------
def update_timer
@timer_sprite.update
end
#--------------------------------------------------------------------------
# * Update Viewport
#--------------------------------------------------------------------------
def update_viewports
@viewport1.tone = $game_map.screen.tone
@viewport1.ox = $game_map.screen.shake
@viewport2.color = $game_map.screen.flash_color
@viewport3.color.set(0, 0, 0, 255 - $game_map.screen.brightness)
@viewport1.update
@viewport2.update
@viewport3.update
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
#--------------------------------------------------------------------------
# * Make Fog
#--------------------------------------------------------------------------
def make_fog(fog,x,y,opserv=true,opacity=64)
$game_map.fog_name = fog
$game_map.fog_sx = x
$game_map.fog_sy = y
$game_map.opserv = opserv
$game_map.opacity = opacity
end
end