Mini Mapa Reino RPG

#==============================================================================
# ReinoRPG Mini-Mapa (RPG Maker VX)
#------------------------------------------------------------------------------
# Bennamy (Amy Productions) & RTH (PRCoders)
# Version 1.0
# 09/10/2008
# Traducido al Castellano por KnuP (A lo que salga xD)
# Modificado por  KnuP (Ver Obs. 2 en las Instrucciones)
#------------------------------------------------------------------------------
# Descripcion:
#
#   Este script exhibe un mini-mapa en una esquina de la pantalla donde en el salen mostrados
#   los tiles pasables y los tiles no pasables (donde el personaje puede caminar
#   y donde él no puede caminar). En el mini-mapa poden ser mostradas las posiciones de
#   ciertos eventos; basta colocar comentários específicos para cada evento.
#   Todos los gráficos exigidos en este mini-mapa son totalmente modificables.
#------------------------------------------------------------------------------
# Instruciones:
#
#   Coloque este script arriba de "Main".
#
#   Copie todas las imagenes necesarias en la carpeta "Pictures" de su proyecto.
#
#   Para exhibir un determinado evento en el minimamapa debe agregar un
#   comentário en la pagina de comandos de este evento. Los comentários pueden ser:
#    - npc = Para NPCs
#    - transporte = Para TELETRANSPORTES/PASAJES
#    - posada = Para POSADAS/PUNTOS PARA SALVAR EL JUEGO
#    - baul = Para BAULES/TESOROS
#    - enemigo = Para ENIMIGOS
#    - otro = Para SHOPS/COMPAÑEROS/ITEMS INTERACTIVOS DEL MAPA
#
#   OBS.: Los comentários de los eventos del mini-mapa pueden ser modificados en:
#         CONFIGURACIONES DE EXHIBICION DE EVENTOS EN EL MINI-MAPA
#
#   **OBS.2: Agrege la opcion de comentario "nada", para que el evento que mostraba el icono de cofre por ejemplo,
#          al pooner esto luego, ya no sera visible en el minimapa, cosa que no hace automaticamente
#          al cambiar de hoja en la pag de eventos.
#
#------------------------------------------------------------------------------
# Personalización:
#
#   Para modificar el Switch que ACTIVA/DESACTIVA el mini-mapa, solo basta buscar donde
#   comienza la CONFIGURACION del script y alterar el valor de MM_ACTIVATED_ID.
#
#   Para modificar el lugar donde el mini-mapa será exhibido, primero usted debe
#   escojer que variáble definirá el lugar del mini-mapa, esto puede ser hecho
#   alterando el valor de MM_CORNER_VAR. Despues és necesario alterar también el
#   valor de la variáble indicada, por consiguiente, los valores pueden ser:
#    1 = Para exhibir el mini-mapa en la Esquina SUPERIOR IZQUERDA de la pantalla
#    2 = Para exhibir el mini-mapa en la Esquina SUPERIOR DERECHA de la pantalla
#    3 = Para exhibir el mini-mapa en la Esquina INFERIOR IZQUERDA de la pantalla
#    4 = Para exhibir el mini-mapa en la Esquina INFERIOR DERECHA de la pantalla
#
#   OBS.: Modificaciones pueden ser efectuadas en la parte de CONFIGURACIONES del script.
#
#------------------------------------------------------------------------------
# Créditos y Agradecimentos:
#
#   Bennamy (Amy Productions) & RTH (PRCoders) - Por la creacion de este script.
#   Selwyn (squall) - Por haber creado el script para RMXP que era usado como base.
#   Fanha Giang (aka fanha99) - Por el método de exhibir autotiles.
#
#------------------------------------------------------------------------------
# Terminos de Uso y Disponibilidad:
#
#   Usted debe insertar um link hacia el tópico (De este script) del foro ReinoRPG.
#   Usted debe insertar um link hacia www.rmzine.reinorpg.com
#   Usted debe dar creditos a los autores y demas involucrados en la producion de este material.
#   Aun cuando se edite este contenido (script), estas reglas deben valer.
#
#==============================================================================

  #--------------------------------------------------------------------------
  # CONFIGURACIONES
  #--------------------------------------------------------------------------
