Anti-Lag VX

[Fegarur 0]

Descripción:
Hace tiempo que Anaryu me dio permiso para postearlo, pero no he podido ponerlo por falta de tiempo. Como su nombre indica, sirve para reducir en lo posible el lag de los juegos de RMVX. Y la verdad es que no lo hace nada mal.

Demo:
Descargar Demo (SkyDrive)
Descargar Demo (MegaUpload)
Descargar Demo (FileFront)
Descargar Demo (Fortaleza Friki)

Script:
[SPOILER]

CODE

#==============================================================================
# A N T I L A G    V X
#------------------------------------------------------------------------------
#  Autor: Andrew McKellar (Anaryu) ([email protected])
#
#  Versión: 1.2e
#
#  1.2 5 de Marzo 4:15pm EST: Implementado feedback de (Zeriab) y otras ideas
#     para actualizar sprites/eventos que están fuera de pantalla/proceso
#     paralelo. También añadida actualización para eventos fuera de pantalla
#     que tienen una ruta de movimiento específica.
#  1.2a 6 de Marzo 5:09am EST: Cambiado on_screen para usar el módulo Graphics
#     en vez de valores estáticos. (Zeriab)
#  1.2b 7 de Marzo 12:36am EST: Cambios en Game_Player para usar funciones
#     estándar en vez de especiales. Cambiado empty array check para usar
#     proper empty?
#  1.2c 10 de Marzo 10:13pm EST: Actualizados los eventos que usan un tile y
#     un chara en múltiples páginas para ser dibujados correctamente
#     como sprites. (eugene)
#  1.2d 14 de Marzo 4:12am EST: Arreglados errores con vehículos, pasabilidad,
#     y aterrizaje de barco volador.
#  1.2e 18 de Marzo 1:47am EST: Arreglados errores con la pasabilidad y los
#     gráficos de tileset en eventos de múltiples páginas.
#
#  Este script modifica funciones de fondo, sólo scripts de bajo-nivel o
#  modificaciones de mapa deberían crear conflictos.
#
#  Por favor, da crédito si lo usas, no es necesario pedir permiso para
#  proyectos de uso comercial.
#==============================================================================

# Si es true, esto permitirá al sistema ignorar todos los eventos que están
# fuera de pantalla a menos que añadas "DOUPDATE" a su nombre. (Eventos
# con DOUPDATE siempre se actualizarán)
#
# Si es false, esto significará que el sistema SIEMPRE actualizará CADA EVENTO
# del mapa - esto sólo debería usarse si experimentas problemas extraños
# de compatibilidad debido a algún script personalizado. Es mejor poner
# la etiqueta DOUPDATE en eventos que hacen algo especial o tienen ajustes
# particulares que no funcionan si esta etiqueta está activa.

ALLOW_SCREEN_IGNORE = true

