Anti Lag Zeriab Script

    jiraya
    jiraya
    Administrador
    Administrador

    Mensagens : 1299
    Credibilidade : 54

    Anti Lag Zeriab Script Empty Anti Lag Zeriab Script

    Mensagem por jiraya em Sab Abr 28, 2012 6:10 pm

    Anti Lag Zeriab Script

    Spoiler:
    Código:
    #==============================================================================
    # * 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)
    #  - lammer 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)
    #  - lammer 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)
    #  - lammer a case where an event could be registered twice causing transparent
    #      events to look less transparent.
    #
    #  Version 1.2b ------------------------------------------------- (2008-09-12)
    #  - lammer 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
    tecao98
    tecao98
    Membro Experiente
    Membro Experiente

    Mensagens : 146
    Credibilidade : 17

    Anti Lag Zeriab Script Empty Re: Anti Lag Zeriab Script

    Mensagem por tecao98 em Dom Abr 29, 2012 8:25 am

    Aqui no meu rpg não da lag mais eu espero que este seja melhor que alguns que não ajuda em nada...
    Vai servir para muitas pessoas este script!

      Data/hora atual: Dom Ago 18, 2019 8:22 am