module CONFIG
  # CONFIGURACIONES DE LAS FUNCIONES DEL MINI-MAPA:
  MM_ACTIVATED_ID = 99               # ID del Switch que Activa/Desactiva el MM
  MM_CORNER_VAR = 94                 # Variáble que indica la posición del MM en la pantalla
  MM_OPACITY = 255                  # Transparencia del MM

  # CONFIGURACIONES DE LAS IMAGENES EXHIBIDAS EN EL MINI-MAPA:
  MM_MAP_BACK = "bg_map"            # Imagen que representa el Fondo en el MM
  MM_TILES = "tile_map"             # Imagen que representa el Autotile en el MM
  MM_CURSOR = "heroi_cursor"        # Imagen que representa el Personaje en MM
  MM_OTHER = "outro"                # Imagen que representa los Otros Eventos en el MM
  MM_ENEMY = "inimigo"              # Imagen que representa los Enemigos en el MM
  MM_TELEPORT = "passagem"          # Imagen que representa las Pasajes/Transportes en el MM
  MM_CHEST = "bau"                  # Imagen que representa los Baules y Tesoros en el MM
  MM_NPC = "npc"                    # Imagen que representa los Npcs en el MM
  MM_SAVEPOINT = "pousada"          # Imagen que representa las Posadas en el MM
  MM_NADA = "nada"                  # Imagen añadida para que un evento que antes se mostraba, ya no lo haga.

  # CONFIGURACIONES DE EXHIBICION DE EVENTOS EN EL MINI-MAPA:
  MM_EVENT_OTHER = "otro"           # Comentário para exibir el evento "OTRO"
  MM_EVENT_ENEMY = "iglesia"        # Comentário para exibir el evento "ENIMIGO"
  MM_EVENT_TELEPORT = "ciudad"  # Comentário para exibir el evento "TRANSPORTE"
  MM_EVENT_CHEST = "baul"           # Comentário para exibir el evento "BAÚL"
  MM_EVENT_NPC = "npc"              # Comentário para exibir el evento "NPC"
  MM_EVENT_SAVEPOINT = "pub"     # Comentário para exibir el evento "POSADA"
  MM_EVENT_NADA = "nada"            # Comentario para que un evento que se mostraba, ya no se muestre.
end
  #--------------------------------------------------------------------------
  # FIN DE LAS CONFIGURACIONES
  #--------------------------------------------------------------------------

#==============================================================================
# Scene_Map
#------------------------------------------------------------------------------
# Classe das operações nos mapas.
#==============================================================================

class Scene_Map
  include CONFIG
  #--------------------------------------------------------------------------
  # Lista de métodos aliasados
  #--------------------------------------------------------------------------
  @@pre_terminate_aliased = false
  unless method_defined?(:amy_mm_main)
    alias amy_mm_main main
    alias amy_mm_update update
    alias amy_mm_perform_battle_transition perform_battle_transition
    if method_defined?(:pre_terminate)
      alias amy_mm_pre_terminate pre_terminate
      @@pre_terminate_aliased = true
    end
  end
  #--------------------------------------------------------------------------
  # Inicializacion del objeto
  #--------------------------------------------------------------------------
  def initialize
    @corner = $game_variables[MM_CORNER_VAR]
  end
  #--------------------------------------------------------------------------
  # Principal
  #--------------------------------------------------------------------------
  def main
    @mini_map = Map_Event.new(@corner)
    amy_mm_main
    @mini_map.dispose
  end
  #--------------------------------------------------------------------------
  # Actualizacion de la pantalla
  #--------------------------------------------------------------------------
  def update
    if $game_variables[MM_CORNER_VAR] != @corner
      @corner = $game_variables[MM_CORNER_VAR]
      @mini_map.corner = @corner
    end
    @mini_map.update
    if $game_map.interpreter.running?
      @mini_map.visible = false
    elsif @mini_map.on?
      @mini_map.visible = true
    end
    amy_mm_update
  end
  #--------------------------------------------------------------------------
  # Transicion
  #--------------------------------------------------------------------------
  def minimap_transfer
    @mini_map.dispose
    @mini_map = Map_Event.new(@corner)
  end
  #--------------------------------------------------------------------------
  # Ejecucion de la transicion de batalla
  #--------------------------------------------------------------------------
  def perform_battle_transition
    @mini_map.visible = false
    amy_mm_perform_battle_transition
  end
  #--------------------------------------------------------------------------
  # Fin del processo
  #--------------------------------------------------------------------------
  def pre_terminate
    @mini_map.visible = true
    amy_mm_pre_terminate if @@pre_terminate_aliased
  end

end

