Script Mini-mapa renan hangai

Mini Mapa
por Renan Tsuneo Hangai
postado por matheus180

Introdução

Mostra um Mini mapa com várias idicações

Características

• Mostra um Mini mapa com várias idicações

Screenshots


Como usar

Para instalá-lo, apenas cole o script acima do main.
Você deve colocar as imagens em anexo dentro da pasta Pictures

Adicionando indicações

Você deve inserir um comentário (6º comando da Aba de eventos) no inicio do evento para que a indiação dele apareceça no mapa.

Os comentários são os seguintes

minimap npc

minimap bau

minimap tele

destino dest
blink
(ps.: os comentarios "destino dest" e "blink" comentários devem ser inseridos em sequencia)

Apesar dos nomes eles não tem uso especifico, sendo a unica diferença entre eles a cor da indicação

Você precisará das imagens que estão em anexo na sua pasta Pircutes.

Para ativar o minimapa Você deve ligar a Switch ID 1
você pode mudar a ID da Swithc que liga o mini mapa nesta linha:

Código:

  MAP_ON_SWITCH = 1

Para mudar a posição do mapa é so mudar o valor da variável ID 1:
você pode mudar a ID da Variavel que muda a posição do mini mapa nesta linha:

Código:

    MAP_CANTO_VARIABLE = 1

Demo

Não necessita de demo

Script

Código:

#===============================================================================
# RTH Mini_Mapa
# por Renan Tsuneo Hangai Junior
#===============================================================================
# Mostra um Mini Mapa na tela do jogo
#===============================================================================

module RTH
 
  # Largura do mini mapa
  MINI_MAP_LARG        = 160
  # Altura do mini mapa
  MINI_MAP_ALT          = 120
  # Transparencia do mini mapa
  MINI_MAP_OPACITY      = 210
  # Nome do arquivo de imagem da pasta pictures do fundo do mini mapa
  MINI_MAP_BACK_NAME    = "mapback"
  # Largura do fundo mini mapa ( Igual ao da imagem na pasta Pictures )
  MINI_MAP_BACK_LARG    = 180
  # Altura do fundo mini mapa ( Igual ao da imagem na pasta Pictures )
  MINI_MAP_BACK_ALT    = 140
  # Transparencia do fundo do mini mapa
  MINI_MAP_BACK_OPACITY = 140
  # Nome do arquivo de imagem da pasta pictures do herói
  MINI_MAP_HERO_BITMAP_NAME = "heroi"
  # Switch que ativa o mapa
  MAP_ON_SWITCH = 1
  # Variavel que define o canto do mapa
  MAP_CANTO_VARIABLE = 1
 
end

$RTHScript = {} if $RTHScript.nil?
$RTHScript["Mini_Map"] = true

