Login

**Zeriab** · (This post was last modified: 02-14-2026, 05:56 AM by DerVVulfman.)

Zeriab's Anti Event Lag System
Version: 1.2

Introduction

This system changes the design used for controlling the events on the game map as well as reducing the number of character sprites outside of the visible area.
The new design for the events should in most cases give faster collision detection
In certain situations this system should be slightly slower though I doubt it can make any noticeable difference.
This script only makes event collision detection faster in the case where all the events are visible.
The greatest benefit from this script comes from large maps with sparse population of events. Basically, events do no come together loads at a time.

Version history

For anyone interested

Features

Easy to alter the size of the visible area. (In combination with resolution scripts for example)
Pattern matching on event names to ease determination of events needing special treatment. (Never update and always update)
Specify special update schemes for events by their id and the map they are on.

Screenshots

The screenshot was taking from my test map included as an attachment. There are 662 events on that 500x500 map.

Demo
Sendspace Rar link (Homepage zip version)
* Both demo links above are dead
Simple demo made by DerVVulfman: https://www.mediafire.com/file/r7pmeldr6dtyst9

Script

Zeriab's Anti Event Lag System version 1.2
Note: The comments in the script are aimed at other scripters. Don't be scared by it.

Version 1.2 now IN the post and not attached

Code:
#==============================================================================

# ** Anti Event Lag System

#------------------------------------------------------------------------------

# Zeriab

# Version 1.2b

# 2008-09-12 (Year-Month-Day)

#------------------------------------------------------------------------------

# * Requirements :

#   

#   If you have the SDK : Version 2.0+, Part I, II

#   Does not require the SDK

#------------------------------------------------------------------------------

# * Version History :

#

#   Version 0.8 -------------------------------------------------- (2007-09-03)

#    - First release

#

#   Version 0.81 ------------------------------------------------- (2007-09-05)

#    - Overwrote Game_Map's passable? method for faster collision detection

#

#   Version 0.9 -------------------------------------------------- (2007-09-12)

#    - Support for the Non-SDK patch

#    - Support for defining whether an event will always be updated or never

#      be updated by defining name patterns.

#

#   Version 1.0 -------------------------------------------------- (2007-09-24)

#   - Fixed compatibility issue with Blizzard's Caterpillar script

#   - Overwrote more methods scanning for events on a specific tile

#   - Support for defining whether an event will always be updated or never

#      be updated by specifying the event's id and map_id

#   - Some structural changes.

#   - Integrated the Non-SDK patch into the main script

#

#   Version 1.05 ------------------------------------------------- (2007-11-18)

#   - Fixed bug where sprites might not be disposed when changing scene.

#

#   Version 1.1 -------------------------------------------------- (2008-04-10)

#   - Added declaration to which common events to update

#

#   Version 1.15 ------------------------------------------------- (2008-06-19)

#   - Added automatic detection of which common events to update (optional)

#

#   Version 1.2 -------------------------------------------------- (2008-07-04)

#   - Fixed a case where an event could be registered twice causing transparent

#      events to look less transparent.

#

#   Version 1.2b ------------------------------------------------- (2008-09-12)

#   - Fixed a stack error problem caused when pressing F12.

#------------------------------------------------------------------------------

# * Description :

#

#   This script was designed to reduce lag by changing the data structure of 

#   the events in the Game_Map class and update the functionality accordingly

#   A goal of this script is not to change the normal event behavior, so

#   implementing it into a project should not effect previous events. It might

#   effect custom scripts.

#------------------------------------------------------------------------------

# * License :

#

#   Copyright (C) 2007, 2008  Zeriab

#

#   This program is free software: you can redistribute it and/or modify

#   it under the terms of the GNU Lesser Public License as published by

#   the Free Software Foundation, either version 3 of the License, or

#   (at your option) any later version.

#

#   This program is distributed in the hope that it will be useful,

#   but WITHOUT ANY WARRANTY; without even the implied warranty of

#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#   GNU Lesser Public License for more details.

#

#   For the full license see <http://www.gnu.org/licenses/> 

#   The GNU General Public License: http://www.gnu.org/licenses/gpl.txt

#   The GNU Lesser General Public License: http://www.gnu.org/licenses/lgpl.txt

#------------------------------------------------------------------------------

# * Compatibility :

#

#   This is SDK compliant. It is written for SDK version 2.3.

#   It requires SDK 2.0+ if you are using the SDK

#   The Non-SDK patch is integrated so you can run it without the SDK

#   

#   The following methods has been overwritten:

#    * Game_Character.passable?

#    * Game_Map.passable?

#    * Game_Map.update_events

#    * Game_Player.check_event_trigger_here

#    * Game_Player.check_event_trigger_there

#    * Game_Player.check_event_trigger_touch

#    * Spriteset_Map.init_characters

#    * Spriteset_Map.update_character_sprites

#

#   The following methods have been aliased

#    * Game_Event.jump

#    * Game_Event.moveto

#    * Game_Event.move_down

#    * Game_Event.move_left

#    * Game_Event.move_right

#    * Game_Event.move_up

#    * Game_Event.move_lower_left

#    * Game_Event.move_lower_right

#    * Game_Event.move_upper_left

#    * Game_Event.move_upper_right

#    * Game_Map.setup

#------------------------------------------------------------------------------

# * Instructions :

#

#   Place this script just below the SDK if you are using the SDK.

#   Place this script just below the default if using the Non-SDK Patch

#   

#   default scripts

#   (SDK)

#   Zeriab's Anti Event Lag System

#   (custom scripts)

