MBS - Isometric

[Brandt]

[box2 class=titlebg]

MBS - Isometric

[/box2]

por Masked

Lag: Variável (depende do mapa)
Compatibilidade: Não testado
Facilidade: Médio

[box2 class=titlebg title=Introdução]Oe!
Finalmente terminei o script, consegui fazer rodar lindamente sem DLLs (bens a deus), apesar de alguns mapas travarem um pouco (principalmente quando tem paredes de 5 tiles de altura...), então mesmo sem os autotiles acho que já dá pra compartilhar com vocês esse meu monstrinho.[/box2]

[box2 class=titlebg title=Características]O script cria um mapa isométrico a partir de um mapa normal do maker, ele carrega os gráficos dos tiles isométricos de um arquivo na pasta do jogo (tipo um tileset normal, mas com tiles isométricos e com uma grade de 64x64), ele também permite que sejam feitos mapas com altura através das regiões, e você configura a altura máxima dos tiles (assim você pode usar as regiões restantes pra outras coisas).
Ele também tem um recurso que permite que os tiles que cobrirem algum char (evento, jogador, seguidor...) fique semi-transparente, pra dar pra ver eles.
Além disso, o movimento é em 8 direções.[/box2]

[box2 class=titlebg title=Instruções]Primeiro, configure no script (nas primeiras linhas) tudo que precisar.
Se quiser testar, use esse tileset (foi o que eu usei nas screens):

Spoiler

[close]

O resto está nas instruções no cabeçalho do script.[/box2]

[box2 class=titlebg title=Screenshots]

Spoiler

[close]

Spoiler

[close]

[/box2]

[box2 class=titlebg title=DEMO]4Shared[/box2]

[box2 class=titlebg title=Script]

Código: Script

#==============================================================================
# MBS - Isometric
#------------------------------------------------------------------------------
# por Masked
#==============================================================================
#==============================================================================
# Instruções
#------------------------------------------------------------------------------
# 1. Tileset
#
# O script usa um tileset com cubos isométricos, a grade do tileset deve ter
# 64 pixels, o tileset deve ter 8 colunas e no máximo 16 linhas.
# O primeiro tile do tileset será sempre transparente, então você pode por o 
# que quiser nele (um template pros blocos, por exemplo).
# Depois é só salvar o tileset na pasta do jogo e configurar o caminho do 
# arquivo.
# Os tilesets isométricos devem ter o nome dos tilesets no database (Ex.: 
# O tileset 'Mundo' no database carrega o tileset isométrico 'Mundo.png' na
# pasta escolhida)
#
# 2. Configuração no database
# 
# O tileset no database deve ter só os tiles A5 e B-E, qualquer outro tile será
# ignorado.
# Nas abas B-E, todos os tiles que tiverem uma continuação vertical (por 
# exemplo uma árvore) devem ser macados com terrenos, o terreno (0-7) determina
# a altura daquele tile (no exemplo da árvore, o tronco deve ser 0 e as folhas
# devem ser 1).
#
# 3. Mapas
# 
# Para definir um mapa como isométrico, é só adicionar "[Isometric]" 
# (sem aspas) às notas dele.
# O mapeamento é igual ao normal, a única diferença é que é possível definir a
# altura de um tile (para fazer uma parede, por exemplo), a altura máxima é
# definida nas configurações, não é recomendado mudar (além do que ninguém 
# deveria precisar de mais de 5 tiles de altura...), mas fique a vontade.
# Para definir a altura do tile, basta marcar ele com uma região (F7) de número
# correspondente à altura.
# Obs.: A altura do tile também influencia na passabilidade, um tile só é 
# passável se a diferença de altura entre ele e o char for menor que 2, isso 
# impede que o jogador pule sobre uma parede de 2 tiles de altura a menos que
# ele esteja em um tile com 1 de altura ou que ele pule de uma parede de 2 
# tiles de altura direto para o chão.
#==============================================================================
($imported ||= {})[:mbs_isometric] = true
#==============================================================================
module MBS
  module Isometric
#==============================================================================
# Configurações
#==============================================================================
    # Altura máxima de um tile
    MAX_HEIGHT = 5

    # Caso queira que as paredes fiquem transparentes quando um char passar por
    # trás dela deixe como true, se não deixe como false
    $view_behind = true

    # Pasta onde ficam os tilesets isométricos
    ISO_TILESET = 'Graphics/Iso/'
    
    # Caso queira que o movimento seja em 8 direções, deixe como true, se não,
    # mude para false
    DIR8 = true