class Mini_Map_Base
 
  attr_reader :map_rect, :bitmap_rect, :map_dif_width, :map_dif_height, :visible
 
  def initialize(canto)
    @canto = canto
    @x = 0
    @y = 0
    @difbx = (RTH::MINI_MAP_BACK_LARG - RTH::MINI_MAP_LARG) / 2
    @difby = (RTH::MINI_MAP_BACK_ALT - RTH::MINI_MAP_ALT) / 2
    draw_map
    self.visible = false
  end
 
  def draw_map
    @id = $game_map.map_id
    @layers = []
    viewport = Viewport.new(0, 0, 640, 480)
    viewport.z = 6000
    @bitmap_rect = Rect.new(0, 0, RTH::MINI_MAP_LARG, RTH::MINI_MAP_ALT)
    @back_bitmap_rect = Rect.new(0, 0, RTH::MINI_MAP_BACK_LARG, RTH::MINI_MAP_BACK_ALT)
    w = RTH::MINI_MAP_LARG.to_f * ($game_map.width.to_f * 32.0) / 640.0
    h = RTH::MINI_MAP_ALT.to_f * ($game_map.height.to_f * 32.0) / 480.0
    @map_dif_width = ($game_map.width.to_f * 32.0) / w
    @map_dif_height = ($game_map.height.to_f * 32.0) / h
    @map_rect = Rect.new(0, 0, w, h)
    @back_sprite = Sprite.new(viewport)
    @back_sprite.bitmap = Bitmap.new(@back_bitmap_rect.width, @back_bitmap_rect.height)
    back_bitmap = RPG::Cache.picture(RTH::MINI_MAP_BACK_NAME)
    @back_sprite.bitmap.stretch_blt(@back_bitmap_rect, back_bitmap, Rect.new(0, 0, back_bitmap.width, back_bitmap.height))
    src_rect = Rect.new(0, 0, $game_map.width * 32, $game_map.height * 32)
    for i in 0..5
      @layers[i] = Sprite.new(viewport)
      @layers[i].z = 10000 + (i * 20)
      @layers[i].x = (@back_bitmap_rect.width - @bitmap_rect.width) / 2
      @layers[i].y = (@back_bitmap_rect.height - @bitmap_rect.height) / 2
      @layers[i].bitmap = Bitmap.new(@map_rect.width, @map_rect.height)
      @layers[i].bitmap.stretch_blt(@map_rect, RPG::Cache.map_bitmap(@id, i), src_rect)
    end
  end
   
  def update
    if @layers.nil?
      draw_map
    end
    canto = $game_variables[RTH::MAP_CANTO_VARIABLE] % 4
    case canto
    when 0
      @x, @y = 16, 16
    when 1
      @x, @y = (640 - 16 - @back_bitmap_rect.width), 16
    when 2
      @x, @y = 16, (480 - 16 - @back_bitmap_rect.height)
    when 3
      @x, @y = (640 - 16 - @back_bitmap_rect.width), (480 - 16 - @back_bitmap_rect.height)
    end
    @back_sprite.x = @x
    @back_sprite.y = @y
    @back_sprite.opacity = RTH::MINI_MAP_BACK_OPACITY
    for layer in @layers
      layer.x = @x + @difbx
      layer.y = @y + @difby
      layer.opacity = RTH::MINI_MAP_OPACITY
      ox = ($game_map.display_x / 4) / @map_dif_width
      oy = ($game_map.display_y / 4) / @map_dif_height
      layer.src_rect.set(ox, oy, @bitmap_rect.width, @bitmap_rect.height)
    end
  end
 
  def dispose(dp=false)
    for layer in @layers
      layer.bitmap.dispose
      layer.dispose
    end
    @layers = nil
    @back_sprite.bitmap.dispose
    @back_sprite.dispose
    @back_sprite = nil
    RPG::Cache.dispose_map_bitmap(@id) if dp
  end
 
end   

