Legacy Engine - Básico (Mapa)
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
é o script básico para os sistemas de mapa do Legacy Engine, é
necessário para o funcionamento de todos os scripts de mapa do Legacy
Engine.
Este script em si não oferece nenhuma funcionalidade
especial, além do fato de re-escrever alguns metodos de forma mais
organizada, o que possibilita a total compatibilidade entre todos os
scripts do sistema.

Características

• Script necessário para funcionamento do scripts de mapa do Legacy Engine

Screenshots

Não possiu efeitos visuais perceptíveis por ScreenShots

Como usar

Para instalá-lo, apenas cole o script acima do script Main.

Demo

Não necessita de Demo

Script

Código:

#==============================================================================
# Legacy Engine - Básico (Mapa)
# 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
#  v 1.2 - 16 / 07 / 2011 - Compatibilidade com Iluminação
#
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Este é o script básico para os sistemas de mapa do Legacy Engine, é
# necessário para o funcionamento de todos os scripts de mapa do Legacy Engine.
# Este script em si não oferece nenhuma funcionalidade especial, além do fato
# de re-escrever alguns metodos de forma mais organizada, o que possibilita
# a total compatibilidade entre todos os scripts do sistema.
#
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Ordem dos scripts:
# Para evitar problemas de compatibilidade, os scripts do Legacy Engine devem
# ser colocados nesta ordem:
#
# - LE | Básico (Mapa)
# - LE | Anti Lag
# - LE | Loop no Mapa
# - LE | Iluminação
# - LE | Multi Frames
# - LE | Movimento Diagonal
# - LE | Controle de Animação
# - LE | Movimento por Pixel
# - LE | Caixas para Colisões
# - LE | Movimento Rotacional
# - LE | Plataformas
# - LE | Salto Livre
# - LE | Caterpillar
# - LE | Corrida
#
# Coloar os scripts em ordens diferentes algumas vezes pode causar bug, por
# isso não é recomendado fazer isto.
#
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Lista de Métodos re-escritos:
# Scripts que re-escrevam estes mesmos métodos causarão incompatibilidade
# com os scripts do sitema Legacy Engine
#
# class Game_Map
#  def passable?
#  def update
#
# class Game_Character
#  def passable?
#  def moveto
#  def move_down
#  def move_left
#  def move_right
#  def move_up
#  def move_down
#  def move_lower_left
#  def move_lower_right
#  def move_upper_left
#  def move_upper_right
#  def jump
#  def update_move
#  def move_toward_player
#  def move_away_from_player
#  def turn_toward_player
#  def turn_away_from_player
#
# class Game_Player < Game_Character
#  def update
#
# class Sprite_Character < RPG::Sprite
#  def update
#
# class Spriteset_Map
#  def initialize
#  def dispose
#  def update
#
#==============================================================================

$legacy_engine = {} if $legacy_engine.nil?
$legacy_engine["Basic Movement"] = true