#   main

#

#   ~ Game_Map ~

#   There are 4 constants you can change at will in the top of the

#   Game_Map class: (You don't have to ;))

#   

#   ALWAYS_UPDATE ~ The default is false

#   -------------------------------

#   You can set this to true if you want all events to be update always

#   This a slower option, but events behave like they do without the script.

#   You will still benifit from the faster collision detection and fewer sprites

#   This has higher priority than the event specific features. I.e never_update

#

#   BUFFER_SIZE ~ The default is 2

#   -------------------------

#   You can increase or decrease the buffer size by altering this value.

#   The greater this value the greater area around the visible area is updated

#   at the price of potential more lag.

#   The lower this value the smaller area around the visible area is update

#   with the potential of less lag.

#   Too low a value may get the sprites to sort of 'freeze' in the outskirts

#   of the screen.

#   Bigger sprites requires bigger buffer to prevent this.

#   

#   TILES_VERTICAL ~ The default is 15

#   -----------------------------

#   Specifies how many tiles there are vertical

#   I included the option to change this value if you want to alter

#   the size of the game window.

#   If you for example want 800x600 I suggest changing this value to 20

#

#   TILES_HORIZONTAL ~ The default is 20

#   -------------------------------

#   Specifies how many tiles there are horizontal

#   I included the option to change this value if you want to alter

#   the size of the game window.

#   If you for example want 800x600 I suggest changing this value to 27

#   

#   LIMIT_COMMON_EVENTS - The default is true

#   -----------------------------

#   You can see this to false if you want all common events updated.

#   This constant only has an effect during the upstart of the program. Changing

#   it during the game will have no effect.

#   If it is set to false you can safely ignore the following three constants

#

#   SPECIFY_COMMON_EVENTS_MANUALLY - The default is false

#   -----------------------------

#   Specifies whether you want to enter which common events should be updated

#   manually. If this is set to false you can safely ignore 

#   COMMON_EVENTS_TO_UPDATE while COMMON_EVENT_FILEPATH is of importance.

#   Vice-versa is COMMON_EVENTS_TO_UPDATE important and COMMON_EVENT_FILEPATH

#   safe to ignore if SPECIFY_COMMON_EVENTS_MANUALLY is set to true.

#   If this is set to false which common events to update will be atomatically

#   detected.

#   As a general rule of thumb: Only change this to true if you have problems

#   with the automatic detection or you want to prevent certain common events

#   with autorun or parallel process as trigger.

#

#   COMMON_EVENTS_TO_UPDATE

#   -----------------------------

#   This constant is an array of common event ids. Only the common events with

#   the ids specified in the array will be updated. The ids are the numbers

#   shown in the database with any leading 0s removed. In general only common

#   events which have autorun or parallel process needs to be updated.

#   It will have no effect if SPECIFY_COMMON_EVENTS_MANUALLY is false

#   Let's say we want the common events 005, 009 and 020 to be updated. First we

#   will remove the leading 0s and get 5, 9 and 20. Next we will put them in the

#   array and get as end result:

#

#     COMMON_EVENTS_TO_UPDATE = [5, 9, 20]

#

#   If we had put [005, 009, 020] as the array we would have gotten an error

#   when starting the game. 

#   If we now want to update common event 045 we would add 45 to the array:

#

#     COMMON_EVENTS_TO_UPDATE = [5, 9, 20, 45]

#

#

#   COMMON_EVENT_FILEPATH - The default is 'Data/CommonEvents.rxdata'

#   -----------------------------

#   Specifies the relative file path (To the directory of where the Game.exe is)

#   to where the common events are stored.

#   Only change this if you have changed the name or place of the

#   CommonEvents.rxdata file.

#   It will have no effect if SPECIFY_COMMON_EVENTS_MANUALLY is true

#

#

#   ~ Game_Event ~

#   Next we come to the Constants in Game_Event. They are given above the

#   Game_Map code. They have been split from the other Game_Event code for

#   Easier access:

#

#   SPECIAL_UPDATE_IDS

#   ------------------

#   This constant contains a hash where you can specify how specific events

#   should be updated. Special update ids has priority over name patterns.

#   The keys are all a 2-elements array. [Map_ID, Event_ID]

#   The value is either an 'A' for always update or 'N' for never update.

#   Here is an example:

#

#     SPECIAL_UPDATE_IDS = {[1,1]=>'A',

#                           [1,2]=>'N'}

#   

#   Notice the first line [1,1]=>'A'

#   It means that the event with id 1 on map 1 will always be updated.

#

#   Notice the first line [1,2]=>'N'

#   It means that the event with id 2 on map 1 will never be updated.

#   Let's say we wanted the event with id 5 on map 3 to always be updated.

#   This can be achieved by adding [5,3]=>'A' to the hash:

#

#     SPECIAL_UPDATE_IDS = {[1,1]=>'A',

#                           [1,2]=>'N',

#                           [5,3]=>'A'}

#

#

#   NEVER_UPDATE_NAME_PATTERNS

#   --------------------------

#   Here you can specify any number of patterns which will be checked when a

#   new map is loaded. Any events which matches at least one of the patterns

#   given here will never be updated.

#   A pattern is assumed to be either a String or a RegExp. In the case of a

#   String name.include?(string) is used. Otherwise the =~ operator is used

#   Note: The never_update feature has higher priority than the always_update.

#   If an event's name matches both a always update pattern and a never_update

#   pattern it will never update.

#

#   ALWAYS_UPDATE_NAME_PATTERNS

#   ---------------------------

#   Here you can specify any number of patterns which will be checked when a