class Mini_Map < Mini_Map_Base
 
  def draw_map
    super
    viewport = Viewport.new(0, 0, 640, 480)
    viewport.z = 10010
    @hero = Sprite.new(viewport)
    @hero.bitmap = RPG::Cache.picture(RTH::MINI_MAP_HERO_BITMAP_NAME)
    @events = []
    @events_sprites = []
    @destinies = []
    @destinies_event = []
    @blinked_events = []
    @blink_count = 0
    i = 0
    for event in $game_map.events.values
      next if event.nil?
      next if event.list.nil? or event.list.size <= 0
      maped = false
      blinked = false
      @blinked_events[i] = false
      for item in event.list
        next if item.nil?
        if item.code == 108 or item.code == 408
          unless maped
            if item.parameters[0].downcase.include?("minimap")
              name = item.parameters[0].split[1]
              sprite = Sprite.new(viewport)
              sprite.bitmap = RPG::Cache.picture(name)
              @events[i] = event
              @events_sprites[i] = sprite
              maped = true
              i += 1
            elsif item.parameters[0].downcase.include?("destino")
              name = item.parameters[0].split[1]
              sprite = Sprite.new(viewport)
              sprite.bitmap = RPG::Cache.picture(name)
              @destinies[i] = sprite
              @destinies_event[i] = event
              maped = true
              i += 1
            end
          end
          unless blinked
            if item.parameters[0].downcase.include?("blink")
              adx = (maped == true ? -1 : 0)
              @blinked_events[i + adx] = true
              blinked = true
            end
          end
          break if blinked and maped
        end
      end
    end
  end
 
  def visible=(valor)
    return if !@visible.nil? and @visible == valor
    @visible = valor
    @back_sprite.visible = valor
    for layer in @layers
      layer.visible = valor
    end
    for sprite in @events_sprites + @destinies
      next if sprite.nil?
      sprite.visible = valor
    end
    @hero.visible = valor
  end
     
  def update
    self.visible = true
    self.visible = false if $game_system.map_interpreter.running?
    self.visible = $game_switches[RTH::MAP_ON_SWITCH] if @visible == true
    return if @visible == false
    super
    @blink_count = (@blink_count + 1) % 10
    if @destinies.size > 0
      for i in 0...@destinies.size
        next if @destinies[i].nil?
        max_x = RTH::MINI_MAP_LARG + @layers[0].x - (@destinies[i].src_rect.width / 2)
        max_y = RTH::MINI_MAP_ALT + @layers[0].y - (@destinies[i].src_rect.height / 2)
        x = (@destinies_event[i].screen_x.to_f / self.map_dif_width) + @layers[0].x - (@destinies[i].src_rect.width / 2)
        y = (@destinies_event[i].screen_y.to_f / self.map_dif_height) + @layers[0].y - @destinies[i].src_rect.height
        @destinies[i].x = (x >= max_x ? max_x : x <= @layers[0].x ? @layers[0].x : x)
        @destinies[i].y = (y >= max_y ? max_y : y <= @layers[0].y ? @layers[0].y : y)
        @destinies[i].visible = (not @destinies[i].visible) if @blink_count == 0 and @blinked_events[i]
      end
    end
    for i in 0...@events_sprites.size
      next if @events[i].nil?
      @events_sprites[i].x = (@events[i].screen_x.to_f / self.map_dif_width) + @layers[0].x - (@events_sprites[i].src_rect.width / 2)
      @events_sprites[i].y = (@events[i].screen_y.to_f / self.map_dif_height) + @layers[0].y - @events_sprites[i].src_rect.height
      @events_sprites[i].visible = (@events_sprites[i].x >= @layers[0].x and @events_sprites[i].x <= @layers[0].x + @bitmap_rect.width and @events_sprites[i].y >= @layers[0].y and @events_sprites[i].y <= @layers[0].y + @bitmap_rect.height)
    end
    @hero.x = ($game_player.screen_x.to_f / self.map_dif_width) + @layers[0].x - (@hero.src_rect.width / 2)
    @hero.y = ($game_player.screen_y / self.map_dif_height) + @layers[0].y - @hero.src_rect.height
  end
 
  def dispose(dp=false)
    super(dp)
    for sprite in @events_sprites + @destinies
      next if sprite.nil?
      sprite.bitmap.dispose
      sprite.dispose
    end
    @hero.bitmap.dispose
    @hero.dispose
  end
 
  def redraw_map
    dispose
    draw_map
  end
 
end

class Spriteset_Map
 
  attr_reader :mini_mapa
 
  alias rth_mini_map_spmap_initialize initialize
  alias rth_mini_map_spmap_dispose dispose
  alias rth_mini_map_spmap_update update
 
  def initialize
    @mini_mapa = Mini_Map.new(0)
    rth_mini_map_spmap_initialize
  end
 
  def dispose
    @mini_mapa.dispose(true)
    rth_mini_map_spmap_dispose
  end
 
  def update
    @mini_mapa.update
    rth_mini_map_spmap_update
  end
   