#==============================================================================
# Game_Player
#------------------------------------------------------------------------------
# Esta classe controla las informaciones del jugador. Entre ellas: los vehículos,
# los eventos (cuando inicián los), o loop del mapa... etc.
# Puede ser accesada utilizando $game_player.
#==============================================================================

class Game_Player < Game_Character
  unless method_defined?(:amy_mm_perform_transfer)
    alias amy_mm_perform_transfer perform_transfer
  end
  #--------------------------------------------------------------------------
  # Teletransportar
  #--------------------------------------------------------------------------
  def perform_transfer
    amy_mm_perform_transfer
    $scene.minimap_transfer
  end
end

#==============================================================================
# Map_Base
#------------------------------------------------------------------------------
# Una clase Base para mini mapas
#==============================================================================

class Map_Base < Sprite
  include CONFIG
  #--------------------------------------------------------------------------
  # Constantes e Instancias
  #--------------------------------------------------------------------------
  PMP_VERSION  = 7
  attr_reader :event
  attr_reader :corner
  #--------------------------------------------------------------------------
  # Inicializacion del objeto
  #--------------------------------------------------------------------------
  def initialize(corner)
    super(Viewport.new(16, 16, width, height))
    viewport.z = 8000
    @border = Sprite.new
    @border.x = viewport.rect.x - 6
    @border.y = viewport.rect.y - 6
    @border.z = viewport.z - 1
    @border.bitmap = Cache.picture(MM_MAP_BACK)
    self.visible = on?
    self.opacity = MM_OPACITY
    @corner = -1
    self.corner = corner
    self.visible = on?
  end
  #--------------------------------------------------------------------------
  # Corner
  #--------------------------------------------------------------------------
  def corner=(valor)
    return if @corner == valor
    @corner = valor.to_i
    case @corner
    when 2
      self.x = 544 - width - 16
      self.y = 16
    when 3
      self.x = 16
      self.y = 416 - height - 16
    when 4
      self.x = 544 - width - 16
      self.y = 416 - height - 16
    else
      self.x = 16
      self.y = 16
    end
  end
  #--------------------------------------------------------------------------
  # Dispose
  #--------------------------------------------------------------------------
  def dispose
    @border.dispose
    super
  end
  #--------------------------------------------------------------------------
  # x=
  #--------------------------------------------------------------------------
  def x=(x)
    self.viewport.rect.x = x
    @border.x = x - 6
  end
  #--------------------------------------------------------------------------
  # y=
  #--------------------------------------------------------------------------
  def y=(y)
    self.viewport.rect.y = y
    @border.y = y - 6
  end
  #--------------------------------------------------------------------------
  # Visible=
  #--------------------------------------------------------------------------
  def visible=(bool)
    super
    self.viewport.visible = bool
    @border.visible = bool
  end
  #--------------------------------------------------------------------------
  # Minimap_on?
  #--------------------------------------------------------------------------
  def on?
    return $game_switches[MM_ACTIVATED_ID]
  end
  #--------------------------------------------------------------------------
  # Atualizacion de la pantalla
  #--------------------------------------------------------------------------
  def update
    super
    self.visible = on?
    if viewport.ox < display_x
      viewport.ox += 1
    elsif viewport.ox > display_x
      viewport.ox -= 1
    end
    if viewport.oy < display_y
      viewport.oy += 1
    elsif viewport.oy > display_y
      viewport.oy -= 1
    end
  end
   #--------------------------------------------------------------------------
  # Anchura
  #--------------------------------------------------------------------------
  def width
    return 102
  end
  #--------------------------------------------------------------------------
  # Altura
  #--------------------------------------------------------------------------
  def height
    return 78
  end
  #--------------------------------------------------------------------------
  # Display_x
  #--------------------------------------------------------------------------
  def display_x
    return $game_map.display_x * 3 / 128
  end
  #--------------------------------------------------------------------------
  # Display_y
  #--------------------------------------------------------------------------
  def display_y
    return $game_map.display_y * 3 / 128
  end
end

#==============================================================================
# Map_Passability
#------------------------------------------------------------------------------
# Exhibe el Mini-mapa
# Agradecimentos para Fanha Giang (a.k.a. fanha99) por el método de exhibir autotiles
#==============================================================================

