Legacy Engine - Anti Lag
por Victor Sant


O
que é o Legacy Engine? O Legacy Engine é um conjunto de scripts com
funções váriadas para personalização de projetos. No geral são scripts
independentes que funcionam sozinhos (exceto pelos scripts 'base' que
são requisitos para o funcionamento deles), mas que podem ser usados
juntos com total compatibilidade, claro que algumas funções não podem
ser usadas em conjuto, porém não ocorrerão erros de incopatibilidade.

Introdução

Este
script tem como função reduzir o lag causado quando se tem muitos
eventos em um mesmo mapa, ou muitos eventos comuns no database.

Diferente
dos outros anti-lags, que apenas "pulam" a atualização, mas ainda assim
verificam cada um dos eventos, este anti-lag não somente ignora eles
mas nem sequer faz a verificação, pois ele previamente lista os eventos
que serão atualizados.

Características

• Requer o script Legacy Engine - Básico (Mapa)

• Alta redução do Lag causado por eventos

Screenshots

Imagem
de um mapa de 100 x 100, com 999 eventos em movimento com diferentes
freqüencias e velocidade, e 3 eventos comuns em processo paralelo.
Repare que o FPS está no máximo do RPG Maker XP: 40 FPS.
O desempenho pode variar de acordo com as especificações do seu computador, mas no geral a redução é bem grande.

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]

Como usar

Para instalá-lo, apenas cole o script acima do script Main.
Deixe-o sempre abaixo do script 'Legacy Engine - Básico (Mapa)'
Se
usado junto de outros scripts do Legacy Engine, verifique a ordem
correta dos scripts no script 'Legacy Engine - Básico (Mapa)'
Scripts que não façam parte do 'Legacy Engine' devem ficar acima do script 'Legacy Engine - Básico (Mapa)'

Demais intruções de uso no cabeçalho do script.

Demo

Não necessita de Demo

Script

Código:

#==============================================================================
# Legacy Engine - Anti Lag
# por Victor Sant
#==============================================================================
# Atualizações
#  v 1.0 - 28 / 06 / 2011 - Script Lançado
#  v 1.1 - 05 / 07 / 2011 - Compatibilidade com Loop no Mapa
#
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Este script tem como função reduzir o lag causado quando se tem muitos
# eventos em um mesmo mapa, ou muitos eventos comuns no database.
#
# Diferente dos outros anti-lags, que apenas "pulam" a atualização, mas ainda
# assim verificam cada um dos eventos, este anti-lag não somente ignora eles
# mas nem sequer faz a verificação, pois ele previamente lista os eventos
# que serão atualizados.
#
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#
# EVENTOS:
# Por padrão todos os eventos fora da tela, exceto os processos paralelos e
# eventos em início automático não são atualizados.
#
# Sempre atualizar evento:
# Se por alguma razão você precisar que um evento atualize sempre, independente
# de sua posição na tela, adicione "[A]" ao seu nome.
# Ex.: EV001[A]
#
# Nunca atualizar evento?
# Se por alguma razão você que um evento nunca atualize, por exemplo o evento
# de um objeto, independente de sua posição na tela, adicione "[N]" ao seu nome.
# Ex.: EV001[N]
#
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#
# EVENTOS COMUNS:
# Por padrão nenhum evento comum é atualizado, até ser chamado atrávez do
# comando de eventos 'Evento Comum' ou ser adicionado manualmente à lista de
# atualização
#
# Sempre atualizar evento comum:
# Eventos comuns em processo paralelo e inicio automático não são atualizados
# mesmo que o switch de ativação seja ligado, para mudar isto é necessário
# adicionar "[A]" ao seu nome.
# Ex.: Evento Comum[A]
#
# Adicionar eventos comuns manualmente:
# Para adicionar eventos comuns à lista de atualização (útil para eventos em
# processo paralelo e inicio automatico que serão usados temporariamente)
# deve-se usar o comando de eventos 'Chamar Script' com o código:
#  add_common_event(a, b, c...)
#  a, b, c... são as ids dos eventos que serão atualizados, pode-se adicionar
#    quantas IDs quiser
# Ex.: add_common_event(1)
#      add_common_event(1, 2, 3)
#
# Remover eventos comuns manualmente:
# Para remover eventos comuns da lista de atualização deve-se usar o comando
# de eventos 'Chamar Script' com o código:
#  remove_common_event(a, b, c...)
#  a, b, c... são as ids dos eventos que serão atualizados, pode-se adicionar
#    quantas IDs quiser
# Ex.: remove_common_event(1)
#      remove_common_event(1, 2, 3)
#
# IMPORTANTE: a lista de eventos comuns é limpa sempre que ocorre uma
#  mudança de mapa. Apenas os eventos que atualizam sempre permanecem.
#
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Agradecimentos:
# - Zeriab
#  Pelo seu script de Anti Lag que foi usado para estudos.
# - Megalukes
#  Intensivo beta testing
#
#==============================================================================