end

class Scene_Map
  attr_reader :spriteset
end

class Game_Map
 
  alias rth_mini_map_gmap_refresh refresh
  def refresh
    rth_mini_map_gmap_refresh
    if $scene.instance_of?(Scene_Map)
      if $scene.spriteset != nil and $scene.spriteset.mini_mapa != nil
        $scene.spriteset.mini_mapa.redraw_map
      end
    end
  end
 
end

class Interpreter
 
  alias rth_mini_map_iterpreter_command_123 command_123
  def command_123
    valor = rth_mini_map_iterpreter_command_123
    if $scene.instance_of?(Scene_Map)
      $scene.spriteset.mini_mapa.redraw_map
    end
  end
 
end

class Scene_Full_Map
 
  def main
    @rw = $game_map.width * 32
    @rh = $game_map.height * 32
    @full_map = Sprite.new
    @full_map.bitmap = Bitmap.new(@rw, @rh)
    for i in 0..5
      @full_map.bitmap.blt(0, 0, RPG::Cache.map_bitmap($game_map.map_id, i), Rect.new(0, 0, @rw, @rh))
    end
    #RPG::Cache.dispose_map_bitmap($game_map.map_id)
    @ox = ($game_map.display_x / 4)
    @oy = ($game_map.display_y / 4)
    @full_map.ox = @ox
    @full_map.oy = @oy
    @full_map.zoom_x = 0.8
    @full_map.zoom_y = 0.8
    @full_map.x = (640 - (640 * @full_map.zoom_x)) / 2
    @full_map.y = (480 - (480 * @full_map.zoom_y)) / 2
    Graphics.transition(20)
    while $scene == self
      Graphics.update
      Input.update
      update
    end
    Graphics.freeze
    @full_map.bitmap.dispose
    @full_map.dispose
  end
 
  def update
    @full_map.update
    cw = (@rw * @full_map.zoom_x)
    ch = (@rh * @full_map.zoom_y)
    if cw + @full_map.x > 640 - @full_map.x
      if [1, 4, 7].include?(Input.dir8) and @ox > 0
        @ox -= 10
      elsif [3, 6, 9].include?(Input.dir8) and @ox < (@rw - (@full_map.x * 2) - (640 * @full_map.zoom_x))
        @ox += 10
      end
    end
    if ch + @full_map.y > 480 - @full_map.y
      if [7, 8, 9].include?(Input.dir8) and @oy > 0
        @oy -= 10
      elsif [1, 2, 3].include?(Input.dir8) and @oy < (@rh - (@full_map.y * 2) - (480 * @full_map.zoom_y))
        @oy += 10
      end
    end
    #@full_map.src_rect.set(@ox, @oy, @rw, @rh)
    @full_map.ox = @ox
    @full_map.oy = @oy
    if Input.trigger?(Input::C) or Input.trigger?(Input::B)
      $scene = Scene_Map.new
    end
  end
 
end

class Game_Map
 
  def mmsetup(id)
    @map_id = id
    @map = load_data(sprintf("Data/Map%03d.rxdata", @map_id))
    tilesets = load_data("Data/Tilesets.rxdata")
    tileset = tilesets[@map.tileset_id]
    @tileset_name = tileset.tileset_name
    @autotile_names = tileset.autotile_names
    @priorities = tileset.priorities
  end
 
end

