[RGSS] Ugly anti lag

if Module.constants.include?('SDK') then SDK.log('Anti Event Lag System',
'Zeriab', 1.2, '2008-06-25'); SDK.check_requirements(2.0); end
if !Module.constants.include?('SDK') || SDK.enabled?('Anti Event Lag System')
class Game_Map; ALWAYS_UPDATE = false; BUFFER_SIZE = 2; TILES_VERTICAL = 15
TILES_HORIZONTAL = 20; LIMIT_COMMON_EVENTS = true; SPECIFY_COMMON_EVENTS_MANUALLY = false
COMMON_EVENTS_TO_UPDATE = []; COMMON_EVENT_FILEPATH = 'Data/CommonEvents.rxdata'; end
class Game_Event; SPECIAL_UPDATE_IDS = {}; NEVER_UPDATE_NAME_PATTERNS = ['[N]']
ALWAYS_UPDATE_NAME_PATTERNS = ['[A]']; end
class Game_Map; if LIMIT_COMMON_EVENTS && !SPECIFY_COMMON_EVENTS_MANUALLY
COMMON_EVENTS_TO_UPDATE = []; common_events = load_data(COMMON_EVENT_FILEPATH)
for common_event in common_events.compact; if common_event.trigger > 0
COMMON_EVENTS_TO_UPDATE << common_event.id; end; end; end; end; class Game_Map
attr_reader :event_map; alias_method :zeriab_antilag_gmmap_setup, :setup
def setup(*args) @event_map = {}; zeriab_antilag_gmmap_setup(*args)
for event in @events.values; event.check_update; end; end; def update_events
for event in @events.values; if ALWAYS_UPDATE || event.need_update? then event.update
end; end; end; if LIMIT_COMMON_EVENTS then def update_common_events
for i in COMMON_EVENTS_TO_UPDATE; @common_events[i].update; end; end; end
def move_event(old_x,old_y,event); return if old_x == event.x && old_y == event.y
remove_event(old_x, old_y, event); add_event(event.x,event.y,event)
spriteset = $scene.instance_eval('@spriteset'); if spriteset.is_a?(Spriteset_Map) &&
spriteset.respond_to?(:update_event); spriteset.update_event(old_x,old_y,event)
end; end; def add_event(x,y,event); if @event_map[[x,y]].nil?
@event_map[[x,y]] = [event] else; @event_map[[x,y]] << event; end; end
def remove_event(x,y,event) return if @event_map[[x,y]].nil?
if @event_map[[x,y]].size > 1 then @event_map[[x,y]].delete(event) else
@event_map.delete([x,y]); end; end; def get_tile_area(rect = false)
x = $game_map.display_x / 128; y = $game_map.display_y / 128; min_x = x - BUFFER_SIZE
min_y = y - BUFFER_SIZE; max_x = x + TILES_HORIZONTAL + BUFFER_SIZE
max_y = y + TILES_VERTICAL + BUFFER_SIZE; if min_x < 0 then min_x = 0; end
if max_x >= $game_map.width then max_x = $game_map.width - 1; end; if min_y < 0
min_y = 0; end; if max_y >= $game_map.height then max_y = $game_map.height - 1
end; if rect then return Rect.new(min_x, min_y, max_x - min_x, max_y - min_y)
else; return min_x, max_x, min_y, max_y; end; end; def visible?(x,y)
min_x = $game_map.display_x / 128; min_y = $game_map.display_y / 128
if x >= min_x - BUFFER_SIZE && x <= min_x + BUFFER_SIZE + TILES_HORIZONTAL &&
y >= min_y - BUFFER_SIZE && y <= min_y + BUFFER_SIZE + TILES_VERTICAL
return true; end; return false; end; def check_event(x, y) events = event_map[[x,y]]
unless events.nil?; for event in events; if event.x == x and event.y == y
return event.id; end; end; end; end; def passable?(x, y, d, self_event = nil)
unless valid?(x, y); return false; end; bit = (1 << (d / 2 - 1)) & 0x0f
events = event_map[[x,y]]; unless events.nil?; for event in events
if event.tile_id >= 0 and event != self_event and not event.through
if @passages[event.tile_id] & bit != 0; return false
elsif @passages[event.tile_id] & 0x0f == 0x0f; return false
elsif @priorities[event.tile_id] == 0; return true; end; end; end; end
for i in [2, 1, 0]; tile_id = data[x, y, i]; if tile_id == nil; return false
elsif @passages[tile_id] & bit != 0; return false
elsif @passages[tile_id] & 0x0f == 0x0f; return false; elsif @priorities[tile_id] == 0
return true; end; end; return true; end; end; class Game_Character
def passable?(x, y, d); new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0); new_y = y +
(d == 2 ? 1 : d == 8 ? -1 : 0); unless $game_map.valid?(new_x, new_y)
return false; end; if @through; return true; end
unless $game_map.passable?(x, y, d, self); return false; end
unless $game_map.passable?(new_x, new_y, 10 - d); return false; end
if $game_player.x == new_x and $game_player.y == new_y; unless $game_player.through
if @character_name != ""; return false; end; end; end
events = $game_map.event_map[[new_x,new_y]]; if events.nil?; return true; end
for event in events; if event.x == new_x and event.y == new_y; unless event.through
if self != $game_player; return false; end; if event.character_name != ""; return false
end; end; end; end; return true; end; end; class Game_Event; AX = [:jump, :moveto,
:move_down, :move_left, :move_right, :move_up, :move_lower_left, :move_lower_right,
:move_upper_left, :move_upper_right]; for method in AX; new_method_as_string =
'zeriab_antilag_gmtev_' + method.to_s; new_method = new_method_as_string.to_sym
next if self.method_defined?(new_method); alias_method(new_method, method)
PROG = <<FIN
def #{method}(*args); old_x = @x; old_y = @y; #{new_method}(*args)
unless old_x == @x && old_y == @y; $game_map.move_event(old_x, old_y, self)
end; end
FIN
eval(PROG); end; attr_writer :always_update; def always_update; @always_update =
false if @always_update.nil?; return @always_update; end; attr_writer :never_update
def never_update; @never_update = false if @never_update.nil?; return @never_update
end; def need_update?; return false if never_update; return true if always_update
return true if $game_map.visible?(x, y); return true if @move_type == 3
return @trigger == 3 || @trigger == 4; end; def check_update; name = @event.name
for pattern in NEVER_UPDATE_NAME_PATTERNS; if (pattern.is_a?(String) &&
name.include?(pattern)) || !(pattern =~ name).nil?; self.never_update = true; end
end; for pattern in ALWAYS_UPDATE_NAME_PATTERNS; if (pattern.is_a?(String) &&
name.include?(pattern)) || !(pattern =~ name).nil?; self.always_update = true
end; end; special_update = SPECIAL_UPDATE_IDS[[@map_id,@id]]; unless special_update.nil?
if special_update.downcase == 'n'; self.never_update = true; self.always_update =
false elsif special_update.downcase == 'a'; self.always_update = true
self.never_update = false; end; end; end; end; class Game_Player
def check_event_trigger_here(triggers) result = false; if $game_system.map_interpreter.
running?; return result; end; events = $game_map.event_map[[@x,@y]]; unless events.nil?
for event in events; if triggers.include?(event.trigger); if not event.jumping? and
event.over_trigger?; event.start; result = true; end; end; end; end; return result
end; def check_event_trigger_there(triggers); result = false; if $game_system.
map_interpreter.running?; return result; end; new_x = @x + (@direction == 6 ? 1 :
@direction == 4 ? -1 : 0); new_y = @y + (@direction == 2 ? 1 : @direction == 8 ? -1 :
0); events = $game_map.event_map[[new_x,new_y]]; unless events.nil?; for event in
events; if triggers.include?(event.trigger); if not event.jumping? and not event.
over_trigger?; event.start; result = true; end; end; end; end; if result == false
if $game_map.counter?(new_x, new_y); new_x += (@direction == 6 ? 1 : @direction ==
4 ? -1 : 0); new_y += (@direction == 2 ? 1 : @direction == 8 ? -1 : 0); events =
$game_map.event_map[[new_x,new_y]]; unless events.nil?; for event in events; if
triggers.include?(event.trigger); if not event.jumping? and not event.over_trigger?
event.start; result = true; end; end; end; end; end; end; return result; end; def
check_event_trigger_touch(x, y); result = false; if $game_system.map_interpreter.
running?; return result; end; events = $game_map.event_map[[x,y]]; unless events.nil?
for event in events; if [1,2].include?(event.trigger); if not event.jumping? and
not event.over_trigger?; event.start; result = true; end; end; end; end; return
result; end; end; class Spriteset_Map; def init_characters; @character_sprites = []
refresh_characters; refresh_character_sprites; end; def refresh_characters
@character_event_sprites = []; @character_spritemap = {}; min_x, max_x, min_y,
max_y = $game_map.get_tile_area; for x in min_x..max_x; for y in min_y..max_y
add_sprites(x,y); end; end; end; def refresh_character_sprites
@character_event_sprites = @character_spritemap.values.flatten; @last_screen_x =
$game_map.display_x / 128; @last_screen_y = $game_map.display_y / 128; @need_refresh =
false; end; def update_character_sprites; unless @last_screen_x == $game_map.
display_x / 128 && @last_screen_y == $game_map.display_y / 128; diff_x =
@last_screen_x - $game_map.display_x / 128; diff_y = @last_screen_y - $game_map.
display_y / 128; if diff_x.abs > 1 || diff_y.abs > 1; @character_event_sprites.
each {|sprite| sprite.dispose}; init_characters; else; update_buffer(diff_x, diff_y)
end; refresh_character_sprites; else; refresh_character_sprites if @need_refresh
end; @character_event_sprites.each {|sprite| sprite.update}; @character_sprites.
each {|sprite| sprite.update}; end; def update_buffer(diff_x, diff_y); min_x, max_x,
min_y, max_y = $game_map.get_tile_area; if diff_x > 0; unless max_x >= $game_map.
width - 1; for y in min_y..max_y; dispose_sprites(max_x+1, y); end; end; for y in
min_y..max_y; add_sprites(min_x, y) if @character_spritemap[[min_x,y]].nil?; end
elsif diff_x < 0; unless min_x <= 0; for y in min_y..max_y; dispose_sprites(min_x-1,
y); end; end; for y in min_y..max_y; add_sprites(max_x, y) if @character_spritemap[
[max_x,y]].nil?; end; end; if diff_y > 0; unless max_y >= $game_map.height - 1
for x in min_x..max_x; dispose_sprites(x, max_y+1); end; end; for x in min_x..max_x
add_sprites(x, min_y) if @character_spritemap[[x,min_y]].nil?; end; elsif diff_y < 0
unless min_y <= 0; for x in min_x..max_x; dispose_sprites(x, min_y-1); end; end
for x in min_x..max_x; add_sprites(x, max_y) if @character_spritemap[[x,max_y]].nil?
end; end; end; def update_event(old_x,old_y,event); sprites = @character_spritemap[
[old_x,old_y]]; unless sprites.nil?; sprite = nil; for sprite in sprites; break if
sprite.character == event; end; end; if sprite.nil?; if $game_map.visible?(event.x,
event.y); sprite = Sprite_Character.new(@viewport1, event); add_sprite(event.x,event.
y,sprite); @need_refresh = true; end; else; if $game_map.visible?(event.x, event.y)
move_event(old_x, old_y, sprite); else; remove_sprite(old_x,old_y,sprite); sprite.
dispose; @need_refresh = true; end; end; end; def add_sprites(x,y); return if
$game_map.event_map[[x,y]].nil?; for event in $game_map.event_map[[x,y]]; sprite =
Sprite_Character.new(@viewport1, event); add_sprite(x,y,sprite); end; end; def
dispose_sprites(x,y); return if @character_spritemap[[x,y]].nil?; for sprite in
@character_spritemap[[x,y]]; remove_sprite(x,y,sprite); sprite.dispose unless sprite.
dispose; end; end; def move_event(old_x,old_y,sprite); event = sprite.character
return if old_x == event.x && old_y == event.y; remove_sprite(old_x, old_y, sprite)
add_sprite(event.x, event.y, sprite); end; def add_sprite(x,y,sprite); if
@character_spritemap[[x,y]].nil?; @character_spritemap[[x,y]] = [sprite] else
@character_spritemap[[x,y]] << sprite; end; end; def remove_sprite(x,y,sprite)
return unless !@character_spritemap[[x,y]].nil? && @character_spritemap[[x,y]].
include?(sprite); if @character_spritemap[[x,y]].size > 1; @character_spritemap[
[x,y]].delete(sprite); else; @character_spritemap.delete([x,y]); end; end; end; end
unless Module.constants.include?('SDK'); class Game_Map; def update_common_events
for common_event in @common_events.values; common_event.update; end; end; def update
if $game_map.need_refresh; refresh; end; if @scroll_rest > 0; distance = 2 **
@scroll_speed; case @scroll_direction; when 2; scroll_down(distance); when 4
scroll_left(distance); when 6; scroll_right(distance); when 8; scroll_up(distance)
end; @scroll_rest -= distance; end; update_events; update_common_events; @fog_ox -=
@fog_sx / 8.0; @fog_oy -= @fog_sy / 8.0; if @fog_tone_duration >= 1; d =
@fog_tone_duration; target = @fog_tone_target; @fog_tone.red = (@fog_tone.red *
(d - 1) + target.red) / d; @fog_tone.green = (@fog_tone.green * (d - 1) + target.
green) / d; @fog_tone.blue = (@fog_tone.blue * (d - 1) + target.blue) / d
@fog_tone.gray = (@fog_tone.gray * (d - 1) + target.gray) / d; @fog_tone_duration -= 1
end; if @fog_opacity_duration >= 1; d = @fog_opacity_duration; @fog_opacity =
(@fog_opacity * (d - 1) + @fog_opacity_target) / d; @fog_opacity_duration -= 1
end; end; end; class Spriteset_Map; def initialize; @viewport1 = Viewport.new(0, 0,
640, 480); @viewport2 = Viewport.new(0, 0, 640, 480); @viewport3 = Viewport.new(0,
0, 640, 480); @viewport2.z = 200; @viewport3.z = 5000; @tilemap = Tilemap.new(
@viewport1); @tilemap.tileset = RPG::Cache.tileset($game_map.tileset_name); for i in
0..6; autotile_name = $game_map.autotile_names[i]; @tilemap.autotiles[i] = RPG::
Cache.autotile(autotile_name); end; @tilemap.map_data = $game_map.data; @tilemap.
priorities = $game_map.priorities; @panorama = Plane.new(@viewport1); @panorama.
z = -1000; @fog = Plane.new(@viewport1); @fog.z = 3000; init_characters
@character_sprites.push(Sprite_Character.new(@viewport1, $game_player)); @weather =
RPG::Weather.new(@viewport1); @picture_sprites = []; for i in 1..50; @picture_sprites.
push(Sprite_Picture.new(@viewport2,$game_screen.pictures[i])); end; @timer_sprite =
Sprite_Timer.new; update; end; def dispose; @tilemap.tileset.dispose; for i in 0..6
@tilemap.autotiles[i].dispose; end; @tilemap.dispose; @panorama.dispose; @fog.
dispose; @weather.dispose; for sprite in @picture_sprites; sprite.dispose; end
for sprite in @character_event_sprites; sprite.dispose unless sprite.disposed?
end; @timer_sprite.dispose; @viewport1.dispose; @viewport2.dispose; @viewport3.
dispose; end; def update; if @panorama_name != $game_map.panorama_name or
@panorama_hue != $game_map.panorama_hue; @panorama_name = $game_map.panorama_name
@panorama_hue = $game_map.panorama_hue; if @panorama.bitmap != nil; @panorama.bitmap.
dispose; @panorama.bitmap = nil; end; if @panorama_name != ""; @panorama.bitmap =
RPG::Cache.panorama(@panorama_name, @panorama_hue); end; Graphics.frame_reset
end; if @fog_name != $game_map.fog_name or @fog_hue != $game_map.fog_hue; @fog_name =
$game_map.fog_name; @fog_hue = $game_map.fog_hue; if @fog.bitmap != nil: @fog.bitmap.
dispose; @fog.bitmap = nil; end; if @fog_name != ""; @fog.bitmap = RPG::Cache.fog(
@fog_name, @fog_hue); end; Graphics.frame_reset; end; @tilemap.ox = $game_map.
display_x / 4; @tilemap.oy = $game_map.display_y / 4; @tilemap.update; @panorama.
ox = $game_map.display_x / 8; @panorama.oy = $game_map.display_y / 8; @fog.zoom_x =
$game_map.fog_zoom / 100.0; @fog.zoom_y = $game_map.fog_zoom / 100.0; @fog.opacity =
$game_map.fog_opacity; @fog.blend_type = $game_map.fog_blend_type; @fog.ox =
$game_map.display_x / 4 + $game_map.fog_ox; @fog.oy = $game_map.display_y / 4 +
$game_map.fog_oy; @fog.tone = $game_map.fog_tone; update_character_sprites; @weather.
type = $game_screen.weather_type; @weather.max = $game_screen.weather_max; @weather.
ox = $game_map.display_x / 4; @weather.oy = $game_map.display_y / 4; @weather.update
for sprite in @picture_sprites; sprite.update; end; @timer_sprite.update; @viewport1.
tone = $game_screen.tone; @viewport1.ox = $game_screen.shake; @viewport3.color =
$game_screen.flash_color; @viewport1.update; @viewport3.update; end; end; end