#   new map is loaded. Any events which matches at least one of the patterns

#   given here will always be updated.

#   Note: The always_update feature has lower priority than the never_update.

#   If an event's name matches both a always update pattern and a never_update

#   pattern it will never update.

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

if Module.constants.include?('SDK')

  #----------------------------------------------------------------------------

  # * SDK Log Script

  #----------------------------------------------------------------------------

  SDK.log('Anti Event Lag System', 'Zeriab', 1.2, '2008-06-25')

  SDK.check_requirements(2.0)

end

#------------------------------------------------------------------------------

# * Begin SDK Enable Test

#------------------------------------------------------------------------------

if !Module.constants.include?('SDK') || SDK.enabled?('Anti Event Lag System')

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

# ** Constants for the anti lag script

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

class Game_Map

  ALWAYS_UPDATE = false

  BUFFER_SIZE = 2

  TILES_VERTICAL = 15

  TILES_HORIZONTAL = 20

  LIMIT_COMMON_EVENTS = true

  SPECIFY_COMMON_EVENTS_MANUALLY = false

  # If you want to specify which common events to update

  COMMON_EVENTS_TO_UPDATE = []

  # If you want the script to automatically read the common events and find

  # out which to update. Must be the path to the CommonEvents.rxdata

  COMMON_EVENT_FILEPATH = 'Data/CommonEvents.rxdata'

end

class Game_Event

  SPECIAL_UPDATE_IDS = {}

  NEVER_UPDATE_NAME_PATTERNS = ['[N]'] # [N] in the event name => not updated

  ALWAYS_UPDATE_NAME_PATTERNS = ['[A]'] # [A] in the event name => always updated 

end

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

# ** Automatic configuration generation

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

class Game_Map

  if LIMIT_COMMON_EVENTS && !SPECIFY_COMMON_EVENTS_MANUALLY

    # Find the common events which needs to be updated

    COMMON_EVENTS_TO_UPDATE = []

    # Load the common events

    common_events = load_data(COMMON_EVENT_FILEPATH)

    # Go through the common events

    for common_event in common_events.compact

      # Check if there is a need for the common event to update

      if common_event.trigger > 0

        # C

        COMMON_EVENTS_TO_UPDATE << common_event.id

      end

    end

  end

end

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

# ** Game_Map

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