#==============================================================================
# ** 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   :pmap
 attr_reader   :emap
 attr_accessor :etilemap
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 alias :pre_antilag_setup     :setup
 def setup(map_id)
   # Run normal initialize
   pre_antilag_setup(map_id)
   # Add events to map
   @emap = {}
   for event in @events.values
     if not event.ignore_location
       loc = event.x.to_s + "_" + event.y.to_s
       @emap[loc] = [] if @emap[loc] == nil
       @emap[loc].push(event.id)
     end
   end
   # Create the passability map
   @pmap = Table.new($game_map.width, $game_map.height)
   for i in 0...$game_map.width
     for j in 0...$game_map.height
       passable?(i,j) ? pass = 1 : pass = 0
       @pmap[i,j] = pass
     end
   end
 end
 #--------------------------------------------------------------------------
 # * Clear Event location
 #--------------------------------------------------------------------------
 def clear_event_loc(event)
   # Add the event into the @emap hash
   loc = event.x.to_s + "_" + event.y.to_s
   if @emap[loc] != nil
     @emap[loc].delete(event.id)
     # Clean up after ourselves
     @emap.delete(loc) if @emap[loc].empty?
   end
 end
 #--------------------------------------------------------------------------
 # * Set Event location
 #--------------------------------------------------------------------------
 def set_event_loc(event)
   # Add the event into the @emap hash
   loc = event.x.to_s + "_" + event.y.to_s
   @emap[loc] = [] if @emap[loc] == nil
   @emap[loc].push(event.id)
 end
 #--------------------------------------------------------------------------
 # * Get array of event at designated coordinates
 #     x : x-coordinate
 #     y : y-coordinate
 #--------------------------------------------------------------------------
 alias :pre_antilag_events_xy   :events_xy
 def events_xy(x, y)
   # Grab the events from the hash
   loc = x.to_s + "_" + y.to_s
   event_ids = @emap[loc]
   # Use the IDs to build an array of events
   events = []
   if event_ids != nil
     for id in event_ids
       if id == 0
         events.push($game_player)
       else
         events.push(@events[id])
       end
     end
   end
   # Return this array for the passability to use
   return events
 end
 #--------------------------------------------------------------------------
 # * Determine if Passable
 #     x    : x coordinate
 #     y    : y coordinate
 #     flag : The impassable bit to be looked up
 #            (normally 0x01, only changed for vehicles)
 #--------------------------------------------------------------------------
 alias :pre_antilag_passable?    :passable?
 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
   if @etilemap != nil
     for i in [2, 1, 0]                      # in order from on top of layer
       tile_id = @etilemap[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
   end
   return false                            # Impassable
 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
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 attr_reader   :ignore_update
 attr_reader   :ignore_sprite
 attr_reader   :ignore_location
 attr_reader   :force_update
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 alias :pre_antilag_initialize    :initialize
 def initialize
   # Run normal initialize
   pre_antilag_initialize
   # Set our ignore flag based on our event name
   @ignore_update = false
   @ignore_sprite = false
   @ignore_location = false
   @force_update = false
 end
 #--------------------------------------------------------------------------
 # * On Screen
 #--------------------------------------------------------------------------
 def on_screen
   x_range = ((@real_x <= ($game_map.display_x + ((Graphics.width + 32) * 8))) and (@real_x >= ($game_map.display_x - 256)))
   y_range = ((@real_y <= ($game_map.display_y + ((Graphics.height + 32) * 8))) and (@real_y >= ($game_map.display_y - 256)))
   if x_range and y_range
     return true
   end
   return false
 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
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 attr_reader   :id
 attr_reader   :original_forced_update
 #--------------------------------------------------------------------------
 # * Object Initialization
 #     map_id : map ID
 #     event  : event (RPG::Event)
 #--------------------------------------------------------------------------
 alias :pre_antilag_event_initialize    :initialize
 def initialize(map_id, event)
   # Run normal initialize
   pre_antilag_event_initialize(map_id, event)
   # Set our ignore flag based on our event name
   decide_ignore
 end
 #--------------------------------------------------------------------------
 # * Frame Update
 #--------------------------------------------------------------------------
 alias :pre_antilag_update    :update
 def update
   # Only run update if @ignore_update is false
   if update?
     pre_antilag_update
   end
 end
 #--------------------------------------------------------------------------
 # * Frame Update
 #--------------------------------------------------------------------------
 def update?
   # Check our logic and return if we should update
   ignore = ((not @ignore_update) and (on_screen and ALLOW_SCREEN_IGNORE))
   return (@force_update or ignore or @move_route_forcing)
 end
 #--------------------------------------------------------------------------
 # * Event page setup
 #--------------------------------------------------------------------------
 alias :pre_antilag_setup  :setup
 def setup(new_page)
   # Run normal setup
   pre_antilag_setup(new_page)
   # Set our forced flag if we're running as a parallel process now
   # if not, set it to our "default" set during the decide_ignore function
   if @trigger == 4 or @trigger == 3
     @force_update = true
   else
     @force_update = @original_force_update
   end
 end
 #--------------------------------------------------------------------------
 # * Decide if Ignorable for Updates or Sprites
 #--------------------------------------------------------------------------
 def decide_ignore
   # Not ignore by default
   @ignore_location = true
   @ignore_sprite = true
   @ignore_update = false
   @original_force_update = false
   # Decide if we should ignore ourselves or not
   if @event.name == "IGNORE"
     @ignore_update = true
   elsif @event.pages.size == 1
     if @list != nil
       if @list.size == 1
         if @character_name == "" or @tile_id != 0
           @ignore_update = true
         end
       end
     end
   end
   # Check if we'll ever need a sprite
   tiles = []
   for page in @event.pages
     # Check for single-tile events
     if page.graphic.tile_id != 0
       tiles.push(page.graphic.tile_id) if not tiles.include?(page.graphic.tile_id)
       if page.priority_type == 2 or tiles.size > 1 or @event.pages.size > 1
         @ignore_sprite = false
         @ignore_location = false
       end
     end
     # Check for character graphic instead
     if page.graphic.character_name != ""
       @ignore_sprite = false
       @ignore_location = false
     end
     # Check all pages for code to run
     if page.list.size > 1
       for item in page.list
         if item.code != 108
           @ignore_location = false
         end
       end
     end
   end
   # Check to see if we have any tiles and a no initial page
   if @list == nil and tiles.size > 0
     @ignore_sprite = false
     @ignore_location = false
   end
   # Force tags
   if @event.name.include?("DOSPRITE")
     @ignore_sprite = false
   end
   if @event.name.include?("DOLOC")
     @ignore_location = false
   end
   if @event.name.include?("DOUPDATE")
     @ignore_update = false
     @force_update = true
     @original_force_update = true
   end
 end
 #--------------------------------------------------------------------------
 # * Move Functions
 #--------------------------------------------------------------------------
 alias :pre_antilag_move_down     :move_down
 def move_down(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_down(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_left     :move_left
 def move_left(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_left(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_right     :move_right
 def move_right(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_right(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_up     :move_up
 def move_up(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_up(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_lower_left     :move_lower_left
 def move_lower_left(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_lower_left(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_upper_left     :move_upper_left
 def move_upper_left(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_upper_left(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_lower_right     :move_lower_right
 def move_lower_right(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_lower_right(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_upper_right     :move_upper_right
 def move_upper_right(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_upper_right(turn_ok)
   $game_map.set_event_loc(self)
 end
end


#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
#  This class handles maps. It includes event starting determinants and map
# scrolling functions. The instance of this class is referenced by $game_map.
#==============================================================================

class Game_Player < Game_Character
 #--------------------------------------------------------------------------
 # * Priority Type
 #--------------------------------------------------------------------------
 def priority_type
   return 1
 end
 #--------------------------------------------------------------------------
 # * Triggers
 #--------------------------------------------------------------------------
 def trigger
   return -1
 end
 #--------------------------------------------------------------------------
 # * Triggers
 #--------------------------------------------------------------------------
 def triggers
   return []
 end
 #--------------------------------------------------------------------------
 # * Triggers
 #--------------------------------------------------------------------------
 def id
   return 0
 end
 #--------------------------------------------------------------------------
 # * Triggers
 #--------------------------------------------------------------------------
 def tile_id
   return 0
 end
 #--------------------------------------------------------------------------
 # * Determine if Airship can Land
 #     x : x-coordinate
 #     y : y-coordinate
 #--------------------------------------------------------------------------
 alias :pre_antilag_airship_land_ok?   :airship_land_ok?
 def airship_land_ok?(x, y)
   unless $game_map.airship_land_ok?(x, y)
     return false    # The tile passable attribute is unlandable
   end
   # Check all events to ensure only the player is there
   for event in $game_map.events_xy(x, y)
     if event != $game_player
       return false
     end
   end
   return true       # Can land
 end
 #--------------------------------------------------------------------------
 # * Move Functions
 #--------------------------------------------------------------------------
 alias :pre_antilag_move_down     :move_down
 def move_down(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_down(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_left     :move_left
 def move_left(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_left(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_right     :move_right
 def move_right(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_right(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_up     :move_up
 def move_up(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_up(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_lower_left     :move_lower_left
 def move_lower_left(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_lower_left(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_upper_left     :move_upper_left
 def move_upper_left(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_upper_left(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_lower_right     :move_lower_right
 def move_lower_right(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_lower_right(turn_ok)
   $game_map.set_event_loc(self)
 end
 alias :pre_antilag_move_upper_right     :move_upper_right
 def move_upper_right(turn_ok = true)
   $game_map.clear_event_loc(self)
   pre_antilag_move_upper_right(turn_ok)
   $game_map.set_event_loc(self)
 end
end

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

class Spriteset_Map
 #--------------------------------------------------------------------------
 # * Create Character Sprite
 #--------------------------------------------------------------------------
 alias :pre_antilag_create_characters    :create_characters
 def create_characters
   @character_sprites = []
   for i in $game_map.events.keys.sort
     unless $game_map.events[i].ignore_sprite
       sprite = Sprite_Character.new(@viewport1, $game_map.events[i])
       @character_sprites.push(sprite)
     end
   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 Tilemap
 #--------------------------------------------------------------------------
 alias :pre_antilag_create_tilemap   :create_tilemap
 def create_tilemap
   # Normal tilemap creation
   pre_antilag_create_tilemap
   # Add the new tilemap!
   @etilemap = Tilemap.new(@viewport1)
   @etilemap.bitmaps[0] = Cache.system("TileA1")
   @etilemap.bitmaps[1] = Cache.system("TileA2")
   @etilemap.bitmaps[2] = Cache.system("TileA3")
   @etilemap.bitmaps[3] = Cache.system("TileA4")
   @etilemap.bitmaps[4] = Cache.system("TileA5")
   @etilemap.bitmaps[5] = Cache.system("TileB")
   @etilemap.bitmaps[6] = Cache.system("TileC")
   @etilemap.bitmaps[7] = Cache.system("TileD")
   @etilemap.bitmaps[8] = Cache.system("TileE")
   emap = Table.new($game_map.data.xsize, $game_map.data.ysize, 3)
   # Add only events that are not "above" character
   for event in $game_map.events.values
     if event.tile_id > 0 and event.priority_type < 2 and event.ignore_sprite
       emap[event.x, event.y, 1] = event.tile_id
     end
   end
   @etilemap.map_data = emap
   $game_map.etilemap = emap
 end
 #--------------------------------------------------------------------------
 # * Dispose of Tilemap
 #--------------------------------------------------------------------------
 alias :pre_antilag_dispose_tilemap    :dispose_tilemap
 def dispose_tilemap
   # Normal dispose
   pre_antilag_dispose_tilemap
   # Dispose of new event tilemap
   @etilemap.dispose
 end
 #--------------------------------------------------------------------------
 # * Update Tilemap
 #--------------------------------------------------------------------------
 alias :pre_antilag_update_tilemap   :update_tilemap
 def update_tilemap
   # Normal update
   pre_antilag_update_tilemap
   # Work with new event tilemap
   @etilemap.ox = $game_map.display_x / 8
   @etilemap.oy = $game_map.display_y / 8
   @etilemap.update
 end
 #--------------------------------------------------------------------------
 # * Update Character Sprite
 #--------------------------------------------------------------------------
 alias :pre_antilag_update_characters  :update_characters
 def update_characters
   for sprite in @character_sprites
     sprite.update if sprite.character.on_screen
   end
 end
end

[/SPOILER]
Instrucciones:
Creo que todo lo necesario para su uso está traducido en los comentarios del script.
Probablemente os baste con colocarlo sobre Main. Como él mismo dice, si os parece que hay lag con su anti-lag, probad a quitarlo...

Créditos:
Script creado por Anaryu.

[Killeranko 0]

¿que es lag?

[TN-69 0]

El lag es el termino que se usa para desginar al hecho de que un proceso se ralentize. Es decir el lag es aquello que te ocurre cuando estas jugando 5 juegos a la vez con los graficos a tope, y la pantalla se te ralentiza, como a camara lenta xD En RPG Maker sucede esto cuando usas demasiados eventos o hay demasiados scripts corruptos o simplemento por un mapa muuuy grande con muuuchos graficos y un ordenador patata xD. Este script reduce el lag en algunas ocasiones, pero no en el 100% de los casos.


Byeees.

[Killeranko 0]

Oye , lo e probado y no funciona, dice k le falta el rgss202E.dll, se lo pongoy me sale otro error, habro el proyecto, y dice que hay incompatibilidad.

K ago?

[xXDarkDragonXx 1]

Actualizar tu version del RPG Maker VX. =)

[Fegarur 0]

Jajaja, qué mala persona.
Bueno, la chapucilla es fácil... abre el archivo Game (el de configuración, el que se abre con el Bloc de Notas ) y cambia Library=RGSS202E.dll por Library=RGSS200E.dll.

[Greed 0]

Muy bueno a mi siempre me jode el lago y no hace anda malo tenerlo ^^ muchas gracias