$legacy_engine = {} if $legacy_engine.nil?
$legacy_engine["Anti Lag"] = true

module Legacy_Engine
 
  # Área em tile que define o "limite" de atualização da tela.
  # Quanto maior o valor, eventos mais longe da tela serão atualizado
  # Porém isso pode aumentar o lag potencialmente se o valor for muito alto.
  Update_Area = 0
 
end

#==============================================================================
# ** Game_CommonEvent
#------------------------------------------------------------------------------
# Esta classe engloba os Eventos Comuns. Isto inclui a execução dos Eventos de
# Processos Paralelos. Esta classe é usada em conjunto com a classe $game_map.
#==============================================================================

class Game_CommonEvent
  #--------------------------------------------------------------------------
  # Definir ID do evento comum
  #--------------------------------------------------------------------------
  def id
    return @common_event_id
  end
end

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
# Esta classe engloba o mapa. Isso determina o Scroll e a determinante de
# passagem. Se refere a $game_map para as instâncias desta classe.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # Variáveis Públicas
  #--------------------------------------------------------------------------
  attr_accessor :event_map
  attr_accessor :update_list
  attr_accessor :common_events_update
  #--------------------------------------------------------------------------
  # Configurar
  #    map_id : ID do mapa
  #--------------------------------------------------------------------------
  alias setup_antilag setup
  def setup(map_id)
    @event_map = {}
    @event_list = []
    @update_list = []
    setup_antilag(map_id)
    @common_events_update = []
    awayls_update
  end
  #--------------------------------------------------------------------------
  # Definição da lista de eventos
  #--------------------------------------------------------------------------
  def event_list
    return @event_list
  end
  #--------------------------------------------------------------------------
  # Definir lista de eventos
  #    n = novo valor
  #--------------------------------------------------------------------------
  def event_list=(n)
    @event_list = n
  end
  #--------------------------------------------------------------------------
  # Definição de visibilidade do evento
  #    x : coordenada x
  #    y : coordenada y
  #    w : largura
  #    h : altura
  #--------------------------------------------------------------------------
  def visible?(x, y, w = 128, h = 128)
    a = [(Legacy_Engine::Update_Area + 1) * 32, 32].max
    w = a + w / 128
    h = a + h / 128
    return (x.between?(-w, w + 20 * 32) and y.between?(-h, h + 15 * 32))
  end
  #--------------------------------------------------------------------------
  # Atualização da lista de eventos após movimento
  #    old_x  : antiga coordenada x
  #    old_y  : antiga coordenada y
  #    event  : evento a ser atualizado
  #    forced : flag de atualização forçada
  #--------------------------------------------------------------------------
  def move_event(old_x, old_y, event, forced = false)
    return if $legacy_engine["Map Loop"] and not forced
    return unless old_x != event.x or old_y != event.y or forced
    remove_event(old_x, old_y, event.id)
    add_event(event.x, event.y, event.id)
  end
  #--------------------------------------------------------------------------
  # Adicionar evento à lista de atualização
  #    x  : coordenada x
  #    y  : coordenada y
  #    id : ID do evento
  #--------------------------------------------------------------------------
  def add_event(x, y, id)
    @event_map[[x,y]] = [] if @event_map[[x,y]].nil?
    @event_map[[x,y]] << id
  end
  #--------------------------------------------------------------------------
  # Remover evento da lista de atualização
  #    x  : coordenada x
  #    y  : coordenada y
  #    id : ID do evento
  #--------------------------------------------------------------------------
  def remove_event(x, y, id)
    return if @event_map[[x,y]].nil?
    if @event_map[[x,y]].size > 1
      @event_map[[x,y]].delete(id)
    else
      @event_map.delete([x,y])
    end
  end
  #--------------------------------------------------------------------------
  # Definição da área visível do mapa
  #--------------------------------------------------------------------------
  def visible_area
    x = display_x / 128
    y = display_y / 128
    a = Legacy_Engine::Update_Area
    min_x = x - a - ($legacy_engine["Map Loop"] ? 5 : 1)
    min_y = y - a - ($legacy_engine["Map Loop"] ? 5 : 1)
    max_x = x + a + 20 + ($legacy_engine["Map Loop"] ? 5 : 1)
    max_y = y + a + 15 + ($legacy_engine["Map Loop"] ? 5 : 1)
    return min_x, max_x, min_y, max_y
  end
  #--------------------------------------------------------------------------
  # Adicionar Eventos Comuns que sempre atualizam
  #--------------------------------------------------------------------------
  def awayls_update
    for event in @common_events.values
      @common_events_update << event.id if (event.name =~ /\[a\]/i)
    end
    @common_events_update.uniq!
    @common_events_update.sort!
  end
  #--------------------------------------------------------------------------
  # Atualização dos eventos
  #--------------------------------------------------------------------------
  def update_events
    for event in @event_list
      next unless event.update?
      event.update
    end
    for id in @common_events_update
      common_event = @common_events[id]
      common_event.update
    end
  end