#==============================================================================
# Fim das Configurações
#==============================================================================
    ISO_TAG = /[Isometric]/i
  end
end

#------------------------------------------------------------------------------
# Ajuste de performance
#------------------------------------------------------------------------------
Win32API.new('kernel32', 'SetPriorityClass', 'pi', 'i').call(-1, 0x080)
Graphics.frame_rate = 40

#==============================================================================
# ** Isomap
#------------------------------------------------------------------------------
# Esta classe desenha o mapa isométrico, bem como os chars do mapa
#==============================================================================
class Isomap
  
  #--------------------------------------------------------------------------
  # Inclusão do módulo MBS::Isometric
  #--------------------------------------------------------------------------
  include MBS::Isometric
  
  #--------------------------------------------------------------------------
  # Definição dos atributos
  #--------------------------------------------------------------------------
  attr_accessor :flags, :bitmaps, :characters, :ox, :oy, :viewport
  attr_reader :sprite, :data
  
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #     viewport : A camada da tela onde fica o sprite
  #--------------------------------------------------------------------------
  def initialize(viewport)
    @viewport = viewport
    setup
  end
  
  #--------------------------------------------------------------------------
  # * Configuração das variáveis
  #--------------------------------------------------------------------------
  def setup
    @ox = 0
    @oy = 0
    @tileset = nil
    @data = nil
    @todraw = nil
    @flags = []
    @bitmaps = []
    @characters = []
    @sprite = Sprite.new(self.viewport)
    @sprite.z = 200
    @sprite.bitmap = Bitmap.new(Graphics.width, Graphics.height)
  end

  #--------------------------------------------------------------------------
  # * Atualização do objeto
  #--------------------------------------------------------------------------
  def update
    @sprite.update
    return unless @tileset
    draw_sprites
  end
  
  #--------------------------------------------------------------------------
  # * Definição do tileset isométrico
  #     name : Nome do arquivo de tileset
  #--------------------------------------------------------------------------
  def data=(table)
    @data = table
    @todraw = Table.new(table.xsize, table.ysize, 7)
  end
  
  #--------------------------------------------------------------------------
  # * Definição do tileset isométrico
  #     name : Nome do arquivo de tileset
  #--------------------------------------------------------------------------
  def tileset=(name)
    @tileset = Bitmap.new(ISO_TILESET + name)
  end
  
  #--------------------------------------------------------------------------
  # * Verificação de se um char está atrás de um bloco na posição XY
  #     x : Coordenada X
  #     y : Coordenada Y
  #     h : Altura do bloco
  #--------------------------------------------------------------------------
  def char_hidden?(x, y, h)
    @characters.each do |spr|
      next unless spr.visible
      char = spr.character
      ch = char.region_id % (MAX_HEIGHT + 1)
      next if ch >= h
      return true if catch(:any) do
        (1...(h - ch)).each do |i|
          throw(:any, true) if (char.x == x && char.y == y - i || 
           char.x == x - i && char.y == y || 
           char.x == x - i && char.y == y - i)
         end
         false
      end
    end
    false
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição do ID de um tile A5
  #--------------------------------------------------------------------------
  def tileA5(id)
    return id - 0x600 # 0x600 = 1536 (número de tiles A1-A4)
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição da região de um tile
  #--------------------------------------------------------------------------
  def region_id(x, y)
    (data[x, y, 3] >> 8) % (MAX_HEIGHT + 1)
  end
  
  #-------------------------------------------------------------------------- 
  # * Desenho dos sprites na tela
  #--------------------------------------------------------------------------
  def draw_sprites
    return unless @data
    @sprite.bitmap.clear
    return if @data.xsize <= 0 || @data.ysize <= 0
    for y in 0...@data.ysize
      for x in 0...@data.xsize
        catch(:draw) do
          # Desenho do bloco de chão/parede
          tile_id = data[x, y, 0]
          id = tileA5(tile_id)
          if id > 0 && id <= 128
            region = region_id(x, y)
            draw_block(x, y, id, $view_behind ? char_hidden?(x, y, region) : false)
          end
          
          # Desenho dos tiles B-E (Abaixo do personagem)
          tile_id = data[x, y, 2]
          if (tile_id || 0) >= 0 && flags[tile_id] & 0x0010 == 0       
            draw_second_layer(x, y, tile_id)
          end
          
          # Desenho dos chars
          @characters.select do |spr| 
            spr.visible && spr.character.real_x.ceil == x && 
            spr.character.real_y.ceil == y
          end.each do |spr|
            draw_character(spr)
          end
          
          # Desenho dos tiles B-E (Acima do personagem)
          if (tile_id || 0) <= 0 || flags[tile_id] & 0x0010 == 0 
            next
          else
            draw_second_layer(x, y, tile_id)
          end
        end
      end
    end
  end
  
  #--------------------------------------------------------------------------
  # * Ajuste das coordenadas
  #     x : Coordenada X
  #     y : Coordenada Y
  #--------------------------------------------------------------------------
  def adjust_xy(x, y)
    [x - self.ox - 32, y - self.oy + (MAX_HEIGHT + 1) * 32]
  end
  
  #--------------------------------------------------------------------------
  # * Desenho de um bloco de tile na tela
  #     a          : Coordenada X
  #     y          : Coordenada Y
  #     id         : ID do tile
  #     translucid : Se o tile será semi-transparente ou não
  #--------------------------------------------------------------------------
  def draw_block(a, b, id, translucid=false)
    return if id <= 0
    # Retângulo do bloco no tileset
    rect = Rect.new((id % 8) * 64, (id / 8) * 64, 64, 64)
    
    # Coordenadas
    x = (a - b) * 32
    y = (a + b) * 16
    x, y = *adjust_xy(x, y)
    
    # Altura do bloco
    height = region_id(a, b) 
    
    # Interrompe o desenho se estiver fora da tela
    return if x < -64 || y < -64
    if x >= Graphics.width || (y - MAX_HEIGHT * 32 - 32) >= Graphics.height
      throw(:draw)
    end

    # Desenho do bloco
    @sprite.bitmap.blt(x, y, @tileset, rect)
    for h in 1..height
      @sprite.bitmap.blt(x, y - h * 32, @tileset, rect, translucid ? 50 : 255)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Desenho de um tile da segunda camada na tela
  #--------------------------------------------------------------------------
  def draw_second_layer(a, b, tile_id)
    
    # Valores do tile
    id = tile_id % 0x100                     # ID do tile
    lt = tile_id / 0x100                     # Tileset (0-4)
    tt = (@flags[tile_id] & 0xf000) / 0x1000 # Tag de terreno do tile (0-7)
    height = (data[a, b + tt, 3] >> 8) % (MAX_HEIGHT + 1) # Altura do tile
    
    # Alistamento do tile para desenho posterior
    if tt > 0 && @todraw[a, b+tt, tt-1] != tile_id
      @todraw[a, b+tt, tt-1] = tile_id
      return
    end
    
    # Desenho dos tiles alistados
    for i in 0...7
      if @todraw[a, b, i] > 0
        draw_second_layer(a, b-i-1, @todraw[a, b, i])
        @todraw[a, b, i] = 0
      end
    end
    
    # Bitmap do tileset
    bmp = @bitmaps[5 + lt] 
    
    # Coordenadas
    a -= tt
    x = (a - b) * 32
    y = (a + b) * 16
    x, y = *adjust_xy(x, y)
    
    # Retângulo do tile
    if id < 128
      rect = Rect.new((id % 8) * 32, (id / 8) * 32, 32, 32)
    else
      id -= 128
      rect = Rect.new((id % 8) * 32 + 256, (id / 8) * 32, 32, 32)
    end 
    
    # Desenho do tile
    @sprite.bitmap.blt(x + 16, y - 8 - height * 32, bmp, rect)
  end
  
  #--------------------------------------------------------------------------
  # * Desenho de um char na tela
  #--------------------------------------------------------------------------
  def draw_character(sprite)
    return unless sprite.is_a?(Sprite_Character)
    # Coordenadas
    x, y = *adjust_xy(sprite.x - sprite.ox, sprite.y - sprite.oy)
    
    return if x < -64 || y < -64 || x >= Graphics.width || (y - sprite.src_rect.height) >= Graphics.height
    
    # Desenho do char
    @sprite.bitmap.blt(x, y, sprite.bitmap, sprite.src_rect)
  end
  
  #--------------------------------------------------------------------------
  # * Disposição do objeto
  #--------------------------------------------------------------------------
  def dispose
    @sprite.dispose
  end