class Game_Map

  #--------------------------------------------------------------------------

  # * Public Instance Variables

  #--------------------------------------------------------------------------

  attr_reader :event_map

  #--------------------------------------------------------------------------

  # * Alias Listings

  #--------------------------------------------------------------------------

  alias_method :zeriab_antilag_gmmap_setup,   :setup

  #--------------------------------------------------------------------------

  # * Setup

  #--------------------------------------------------------------------------

  def setup(*args)

    # Makes an event map as a hash

    @event_map = {}

    # Original Setup

    zeriab_antilag_gmmap_setup(*args)

    # Go through each event

    for event in @events.values

      # Check how the event should be updated

      event.check_update

    end

  end

  #--------------------------------------------------------------------------

  # * Update Events ~ Overwritten to only updating visible and special events

  #--------------------------------------------------------------------------

  def update_events

    # Runs through the events

    for event in @events.values

      # checks if the event is visible or needs to be updated

      if ALWAYS_UPDATE || event.need_update?

        event.update

      end

    end

  end

  # Only overwrite this method if common events should be limited

  if LIMIT_COMMON_EVENTS

    #--------------------------------------------------------------------------

    # * Update Common Events ~ Updates only the necessary common events

    #--------------------------------------------------------------------------

    def update_common_events

      for i in COMMON_EVENTS_TO_UPDATE

        @common_events[i].update

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Called when an event has been moved with it's old x and y coordinate

  #   Used to update its position in the event_map

  #--------------------------------------------------------------------------

  def move_event(old_x,old_y,event)

    # Checks if the event has moved to a new position.

    return if old_x == event.x && old_y == event.y

    # Removes the event from its old position

    remove_event(old_x, old_y, event)

    # Adds the event to its new position

    add_event(event.x,event.y,event)

    # Gets the spriteset from Scene_Map

    spriteset = $scene.instance_eval('@spriteset')

    # Checks that it actually is a Spriteset_Map.

    if spriteset.is_a?(Spriteset_Map) && spriteset.respond_to?(:update_event)

      # Tells the spriteset to update the event to its new position

      spriteset.update_event(old_x,old_y,event)

    end

  end

  #--------------------------------------------------------------------------

  # * Adds an event to the event_map at the given x and y coordinate

  #--------------------------------------------------------------------------

  def add_event(x,y,event)

    # Checks if there are not any events on the specific tile

    if @event_map[[x,y]].nil?

      # Sets the position on the map to be an array containing the given

      # event. (In case there are placed additional events on this tile)

      @event_map[[x,y]] = [event]

    else

      # Adds the event to the array of events on the specific tile

      @event_map[[x,y]] << event

    end

  end

  #--------------------------------------------------------------------------

  # * Removes an event from the event_map with the given x and y coordinate

  #--------------------------------------------------------------------------

  def remove_event(x,y,event)

    # Checks if there actually are an event on the given coordinates

    return if @event_map[[x,y]].nil?

    # Checks whether or not there are more events than the given event on

    # with the given coordinates

    if @event_map[[x,y]].size > 1

      # Deletes the events from the array of events

      @event_map[[x,y]].delete(event)

    else

      # Deletes the key along with the corresponding value from the hashmap

      # since there are no other events on the tile.

      @event_map.delete([x,y])

    end

  end

  #--------------------------------------------------------------------------

  # * Gets min_x, max_x, min_y and max_y including the buffer-size

  # Returns min_x, max_x, min_y, max_y  (tile-coordinates)

  # Returns a Rect if 'true' is given as the argument

  #--------------------------------------------------------------------------  

  def get_tile_area(rect = false)

    # Gets the upper left x and y tile-coordinate

    x = $game_map.display_x / 128

    y = $game_map.display_y / 128

    # Computes the min and max coordinates when considering the buffer-size

    min_x = x - BUFFER_SIZE

    min_y = y - BUFFER_SIZE

    max_x = x + TILES_HORIZONTAL + BUFFER_SIZE

    max_y = y + TILES_VERTICAL + BUFFER_SIZE

    # Makes sure the min and max coordinates are within the map

    if min_x < 0

      min_x = 0

    end

    if max_x >= $game_map.width

      max_x = $game_map.width - 1

    end

    if min_y < 0

      min_y = 0

    end

    if max_y >= $game_map.height

      max_y = $game_map.height - 1

    end

    # Checks if the return should be a Rect

    if rect

      # Returns the result as a Rect

      return Rect.new(min_x, min_y, max_x - min_x, max_y - min_y)

    else

      # Returns the result as the min and max coordinates

      return min_x, max_x, min_y, max_y

    end

  end

  #--------------------------------------------------------------------------

  # * Checks if the tile with the given x and y coordinate is visible.

  #   Takes the buffer size into account.

  #--------------------------------------------------------------------------

  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

  #--------------------------------------------------------------------------

  # * Get Designated Position Event ID

  #     x          : x-coordinate

  #     y          : y-coordinate

  #--------------------------------------------------------------------------

  def check_event(x, y)

    # Retrives the events on the specified tile

    events = event_map[[x,y]]

    unless events.nil?

      # Loop through events on tile

      for event in events

        if event.x == x and event.y == y

          return event.id

        end

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Determine if Passable

  #     x          : x-coordinate

  #     y          : y-coordinate

  #     d          : direction (0,2,4,6,8,10)

  #                  *  0,10 = determine if all directions are impassable

  #     self_event : Self (If event is determined passable)

  #--------------------------------------------------------------------------

  def passable?(x, y, d, self_event = nil)

    # If coordinates given are outside of the map

    unless valid?(x, y)

      # impassable

      return false

    end

    # Change direction (0,2,4,6,8,10) to obstacle bit (0,1,2,4,8,0)

    bit = (1 << (d / 2 - 1)) & 0x0f

    # Retrives the events on the specified tile

    events = event_map[[x,y]]

    unless events.nil?

      # Loop through events on tile

      for event in events

        # If tiles other than self are consistent with coordinates

        if event.tile_id >= 0 and event != self_event and not event.through

          # If obstacle bit is set

          if @passages[event.tile_id] & bit != 0

            # impassable

            return false

          # If obstacle bit is set in all directions

          elsif @passages[event.tile_id] & 0x0f == 0x0f

            # impassable

            return false

          # If priorities other than that are 0

          elsif @priorities[event.tile_id] == 0

            # passable

            return true

          end

        end

      end

    end

    # Loop searches in order from top of layer

    for i in [2, 1, 0]

      # Get tile ID

      tile_id = data[x, y, i]

      # Tile ID acquistion failure

      if tile_id == nil

        # impassable

        return false

      # If obstacle bit is set

      elsif @passages[tile_id] & bit != 0

        # impassable

        return false

      # If obstacle bit is set in all directions

      elsif @passages[tile_id] & 0x0f == 0x0f

        # impassable

        return false

      # If priorities other than that are 0

      elsif @priorities[tile_id] == 0

        # passable

        return true

      end

    end

    # passable

    return true

  end

end

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

# ** Game_Character

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

class Game_Character

  #--------------------------------------------------------------------------

  # * Determine if Passable (Overwrite)

  #     x : x-coordinate

  #     y : y-coordinate

  #     d : direction (0,2,4,6,8)

  #         * 0 = Determines if all directions are impassable (for jumping)

  #--------------------------------------------------------------------------

  def passable?(x, y, d)

    # Get new coordinates

    new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)

    new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)

    # If coordinates are outside of map

    unless $game_map.valid?(new_x, new_y)

      # impassable

      return false

    end

    # If through is ON

    if @through

      # passable

      return true

    end

    # If unable to leave first move tile in designated direction

    unless $game_map.passable?(x, y, d, self)

      # impassable

      return false

    end

    # If unable to enter move tile in designated direction

    unless $game_map.passable?(new_x, new_y, 10 - d)

      # impassable

      return false

    end

    # If player coordinates are consistent with move destination

    if $game_player.x == new_x and $game_player.y == new_y

      # If through is OFF

      unless $game_player.through

        # If your own graphic is the character

        if @character_name != ""

          # impassable

          return false

        end

      end

    end

    # Checks for events on the new position

    events = $game_map.event_map[[new_x,new_y]]

    if events.nil?

      # passable

      return true

    end

    # Loop all events on the tile

    for event in events

      # If event coordinates are consistent with move destination

      if event.x == new_x and event.y == new_y

        # If through is OFF

        unless event.through

          # If self is event

          if self != $game_player

            # impassable

            return false

          end

          # With self as the player and partner graphic as character

          if event.character_name != ""

            # impassable

            return false

          end

        end

      end

    end

    # passable

    return true

  end

end

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

# ** Game_Event

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