class Map_Passability < Map_Base
  include CONFIG
  #--------------------------------------------------------------------------
  # Constantes
  #--------------------------------------------------------------------------
  INDEX  =
  [
  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
  ]
  X = [0, 1, 0, 1]
  Y = [0, 0, 1, 1]
  #--------------------------------------------------------------------------
  # Inicializacion del objeto
  #--------------------------------------------------------------------------
  def initialize(corner)
    super(corner)
    @autotile = Cache.picture(MM_TILES)
    setup()
  end
  #--------------------------------------------------------------------------
  # setup
  #--------------------------------------------------------------------------
  def setup()
    @map = load_data(sprintf("Data/Map%03d.rvdata", $game_map.map_id))
    @passages = $data_system.passages
    redefine_tiles
    refresh
  end
  #--------------------------------------------------------------------------
  # pass
  #--------------------------------------------------------------------------
  def pass(tile_id)
    return 0xf if tile_id == nil
    return @passages[tile_id] != nil ? @passages[tile_id] & 0xf : 15
  end
  #--------------------------------------------------------------------------
  # passable
  #--------------------------------------------------------------------------
  def passable(tile_id, flag = 0x01)
    pass = pass(tile_id)
    return true if pass & flag == 0x00
    return false if pass & flag == flag
    return false
  end
  #--------------------------------------------------------------------------
  # redefine_tile
  #--------------------------------------------------------------------------
  def redefine_tiles
    width = @map.width
    height = @map.height
    map = RPG::Map.new(width, height)
    map.data = @map.data.dup
    for x in 0...width
      for y in 0...height
        for level in [1, 2]
          id = @map.data[x, y, level]
          if id != 0
            @map.data[x, y, 0] = id
            @passages[@map.data[x, y, 0]] = @passages[id]
          end
        end
      end
    end
    for x in 0...width
      for y in 0...height
        for level in [0]
        tile = @map.data[x, y, level]
        u = @map.data[x,   y-1, level]
        l = @map.data[x-1, y,   level]
        r = @map.data[x+1, y,   level]
        d = @map.data[x,   y+1, level]
        if !passable(tile)
          map.data[x, y] = 0
        else
          if tile == 0
            map.data[x, y, level] = 0
            next
          end
          if pass(tile) > 0
            if !passable(u) and !passable(l) and !passable(r) and !passable(d)
              map.data[x, y, level] = 0
            elsif !passable(u) and !passable(l) and !passable(r) and passable(d)
              map.data[x, y, level] = 90
            elsif !passable(u) and !passable(l) and !passable(d) and passable(r)
              map.data[x, y, level] = 91
            elsif !passable(u) and !passable(r) and !passable(d) and passable(l)
              map.data[x, y, level] = 93
            elsif !passable(l) and !passable(r) and !passable(d) and passable(u)
              map.data[x, y, level] = 92
            elsif !passable(u) and !passable(d) and passable(r) and passable(l)
              map.data[x, y, level] = 81
            elsif !passable(u) and !passable(r) and passable(d) and passable(l)
              map.data[x, y, level] = 84
            elsif !passable(u) and !passable(l) and passable(d) and passable(r)
              map.data[x, y, level] = 82
            elsif !passable(d) and !passable(r) and passable(l) and passable(u)
              map.data[x, y, level] = 86
            elsif !passable(d) and !passable(l) and passable(r) and passable(u)
              map.data[x, y, level] = 88
            elsif !passable(r) and !passable(l) and passable(d) and passable(u)
              map.data[x, y, level] = 80
            elsif !passable(u) and passable(d) and passable(r) and passable(l)
              map.data[x, y, level] = 68
            elsif !passable(d) and passable(u) and passable(r) and passable(l)
              map.data[x, y, level] = 76
            elsif !passable(r) and passable(d) and passable(u) and passable(l)
              map.data[x, y, level] = 72
            elsif !passable(l) and passable(d) and passable(u) and passable(r)
              map.data[x, y, level] = 64
            else
              map.data[x, y, level] = 48
            end
          else
            map.data[x, y, level] = 0
          end
        end
        end
      end
    end
    @map = map.dup
    map = nil
  end
  #--------------------------------------------------------------------------
  # Actualizacion
  #--------------------------------------------------------------------------
  def refresh
    self.visible = false
    self.bitmap = Bitmap.new(@map.width * 6, @map.height * 6)
    bitmap = Bitmap.new(@map.width * 6, @map.height * 6)
    rect1 = Rect.new(6, 0, 6, 6)
    for y in 0...@map.height
      for x in 0...@map.width
        for level in [0]
          tile_id = @map.data[x, y, level]
          next if tile_id == 0
          id = tile_id / 48 - 1
          tile_id %= 48
          for g in 0..3
            h = 4 * tile_id + g
            y1 = INDEX[h] / 6
            x1 = INDEX[h] % 6
            rect2 = Rect.new(x1 * 3, y1 * 3, 3, 3)
            bitmap.blt(x * 6 + X[g] *  3, y * 6 + Y[g] * 3, @autotile, rect2)
          end
        end
      end
    end
    d_rect = Rect.new(0, 0, @map.width * 6, @map.height * 6)
    s_rect = Rect.new(0, 0, bitmap.width, bitmap.height)
    self.bitmap.stretch_blt(d_rect, bitmap, s_rect)
    self.viewport.ox = display_x
    self.viewport.oy = display_y
    bitmap.clear
    bitmap.dispose
  end