end

#==============================================================================
# * Game_CharacterBase
#------------------------------------------------------------------------------
# Aqui são feitas as modificações nos characters para corrigir a posição na
# tela e ajustar o movimento diagonal
#==============================================================================
class Game_CharacterBase
  #--------------------------------------------------------------------------
  # Alias
  #--------------------------------------------------------------------------
  alias mbsisomovediagonal move_diagonal
  alias mbsisomovestraight move_straight
  alias mbsisomappassable map_passable?
  alias mbsisoscreenx screen_x
  alias mbsisoscreeny screen_y
  alias mbsisoshifty shift_y
  alias mbsisoopacity opacity
  
  #--------------------------------------------------------------------------
  # * Definição de coordenada X na tela
  #--------------------------------------------------------------------------
  def screen_x
    return (@real_x - @real_y + 1) * 32 if $game_map.isometric?
    mbsisoscreenx
  end
  #--------------------------------------------------------------------------
  # * Definição de coordenada Y na tela
  #--------------------------------------------------------------------------
  def screen_y
    if $game_map.isometric?
      return (@real_x + @real_y + 1) * 16 - shift_y - jump_height - region_height
    end
    mbsisoscreeny
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição da altura do char de acordo com a região
  #--------------------------------------------------------------------------
  def region_height
    (region_id % (MBS::Isometric::MAX_HEIGHT + 1)) * 32 
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição da mudança de posição sobre tile
  #--------------------------------------------------------------------------
  def shift_y
    return 0 if $game_map.isometric?
    mbsisoshifty
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição da opacidade do char
  #--------------------------------------------------------------------------
  def opacity
    return 0 if $game_map.isometric?
    mbsisoopacity 
  end
  
  #--------------------------------------------------------------------------
  # * Movimento na diagonal
  #     horz : Direção horizontal (4 ou 6)
  #     vert : Direção vertical (2 ou 8)
  #--------------------------------------------------------------------------
  def move_diagonal(horz, vert)
    # Ajuste de velocidade
    if $game_map.isometric?
      if (horz == 4 && vert == 2) || (horz == 6 && vert == 8)
        unless @dsa
          @move_speed /= 1.25
          @dsa = true
        end
      elsif @dsa
        @move_speed *= 1.25
        @dsa = false
      end
    end
    mbsisomovediagonal(horz, vert)
  end
  
  #--------------------------------------------------------------------------
  # * Movimento em linha reta
  #--------------------------------------------------------------------------
  def move_straight(*args)
    # Ajuste de velocidade
    if @dsa
      @move_speed *= 1.25
      @dsa = false
    end
    mbsisomovestraight(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Aquisição da diferença entre as regiões do character e do tile XY no 
  #   mapa
  #     x : coordenada X
  #     y : coordenada Y
  #--------------------------------------------------------------------------
  def region_difference(x, y)
    mh = MBS::Isometric::MAX_HEIGHT
    (($game_map.region_id(x, y) % (mh + 1)) - (region_id % (mh + 1))).abs
  end
  
  #--------------------------------------------------------------------------
  # * Definição de passagem no mapa
  #     x : coordenada X
  #     y : coordenada Y
  #     d : direção (2,4,6,8)
  #--------------------------------------------------------------------------
  def map_passable?(x, y, d)
    if $game_map.isometric?
      return mbsisomappassable(x, y, d) && region_difference(x, y) < 2
    end
    mbsisomappassable(x, y, d)
  end
end

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
# Aqui são feitas as modificações para evitar que a tela mude de posição
#==============================================================================
class Game_Map  
  #--------------------------------------------------------------------------
  # Alias
  #--------------------------------------------------------------------------
  alias mbsisosetdisplaypos set_display_pos
  
  #--------------------------------------------------------------------------
  # * Definir a posição de exibição
  #     x : coordenada X de exibição
  #     y : coordenada Y de exibição
  #--------------------------------------------------------------------------
  def set_display_pos(x, y)
    if isometric?
      @parallax_x = x
      @parallax_y = y
    else
      mbsisosetdisplaypos(x, y)
    end
  end
  
  #--------------------------------------------------------------------------
  # * Verificação de se o mapa é isométrico
  #--------------------------------------------------------------------------
  def isometric?
    !@map.note[MBS::Isometric::ISO_TAG].nil?
  end
end

#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
# Aqui são feitas as modificações para evitar que a tela mude de posição e para
# o movimento diagonal
#==============================================================================
class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  # Alias
  #--------------------------------------------------------------------------
  alias mbsisoupdatescroll update_scroll
  
  #--------------------------------------------------------------------------
  # * Atualização da rolagem
  #     last_real_x : ultima coordenada X real
  #     last_real_y : ultima coordenada Y real
  #--------------------------------------------------------------------------
  def update_scroll(*args)
    return if $game_map.isometric?
    mbsisoupdatescroll(*args)
  end
  
  #--------------------------------------------------------------------------
  # Movimento diagonal
  #--------------------------------------------------------------------------
  if MBS::Isometric::DIR8
    #------------------------------------------------------------------------
    # * Processamento de movimento através de pressionar tecla
    #------------------------------------------------------------------------
    def move_by_input
      return if !movable? || $game_map.interpreter.running?
      case Input.dir8
      when 1 # Esquerda-cima
        @direction = 4
        move_diagonal(4,2)
      when 2 # Cima
        move_straight(2)
      when 3 # Direita-cima
        @direction = 2
        move_diagonal(6,2)
      when 4 # Esquerda
        move_straight(4)
      when 6 # Direita
        move_straight(6)
      when 7 # Esquerda-baixo
        @direction = 8
        move_diagonal(4,8)
      when 8 # Baixo
        move_straight(8)
      when 9 # Direita-baixo
        @direction = 6
        move_diagonal(6,8)
      end
    end
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
# Aqui são feitas as modificações nos sprites do mapa para se mostrar o Isomap
# e não o Tilemap
#==============================================================================
class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Alias
  #--------------------------------------------------------------------------
  alias mbsisoinitialize initialize
  alias mbsisoloadtileset load_tileset
  alias mbsisoupdatetilemap update_tilemap
  alias mbsisocreatetilemap create_tilemap
  
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize(*args)
    mbsisoinitialize(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Criação do tilemap
  #--------------------------------------------------------------------------
  def create_tilemap
    mbsisocreatetilemap
    setup_tilemap
  end
  
  #--------------------------------------------------------------------------
  # * Configuração do tilemap
  #--------------------------------------------------------------------------
  def setup_tilemap
    if @tilemap.is_a?(Tilemap) && $game_map.isometric?
      @tilemap = Isomap.new(@viewport1)
      load_tileset
    elsif @tilemap.is_a?(Isomap) && !$game_map.isometric?
      mbsisocreatetilemap
    end
  end
  
  #--------------------------------------------------------------------------
  # * Atualização do tilemap
  #--------------------------------------------------------------------------
  def update_tilemap
    setup_tilemap
    if @tilemap.is_a?(Isomap)
      @tilemap.data = $game_map.data
      @tilemap.characters = @character_sprites
      @tilemap.ox = $game_player.screen_x - Graphics.width / 2 + $game_map.display_x * 32
      @tilemap.oy = $game_player.screen_y - Graphics.height / 2 + (MBS::Isometric::MAX_HEIGHT + 1) * 32 + $game_map.display_y * 16
      @tilemap.update
    else
      mbsisoupdatetilemap
    end
  end
  
  #--------------------------------------------------------------------------
  # * Carregamento dos tilesets
  #--------------------------------------------------------------------------
  def load_tileset
    mbsisoloadtileset
    @tilemap.tileset = @tileset.name if @tilemap.is_a?(Isomap)
  end
  
  #--------------------------------------------------------------------------
  # * Disposição do tilemap
  #--------------------------------------------------------------------------
  def dispose_tilemap
    @tilemap.dispose
  end
end

[/box2]

[box2 class=titlebg title=Créditos e Agradecimentos]- a mim por criar[/box2]

[Geraldo de Rívia]

Caraca, isso é lindo! 
Eu até já tinha visto, acho que em vídeos randoms espalhados por aí, mas aparentemente era algo
muito complicado de se usar, talvez por estarem em outros idiomas também.
Mas muito bom mesmo, já fico feliz se um dia eu animar a tentar fazer um tactical, que é um gênero
que curto muito. Vai sair uma batalha nesse mapa também? 

[Drake]

Caramba filhão ta trabalhando duro heim , meus parabéns está ficando ótimo ,
depois de prontinho e testado esse script vai abrir muitas portas e idéias ai no centro !

[Silverlake]

Uau, que script legal. 
Já consegui imaginá-lo em um jogo de RPG tático assim como FFTatics.
Pde crer que isso será muito útil. Tá de parabéns.

[miguel8884]

Realmente a um script a ponto de se aplaudir e muito, grande conquista Masked, mostre para o mundo que pessoas que 14 anos não sabem apenas gritar HUEHUE. Meus parabéns 

[Makers]

Incrível. Imagino eu que de pra fazer algo bem criativo e divertido com este script. Quando puder irei testa-lo, quero ver umas possibilidades que tenho em mente.

Bom trabalho tio Masked!

[Brandt]

Caraca, isso é lindo! 
Eu até já tinha visto, acho que em vídeos randoms espalhados por aí, mas aparentemente era algo
muito complicado de se usar, talvez por estarem em outros idiomas também.
Mas muito bom mesmo, já fico feliz se um dia eu animar a tentar fazer um tactical, que é um gênero
que curto muito. Vai sair uma batalha nesse mapa também? 

Valeu King, também tinha visto uns sistemas assim por aí, mas era abobrinha demais (tinha até editor especial pro mapa com uns paranauês impossíveis de mexer) e estava tudo em francês.

Vish, mais treta pra mim xP
Vou terminar de ajustar o script aqui (acho que dá pra por autotiles), se der eu já aproveito e faço um TBS xD

Caramba filhão ta trabalhando duro heim , meus parabéns está ficando ótimo ,
depois de prontinho e testado esse script vai abrir muitas portas e idéias ai no centro !

Valeu, realmente deu trabalho de fazer, a confusão no meio das coordenadas é forte :P

Uau, que script legal. 
Já consegui imaginá-lo em um jogo de RPG tático assim como FFTatics.
Pde crer que isso será muito útil. Tá de parabéns.

Ah, sim, acho que a primeira coisa que vem na cabeça de todo mundo é FF Tactics xD

Realmente a um script a ponto de se aplaudir e muito, grande conquista Masked, mostre para o mundo que pessoas que 14 anos não sabem apenas gritar HUEHUE. Meus parabéns 

Obrigado, pra ser sincero eu até gostaria de mostrar pro mundo nosso potencial, mas tem uma galera que não deixa 

Incrível. Imagino eu que de pra fazer algo bem criativo e divertido com este script. Quando puder irei testa-lo, quero ver umas possibilidades que tenho em mente.

Bom trabalho tio Masked!

Valeu, realmente dá pra fazer bastante coisa com o script, tipo uma batalha tática, um sistema de escalação, uma batalha tática, um labirinto 3D, e quem sabe uma batalha tática também! xD

[Brandt]

Atualização :)

• Corrigido bug que fazia com que as árvores fossem sobrepostas pelo chão;
  
• Adicionada a possibilidade de criar mapas isométricos e não-isométricos, agora para que um mapa seja isométrico ele deve ter "[Isometric]" (sem aspas) nas notas.
  

[Speed]

 Gostei muito do script parabéns Masked.
Eu queria testar mas não consegui seguir as instruções, você poderia fazer uma demo ?
Obrigado e um abração.

[Raizen]

E ai tem nego que vai caçar na gringa por scripts...  :será:

Sem mais, é um script sensacional, e como todo mundo falou, fazer um TBS nisso encaixaria perfeitamente!, apesar que se realmente for fazer um TBS acho ideal fazer no Scene_Battle :P


De qualquer modo parabéns mesmo manolo! Excelente como sempre 

[Brandt]

@Speed: Valeu, vou fazer uma demo aqui então, quando terminar eu atualizo o tópico.

@Raizen: Né? Agora vamos fazer os gringos virem pra cá
Depois eu parei pra pensar, e realmente seria melhor usar a Scene_Battle (se não as tretas com eventos seriam intermináveis), mas não deve dar tanto trabalho, é só criar uma instância do Isomap no Spriteset_Battle e boas (isso tirando o sistema em si, lógico, aí sim vai dar trabalho xP).
Acho que vou começar a fazer um TBS

[hategum rpg]

Na demo se fizer um hadouken perto da arvore o personagem anda por cima dela...

O bug mais ou menos capturado mas da pra ver como acontece...