class Game_Event

  # The method to alias and overwrite

  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

    # Aliases the old method

    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)

    # Overwrites the old 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

    # Evaluates the method definition

    eval(PROG)

  end

  #--------------------------------------------------------------------------

  # * Always_update property (is false by default) priority under never_update

  #--------------------------------------------------------------------------

  attr_writer :always_update

  def always_update

    @always_update = false  if @always_update.nil?

    return @always_update

  end

  #--------------------------------------------------------------------------

  # * Never_update property (is false by default) priority over always_update

  #--------------------------------------------------------------------------

  attr_writer :never_update

  def never_update

    @never_update = false  if @never_update.nil?

    return @never_update

  end

  #--------------------------------------------------------------------------

  # * Need Update method. Fast checks here.

  #--------------------------------------------------------------------------

  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

  #--------------------------------------------------------------------------

  # * Checks how the event should be updated.

  #--------------------------------------------------------------------------

  def check_update

    name = @event.name

    # Checks if the event is never to be updated. (For decoration)

    for pattern in NEVER_UPDATE_NAME_PATTERNS

      if (pattern.is_a?(String) && name.include?(pattern)) ||

        !(pattern =~ name).nil? 

        self.never_update = true

      end

    end

    # Checks if the event is to be always updated.

    for pattern in ALWAYS_UPDATE_NAME_PATTERNS

      if (pattern.is_a?(String) && name.include?(pattern)) ||

        !(pattern =~ name).nil? 

        self.always_update = true

      end

    end

    # Checks for special update for the particular id (overrules the patterns)

    special_update = SPECIAL_UPDATE_IDS[[@map_id,@id]]

    unless special_update.nil?

      # Checks if it never should be updated

      if special_update.downcase == 'n'

        self.never_update = true

        self.always_update = false

      # Checks if it always should be updated

      elsif special_update.downcase == 'a'

        self.always_update = true

        self.never_update = false

      end

    end

  end

end

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

# ** Game_Event

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

class Game_Player

  #--------------------------------------------------------------------------

  # * Same Position Starting Determinant

  #--------------------------------------------------------------------------

  def check_event_trigger_here(triggers)

    result = false

    # If event is running

    if $game_system.map_interpreter.running?

      return result

    end

    # Retrives the events on the specified tile

    events = $game_map.event_map[[@x,@y]]

    unless events.nil?

      # Loop through events on tile

      for event in events

        # If event triggers are consistent

        if triggers.include?(event.trigger)

          # If starting determinant is same position event (other than jumping)

          if not event.jumping? and event.over_trigger?

            event.start

            result = true

          end

        end

      end

    end

    return result

  end

  #--------------------------------------------------------------------------

  # * Front Event Starting Determinant

  #--------------------------------------------------------------------------

  def check_event_trigger_there(triggers)

    result = false

    # If event is running

    if $game_system.map_interpreter.running?

      return result

    end

    # Calculate front event coordinates

    new_x = @x + (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)

    new_y = @y + (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)

    # Retrives the events on the specified tile

    events = $game_map.event_map[[new_x,new_y]]

    unless events.nil?

      # Loop through events on tile

      for event in events

        # If event triggers are consistent

        if triggers.include?(event.trigger)

          # If starting determinant is front event (other than jumping)

          if not event.jumping? and not event.over_trigger?

            event.start

            result = true

          end

        end

      end

    end

    # If fitting event is not found

    if result == false

      # If front tile is a counter

      if $game_map.counter?(new_x, new_y)

        # Calculate 1 tile inside coordinates

        new_x += (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)

        new_y += (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)

        # Retrives the events on the specified tile

        events = $game_map.event_map[[new_x,new_y]]

        unless events.nil?

          # Loop through events on tile

          for event in events

            # If event triggers are consistent

            if triggers.include?(event.trigger)

              # If starting determinant is front event (other than jumping)

              if not event.jumping? and not event.over_trigger?

                event.start

                result = true

              end

            end

          end

        end

      end

    end

    return result

  end

  #--------------------------------------------------------------------------

  # * Touch Event Starting Determinant

  #--------------------------------------------------------------------------

  def check_event_trigger_touch(x, y)

    result = false

    # If event is running

    if $game_system.map_interpreter.running?

      return result

    end

    # Retrives the events on the specified tile

    events = $game_map.event_map[[x,y]]

    unless events.nil?

      # Loop through events on tile

      for event in events

        # If event coordinates and triggers are consistent

        if [1,2].include?(event.trigger)

          # If starting determinant is front event (other than jumping)

          if not event.jumping? and not event.over_trigger?

            event.start

            result = true

          end

        end

      end

    end

    return result

  end

end

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

# ** Spriteset_Map

#------------------------------------------------------------------------------

# Overwrites init_characters and update_character_sprites

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

