Sistema de pegar carros

Eu tava pensando o que eu ia fazer,mas eu nao pensava nada de novo
para a RMB ai eu olhei um tópico de montaria e de carro,mas era muito
complicado,ai eu resolvi só dá um conselho para o de carro,mas vamos ao que interessa.
Vá em scripts,e va na aba Game_Vehicle,nesse script procure um nome verde "Atualização",embaixo dele tem isto @priority_type = 1
@move_speed = 4
substitua o 4 por um 6.
Após ter feito isso, cole esse script acima do Main:

Código:


#===============================================================================
#Script de veiculo terrestre
#Criado pelo: M3V
#Site: Mundorpgmaker.com
#quarto Script
#Marca: M3V
#Cole acima do Main
#Sites Compartilhados (Mundorpgmaker.com | Reinorpg.com | Brasilmaker.com)
#===============================================================================
#===============================================================================
#==================================M3V==========================================
#===============================================================================

#==============================================================================
# Game_Map
#------------------------------------------------------------------------------
# Esta classe controla o mapa do jogo. Funções como passagem, scroll e loop
# são definidas aqui. Pode ser acessada utilizando $game_map.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader  :screen                  # Tela do mapa
  attr_reader  :interpreter              # Interpretador de eventos
  attr_reader  :display_x                # Coordenada X * 256
  attr_reader  :display_y                # Coordenada Y * 256
  attr_reader  :parallax_name            # Arquivo de panorama
  attr_reader  :passages                # Tabela de passagem
  attr_reader  :events                  # Eventos
  attr_reader  :vehicles                # Veículos
  attr_accessor :need_refresh            # Atualização
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    @screen = Game_Screen.new
    @interpreter = Game_Interpreter.new(0, true)
    @map_id = 0
    @display_x = 0
    @display_y = 0
    create_vehicles
  end
  #--------------------------------------------------------------------------
  # Configuração inicial
  #    map_id : ID do mapa
  #--------------------------------------------------------------------------
  def setup(map_id)
    @map_id = map_id
    @map = load_data(sprintf("Data/Map%03d.rvdata", @map_id))
    @display_x = 0
    @display_y = 0
    @passages = $data_system.passages
    referesh_vehicles
    setup_events
    setup_scroll
    setup_parallax
    @need_refresh = false
  end
  #--------------------------------------------------------------------------
  # Criar veículos
  #--------------------------------------------------------------------------
  def create_vehicles
    @vehicles = []
    @vehicles[0] = Game_Vehicle.new(0)    # Barco
    @vehicles[1] = Game_Vehicle.new(1)    # Navio
    @vehicles[2] = Game_Vehicle.new(2)    # Airship
  end
  #--------------------------------------------------------------------------
  # Atualizar veículos
  #--------------------------------------------------------------------------
  def referesh_vehicles
    for vehicle in @vehicles
      vehicle.refresh
    end
  end
  #--------------------------------------------------------------------------
  # Criar barco
  #--------------------------------------------------------------------------
  def boat
    return @vehicles[0]
  end
  #--------------------------------------------------------------------------
  # Criar navio
  #--------------------------------------------------------------------------
  def ship
    return @vehicles[1]
  end
  #--------------------------------------------------------------------------
  # Criar airship
  #--------------------------------------------------------------------------
  def airship
    return @vehicles[2]
  end
  #--------------------------------------------------------------------------
  # Configurar eventos
  #--------------------------------------------------------------------------
  def setup_events
    @events = {}          # Eventos do mapa
    for i in @map.events.keys
      @events[i] = Game_Event.new(@map_id, @map.events[i])
    end
    @common_events = {}  # Eventos comuns
    for i in 1...$data_common_events.size
      @common_events[i] = Game_CommonEvent.new(i)
    end
  end
  #--------------------------------------------------------------------------
  # Configurar scroll (movimento de tela no mapa)
  #--------------------------------------------------------------------------
  def setup_scroll
    @scroll_direction = 2
    @scroll_rest = 0
    @scroll_speed = 4
    @margin_x = (width - 17) * 256 / 2      # Largura da imagem / 2
    @margin_y = (height - 13) * 256 / 2    # Altura da imagem / 2
  end
  #--------------------------------------------------------------------------
  # Configurar panoramas
  #--------------------------------------------------------------------------
  def setup_parallax
    @parallax_name = @map.parallax_name
    @parallax_loop_x = @map.parallax_loop_x
    @parallax_loop_y = @map.parallax_loop_y
    @parallax_sx = @map.parallax_sx
    @parallax_sy = @map.parallax_sy
    @parallax_x = 0
    @parallax_y = 0
  end
  #--------------------------------------------------------------------------
  # Posicionar panoramas
  #    x : coordenada X (*256)
  #    y : coordenada Y (*256)
  #--------------------------------------------------------------------------
  def set_display_pos(x, y)
    @display_x = (x + @map.width * 256) % (@map.width * 256)
    @display_y = (y + @map.height * 256) % (@map.height * 256)
    @parallax_x = x
    @parallax_y = y
  end
  #--------------------------------------------------------------------------
  # Calcular coordenada X do panorama
  #    bitmap : bitmap do panorama
  #--------------------------------------------------------------------------
  def calc_parallax_x(bitmap)
    if bitmap == nil
      return 0
    elsif @parallax_loop_x
      return @parallax_x / 16
    elsif loop_horizontal?
      return 0
    else
      w1 = bitmap.width - 544
      w2 = @map.width * 32 - 544
      if w1 <= 0 or w2 <= 0
        return 0
      else
        return @parallax_x * w1 / w2 / 8
      end
    end
  end
  #--------------------------------------------------------------------------
  # Calcular coordenada Y do panorama
  #    bitmap : bitmap do panorama
  #--------------------------------------------------------------------------
  def calc_parallax_y(bitmap)
    if bitmap == nil
      return 0
    elsif @parallax_loop_y
      return @parallax_y / 16
    elsif loop_vertical?
      return 0
    else
      h1 = bitmap.height - 416
      h2 = @map.height * 32 - 416
      if h1 <= 0 or h2 <= 0
        return 0
      else
        return @parallax_y * h1 / h2 / 8
      end
    end
  end
  #--------------------------------------------------------------------------
  # ID do mapa
  #--------------------------------------------------------------------------
  def map_id
    return @map_id
  end
  #--------------------------------------------------------------------------
  # Largura do mapa
  #--------------------------------------------------------------------------
  def width
    return @map.width
  end
  #--------------------------------------------------------------------------
  # Altura do mapa
  #--------------------------------------------------------------------------
  def height
    return @map.height
  end
  #--------------------------------------------------------------------------
  # Criar loop na horizontal?
  #--------------------------------------------------------------------------
  def loop_horizontal?
    return (@map.scroll_type == 2 or @map.scroll_type == 3)
  end
  #--------------------------------------------------------------------------
  # Criar loop na vertical?
  #--------------------------------------------------------------------------
  def loop_vertical?
    return (@map.scroll_type == 1 or @map.scroll_type == 3)
  end
  #--------------------------------------------------------------------------
  # Proibir correr?
  #--------------------------------------------------------------------------
  def disable_dash?
    return @map.disable_dashing
  end
  #--------------------------------------------------------------------------
  # Encontros aleatórios (lista de grupos inimigos)
  #--------------------------------------------------------------------------
  def encounter_list
    return @map.encounter_list
  end
  #--------------------------------------------------------------------------
  # Número de encontros aleatórios
  #--------------------------------------------------------------------------
  def encounter_step
    return @map.encounter_step
  end
  #--------------------------------------------------------------------------
  # Informções do mapa
  #--------------------------------------------------------------------------
  def data
    return @map.data
  end
  #--------------------------------------------------------------------------
  # Cálculo de redução da coordenada X padrão
  #    x : coordenada X
  #--------------------------------------------------------------------------
  def adjust_x(x)
    if loop_horizontal? and x < @display_x - @margin_x
      return x - @display_x + @map.width * 256
    else
      return x - @display_x
    end
  end
  #--------------------------------------------------------------------------
  # Cálculo de redução da coordenada Y padrão
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def adjust_y(y)
    if loop_vertical? and y < @display_y - @margin_y
      return y - @display_y + @map.height * 256
    else
      return y - @display_y
    end
  end
  #--------------------------------------------------------------------------
  # Cálculo da coordenada X após o loop
  #    x : coordenada X
  #--------------------------------------------------------------------------
  def round_x(x)
    if loop_horizontal?
      return (x + width) % width
    else
      return x
    end
  end
  #--------------------------------------------------------------------------
  # Cálculo da coordenada Y após o loop
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def round_y(y)
    if loop_vertical?
      return (y + height) % height
    else
      return y
    end
  end
  #--------------------------------------------------------------------------
  # Cálculo da coordenada X para direção
  #    x        : coordenada X
  #    direction : direção (2,4,6,8)
  #--------------------------------------------------------------------------
  def x_with_direction(x, direction)
    return round_x(x + (direction == 6 ? 1 : direction == 4 ? -1 : 0))
  end
  #--------------------------------------------------------------------------
  # Cálculo da coordenada Y para direção
  #    y        : coordenada Y
  #    direction : direção (2,4,6,8)
  #--------------------------------------------------------------------------
  def y_with_direction(y, direction)
    return round_y(y + (direction == 2 ? 1 : direction == 8 ? -1 : 0))
  end
  #--------------------------------------------------------------------------
  # Arranjo do evento localizado na posição definida
  #    x : coordenada X
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def events_xy(x, y)
    result = []
    for event in $game_map.events.values
      result.push(event) if event.pos?(x, y)
    end
    return result
  end
  #--------------------------------------------------------------------------
  # Mudança automática de BGM / BGS
  #--------------------------------------------------------------------------
  def autoplay
    @map.bgm.play if @map.autoplay_bgm
    @map.bgs.play if @map.autoplay_bgs
  end
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh
    if @map_id > 0
      for event in @events.values
        event.refresh
      end
      for common_event in @common_events.values
        common_event.refresh
      end
    end
    @need_refresh = false
  end
  #--------------------------------------------------------------------------
  # Direção do scroll (abaixo)
  #    distance : distância do scroll
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    if loop_vertical?
      @display_y += distance
      @display_y %= @map.height * 256
      @parallax_y += distance
    else
      last_y = @display_y
      @display_y = [@display_y + distance, (height - 13) * 256].min
      @parallax_y += @display_y - last_y
    end
  end
  #--------------------------------------------------------------------------
  # Direção do scroll (esquerda)
  #    distance : distância do scroll
  #--------------------------------------------------------------------------
  def scroll_left(distance)
    if loop_horizontal?
      @display_x += @map.width * 256 - distance
      @display_x %= @map.width * 256
      @parallax_x -= distance
    else
      last_x = @display_x
      @display_x = [@display_x - distance, 0].max
      @parallax_x += @display_x - last_x
    end
  end
  #--------------------------------------------------------------------------
  # Direção do scroll (direita)
  #    distance : distância do scroll
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    if loop_horizontal?
      @display_x += distance
      @display_x %= @map.width * 256
      @parallax_x += distance
    else
      last_x = @display_x
      @display_x = [@display_x + distance, (width - 17) * 256].min
      @parallax_x += @display_x - last_x
    end
  end
  #--------------------------------------------------------------------------
  # Direção do scroll (acima)
  #    distance : distância do scroll
  #--------------------------------------------------------------------------
  def scroll_up(distance)
    if loop_vertical?
      @display_y += @map.height * 256 - distance
      @display_y %= @map.height * 256
      @parallax_y -= distance
    else
      last_y = @display_y
      @display_y = [@display_y - distance, 0].max
      @parallax_y += @display_y - last_y
    end
  end
  #--------------------------------------------------------------------------
  # Verificação da coordenada
  #    x : coordenada X
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def valid?(x, y)
    return (x >= 0 and x < width and y >= 0 and y < height)
  end
  #--------------------------------------------------------------------------
  # Verificação de passagem
  #    x    : coordenada X
  #    y    : coordenada Y
  #    flag : ´proibição da passagem (Em caso de 0x01 e veículos)
  #--------------------------------------------------------------------------
  def passable?(x, y, flag = 0x01)
    for event in events_xy(x, y)            # Evento a ser verificado
      next if event.tile_id == 0            # ID do tile gráfico
      next if event.priority_type > 0      # Prioridade (abaixo do herói)
      next if event.through                # Passagem
      pass = @passages[event.tile_id]      # Atributo passável
      next if pass & 0x10 == 0x10          # [*]: Nenhuma diferença
      return true if pass & flag == 0x00    # [O]: Passável
      return false if pass & flag == flag  # [X]: Não passável
    end
    for i in [2, 1, 0]                      # Layers do mapa, em ordem
      tile_id = @map.data[x, y, i]          # ID do tile gráfico
      return false if tile_id == nil  # Falha ao pegar ID resulta em não passar
      pass = @passages[tile_id]            # Atributo passável
      next if pass & 0x10 == 0x10          # [*]: Nenhuma diferença
      return true if pass & flag == 0x00    # [O]: Passável
      return false if pass & flag == flag  # [X]: Não passável
    end
    return false                            # Falha na passagem
  end
  #--------------------------------------------------------------------------
  # Barco pode passar?
  #    x : coordenada X
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def boat_passable?(x, y)
    return passable?(x, y, 0x08)
  end
  #--------------------------------------------------------------------------
  # Navio pode passar?
  #    x : coordenada X
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def ship_passable?(x, y)
    return passable?(x, y, 0x04)
  end
  #--------------------------------------------------------------------------
  # Airship pode pousar?
  #    x : coordenada X
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def airship_land_ok?(x, y)
    return passable?(x, y, 0x08)
  end
  #--------------------------------------------------------------------------
  # Está em um gramado?
  #    x : coordenada X
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def bush?(x, y)
    return false unless valid?(x, y)
    return @passages[@map.data[x, y, 1]] & 0x40 == 0x40
  end
  #--------------------------------------------------------------------------
  # É um balcão?
  #    x : coordenada X
  #    y : coordenada Y
  #--------------------------------------------------------------------------
  def counter?(x, y)
    return false unless valid?(x, y)
    return @passages[@map.data[x, y, 0]] & 0x80 == 0x80
  end
  #--------------------------------------------------------------------------
  # Início do scroll
  #    direction : direção do scroll
  #    distance  : distância do scroll
  #    speed    : velocidade do scroll
  #--------------------------------------------------------------------------
  def start_scroll(direction, distance, speed)
    @scroll_direction = direction
    @scroll_rest = distance * 256
    @scroll_speed = speed
  end
  #--------------------------------------------------------------------------
  # Scroll em andamento? (tela em movimento?)
  #--------------------------------------------------------------------------
  def scrolling?
    return @scroll_rest > 0
  end
  #--------------------------------------------------------------------------
  # Atualização da tela
  #--------------------------------------------------------------------------
  def update
    refresh if $game_map.need_refresh
    update_scroll
    update_events
    update_vehicles
    update_parallax
    @screen.update
  end
  #--------------------------------------------------------------------------
  # Atualização do scroll
  #--------------------------------------------------------------------------
  def update_scroll
    if @scroll_rest > 0                # Caso haja continuação do scroll
      distance = 2 ** @scroll_speed    # Converte para distância usando
      case @scroll_direction            # coordenadas do mapa
      when 2  # Abaixo
        scroll_down(distance)
      when 4  # Esquerda
        scroll_left(distance)
      when 6  # Direita
        scroll_right(distance)
      when 8  # Acima
        scroll_up(distance)
      end
      @scroll_rest -= distance          # Subtração da distância restante
    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 dos veículos
  #--------------------------------------------------------------------------
  def update_vehicles
    for vehicle in @vehicles
      vehicle.update
    end
  end
  #--------------------------------------------------------------------------
  # Atualização do panorama
  #--------------------------------------------------------------------------
  def update_parallax
    @parallax_x += @parallax_sx * 4 if @parallax_loop_x
    @parallax_y += @parallax_sy * 4 if @parallax_loop_y
  end
end


Agora mude o gráfico do bote para essa imagem:


Agora escolha um lugar em terra para colocar o bote que virou carro.
Pronto,agora teste e entre no carro que não tem mais aquela velocidade chaaaaata do bote!