end

#==============================================================================
# Map_Event
#------------------------------------------------------------------------------
#  Exhibe la posicion del Héroe en los Eventos del Mini-mapa
#==============================================================================

class Map_Event < Map_Passability
  include CONFIG
  #--------------------------------------------------------------------------
  # Inicializacion del objeto
  #--------------------------------------------------------------------------
  def initialize(corner = 4)
    super(corner)
    @dots = []
    @player = Sprite.new(self.viewport)
    @player.bitmap = Cache.picture(MM_CURSOR)
    @player.src_rect = Rect.new(0, 0, 15, 15)
    @player.z = self.z + 3
    @events = {}
    for key in $game_map.events.keys
      event = $game_map.events[key]
      next if event.list == nil
      for i in 0...event.list.size
        next if event.list[i].code != 108
        @events[key] = Sprite.new(self.viewport)
        @events[key].z = self.z + 2
        param = event.list[i].parameters[0].downcase
        if param.include?(MM_EVENT_OTHER)
          @events[key].bitmap = Cache.picture(MM_OTHER)
        elsif param.include?(MM_EVENT_ENEMY)
          @events[key].bitmap = Cache.picture(MM_ENEMY)
        elsif param.include?(MM_EVENT_TELEPORT)
          @events[key].bitmap = Cache.picture(MM_TELEPORT)
        elsif param.include?(MM_EVENT_CHEST)
          @events[key].bitmap = Cache.picture(MM_CHEST)
        elsif param.include?(MM_EVENT_NPC)
          @events[key].bitmap = Cache.picture(MM_NPC)
        elsif param.include?(MM_EVENT_NADA)
          @events[key].bitmap = Cache.picture(MM_NADA)
        elsif param.include?(MM_EVENT_SAVEPOINT)
          @events[key].bitmap = Cache.picture(MM_SAVEPOINT)
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # dispose
  #--------------------------------------------------------------------------
  def dispose
    @player.dispose
    for event in @events.values
      event.dispose
    end
    super
  end
  #--------------------------------------------------------------------------
  # Actualizacion de la pantalla
  #--------------------------------------------------------------------------
  def update
    super
    @player.x = $game_player.real_x * 3 / 128 - 5
    @player.y = $game_player.real_y * 3 / 128 - 4
    @player.src_rect.x = ($game_player.direction / 2 - 1) * 15
    for key in @events.keys
      event = @events[key]
      mapevent = $game_map.events[key]
      event.x = mapevent.real_x * 3 / 128
      event.y = mapevent.real_y * 3 / 128
      next if mapevent.list == nil
      for list in mapevent.list
        next if list.code != 108
        param = list.parameters[0].downcase
        if param.include?(MM_EVENT_OTHER)
          event.bitmap = Cache.picture(MM_OTHER)
          event.visible = true
          break
        elsif param.include?(MM_EVENT_ENEMY)
          event.bitmap = Cache.picture(MM_ENEMY)
          event.visible = true
          break
        elsif param.include?(MM_EVENT_TELEPORT)
          event.bitmap = Cache.picture(MM_TELEPORT)
          event.visible = true
          break
        elsif param.include?(MM_EVENT_CHEST)
          event.bitmap = Cache.picture(MM_CHEST)
          event.visible = true
          break
        elsif param.include?(MM_EVENT_NPC)
          event.bitmap = Cache.picture(MM_NPC)
          event.visible = true
          break
        elsif param.include?(MM_EVENT_NADA)
          event.bitmap = Cache.picture(MM_NADA)
          event.visible = true
          break
        elsif param.include?(MM_EVENT_SAVEPOINT)
          event.bitmap = Cache.picture(MM_SAVEPOINT)
          event.visible = true
          break
        else
          event.visible = false
        end
      end
    end
  end
end
#==============================================================================