class Spriteset_Map

  #--------------------------------------------------------------------------

  # * Initializes Character Sprites (Overwrite)

  #--------------------------------------------------------------------------

  def init_characters

    # Creates the array used for holding the hero sprite.

    # Is here for compatibility reasons.

    @character_sprites = []

    # Refreshes the characters in the spritemap

    refresh_characters

    # Refreshes the character sprites

    refresh_character_sprites

  end

  #--------------------------------------------------------------------------

  # * Refreshes the characters.

  #--------------------------------------------------------------------------

  def refresh_characters

    # Make character sprites

    @character_event_sprites = []

    @character_spritemap = {}

    # Gets the tile area to search for events

    min_x, max_x, min_y, max_y = $game_map.get_tile_area

    # Goes through all the visible tiles and adds the sprites on those tiles

    for x in min_x..max_x

      for y in min_y..max_y

        add_sprites(x,y)

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Refreshes the character sprites.

  #--------------------------------------------------------------------------

  def refresh_character_sprites

    # Gets the character sprites

    @character_event_sprites = @character_spritemap.values.flatten

    #### Note: I do not think character sprites have to be sorted, but here it

    ####       is if you for some reason need them sorted.

    #@character_event_sprites.sort! {|a,b| a.character.id <=> b.character.id}

    # Updates the last screen x and y to the current x and y

    @last_screen_x = $game_map.display_x / 128

    @last_screen_y = $game_map.display_y / 128

    # The sprites have just been refresh, no need to do this every frame.

    @need_refresh = false

  end

  #--------------------------------------------------------------------------

  # * Updates Character Sprites

  #--------------------------------------------------------------------------

  def update_character_sprites

    # Checks if the player has moved

    unless @last_screen_x == $game_map.display_x / 128 &&

           @last_screen_y == $game_map.display_y / 128

      # Gets the difference in the x and y coordinate

      diff_x = @last_screen_x - $game_map.display_x / 128

      diff_y = @last_screen_y - $game_map.display_y / 128

      # Checks if the player has moved more than one tile. (Supports 8-way)

      if diff_x.abs > 1 || diff_y.abs > 1

        # The player has moved more than one tile.

        # This section could be extended if some of the previous visible area

        # still is visible and only update the the the new areas as well as

        # the parts of the old area that is now out of side.

        # For ease and because this should be a rare situation I have decided

        # to simple remove all sprites and start over for the new area.

        @character_event_sprites.each {|sprite| sprite.dispose}

        # Initialized the sprites for the new area

        init_characters

      else

        # Updates the buffer

        update_buffer(diff_x, diff_y)

      end

      # Refresh the character sprites. (To which should be updated)

      refresh_character_sprites

    else

      # Refreshed the character sprites if it is needed

      refresh_character_sprites if @need_refresh

    end

    # Updates the sprites.

    @character_event_sprites.each {|sprite| sprite.update}

    # Updates the hero sprite. Is here to increase compatibility with other

    # scripts using this array. Most caterpillar scripts for example

    @character_sprites.each {|sprite| sprite.update}

  end

  #--------------------------------------------------------------------------

  # * Updates Character Sprites

  #--------------------------------------------------------------------------

  def update_buffer(diff_x, diff_y)

    # Gets the tile area to search for events

    min_x, max_x, min_y, max_y = $game_map.get_tile_area

    # For change in x-coordinate

    if diff_x > 0 # Left

      # Removes any sprites outside of the buffer

      unless max_x >= $game_map.width - 1

        for y in min_y..max_y

          dispose_sprites(max_x+1, y)  

        end

      end

      # Adds any new sprites comming into the buffer

      for y in min_y..max_y

        add_sprites(min_x, y)  if @character_spritemap[[min_x,y]].nil?

      end

    elsif diff_x < 0 # Right

      # Removes any sprites outside of the buffer

      unless min_x <= 0

        for y in min_y..max_y

          dispose_sprites(min_x-1, y)  

        end

      end

      # Adds any new sprites comming into the buffer

      for y in min_y..max_y

        add_sprites(max_x, y)  if @character_spritemap[[max_x,y]].nil?

      end

    end

    # For change in y-coordinates

    if diff_y > 0 # Up

      # Removes any sprites outside of the buffer

      unless max_y >= $game_map.height - 1

        for x in min_x..max_x

          dispose_sprites(x, max_y+1)  

        end

      end

      # Adds any new sprites comming into the buffer

      for x in min_x..max_x

        add_sprites(x, min_y)  if @character_spritemap[[x,min_y]].nil?

      end

    elsif diff_y < 0 # Down

      # Removes any sprites outside of the buffer

      unless min_y <= 0

        for x in min_x..max_x

          dispose_sprites(x, min_y-1)  

        end

      end

      # Adds any new sprites comming into the buffer

      for x in min_x..max_x

        add_sprites(x, max_y)  if @character_spritemap[[x,max_y]].nil?

      end

    end

  end

  #--------------------------------------------------------------------------

  # * Called when an event has moved

  #--------------------------------------------------------------------------

  def update_event(old_x,old_y,event)

    # Finds the sprites on the event's old position

    sprites = @character_spritemap[[old_x,old_y]]

    # Checks if there are any sprites on the event's old position

    unless sprites.nil?

      # Goes through the sprites to find which one is attached to the given

      # event. Sprite is nil if no sprite on the event's old position is 

      # attached to the given event.

      sprite = nil

      for sprite in sprites

        break if sprite.character == event

      end

    end

    # If there is not a sprite attached to the event

    if sprite.nil?

      # Checks if the event has become visible

      if $game_map.visible?(event.x, event.y)

        # A sprite is create because the event is now visible

        sprite = Sprite_Character.new(@viewport1, event)

        # The sprite is added at the event's current position

        add_sprite(event.x,event.y,sprite)

        # We need to refresh the character sprites since we added one.

        @need_refresh = true

      end

    else # A sprite is attached to the event

      # Checks if the event is still visible

      if $game_map.visible?(event.x, event.y)

        # The event is still visible and moved from its old coordinate

        # to its new coordinates.

        move_event(old_x, old_y, sprite)

      else

        # The sprite is not visible anymore and thus removed

        remove_sprite(old_x,old_y,sprite)

        # The sprite is disposed since we don't want to wait for Ruby's

        # garbage cleaner to remove the sprite from view. (For big sprites)

        sprite.dispose

        # We need to refresh the character sprites since we removed one.

        @need_refresh = true

      end

    end

  end

  ##

  ## Macros

  ##

  #--------------------------------------------------------------------------

  # * Creates and adds sprites for all the events with the given x and y 

  #   coordinates to the spritemap.

  #--------------------------------------------------------------------------

  def add_sprites(x,y)

    # Returns if there are no events with the given x and y coordinates

    return if $game_map.event_map[[x,y]].nil?

    for event in $game_map.event_map[[x,y]]

      # Creates a sprite for the event

      sprite = Sprite_Character.new(@viewport1, event)

      # Adds the sprite to the spritemap

      add_sprite(x,y,sprite)

    end

  end

  #--------------------------------------------------------------------------

  # * Disposes all the sprites on given x,y tile

  #--------------------------------------------------------------------------

  def dispose_sprites(x,y)

    # Returns if there are no sprites with the given coordinates

    return if @character_spritemap[[x,y]].nil?

    for sprite in @character_spritemap[[x,y]]

      # Removes the sprite from the datastructure

      remove_sprite(x,y,sprite)

      # Disposes the sprite

      sprite.dispose unless sprite.dispose

    end

  end

  #--------------------------------------------------------------------------

  # * Moves the sprite from its old coordinates to its new coordinates

  #--------------------------------------------------------------------------

  def move_event(old_x,old_y,sprite)

    # Gets the event attached to the character

    event = sprite.character

    # Returns if the sprite have not change position

    return if old_x == event.x && old_y == event.y

    # Removes the sprite from its old location

    remove_sprite(old_x, old_y, sprite)

    # Adds the sprite to the new location

    add_sprite(event.x, event.y, sprite)

  end

  ##

  ## Low level methods, alters the datastructure directly

  ##

  #--------------------------------------------------------------------------

  # * Adds the given sprite to the given x and y coordinate to

  #   @character_spritemap.

  #--------------------------------------------------------------------------

  def add_sprite(x,y,sprite)

    # Checks if there a not any sprite on the given tile already

    if @character_spritemap[[x,y]].nil?

      # Adds the sprite to the spriteset as an array containing the sprite

      @character_spritemap[[x,y]] = [sprite]

    else

      # Adds the sprite to the array of sprites with the same x and y

      # coordinates.

      @character_spritemap[[x,y]] << sprite

    end

  end

  #--------------------------------------------------------------------------

  # * Removes the given sprite with the given x and y coordinate from

  #   @character_spritemap.

  #--------------------------------------------------------------------------

  def remove_sprite(x,y,sprite)

    # Returns if there are no sprites with the given x and y coordinate

    return  unless !@character_spritemap[[x,y]].nil? &&

                   @character_spritemap[[x,y]].include?(sprite)

    # Checks if there are more sprites with the same coordinates

    if @character_spritemap[[x,y]].size > 1

      # Removes the sprite from the array of sprites with the given coordinates

      @character_spritemap[[x,y]].delete(sprite)

    else

      # Deletes the key attached to the array since there are no sprites left.

      @character_spritemap.delete([x,y])

    end

  end