#==============================================================================
# ** 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
  #--------------------------------------------------------------------------
  # Determinar se é Passável
  #    x          : coordenada x
  #    y          : coordenada y
  #    d          : direção (0,2,4,6,8,10)
  #                  *  0,10 = determina se todas as direções são passáveis
  #    self_event : automático (se o Evento for determinado passável)
  #--------------------------------------------------------------------------
  def passable?(x, y, d, self_event = nil)
    return false unless valid?(x, y)
    bit = (1 << (d / 2 - 1)) & 0x0f
    for event in event_list
      result = passable_event(x, y, event, self_event, bit)
      return result if result != nil
    end
    for i in [2, 1, 0]
      result = passable_tile(x, y, i, bit)
      return result if result != nil
    end
    return true
  end
  #--------------------------------------------------------------------------
  # Determinar se evento é Passável
  #    x          : coordenada x
  #    y          : coordenada y
  #    event      : evento
  #    self_event : automático (se o Evento for determinado passável)
  #    bit        : passabilidade
  #--------------------------------------------------------------------------
  def passable_event(x, y, event, self_event, bit)
    if event_tile?(x, y, event, self_event)
      return false if @passages[event.tile_id] & bit != 0
      return false if @passages[event.tile_id] & 0x0f == 0x0f
      return true  if @priorities[event.tile_id] == 0
    end
    return nil
  end
  #--------------------------------------------------------------------------
  # Determinar se evento é um tile
  #    x          : coordenada x
  #    y          : coordenada y
  #    event      : evento
  #    self_event : automático (se o Evento for determinado passável)
  #--------------------------------------------------------------------------
  def event_tile?(x, y, event, self_event)
    return (event.tile_id >= 0 and event != self_event and
            event.x == x and event.y == y and not event.through)
  end
  #--------------------------------------------------------------------------
  # Determinar se tile é Passável
  #    x  : coordenada x
  #    y  : coordenada y
  #    i  : índice
  #    bit : passabilidade
  #--------------------------------------------------------------------------
  def passable_tile(x, y, i, bit)
    tile_id = data[x, y, i]
    return false if tile_id == nil
    return false if @passages[tile_id] & bit != 0
    return false if @passages[tile_id] & 0x0f == 0x0f
    return true  if @priorities[tile_id] == 0
    return nil
  end
  #--------------------------------------------------------------------------
  # Verificação da coordenada
  #    x : coordenada X
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def valid?(x, y)
    x = round_x(x)
    y = round_y(y)
    return (x >= 0 and x < width and y >= 0 and y < height)
  end
  #--------------------------------------------------------------------------
  # Determinar as Coordenadas Válidas
  #    x          : coordenada x
  #    y          : coordenada y
  #--------------------------------------------------------------------------
  def valid_real?(x, y)
    return (x >= 0 and x < width * 128 and y >= 0 and y < height * 128)
  end
  #--------------------------------------------------------------------------
  # Atualização do Frame
  #--------------------------------------------------------------------------
  def update
    refresh if $game_map.need_refresh
    update_scroll
    update_events
    update_fog
  end
  #--------------------------------------------------------------------------
  # Atualização do scroll
  #--------------------------------------------------------------------------
  def update_scroll
    if @scroll_rest > 0
      distance = 2 ** @scroll_speed
      case @scroll_direction
      when 2 then scroll_down(distance)
      when 4 then scroll_left(distance)
      when 6 then scroll_right(distance)
      when 8 then scroll_up(distance)
      end
      @scroll_rest -= distance
    end
  end
  #--------------------------------------------------------------------------
  # Atualização dos eventos
  #--------------------------------------------------------------------------
  def update_events
    for event in @events.values
      event.update
    end
    for common_event in @common_events.values
      common_event.update
    end
  end
  #--------------------------------------------------------------------------
  # Atualização da névoa
  #--------------------------------------------------------------------------
  def update_fog
    @fog_ox -= @fog_sx / 8.0
    @fog_oy -= @fog_sy / 8.0
    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
    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
  #--------------------------------------------------------------------------
  # Definição de eventos a serem atualizados
  #--------------------------------------------------------------------------
  def event_list
    return events.values
  end 
  #--------------------------------------------------------------------------
  # Cálculo de redução da coordenada X padrão
  #    x : coordenada X
  #--------------------------------------------------------------------------
  def adjust_x(x)
    return x - @display_x
  end
  #--------------------------------------------------------------------------
  # Cálculo de redução da coordenada Y padrão
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def adjust_y(y)
    return y - @display_y
  end
  #--------------------------------------------------------------------------
  # Cálculo da coordenada X após o loop
  #    x : coordenada X
  #--------------------------------------------------------------------------
  def round_x(x)
    return x
  end
  #--------------------------------------------------------------------------
  # Cálculo da coordenada Y após o loop
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def round_y(y)
    return y
  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
  #--------------------------------------------------------------------------
  # Variáveis Públicas
  #--------------------------------------------------------------------------
  attr_accessor :sprite
  attr_accessor :move_speed
  #--------------------------------------------------------------------------
  # Determinar se é Passável
  #    x : coordenada x
  #    y : coordenada y
  #    d : direção (0,2,4,6,8)
  #        * 0 = Determina que todas as direções estão bloqueadas (para pulo)
  #--------------------------------------------------------------------------
  def passable?(x, y, d)
    old_x = $game_map.round_x(x)
    old_y = $game_map.round_y(y)
    new_x = $game_map.round_x(x + (d == 6 ? 1 : d == 4 ? -1 : 0))
    new_y = $game_map.round_y(y + (d == 2 ? 1 : d == 8 ? -1 : 0))
    return false unless $game_map.valid?(new_x, new_y)
    return true if @through
    return false unless $game_map.passable?(old_x, old_y, d, self)
    return false unless $game_map.passable?(new_x, new_y, 10 - d)
    for event in $game_map.event_list
      if event.x == new_x and event.y == new_y
        unless event.through
          return false if self != $game_player or event.character_name != ""
        end
      end
    end
    if $game_player.x == new_x and $game_player.y == new_y
      return false if @character_name != "" and not $game_player.through
    end
    return true
  end
  #--------------------------------------------------------------------------
  # Determinar se está se Movendo
  #--------------------------------------------------------------------------
  def moving?
    return (@real_x != @x * 128 + @move_x or @real_y != @y * 128 + @move_y)
  end
  #--------------------------------------------------------------------------
  # Mover para uma Posição Designada
  #    x : coordenada x
  #    y : coordenada y
  #--------------------------------------------------------------------------
  def moveto(x, y)
    @x = x % $game_map.width
    @y = y % $game_map.height
    @real_x = @x * 128
    @real_y = @y * 128
    @prelock_direction = 0
    @move_x = 0
    @move_y = 0
  end
  #--------------------------------------------------------------------------
  # Mover Abaixo
  #    turn_enabled : flag que permite uma troca de direção
  #    steping      : flag que indica número de passos
  #--------------------------------------------------------------------------
  def move_down(turn_enabled = true, steping = false)
    turn_down if turn_enabled
    if passable_down?
      step_down
    else
      check_event_trigger_touch(@x, @y + 1)
    end
  end
  #--------------------------------------------------------------------------
  # Mover à Esquerda
  #    turn_enabled : flag que permite uma troca de direção
  #    steping      : flag que indica número de passos
  #--------------------------------------------------------------------------
  def move_left(turn_enabled = true, steping = false)
    turn_left if turn_enabled
    if passable_left?
      step_left
    else
      check_event_trigger_touch(@x - 1, @y)
    end
  end
  #--------------------------------------------------------------------------
  # Mover à Direita
  #    turn_enabled : flag que permite uma troca de direção
  #    steping      : flag que indica número de passos
  #--------------------------------------------------------------------------
  def move_right(turn_enabled = true, steping = false)
    turn_right if turn_enabled
    if passable_right?
      step_right
    else
      check_event_trigger_touch(@x + 1, @y)
    end
  end
  #--------------------------------------------------------------------------
  # Mover Acima
  #    turn_enabled : flag que permite uma troca de direção
  #    steping      : flag que indica número de passos
  #--------------------------------------------------------------------------
  def move_up(turn_enabled = true, steping = false)
    turn_up if turn_enabled
    if passable_up?
      step_up
    else
      check_event_trigger_touch(@x, @y - 1)
    end
  end
  #--------------------------------------------------------------------------
  # Mover Esquerda-Abaixo
  #    turn_enabled : flag que permite uma troca de direção
  #    steping      : flag que indica número de passos
  #--------------------------------------------------------------------------
  def move_lower_left(turn_enabled = true, steping = false)
    turn_lower_left if turn_enabled
    if passable_lower_left?
      step_lower_left
    elsif passable_left?
      step_left
    elsif passable_down?
      step_down
    else
      check_event_trigger_touch(@x - 1, @y + 1)
    end
  end
  #--------------------------------------------------------------------------
  # Mover Direita-Abaixo
  #    turn_enabled : flag que permite uma troca de direção
  #    steping      : flag que indica número de passos
  #--------------------------------------------------------------------------
  def move_lower_right(turn_enabled = true, steping = false)
    turn_lower_right if turn_enabled
    if passable_lower_right?
      step_lower_right
    elsif passable_right?
      step_right
    elsif passable_down?
      step_down
    else
      check_event_trigger_touch(@x + 1, @y + 1)
    end
  end
  #--------------------------------------------------------------------------
  # Mover Esquerda-Acima
  #    turn_enabled : flag que permite uma troca de direção
  #    steping      : flag que indica número de passos
  #--------------------------------------------------------------------------
  def move_upper_left(turn_enabled = true, steping = false)
    turn_upper_left if turn_enabled
    if passable_upper_left?
      step_upper_left
    elsif passable_left?
      step_left
    elsif passable_up?
      step_up
    else
      check_event_trigger_touch(@x - 1, @y - 1)
    end
  end
  #--------------------------------------------------------------------------
  # Mover Direita-Acima
  #    turn_enabled : flag que permite uma troca de direção
  #    steping      : flag que indica número de passos
  #--------------------------------------------------------------------------
  def move_upper_right(turn_enabled = true, steping = false)
    turn_upper_right if turn_enabled
    if passable_upper_right?
      step_upper_right
    elsif passable_right?
      step_right
    elsif passable_up?
      step_up
    else
      check_event_trigger_touch(@x + 1, @y - 1)
    end
  end
  #--------------------------------------------------------------------------
  # Pular
  #    x_plus : valor a mais da coordenada x
  #    y_plus : valor a mais da coordenada y
  #--------------------------------------------------------------------------
  def jump(x_plus, y_plus)
    if x_plus != 0 or y_plus != 0
      if x_plus.abs > y_plus.abs
        x_plus < 0 ? turn_left : turn_right
      else
        y_plus < 0 ? turn_up : turn_down
      end
    end
    new_x = @x + x_plus
    new_y = @y + y_plus
    if passable_jump?(new_x, new_y, x_plus, y_plus)
      jump_move(new_x, new_y, x_plus, y_plus)
    end
  end
  #--------------------------------------------------------------------------
  # Determinar Passabilidade para saltos
  #    new_x  : nova coordenada x
  #    new_y  : nova coordenada y
  #    x_plus : modificador da coordenada x
  #    y_plus : modificador da coordenada y
  #--------------------------------------------------------------------------
  def passable_jump?(new_x, new_y, x_plus, y_plus)
    return true if x_plus == 0 and y_plus == 0
    return true if passable?(new_x, new_y, 0)
    return false
  end
  #--------------------------------------------------------------------------
  #
  #    new_x  : nova coordenada x
  #    new_y  : nova coordenada y
  #    x_plus : modificador da coordenada x
  #    y_plus : modificador da coordenada y
  #--------------------------------------------------------------------------
  def jump_move(new_x, new_y, x_plus, y_plus)
    straighten
    @x = new_x
    @y = new_y
    distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
    @jump_peak = 10 + distance - @move_speed
    @jump_count = @jump_peak * 2
    @stop_count = 0
  end
  #--------------------------------------------------------------------------
  # Determinar passabilidade Abaixo
  #--------------------------------------------------------------------------
  def passable_down?
    return passable?(@x, @y, 2)
  end
  #--------------------------------------------------------------------------
  # Determinar passabilidade à Esquerda
  #--------------------------------------------------------------------------
  def passable_left?
    return passable?(@x, @y, 4)
  end
  #--------------------------------------------------------------------------
  # Determinar passabilidade à Direita
  #--------------------------------------------------------------------------
  def passable_right?
    return passable?(@x, @y, 6)
  end
  #--------------------------------------------------------------------------
  # Determinar passabilidade Acima
  #--------------------------------------------------------------------------
  def passable_up?
    return passable?(@x, @y, 8)
  end
  #--------------------------------------------------------------------------
  # Determinar passabilidade Esquerda-Abaixo
  #--------------------------------------------------------------------------
  def passable_lower_left?
    return ((passable?(@x, @y, 2) and passable?(@x, @y + 1, 4)) and
            (passable?(@x, @y, 4) and passable?(@x - 1, @y, 2)))
  end 
  #--------------------------------------------------------------------------
  # Determinar passabilidade Direita-Abaixo
  #--------------------------------------------------------------------------
  def passable_lower_right?
    return ((passable?(@x, @y, 2) and passable?(@x, @y + 1, 6)) and
            (passable?(@x, @y, 6) and passable?(@x + 1, @y, 2)))
  end
  #--------------------------------------------------------------------------
  # Determinar passabilidade Esquerda-Acima
  #--------------------------------------------------------------------------
  def passable_upper_left?
    return ((passable?(@x, @y, 8) and passable?(@x, @y - 1, 4)) and
            (passable?(@x, @y, 4) and passable?(@x - 1, @y, 8)))
  end 
  #--------------------------------------------------------------------------
  # Determinar passabilidade Esquerda-Acima
  #--------------------------------------------------------------------------
  def passable_upper_right?
    return ((passable?(@x, @y, 8) and passable?(@x, @y - 1, 6)) and
            (passable?(@x, @y, 6) and passable?(@x + 1, @y, 8)))
  end
  #--------------------------------------------------------------------------
  # Passo Abaixo
  #    steping : flag que indica número de passos
  #--------------------------------------------------------------------------
  def step_down(steping = false)
    turn_down
    @y += 1
    increase_steps
  end
  #--------------------------------------------------------------------------
  # Passo à Esquerda
  #    steping : flag que indica número de passos
  #--------------------------------------------------------------------------
  def step_left(steping = false)
    turn_left
    @x -= 1
    increase_steps
  end
  #--------------------------------------------------------------------------
  # Passo à Direita
  #    steping : flag que indica número de passos
  #--------------------------------------------------------------------------
  def step_right(steping = false)
    turn_right
    @x += 1
    increase_steps
  end
  #--------------------------------------------------------------------------
  # Passo Acima
  #    steping : flag que indica número de passos
  #--------------------------------------------------------------------------
  def step_up(steping = false)
    turn_up
    @y -= 1
    increase_steps
  end
  #--------------------------------------------------------------------------
  # Passo Esquerda-Abaixo
  #    steping : flag que indica número de passos
  #--------------------------------------------------------------------------
  def step_lower_left(steping = false)
    turn_lower_left
    @x -= 1
    @y += 1
    increase_steps
  end
  #--------------------------------------------------------------------------
  # Passo Direita-Abaixo
  #    steping : flag que indica número de passos
  #--------------------------------------------------------------------------
  def step_lower_right(steping = false)
    turn_lower_right
    @x += 1
    @y += 1
    increase_steps
  end
  #--------------------------------------------------------------------------
  # Passo Esquerda-Acima
  #    steping : flag que indica número de passos
  #--------------------------------------------------------------------------
  def step_upper_left(steping = false)
    turn_upper_left
    @x -= 1
    @y -= 1
    increase_steps
  end
  #--------------------------------------------------------------------------
  # Passo Direita-Acima
  #    steping : flag que indica número de passos
  #--------------------------------------------------------------------------
  def step_upper_right(steping = false)
    turn_upper_right
    @x += 1
    @y -= 1
    increase_steps
  end
  #--------------------------------------------------------------------------
  # Olhar Esquerda-Abaixo
  #--------------------------------------------------------------------------
  def turn_lower_left
    unless @direction_fix
      @direction  = (@direction == 6 ? 4 : @direction == 8 ? 2 : @direction)
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  # Olhar Direita-Abaixo
  #--------------------------------------------------------------------------
  def turn_lower_right
    unless @direction_fix
      @direction  = (@direction == 4 ? 6 : @direction == 8 ? 2 : @direction)
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  # Olhar Esquerda-Acima
  #--------------------------------------------------------------------------
  def turn_upper_left
    unless @direction_fix
      @direction  = (@direction == 6 ? 4 : @direction == 2 ? 8 : @direction)
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  # Olhar Direita-Acima
  #--------------------------------------------------------------------------
  def turn_upper_right
    unless @direction_fix
      @direction  = (@direction == 4 ? 6 : @direction == 2 ? 8 : @direction)
      @stop_count = 0
    end
  end
  #--------------------------------------------------------------------------
  # Atualização do Frame
  #--------------------------------------------------------------------------
  def update
    fix_position
    if jumping?
      update_jump
    elsif moving?
      update_move
    else
      update_stop
    end
    update_animation
    return @wait_count -= 1 if @wait_count > 0
    return move_type_custom if @move_route_forcing
    return if @starting or lock?
    movement_update
  end
  #--------------------------------------------------------------------------
  # Atualização da animação
  #--------------------------------------------------------------------------
  def update_animation
    if @anime_count > 18 - @move_speed * 2
      if not @step_anime and @stop_count > 0
        @pattern = @original_pattern
      else
        @pattern = (@pattern + 1) % 4
      end
      @anime_count = 0
    end
  end
  #--------------------------------------------------------------------------
  # Atualização do movimento
  #--------------------------------------------------------------------------
  def movement_update
    if update_frequency and not moving?
      case @move_type
      when 1 then move_type_random
      when 2 then move_type_toward_player
      when 3 then move_type_custom
      end
    end
  end 
  #--------------------------------------------------------------------------
  # Verificação de frequencia de movimento
  #--------------------------------------------------------------------------
  def update_frequency
    return (@stop_count > (40 - @move_frequency * 2) * (6 - @move_frequency))
  end
  #--------------------------------------------------------------------------
  # Definição de distancia do movimento
  #--------------------------------------------------------------------------
  def distance
    return (2 ** @move_speed).to_i
  end
  #--------------------------------------------------------------------------
  # Atualização do Frame (Movimento)
  #--------------------------------------------------------------------------
  def update_move
    postion_update
    anime_count_update
  end
  #--------------------------------------------------------------------------
  # Atualização da Posição Atual
  #--------------------------------------------------------------------------
  def postion_update
    move_x = (@x * 128 + @move_x)
    move_y = (@y * 128 + @move_y)
    @real_y = [@real_y + distance, move_y].min.to_i if move_y > @real_y
    @real_x = [@real_x - distance, move_x].max.to_i if move_x < @real_x
    @real_x = [@real_x + distance, move_x].min.to_i if move_x > @real_x
    @real_y = [@real_y - distance, move_y].max.to_i if move_y < @real_y
  end
  #--------------------------------------------------------------------------
  # Correção de Posição
  #--------------------------------------------------------------------------
  def fix_position
    if @x != $game_map.round_x(@x)
      plus = $game_map.round_x(@x) - @x
      @x += plus
      @real_x += plus * 128
    end
    if @y != $game_map.round_y(@y)
      plus = $game_map.round_y(@y) - @y
      @y += plus
      @real_y += plus * 128
    end
  end
  #--------------------------------------------------------------------------
  # Coordenada X da tela
  #--------------------------------------------------------------------------
  def screen_x
    return ($game_map.adjust_x(@real_x) + 3) / 4 + 16
  end
  #--------------------------------------------------------------------------
  # Coordenada Y da tela
  #--------------------------------------------------------------------------
  def screen_y
    y = ($game_map.adjust_y(@real_y) + 3) / 4 + 32
    if @jump_count >= @jump_peak
      n = @jump_count - @jump_peak
    else
      n = @jump_peak - @jump_count
    end
    return y - (@jump_peak * @jump_peak - n * n) / 2
  end
  #--------------------------------------------------------------------------
  # Selecionar a Coordenada Z da Tela
  #    height : altura do Peronagem
  #--------------------------------------------------------------------------
  def screen_z(height = 0)
    return 999 if @always_on_top
    z = ($game_map.adjust_y(@real_y) + 3) / 4 + 32
    if @tile_id > 0
      return z + $game_map.priorities[@tile_id] * 32
    else
      return z + ((height > 32) ? 31 : 0)
    end
  end 
  #--------------------------------------------------------------------------
  # Atualização do Contador de Animação
  #--------------------------------------------------------------------------
  def anime_count_update
    if @walk_anime
      @anime_count += 1.5
    elsif @step_anime
      @anime_count += 1
    end
  end
  #--------------------------------------------------------------------------
  # Distância X do character
  #    character : Personagem
  #--------------------------------------------------------------------------
  def distance_x_from_character(character)
    sx = @x - character.x
    return sx
  end
  #--------------------------------------------------------------------------
  # Distância Y do character
  #    character : Personagem
  #--------------------------------------------------------------------------
  def distance_y_from_character(character)
    sy = @y - character.y
    return sy
  end
  #--------------------------------------------------------------------------
  # Seguir herói
  #--------------------------------------------------------------------------
  def move_toward_player
    sx = distance_x_from_character($game_player)
    sy = distance_y_from_character($game_player)
    if sx != 0 or sy != 0
      if sx.abs > sy.abs
        sx > 0 ? move_left : move_right
        sy > 0 ? move_up : move_down if not moving? and sy != 0
      else
        sy > 0 ? move_up : move_down
        sx > 0 ? move_left : move_right if not moving? and sx != 0
      end
    end
  end
  #--------------------------------------------------------------------------
  # Fugir do herói
  #--------------------------------------------------------------------------
  def move_away_from_player
    sx = distance_x_from_character($game_player)
    sy = distance_y_from_character($game_player)
    if sx != 0 or sy != 0
      if sx.abs > sy.abs
        sx > 0 ? move_right : move_left
        sy > 0 ? move_down : move_up if not moving? and sy != 0
      else
        sy > 0 ? move_down : move_up
        sx > 0 ? move_right : move_left if not moving? and sx != 0
      end
    end
  end
  #--------------------------------------------------------------------------
  # Olhar para o Herói
  #--------------------------------------------------------------------------
  def turn_toward_player
    sx = distance_x_from_character($game_player)
    sy = distance_y_from_character($game_player)
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_left : turn_right
    else
      sy > 0 ? turn_up : turn_down
    end
  end
  #--------------------------------------------------------------------------
  # Girar Herói (Contrário)
  #--------------------------------------------------------------------------
  def turn_away_from_player
    sx = distance_x_from_character($game_player)
    sy = distance_y_from_character($game_player)
    return if sx == 0 and sy == 0
    if sx.abs > sy.abs
      sx > 0 ? turn_right : turn_left
    else
      sy > 0 ? turn_down : turn_up
    end
  end   
  #--------------------------------------------------------------------------
  # Determinar número de quadros
  #--------------------------------------------------------------------------
  def frames
    return 4
  end
  #--------------------------------------------------------------------------
  # Definição de Largura
  #--------------------------------------------------------------------------
  def box_width
    @box_width = 128
    return @box_width
  end
  #--------------------------------------------------------------------------
  # Definição de Altura
  #--------------------------------------------------------------------------
  def box_height
    @box_height = 128
    return @box_height
  end
  #--------------------------------------------------------------------------
  # Determinar Jogador
  #--------------------------------------------------------------------------
  def player?
    return false
  end
  #--------------------------------------------------------------------------
  # Determinar Evento
  #--------------------------------------------------------------------------
  def event?
    return false
  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
  #--------------------------------------------------------------------------
  # Atualização do Frame
  #--------------------------------------------------------------------------
  def update
    last_real_postion
    move_by_input
    super
    update_scroll
    update_nonmoving
  end
  #--------------------------------------------------------------------------
  # Definição da ultima posição
  #--------------------------------------------------------------------------
  def last_real_postion
    @last_moving = moving?
    @last_real_x = @real_x
    @last_real_y = @real_y
  end
  #--------------------------------------------------------------------------
  # Movimento do personagem
  #--------------------------------------------------------------------------
  def move_by_input
    return unless movable?
    return if $game_system.map_interpreter.running?
    case Input.dir4
    when 2 then move_down
    when 4 then move_left
    when 6 then move_right
    when 8 then move_up
    end
  end
  #--------------------------------------------------------------------------
  # É possível mover?
  #--------------------------------------------------------------------------
  def movable?
    return false if moving?
    return false if @move_route_forcing
    return false if $game_temp.message_window_showing
    return true
  end
  #--------------------------------------------------------------------------
  # Processo de scroll (movimento de tela no mapa)
  #--------------------------------------------------------------------------
  def update_scroll
    ax1 = $game_map.adjust_x(@last_real_x)
    ay1 = $game_map.adjust_y(@last_real_y)
    ax2 = $game_map.adjust_x(@real_x)
    ay2 = $game_map.adjust_y(@real_y)
    $game_map.scroll_down(ay2 - ay1) if ay2 > ay1 and ay2 > CENTER_Y
    $game_map.scroll_left(ax1 - ax2) if ax2 < ax1 and ax2 < CENTER_X
    $game_map.scroll_right(ax2 - ax1) if ax2 > ax1 and ax2 > CENTER_X
    $game_map.scroll_up(ay1 - ay2) if ay2 < ay1 and ay2 < CENTER_Y
  end
  #--------------------------------------------------------------------------
  # Processo de não-movimento
  #    last_moving : último movimento do jogador
  #--------------------------------------------------------------------------
  def update_nonmoving
    return if moving?
    if @last_moving
      result = check_event_trigger_here([1,2])
      update_encounter unless result
    end
    if Input.trigger?(Input::C)
      check_event_trigger_here([0])
      check_event_trigger_there([0,1,2])
    end
  end
  #--------------------------------------------------------------------------
  # Processo de encontros aleatórios
  #--------------------------------------------------------------------------
  def update_encounter
    return if $DEBUG and Input.press?(Input::CTRL)
    @encounter_count -= 1 if @encounter_count > 0
  end
  #--------------------------------------------------------------------------
  # Determinar Jogador
  #--------------------------------------------------------------------------
  def player?
    return true
  end
  #--------------------------------------------------------------------------
  # Determinar Evento
  #--------------------------------------------------------------------------
  def event?
    return false
  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
  #--------------------------------------------------------------------------
  # Nome do Evento
  #--------------------------------------------------------------------------
  def name
    return @event.name
  end
  #--------------------------------------------------------------------------
  # Determinar Jogador
  #--------------------------------------------------------------------------
  def player?
    return false
  end
  #--------------------------------------------------------------------------
  # Determinar Evento
  #--------------------------------------------------------------------------
  def event?
    return true
  end
  #--------------------------------------------------------------------------
  # Retornar lista de comentários do evento
  #--------------------------------------------------------------------------
  def comments
    return [] if @page.nil? or @page.list.nil? or
                @page.list.size <= 0
    comment_list = []
    for item in @page.list
      next if item.nil?
      next unless item.code == 108 or item.code == 408
      comment_list << item.parameters[0]
    end
    return comment_list
  end 
