¡Bienvenido a Universo Maker!
¿Es esta la primera vez que visitas el foro? Si es así te recomendamos que te registres para tener completo acceso a todas las áreas y secciones del foro, así también podrás participar activamente en la comunidad. Si ya tienes una cuenta, conectate cuanto antes.
Iniciar Sesión Registrarme

No estás conectado. Conéctate o registrate

Ver el tema anterior Ver el tema siguiente Ir abajo Mensaje [Página 1 de 1.]

#1 [rpg maker vx] AS: AntiLag el Sáb Sep 08, 2012 1:50 pm

davidaikago

avatar
Script que sirve para quitar el lag, especial si tenemos muchos eventos o muchos mapas
Se recomienda este nombre: AS: AntiLag

Intrucciones:
Colocar encima de main solamente.

Compatibilidad:
Es compatible con rpg maker vx y otros scripts.

Script:

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

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

    ALLOW_SCREEN_IGNORE = true

    #==============================================================================
    # ** Game_Map
    #------------------------------------------------------------------------------
    #  This class handles maps. It includes scrolling and passage determination
    # functions. The instance of this class is referenced by $game_map.
    #==============================================================================

    class Game_Map
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_reader  :pmap
      attr_reader  :emap
      attr_accessor :etilemap
      #--------------------------------------------------------------------------
      # * Object Initialization
      #--------------------------------------------------------------------------
      alias :pre_antilag_setup    :setup
      def setup(map_id)
        # Run normal initialize
        pre_antilag_setup(map_id)
        # Add events to map
        @emap = {}
        for event in @events.values
          if not event.ignore_location
            loc = event.x.to_s + "_" + event.y.to_s
            @emap[loc] = [] if @emap[loc] == nil
            @emap[loc].push(event.id)
          end
        end
        # Create the passability map
        @pmap = Table.new($game_map.width, $game_map.height)
        for i in 0...$game_map.width
          for j in 0...$game_map.height
            passable?(i,j) ? pass = 1 : pass = 0
            @pmap[i,j] = pass
          end
        end
      end
      #--------------------------------------------------------------------------
      # * Clear Event location
      #--------------------------------------------------------------------------
      def clear_event_loc(event)
        # Add the event into the @emap hash
        loc = event.x.to_s + "_" + event.y.to_s
        if @emap[loc] != nil
          @emap[loc].delete(event.id)
          # Clean up after ourselves
          @emap.delete(loc) if @emap[loc].empty?
        end
      end
      #--------------------------------------------------------------------------
      # * Set Event location
      #--------------------------------------------------------------------------
      def set_event_loc(event)
        # Add the event into the @emap hash
        loc = event.x.to_s + "_" + event.y.to_s
        @emap[loc] = [] if @emap[loc] == nil
        @emap[loc].push(event.id)
      end
      #--------------------------------------------------------------------------
      # * Get array of event at designated coordinates
      #    x : x-coordinate
      #    y : y-coordinate
      #--------------------------------------------------------------------------
      alias :pre_antilag_events_xy  :events_xy
      def events_xy(x, y)
        # Grab the events from the hash
        loc = x.to_s + "_" + y.to_s
        event_ids = @emap[loc]
        # Use the IDs to build an array of events
        events = []
        if event_ids != nil
          for id in event_ids
            if id == 0
              events.push($game_player)
            else
              events.push(@events[id])
            end
          end
        end
        # Return this array for the passability to use
        return events
      end
      #--------------------------------------------------------------------------
      # * Determine if Passable
      #    x    : x coordinate
      #    y    : y coordinate
      #    flag : The impassable bit to be looked up
      #            (normally 0x01, only changed for vehicles)
      #--------------------------------------------------------------------------
      alias :pre_antilag_passable?    :passable?
      def passable?(x, y, flag = 0x01)
        for event in events_xy(x, y)            # events with matching coordinates
          next if event.tile_id == 0            # graphics are not tiled
          next if event.priority_type > 0      # not [Below characters]
          next if event.through                # pass-through state
          pass = @passages[event.tile_id]      # get passable attribute
          next if pass & 0x10 == 0x10          # *: Does not affect passage
          return true if pass & flag == 0x00    # o: Passable
          return false if pass & flag == flag  # x: Impassable
        end
        for i in [2, 1, 0]                      # in order from on top of layer
          tile_id = @map.data[x, y, i]          # get tile ID
          return false if tile_id == nil        # failed to get tile: Impassable
          pass = @passages[tile_id]            # get passable attribute
          next if pass & 0x10 == 0x10          # *: Does not affect passage
          return true if pass & flag == 0x00    # o: Passable
          return false if pass & flag == flag  # x: Impassable
        end
        if @etilemap != nil
          for i in [2, 1, 0]                      # in order from on top of layer
            tile_id = @etilemap[x, y, i]          # get tile ID
            return false if tile_id == nil        # failed to get tile: Impassable
            pass = @passages[tile_id]            # get passable attribute
            next if pass & 0x10 == 0x10          # *: Does not affect passage
            return true if pass & flag == 0x00    # o: Passable
            return false if pass & flag == flag  # x: Impassable
          end
        end
        return false                            # Impassable
      end
    end

    #==============================================================================
    # ** Game_Character
    #------------------------------------------------------------------------------
    #  This class deals with characters. It's used as a superclass of the
    # Game_Player and Game_Event classes.
    #==============================================================================

    class Game_Character
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_reader  :ignore_update
      attr_reader  :ignore_sprite
      attr_reader  :ignore_location
      attr_reader  :force_update
      #--------------------------------------------------------------------------
      # * Object Initialization
      #--------------------------------------------------------------------------
      alias :pre_antilag_initialize    :initialize
      def initialize
        # Run normal initialize
        pre_antilag_initialize
        # Set our ignore flag based on our event name
        @ignore_update = false
        @ignore_sprite = false
        @ignore_location = false
        @force_update = false
      end
      #--------------------------------------------------------------------------
      # * On Screen
      #--------------------------------------------------------------------------
      def on_screen
        x_range = ((@real_x <= ($game_map.display_x + ((Graphics.width + 32) * 8))) and (@real_x >= ($game_map.display_x - 256)))
        y_range = ((@real_y <= ($game_map.display_y + ((Graphics.height + 32) * 8))) and (@real_y >= ($game_map.display_y - 256)))
        if x_range and y_range
          return true
        end
        return false
      end
    end

    #==============================================================================
    # ** Game_Event
    #------------------------------------------------------------------------------
    #  This class deals with events. It handles functions including event page
    # switching via condition determinants, and running parallel process events.
    # It's used within the Game_Map class.
    #==============================================================================

    class Game_Event < Game_Character
      #--------------------------------------------------------------------------
      # * Public Instance Variables
      #--------------------------------------------------------------------------
      attr_reader  :id
      attr_reader  :original_forced_update
      #--------------------------------------------------------------------------
      # * Object Initialization
      #    map_id : map ID
      #    event  : event (RPG::Event)
      #--------------------------------------------------------------------------
      alias :pre_antilag_event_initialize    :initialize
      def initialize(map_id, event)
        # Run normal initialize
        pre_antilag_event_initialize(map_id, event)
        # Set our ignore flag based on our event name
        decide_ignore
      end
      #--------------------------------------------------------------------------
      # * Frame Update
      #--------------------------------------------------------------------------
      alias :pre_antilag_update    :update
      def update
        # Only run update if @ignore_update is false
        if update?
          pre_antilag_update
        end
      end
      #--------------------------------------------------------------------------
      # * Frame Update
      #--------------------------------------------------------------------------
      def update?
        # Check our logic and return if we should update
        ignore = ((not @ignore_update) and (on_screen and ALLOW_SCREEN_IGNORE))
        return (@force_update or ignore or @move_route_forcing)
      end
      #--------------------------------------------------------------------------
      # * Event page setup
      #--------------------------------------------------------------------------
      alias :pre_antilag_setup  :setup
      def setup(new_page)
        # Run normal setup
        pre_antilag_setup(new_page)
        # Set our forced flag if we're running as a parallel process now
        # if not, set it to our "default" set during the decide_ignore function
        if @trigger == 4 or @trigger == 3
          @force_update = true
        else
          @force_update = @original_force_update
        end
      end
      #--------------------------------------------------------------------------
      # * Decide if Ignorable for Updates or Sprites
      #--------------------------------------------------------------------------
      def decide_ignore
        # Not ignore by default
        @ignore_location = true
        @ignore_sprite = true
        @ignore_update = false
        @original_force_update = false
        # Decide if we should ignore ourselves or not
        if @event.name == "IGNORE"
          @ignore_update = true
        elsif @event.pages.size == 1
          if @list != nil
            if @list.size == 1
              if @character_name == "" or @tile_id != 0
                @ignore_update = true
              end
            end
          end
        end
        # Check if we'll ever need a sprite
        tiles = []
        for page in @event.pages
          # Check for single-tile events
          if page.graphic.tile_id != 0
            tiles.push(page.graphic.tile_id) if not tiles.include?(page.graphic.tile_id)
            if page.priority_type == 2 or tiles.size > 1 or @event.pages.size > 1
              @ignore_sprite = false
              @ignore_location = false
            end
          end
          # Check for character graphic instead
          if page.graphic.character_name != ""
            @ignore_sprite = false
            @ignore_location = false
          end
          # Check all pages for code to run
          if page.list.size > 1
            for item in page.list
              if item.code != 108
                @ignore_location = false
              end
            end
          end
        end
        # Check to see if we have any tiles and a no initial page
        if @list == nil and tiles.size > 0
          @ignore_sprite = false
          @ignore_location = false
        end
        # Force tags
        if @event.name.include?("DOSPRITE")
          @ignore_sprite = false
        end
        if @event.name.include?("DOLOC")
          @ignore_location = false
        end
        if @event.name.include?("DOUPDATE")
          @ignore_update = false
          @force_update = true
          @original_force_update = true
        end
      end
      #--------------------------------------------------------------------------
      # * Move Functions
      #--------------------------------------------------------------------------
      alias :pre_antilag_move_down    :move_down
      def move_down(turn_ok = true)
        $game_map.clear_event_loc(self)
        pre_antilag_move_down(turn_ok)
        $game_map.set_event_loc(self)
      end
      alias :pre_antilag_move_left    :move_left
      def move_left(turn_ok = true)
        $game_map.clear_event_loc(self)
        pre_antilag_move_left(turn_ok)
        $game_map.set_event_loc(self)
      end
      alias :pre_antilag_move_right    :move_right
      def move_right(turn_ok = true)
        $game_map.clear_event_loc(self)
        pre_antilag_move_right(turn_ok)
        $game_map.set_event_loc(self)
      end
      alias :pre_antilag_move_up    :move_up
      def move_up(turn_ok = true)
        $game_map.clear_event_loc(self)
        pre_antilag_move_up(turn_ok)
        $game_map.set_event_loc(self)
      end
      alias :pre_antilag_move_lower_left    :move_lower_left
      def move_lower_left(turn_ok = true)
        $game_map.clear_event_loc(self)
        pre_antilag_move_lower_left(turn_ok)
        $game_map.set_event_loc(self)
      end
      alias :pre_antilag_move_upper_left    :move_upper_left
      def move_upper_left(turn_ok = true)
        $game_map.clear_event_loc(self)
        pre_antilag_move_upper_left(turn_ok)
        $game_map.set_event_loc(self)
      end
      alias :pre_antilag_move_lower_right    :move_lower_right
      def move_lower_right(turn_ok = true)
        $game_map.clear_event_loc(self)
        pre_antilag_move_lower_right(turn_ok)
        $game_map.set_event_loc(self)
      end
      alias :pre_antilag_move_upper_right    :move_upper_right
      def move_upper_right(turn_ok = true)
        $game_map.clear_event_loc(self)
        pre_antilag_move_upper_right(turn_ok)
        $game_map.set_event_loc(self)
      end
    end


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

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

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

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

Ver el tema anterior Ver el tema siguiente Volver arriba  Mensaje [Página 1 de 1.]

Permisos de este foro:
No puedes responder a temas en este foro.