end

#------------------------------------------------------------------------------

# * End SDK Enable Test

#------------------------------------------------------------------------------

end

unless Module.constants.include?('SDK')

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

  # * Compatibility :

  #

  #   This will probably not be compatible with scripts extending or modifying

  #   the overwritten methods. 

  #   

  #   The following methods has been overwritten:

  #    * Game_Map.update

  #    * Spriteset_Map.initialize

  #    * Spriteset_Map.update

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

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

  # ** Game_Map

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

  class Game_Map

    #--------------------------------------------------------------------------

    # * Update Common Events

    #--------------------------------------------------------------------------

    def update_common_events

      for common_event in @common_events.values

        common_event.update

      end

    end

    #------------------------------------------------------------------------

    # * Frame Update Overwrite

    #------------------------------------------------------------------------

    def update

      # Refresh map if necessary

      if $game_map.need_refresh

        refresh

      end

      # If scrolling

      if @scroll_rest > 0

        # Change from scroll speed to distance in map coordinates

        distance = 2 ** @scroll_speed

        # Execute scrolling

        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

        # Subtract distance scrolled

        @scroll_rest -= distance

      end

      # Update map event

      update_events

      # Update common event

      update_common_events

      # Manage fog scrolling

      @fog_ox -= @fog_sx / 8.0

      @fog_oy -= @fog_sy / 8.0

      # Manage change in fog color tone

      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

      # Manage change in fog opacity level

      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

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

  # ** Spriteset_Map

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

  class Spriteset_Map

    #------------------------------------------------------------------------

    # * Object Initialization Overwrite

    #------------------------------------------------------------------------

    def initialize

      # Make viewports

      @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

      # Make tilemap

      @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

      # Make panorama plane

      @panorama = Plane.new(@viewport1)

      @panorama.z = -1000

      # Make fog plane

      @fog = Plane.new(@viewport1)

      @fog.z = 3000

      # Make character sprites

      init_characters

      # Make hero sprite

      @character_sprites.push(Sprite_Character.new(@viewport1, $game_player))

      # Make weather

      @weather = RPG::Weather.new(@viewport1)

      # Make picture sprites

      @picture_sprites = []

      for i in 1..50

        @picture_sprites.push(Sprite_Picture.new(@viewport2,

          $game_screen.pictures[i]))

      end

      # Make timer sprite

      @timer_sprite = Sprite_Timer.new

      # Frame update

      update

    end

      #--------------------------------------------------------------------------

      # * Dispose

      #--------------------------------------------------------------------------

      def dispose

        # Dispose of tilemap

        @tilemap.tileset.dispose

        for i in 0..6

          @tilemap.autotiles[i].dispose

        end

        @tilemap.dispose

        # Dispose of panorama plane

        @panorama.dispose

        # Dispose of fog plane

        @fog.dispose

        # Dispose of weather

        @weather.dispose

        # Dispose of picture sprites

        for sprite in @picture_sprites

          sprite.dispose

        end

        # Dispose of character sprites

        for sprite in @character_event_sprites

          sprite.dispose unless sprite.disposed?

        end

        # Dispose of timer sprite

        @timer_sprite.dispose

        # Dispose of viewports

        @viewport1.dispose

        @viewport2.dispose

        @viewport3.dispose

      end

    #------------------------------------------------------------------------

    # * Frame Update Overwrite

    #------------------------------------------------------------------------

    def update

      # If panorama is different from current one

      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 is different than current fog

      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

      # Update tilemap

      @tilemap.ox = $game_map.display_x / 4

      @tilemap.oy = $game_map.display_y / 4

      @tilemap.update

      # Update panorama plane

      @panorama.ox = $game_map.display_x / 8

      @panorama.oy = $game_map.display_y / 8

      # Update fog plane

      @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

      update_character_sprites

      # Update weather graphic

      @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

      # Update picture sprites

      for sprite in @picture_sprites

        sprite.update

      end

      # Update timer sprite

      @timer_sprite.update

      # Set screen color tone and shake position

      @viewport1.tone = $game_screen.tone

      @viewport1.ox = $game_screen.shake

      # Set screen flash color

      @viewport3.color = $game_screen.flash_color

      # Update viewports

      @viewport1.update

      @viewport3.update

    end

  end