end

#==============================================================================
# ** Sprite_Character
#------------------------------------------------------------------------------
# Esta é o script que exibe os sprites dos Heróis. Levando em consideração
# a classe Game_Character fazendo correções quando necessário.
#==============================================================================

class Sprite_Character < RPG::Sprite
  #--------------------------------------------------------------------------
  # Atualização do Frame
  #--------------------------------------------------------------------------
  def update
    super
    update_character
    update_rect
    update_misc
    update_battle_animation
  end
  #--------------------------------------------------------------------------
  # Atualização do gráfico do personagem
  #--------------------------------------------------------------------------
  def update_character
    return unless update_character?
    update_character_info
    if @tile_id >= 384
      set_tile_bitmap
    else
      set_character_bitmap
    end
  end
  #--------------------------------------------------------------------------
  # Determinar atualização do gráfico do personagem
  #--------------------------------------------------------------------------
  def update_character?
    return true if @tile_id != @character.tile_id
    return true if @character_name != @character.character_name
    return true if @character_hue != @character.character_hue
    return false
  end
  #--------------------------------------------------------------------------
  # Atualização das informações do personagem
  #--------------------------------------------------------------------------
  def update_character_info
    @tile_id = @character.tile_id
    @character_name = @character.character_name
    @character_hue = @character.character_hue
  end
  #--------------------------------------------------------------------------
  # Determinar bitmap se for um tile
  #--------------------------------------------------------------------------
  def set_tile_bitmap
    self.bitmap = RPG::Cache.tile($game_map.tileset_name,
      @tile_id, @character.character_hue)
    self.src_rect.set(0, 0, 32, 32)
    self.ox = 16
    self.oy = 32
  end
  #--------------------------------------------------------------------------
  # Determinar bitmap se for um personagem
  #--------------------------------------------------------------------------
  def set_character_bitmap
    self.bitmap = RPG::Cache.character(@character.character_name,
      @character.character_hue)
    @cw = bitmap.width / @character.frames
    @ch = bitmap.height / 4
    self.ox = @cw / 2
    self.oy = @ch
  end
  #--------------------------------------------------------------------------
  # Determinar direção
  #--------------------------------------------------------------------------
  def direction
    return @character.direction
  end
  #--------------------------------------------------------------------------
  # Atualização do retangulo do bitmap
  #--------------------------------------------------------------------------
  def update_rect
    if @tile_id == 0
      sx = @character.pattern * @cw
      sy = (direction - 2) / 2 * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
  end
  #--------------------------------------------------------------------------
  # Atualizações variadas
  #--------------------------------------------------------------------------
  def update_misc
    self.visible = (not @character.transparent)
    self.x = @character.screen_x
    self.y = @character.screen_y
    self.z = @character.screen_z(@ch)
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth   
  end
  #--------------------------------------------------------------------------
  # Atualização da animação
  #--------------------------------------------------------------------------
  def update_battle_animation
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
  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
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    create_viewports
    create_tilemap
    create_panorama
    create_fog
    create_characters
    create_weather
    create_pictures
    create_timer
    update
  end
  #--------------------------------------------------------------------------
  # Criação dos viewports
  #--------------------------------------------------------------------------
  def create_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
  end
  #--------------------------------------------------------------------------
  # Criação dos tiles
  #--------------------------------------------------------------------------
  def create_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
  end
  #--------------------------------------------------------------------------
  # Criação do panorama
  #--------------------------------------------------------------------------
  def create_panorama
    @panorama = Plane.new(@viewport1)
    @panorama.z = -1000
  end
  #--------------------------------------------------------------------------
  # Criação da névoa
  #--------------------------------------------------------------------------
  def create_fog
    @fog = Plane.new(@viewport1)
    @fog.z = 3000
  end
  #--------------------------------------------------------------------------
  # Criação dos characters
  #--------------------------------------------------------------------------
  def create_characters
    @character_sprites = []
    for i in $game_map.events.keys.sort
      sprite = Sprite_Character.new(@viewport1, $game_map.events[i])
      @character_sprites.push(sprite)
    end
    @character_sprites.push(Sprite_Character.new(@viewport1, $game_player))
  end
  #--------------------------------------------------------------------------
  # Criação do clima
  #--------------------------------------------------------------------------
  def create_weather
    @weather = RPG::Weather.new(@viewport1)
  end
  #--------------------------------------------------------------------------
  # Criação das pictures
  #--------------------------------------------------------------------------
  def create_pictures
    @picture_sprites = []
    for i in 1..50
      @picture_sprites.push(Sprite_Picture.new(@viewport2,
        $game_screen.pictures[i]))
    end
  end
  #--------------------------------------------------------------------------
  # Criação do timer
  #--------------------------------------------------------------------------
  def create_timer
    @timer_sprite = Sprite_Timer.new
  end
  #--------------------------------------------------------------------------
  # Dispose
  #--------------------------------------------------------------------------
  def dispose
    dispose_tilemap
    dispose_panorama
    dispose_fog
    dispose_characters
    dispose_weather
    dispose_pictures
    dispose_timer
    dispose_viewports
  end
  #--------------------------------------------------------------------------
  # Dispose dos tiles
  #--------------------------------------------------------------------------
  def dispose_tilemap
    @tilemap.tileset.dispose
    for i in 0..6
      @tilemap.autotiles[i].dispose
    end
    @tilemap.dispose
  end
  #--------------------------------------------------------------------------
  # Dispose do panorama
  #--------------------------------------------------------------------------
  def dispose_panorama
    @panorama.dispose
  end
  #--------------------------------------------------------------------------
  # Dispose da névoa
  #--------------------------------------------------------------------------
  def dispose_fog
    @fog.dispose
  end
  #--------------------------------------------------------------------------
  # Dispose dos characters
  #--------------------------------------------------------------------------
  def dispose_characters
    for sprite in @character_sprites
      sprite.dispose
    end
  end
  #--------------------------------------------------------------------------
  # Dispose dos tempos
  #--------------------------------------------------------------------------
  def dispose_weather
    @weather.dispose
  end
  #--------------------------------------------------------------------------
  # Dispose das pictures
  #--------------------------------------------------------------------------
  def dispose_pictures
    for sprite in @picture_sprites
      sprite.dispose
    end
  end
  #--------------------------------------------------------------------------
  # Dispose do timer
  #--------------------------------------------------------------------------
  def dispose_timer
    @timer_sprite.dispose
  end
  #--------------------------------------------------------------------------
  # Dispose dos viewports
  #--------------------------------------------------------------------------
  def dispose_viewports
    @viewport1.dispose
    @viewport2.dispose
    @viewport3.dispose
  end
  #--------------------------------------------------------------------------
  # Atualização da tela
  #--------------------------------------------------------------------------
  def update
    update_tilemap
    update_panorama
    update_fog
    update_characters
    update_weather
    update_pictures
    update_timer
    update_viewports
  end
  #--------------------------------------------------------------------------
  # Atualização dos tiles
  #--------------------------------------------------------------------------
  def update_tilemap
    @tilemap.ox = $game_map.display_x / 4
    @tilemap.oy = $game_map.display_y / 4
    @tilemap.update
  end
  #--------------------------------------------------------------------------
  # Atualização do panorama
  #--------------------------------------------------------------------------
  def update_panorama
    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
    @panorama.ox = $game_map.display_x / 8
    @panorama.oy = $game_map.display_y / 8
  end
  #--------------------------------------------------------------------------
  # Atualização da névoa
  #--------------------------------------------------------------------------
  def update_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
    @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
  end
  #--------------------------------------------------------------------------
  # Atualização dos characters
  #--------------------------------------------------------------------------
  def update_characters
    for sprite in @character_sprites
      sprite.update
    end
  end
  #--------------------------------------------------------------------------
  # Atualização do clima
  #--------------------------------------------------------------------------
  def update_weather
    @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
  end
  #--------------------------------------------------------------------------
  # Atualização das pictures
  #--------------------------------------------------------------------------
  def update_pictures
    for sprite in @picture_sprites
      sprite.update
    end
  end
  #--------------------------------------------------------------------------
  # Atualização do timer
  #--------------------------------------------------------------------------
  def update_timer
    @timer_sprite.update
  end
  #--------------------------------------------------------------------------
  # Atualização dos viewports
  #--------------------------------------------------------------------------
  def update_viewports
    @viewport1.tone = $game_screen.tone
    @viewport1.ox = $game_screen.shake
    @viewport3.color = $game_screen.flash_color
    @viewport1.update
    @viewport3.update
  end
end

Perguntas Frequentes

Pergunta: Fuincona no VX? Você pode fazer um para VX?
Resposta: Respectivamente: não e não.

Pergunta: Por que o nome 'Legacy Engine'?
Resposta:
Muitos dos sistemas que irei disponibilizar, inicialmente foram
projetados para meu projeto 'Legado da Existência'. Por isso decidi
nomea-lo com algo que lembre o nome do meu projeto (Para quem não sabe,
Legacy = Legado em inglês)

Pergunta: Por que o nome em inglês? Não é você que sempre reclama de estrangeirismo nos projetos?
Resposta: Eu pretendo divulgar esse sistema em comunidades estrangeiras. Simplismente por isso.

Créditos e Agradecimentos
•Feito por Victor Sant

Tópico trancado por ser mt antigo.

By: -Luffy