end

#==============================================================================
# ** Game_Character
#------------------------------------------------------------------------------
# Esta classe trata dos Heróis. Esta é usada como uma superclasse para as
# classes Game_Player e Game_Event.
#==============================================================================

class Game_Character
  #--------------------------------------------------------------------------
  # Adicionar eventos comuns à lista de atualização
  #    args : lista das IDs dos eventos
  #--------------------------------------------------------------------------
  def add_common_event(*args)
    $game_map.common_events_update += args
    $game_map.awayls_update
  end
  #--------------------------------------------------------------------------
  # Remover eventos comuns da lista de atualização
  #    args : lista das IDs dos eventos
  #--------------------------------------------------------------------------
  def remove_common_event(*args)
    $game_map.common_events_update -= args
    $game_map.awayls_update
  end
end

#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
# Esta classe engloba o Jogador. Suas funções incluem a inicialização das
# determinantes dos eventos e o scroll do mapa. Se refere a "$game_player" para
# as instâncias desta classe.
#==============================================================================

class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  # Determinante de Inicialização Sobre o Evento
  #--------------------------------------------------------------------------
  def check_event_trigger_here(triggers)
    result = false
    return result if $game_system.map_interpreter.running?
    for event in $game_map.event_list
      if event.x == @x and event.y == @y and triggers.include?(event.trigger)
        if not event.jumping? and event.over_trigger?
          event.start
          result = true
        end
      end
    end
    return result
  end
  #--------------------------------------------------------------------------
  # Determinante de Inicialização na Frente do Evento
  #--------------------------------------------------------------------------
  def check_event_trigger_there(triggers)
    result = false
    return result if $game_system.map_interpreter.running?
    new_x = @x + (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
    new_y = @y + (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
    for event in $game_map.event_list
      if event.x == new_x and event.y == new_y and
        triggers.include?(event.trigger)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
    if result == false
      if $game_map.counter?(new_x, new_y)
        new_x += (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
        new_y += (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
        for event in $game_map.event_list
          if event.x == new_x and event.y == new_y and
            triggers.include?(event.trigger)
            if not event.jumping? and not event.over_trigger?
              event.start
              result = true
            end
          end
        end
      end
    end
    return result
  end
  #--------------------------------------------------------------------------
  # Determinante de Inicialização ao Tocar o Evento
  #--------------------------------------------------------------------------
  def check_event_trigger_touch(x, y)
    result = false
    return result if $game_system.map_interpreter.running?
    for event in $game_map.event_list
      if event.x == x and event.y == y and [1,2].include?(event.trigger)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
    return result
  end
end

#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
# Esta é a classe que engloba os eventos. O que inclui as funções nas páginas de
# evento alterando estas através das Condições de Evento, e faz funcionar os
# Processos Paralelos. Esta classe está inserida na classe Game_Map.
#==============================================================================

class Game_Event < Game_Character
  #--------------------------------------------------------------------------
  # Inicialização do Objeto
  #    map_id : ID do mapa
  #    event  : evento (RPG::Event)
  #--------------------------------------------------------------------------
  alias initialize_antilag_event initialize
  def initialize(map_id, event)
    initialize_antilag_event(map_id, event)
    @update_mode = (self.name =~ /\[a\]/i) ? :always : nil
    @update_mode = (self.name =~ /\[n\]/i) ? :never  : @update_mode
    $game_map.update_list << self if @trigger == 3 or @trigger == 4 or
                                    @move_type == 3 or @update_mode == :always
    $game_map.move_event(self.x, self.y, self, true)
  end
  #--------------------------------------------------------------------------
  # Determinar necessidade de atualização
  #--------------------------------------------------------------------------
  def update?
    return false if @update_mode == :never
    return true  if @update_mode == :always
    return true  if $game_map.visible?(screen_x, screen_y)
    return true  if @move_type == 3
    return (@trigger == 3 or @trigger == 4)
  end
  #--------------------------------------------------------------------------
  # Nome do Evento
  #--------------------------------------------------------------------------
  def name
    return @event.name
  end
  #--------------------------------------------------------------------------
  # Mover Abaixo
  #    turn_enabled : flag que permite uma troca de direção
  #--------------------------------------------------------------------------
  def move_down(turn_enabled = true, steping = false)
    old_x, old_y = @x, @y
    super
    $game_map.move_event(old_x, old_y, self) if old_x != @x or old_y != @y
  end
  #--------------------------------------------------------------------------
  # Mover à Esquerda
  #    turn_enabled : flag que permite uma troca de direção
  #--------------------------------------------------------------------------
  def move_left(turn_enabled = true, steping = false)
    old_x, old_y = @x, @y
    super
    $game_map.move_event(old_x, old_y, self) if old_x != @x or old_y != @y
  end
  #--------------------------------------------------------------------------
  # Mover à Direita
  #    turn_enabled : flag que permite uma troca de direção
  #--------------------------------------------------------------------------
  def move_right(turn_enabled = true, steping = false)
    old_x, old_y = @x, @y
    super
    $game_map.move_event(old_x, old_y, self) if old_x != @x or old_y != @y
  end
  #--------------------------------------------------------------------------
  # Mover Acima
  #    turn_enabled : flag que permite uma troca de direção
  #--------------------------------------------------------------------------
  def move_up(turn_enabled = true, steping = false)
    old_x, old_y = @x, @y
    super
    $game_map.move_event(old_x, old_y, self) if old_x != @x or old_y != @y
  end
  #--------------------------------------------------------------------------
  # Mover Esquerda-Abaixo
  #--------------------------------------------------------------------------
  def move_lower_left(turn_enabled = true, steping = false)
    old_x, old_y = @x, @y
    super
    $game_map.move_event(old_x, old_y, self) if old_x != @x or old_y != @y
  end
  #--------------------------------------------------------------------------
  # Mover Direita-Abaixo
  #--------------------------------------------------------------------------
  def move_lower_right(turn_enabled = true, steping = false)
    old_x, old_y = @x, @y
    super
    $game_map.move_event(old_x, old_y, self) if old_x != @x or old_y != @y
  end
  #--------------------------------------------------------------------------
  # Mover Esquerda-Acima
  #--------------------------------------------------------------------------
  def move_upper_left(turn_enabled = true, steping = false)
    old_x, old_y = @x, @y
    super
    $game_map.move_event(old_x, old_y, self) if old_x != @x or old_y != @y
  end
  #--------------------------------------------------------------------------
  # Mover Direita-Acima
  #--------------------------------------------------------------------------
  def move_upper_right(turn_enabled = true, steping = false)
    old_x, old_y = @x, @y
    super
    $game_map.move_event(old_x, old_y, self) if old_x != @x or old_y != @y
  end
end


#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
# Esta classe engloba todos os sprites da tela, Tilesets, Heróis, etc
# Esta classe está inserida na classe Scene_Map.
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # Criação dos characters
  #--------------------------------------------------------------------------
  def create_characters
    @last_screen_x = ($game_map.display_x / 128).to_i
    @last_screen_y = ($game_map.display_y / 128).to_i
    @character_sprites = []
    for i in $game_map.events.keys.sort
      event = $game_map.events[i]
      $game_map.move_event(event.x, event.y, event, true)
      event.sprite = Sprite_Character.new(@viewport1, event)
    end
    party = ($legacy_engine["Caterpillar"] ? $game_player.actors : [])
    for actor in party.reverse + [$game_player]
      actor.sprite = Sprite_Character.new(@viewport1, actor)
    end 
    refresh_characters
  end
  #--------------------------------------------------------------------------
  # Disposição dos characters
  #--------------------------------------------------------------------------
  def dispose_characters
    for event in $game_map.events.values
      next if event.sprite.nil?
      event.sprite.dispose
      event.sprite = nil
    end
    party = ($legacy_engine["Caterpillar"] ? $game_player.actors : [])
    for actor in party.reverse + [$game_player]
      next if actor.sprite.nil?
      actor.sprite.dispose
      actor.sprite = nil
    end 
    @character_sprites.clear
  end
  #--------------------------------------------------------------------------
  # Redefinição dos characters
  #--------------------------------------------------------------------------
  def refresh_characters
    @character_sprites.clear
    $game_map.event_list.clear
    $game_map.event_list += $game_map.update_list
    min_x, max_x, min_y, max_y = $game_map.visible_area
    for x in min_x..max_x
      for y in min_y..max_y
        add_sprites($game_map.round_x(x), $game_map.round_x(y))
      end
    end
    party = ($legacy_engine["Caterpillar"] ? $game_player.actors : [])
    for actor in party.reverse + [$game_player]
      @character_sprites << actor.sprite
    end
    @character_sprites.compact!
    @character_sprites.uniq!
    $game_map.event_list.compact!
    $game_map.event_list.uniq!
    @last_screen_x = ($game_map.display_x / 128).to_i
    @last_screen_y = ($game_map.display_y / 128).to_i
    @need_refresh = false
  end
  #--------------------------------------------------------------------------
  # Atualização dos characters
  #--------------------------------------------------------------------------
  def update_characters
    unless @last_screen_x == ($game_map.display_x / 128).to_i &&
          @last_screen_y == ($game_map.display_y / 128).to_i
      refresh_characters
    end
    @character_sprites.each {|sprite| sprite.update}
  end
  #--------------------------------------------------------------------------
  # Adicionar sprites à lista de atualização
  #    x : coordenada x
  #    y : coordenada y
  #--------------------------------------------------------------------------
  def add_sprites(x, y)
    return if $game_map.event_map[[x,y]].nil?
    for id in $game_map.event_map[[x,y]]
      event = $game_map.events[id]
      @character_sprites << event.sprite
      $game_map.event_list << event
    end
  end
end

#==============================================================================
# ** Interpreter
#------------------------------------------------------------------------------
# É a classe que interpreta os comandos de eventos do jogo.
# É usada dentro da classe Game_Event e Game_System.
#==============================================================================

class Interpreter
  #--------------------------------------------------------------------------
  # Adicionar eventos comuns à lista de atualização
  #    args : lista das IDs dos eventos
  #--------------------------------------------------------------------------
  def add_common_event(*args)
    $game_map.common_events_update += args
    $game_map.awayls_update
  end
  #--------------------------------------------------------------------------
  # Remover eventos comuns da lista de atualização
  #    args : lista das IDs dos eventos
  #--------------------------------------------------------------------------
  def remove_common_event(*args)
    $game_map.common_events_update -= args
    $game_map.awayls_update
  end
  #--------------------------------------------------------------------------
  # Evento comum
  #--------------------------------------------------------------------------
  alias command_117_antilag command_117
  def command_117
    add_common_event(@params[0]) if $data_common_events[@params[0]] != nil
    command_117_antilag
  end
end

Créditos e Agradecimentos
•Feito por Victor Sant

Muito bom, se eu for criar um jogo com muitos eventos provavelmente irei usar, obg por postar +AG

Vlw ;D Estarei sempre postando scripts ou outras coisas no forum ;D

Tópico trancado por ser mt antigo.

By: -Luffy