module RPG
 
  module Cache
   
    @map_bitmap = []
     
    AUTOTILES_DEFINITION = [
    26, 27, 32, 33, 4,  27, 32, 33, 26, 5,  32, 33, 4,  5,  32, 33,
    26, 27, 32, 11, 4,  27, 32, 11, 26, 5,  32, 11, 4,  5,  32, 11,
    26, 27, 10, 33, 4,  27, 10, 33, 26, 5,  10, 33, 4,  5,  10, 33,
    26, 27, 10, 11, 4,  27, 10, 11, 26, 5,  10, 11, 4,  5,  10, 11,
    24, 25, 30, 31, 24, 5,  30, 31, 24, 25, 30, 11, 24, 5,  30, 11,
    14, 15, 20, 21, 14, 15, 20, 11, 14, 15, 10, 21, 14, 15, 10, 11,
    28, 29, 34, 35, 28, 29, 10, 35, 4,  29, 34, 35, 4,  29, 10, 35,
    38, 39, 44, 45, 4,  39, 44, 45, 38, 5,  44, 45, 4,  5,  44, 45,
    24, 29, 30, 35, 14, 15, 44, 45, 12, 13, 18 ,19, 12, 13, 18, 11,
    16, 17, 22, 23, 16, 17, 10, 23, 40, 41, 46, 47, 4,  41, 46, 47,
    36, 37, 42, 43, 36, 5,  42, 43, 12, 17, 18, 23, 12, 13, 42, 43,
    36, 41, 42, 47, 16, 17, 46, 47, 12, 17, 42, 47, 0,  1,  6,  7
    ]
   
    def self.map_bitmap(map_id, priority=0)
      if @map_bitmap[map_id].nil?
        mapa = Game_Map.new
        mapa.mmsetup(map_id)
        layers = [
          Bitmap.new(mapa.width * 32, mapa.height * 32),
          Bitmap.new(mapa.width * 32, mapa.height * 32),
          Bitmap.new(mapa.width * 32, mapa.height * 32),
          Bitmap.new(mapa.width * 32, mapa.height * 32),
          Bitmap.new(mapa.width * 32, mapa.height * 32),
          Bitmap.new(mapa.width * 32, mapa.height * 32)
        ]
        autotiles = []
        for i in 0..6
          autotiles[i] = self.autotile(mapa.autotile_names[i])
        end
        vx = [0, 1, 0, 1]
        vy = [0, 0, 1, 1]
        for x in 0...mapa.width
          for y in 0...mapa.height
            for level in 0..2
              tile_id = mapa.data[x, y, level]
              prioridade = mapa.priorities[tile_id]
              if tile_id >= 384
                tileset_bitmap = self.tile(mapa.tileset_name, tile_id, 0)
                src_rect = Rect.new(0, 0, 32, 32)
                layers[prioridade].blt(x * 32, y * 32, tileset_bitmap, src_rect)
              elsif tile_id >= 48 and tile_id < 384
                aid = tile_id / 48 - 1
                for j in 0..3
                  h = 4 * (tile_id % 48) + j
                  src_rect = Rect.new((AUTOTILES_DEFINITION[h] % 6) * 16, (AUTOTILES_DEFINITION[h] / 6 ) * 16, 16, 16)
                  ax = x * 32 + vx[j] * 16
                  ay = y * 32 + vy[j] * 16
                  layers[prioridade].blt(ax, ay, autotiles[aid], src_rect)
                end
              end
            end
          end
        end
        @map_bitmap[map_id] = layers
      end
      return @map_bitmap[map_id][priority]
    end
   
    def self.dispose_map_bitmap(id)
      return if @map_bitmap[id].nil?
      for bitmap in @map_bitmap[id]
        bitmap.dispose
      end
      @map_bitmap[id] = nil
    end
   
  end
 
end

Créditos e Agradecimentos
•Feito por Renan Tsuneo Hangai
•Postado por mim :-P

Até...


Dúvidas responde no tópico

Ja vi um mini mapa desse, mas vai ajudar bastante gente :3!
+1 Cred

Obrigado zeroxp.

Será q teria como como por o mini mapa no canto Superior Direito? Se der pra fazer isso voce poderia mostrar qual a linha q eu mudaria e como eu a deixaria para que ela aparecesse no canto superior direito ?

cade as imagens no anexo? '-'

Posta as imagens do anexo aê pra mim baixar T_T