end

Installation

You don't have to do more than copy and paste the script into the script editor BUT where you paste it matters.
If you are using the SDK 2.0+ paste the script just below the SDK.
If you are are not using the SDK then paste the script just below the default scripts

The structure in the script editor should be like this:
default scripts
(SDK)
Zeriab's Anti Event Lag System
(custom scripts)
main

Pasting the script just above main has caused errors!

You can add [A] to the name of an event if you want it always updated. A typical example is that you want an event outside of the screen to move around properly.
You can add [N] to the name of an event and it will never be updated. Great for non-animated decoration events.
Note that if you have both [A] and [N] in the name of the event the event will never be updated.

If you are not satisfied with the default settings or are curious you can look into the customization possibilities

Customization

Q&A's

How can I make sure that an event outside of the screen moves like I told it to?
Change the name of the event so it always updates.
With the default configurations you can do this by adding [A] anywhere in the name.

Compatibility

Technical Details

Rataime's Sun Effect

Near Fantastica's Particle Engine v2

Credits and Thanks

Thanks goes to Enterbrain for making this possible.
Special thanks to Blizzard for many suggestions, help and support :3
Special thanks to:
Eilei
Shadow Wolf
Untravaersil
darksora

I would like to thank everyone using their time to try and use my system.
I would like to thank everyone reading this topic.
Thanks.

Terms and Conditions

Author's Notes

I would be delighted if you report any bug, errors or issues you find.
In fact I would be delighted if you took the time and replied even if you have nothing to report.
Suggestions are more than welcome

And finally: ENJOY!

- Zeriab

**explocion200** · 12-11-2009, 12:53 AM

it gives me an error

never mind i got it to work thanks :)

***DerVVulfman*** · 02-08-2026, 05:23 PM

EMERGENCY EDIT TO MAIN PAGE

Zeriab's sendspace and homepage links no longer exist for the demo and his original script post.

However, I was able to acquire the script and have it uploaded as an attached text file.

***DerVVulfman*** · 02-14-2026, 05:57 AM

SECONDARY EDIT TO MAIN PAGE

The prior attached script contained an error. I resorted to another copy of version 1.2 which worked fine.

Also, I created a DEMO to show it functioning.

Login
Username:
Password:	Lost Password?
	Remember me

Possibly Related Threads…
Thread		Author	Replies	Views	Last Post
	Cameron's Anti-Lag	DerVVulfman	1	85	02-22-2026, 04:32 PM Last Post: DerVVulfman
	Zeriab's Caterpillar Script	Zeriab	2	7,318	02-14-2026, 05:58 AM Last Post: DerVVulfman
	The Wanderers: The Customizable Encounters System	DerVVulfman	0	3,104	08-24-2024, 07:12 PM Last Post: DerVVulfman
	Super Simple Vehicle System - Enhanced	DerVVulfman	65	141,057	06-02-2023, 06:16 PM Last Post: Sujabes467
	Zenith Tactical Battle System Plus (ZTBS+)	DerVVulfman	0	6,121	05-10-2022, 10:42 PM Last Post: DerVVulfman
	Commercial System Package	DerVVulfman	11	24,476	01-04-2020, 12:37 AM Last Post: Pelip
	ACBS - Atoa Custom Battle System 3.2	Victor Sant	150	357,929	03-02-2019, 04:47 AM Last Post: dragonprincess44
	DerVV's Simple Popup System	DerVVulfman	4	17,664	10-08-2017, 04:53 PM Last Post: DerVVulfman
	Melly-Mel's Calendar System	DerVVulfman	23	61,743	12-02-2016, 04:31 AM Last Post: DerVVulfman
	The Magey Mage's Spellbook System	DerVVulfman	3	14,379	10-31-2016, 01:45 AM Last Post: Noctis