Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

Temas importantes
----------------------------------------
Páginas con recursos RPG Maker
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Afiliados
Estadísticas
Tenemos 4139 miembros registrados.
El último usuario registrado es pepus2008.

Nuestros miembros han publicado un total de 84794 mensajes en 12069 argumentos.

[XP] Spriteset Minimap

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP [XP] Spriteset Minimap

Mensaje por Wecoc el 2017-08-21, 20:05

Éste es un script de mini-mapa con un planteamiento algo más complejo que la mayoría de los que hay por ahí. La mayoría imitan el Tilemap en una bitmap plana del mini-mapa mediante stretch_blt y similares. Yo soy más bruto que eso y usé una reescritura del Tilemap directamente.

Hay dos inconvenientes al hacerlo así; en éste caso el mini-mapa no puede ser translúcido, o al menos no fácilmente. Además el tamaño del "zoom" del mini-mapa está fijado a tiles de 8px es decir un 25% del mapa normal (es lo habitual en otros mini-mapas, por defecto). A cambio la ventaja es que puedes hacer cosas muy locas. Ahora el mini-mapa realmente es como un segundo mapa más pequeño, con sus mini-eventitos chiquititos y sus mini-prioridaditas de tilecito xDD (ya se entiende).

En cuanto al lag, más o menos afectan lo mismo. Reescribe varias cosas por defecto así que vigilad con las incompatibilidades. La mayoría no son difíciles de solucionar.

Mi idea es que lo uséis para hacer mini-mapas personalizados para vuestros proyectos, por eso no es muy plug&play que digamos, no quiero ver el mismo en muchos como pasa con otros. Éste script te permite todo tipo de cosas imposibles con otros, y más adelante seguramente os mostraré trucos para personalizarlo más. Si alguien quiere probar a hacer su versión y poner aquí una captura, creo que será interesante verlo. Por defecto se ve como el mapa normal pero más pequeño, eso incluye autotiles animados y todo.

Insertar los scripts

El script requiere una reescritura de tilemap, el Tilemap Rewrite de Poccil.

Código:
#==============================================================================
# ** Tilemap Rewrite
#------------------------------------------------------------------------------
#  Author: Poccil
#==============================================================================

# module Poccil

class CustomTilemapAutotiles
  attr_accessor :changed
 
  def initialize
    @changed = true
    @tiles = [nil,nil,nil,nil,nil,nil,nil]
  end
 
  def []=(i, value)
    @tiles[i] = value
    @changed = true
  end
 
  def [](i)
    return @tiles[i]
  end
end

class Tilemap
 
  Animated_Autotiles_Frames = 15
 
  Autotiles = [
    [ [27, 28, 33, 34], [ 5, 28, 33, 34], [27,  6, 33, 34], [ 5,  6, 33, 34],
      [27, 28, 33, 12], [ 5, 28, 33, 12], [27,  6, 33, 12], [ 5,  6, 33, 12] ],
    [ [27, 28, 11, 34], [ 5, 28, 11, 34], [27,  6, 11, 34], [ 5,  6, 11, 34],
      [27, 28, 11, 12], [ 5, 28, 11, 12], [27,  6, 11, 12], [ 5,  6, 11, 12] ],
    [ [25, 26, 31, 32], [25,  6, 31, 32], [25, 26, 31, 12], [25,  6, 31, 12],
      [15, 16, 21, 22], [15, 16, 21, 12], [15, 16, 11, 22], [15, 16, 11, 12] ],
    [ [29, 30, 35, 36], [29, 30, 11, 36], [ 5, 30, 35, 36], [ 5, 30, 11, 36],
      [39, 40, 45, 46], [ 5, 40, 45, 46], [39,  6, 45, 46], [ 5,  6, 45, 46] ],
    [ [25, 30, 31, 36], [15, 16, 45, 46], [13, 14, 19, 20], [13, 14, 19, 12],
      [17, 18, 23, 24], [17, 18, 11, 24], [41, 42, 47, 48], [ 5, 42, 47, 48] ],
    [ [37, 38, 43, 44], [37,  6, 43, 44], [13, 18, 19, 24], [13, 14, 43, 44],
      [37, 42, 43, 48], [17, 18, 47, 48], [13, 18, 43, 48], [ 1,  2,  7,  8] ]
  ]
 
  FlashOpacity=[100,90,80,70,80,90]
 
  attr_reader  :tileset
  attr_reader  :autotiles
  attr_reader  :map_data
  attr_accessor :flash_data
  attr_accessor :priorities
  attr_reader  :visible
  attr_accessor :ox
  attr_accessor :oy
  attr_reader  :viewport
 
  def initialize(viewport)
    @tileset    = nil  # Refers to Map Tileset Name
    @autotiles  = CustomTilemapAutotiles.new
    @map_data  = nil  # Refers to 3D Array Of Tile Settings
    @flash_data = nil  # Refers to 3D Array of Tile Flashdata
    @priorities = nil  # Refers to Tileset Priorities
    @visible    = true # Refers to Tileset Visibleness
    @ox        = 0    # Bitmap Offsets
    @oy        = 0    # bitmap Offsets
    @plane      = false
    @selfviewport = Viewport.new(0,0,640,480)
    @viewport = viewport ? viewport : @selfviewport
    @tiles = []
    @autotileInfo = []
    @regularTileInfo = []
    @oldOx = 0
    @oldOy = 0
    @layer0 = Sprite.new(viewport)
    @layer0.visible = true
    @nowshown = false
    @layer0.bitmap = Bitmap.new(@viewport.rect.width*2,@viewport.rect.height*2)
    @flash = nil
    @layer0.ox = 0
    @layer0.oy = 0
    @oxLayer0 = 0
    @oyLayer0 = 0
    @oxFlash = 0
    @oyFlash = 0
    @layer0.z = 0
    @priotiles = []
    @prioautotiles = []
    @autosprites = []
    @framecount = []
    @tilesetChanged = true
    @flashChanged = false
    @firsttime = true
    @disposed = false
    @usedsprites = false
    @layer0clip = true
    @firsttimeflash = true
    @fullyrefreshed = false
    @fullyrefreshedautos = false
  end
 
  def disposed?
    return @disposed
  end
 
  def flash_data=(value)
    @flash_data=value
    @flashChanged=true 
  end
 
  def update
    if @autotiles.changed
      refresh_autotiles
      repaintAutotiles
    end
    if @flashChanged
      refresh_flash
    end
    if @tilesetChanged
      refresh_tileset
    end
    if @flash
      @flash.opacity = FlashOpacity[(Graphics.frame_count / 2) % 6]
    end
    if !(@oldOx==@ox && @oldOy==@oy && !@tilesetChanged && !@autotiles.changed)
      refresh
    end
    if (Graphics.frame_count % Animated_Autotiles_Frames == 0) || @nowshown
      repaintAutotiles
      refresh(true)
    end
    @nowshown = false
    @autotiles.changed = false
    @tilesetChanged = false
  end
 
  def priorities=(value)
    @priorities = value
    @tilesetChanged = true
  end
 
  def tileset=(value)
    @tileset=value
    @tilesetChanged=true
  end
 
  def shown?
    return false if !@visible
    ysize = @map_data.ysize
    xsize = @map_data.xsize
    xStart = (@ox / 32) - 1 ; xEnd = ((@ox + @viewport.rect.width)  / 32) + 1
    yStart = (@oy / 32) - 1 ; yEnd = ((@oy + @viewport.rect.height) / 32) + 1
    xStart = 0 if xStart < 0
    xStart = xsize - 1 if xStart >= xsize
    xEnd = 0 if xEnd < 0
    xEnd = xsize - 1 if xEnd >= xsize
    yStart = 0 if yStart < 0
    yStart = ysize - 1 if yStart >= ysize
    yEnd = 0 if yEnd < 0
    yEnd = ysize - 1 if yEnd >= ysize
    return (xStart < xEnd && yStart < yEnd)
  end
 
  def dispose
    return if disposed?
    @help.dispose if @help
    @help = nil
    i = 0 ; len = @autotileInfo.length
    while i < len
      if @autotileInfo[i]
        @autotileInfo[i].dispose
        @autotileInfo[i] = nil
      end
      i += 1
    end
    i = 0 ; len = @regularTileInfo.length
    while i < len
      if @regularTileInfo[i]
        @regularTileInfo[i].dispose
        @regularTileInfo[i] = nil
      end
      i += 1
    end
    i = 0 ; len = @tiles.length
    while i < len
      @tiles[i].dispose
      @tiles[i] = nil
      i += 2
    end
    i = 0 ; len = @autosprites.length
    while i < len
      @autosprites[i].dispose
      @autosprites[i] = nil
      i += 2
    end
    if @layer0
      @layer0.bitmap.dispose if !@layer0.disposed?
      @layer0.bitmap = nil if !@layer0.disposed?
      @layer0.dispose
      @layer0 = nil
    end
    if @flash
      @flash.bitmap.dispose if !@flash.disposed?
      @flash.bitmap = nil if !@flash.disposed?
      @flash.dispose
      @flash = nil
    end
    for i in 0...7
      self.autotiles[i] = nil
    end
    @tiles.clear
    @autosprites.clear
    @autotileInfo.clear
    @regularTileInfo.clear
    @tilemap = nil
    @tileset = nil
    @priorities = nil
    @selfviewport.dispose
    @selfviewport = nil
    @disposed = true
  end
 
  def bltAutotile(bitmap, x, y, id, frame)
    return if frame < 0
    autotile = @autotiles[id / 48 - 1]
    return if !autotile
    if autotile.height == 32
      anim = frame * 32
      src_rect = Rect.new(anim, 0, 32, 32)
      bitmap.blt(x, y, autotile, src_rect)
    else
      anim = frame * 96
      id %= 48
      tiles = Autotiles[id>>3][id&7]
      src = Rect.new(0, 0, 0, 0)
      for i in 0...4
        tile_position = tiles[i] - 1
        src.set(tile_position % 6 * 16 + anim,
        tile_position / 6 * 16, 16, 16)
        bitmap.blt(i % 2 * 16 + x, i / 2 * 16 + y, autotile, src)
      end
    end
  end
 
  def autotileNumFrames(id)
    autotile = @autotiles[id / 48 - 1]
    return 0 if !autotile || autotile.disposed?
    frames = 1
    if autotile.height == 32
      frames = autotile.width / 32
    else
      frames = autotile.width / 96
    end
    return frames
  end
 
  def autotileFrame(id)
    autotile = @autotiles[id / 48 - 1]
    return -1 if !autotile || autotile.disposed?
    frames = 1
    if autotile.height == 32
      frames = autotile.width / 32
    else
      frames = autotile.width / 96
    end
    return (Graphics.frame_count / Animated_Autotiles_Frames) % frames
  end
 
  def repaintAutotiles
    for i in 0...@autotileInfo.length
      next if !@autotileInfo[i]
      frame = autotileFrame(i)
      bltAutotile(@autotileInfo[i], 0, 0, i, frame)
    end
  end
 
  def getAutotile(sprite, id)
    anim = autotileFrame(id)
    return if anim < 0
    bitmap = @autotileInfo[id]
    if !bitmap
      bitmap = Bitmap.new(32, 32)
      bltAutotile(bitmap, 0, 0, id, anim)
      @autotileInfo[id] = bitmap
    end
    if !sprite.equal?(bitmap) || sprite.bitmap != bitmap
      sprite.bitmap = bitmap
    end
  end
 
  def getRegularTile(sprite, id)
    if false
      if !sprite.equal?(@tileset) || sprite.bitmap != @tileset
        sprite.bitmap = @tileset
      end
      sprite.src_rect.set((id - 384) % 8 * 32, (id - 384) / 8 * 32, 32, 32)
    else
      bitmap = @regularTileInfo[id]
      if !bitmap
        bitmap = Bitmap.new(32,32)
        rect = Rect.new((id - 384) % 8 * 32, (id - 384) / 8 * 32, 32, 32)
        bitmap.blt(0, 0, @tileset, rect)
        @regularTileInfo[id] = bitmap
      end
      if !sprite.equal?(bitmap) || sprite.bitmap != bitmap
        sprite.bitmap = bitmap
      end
    end
  end

  def addTile(tiles, count, xpos, ypos, id)
    if id >= 384
      if count >= tiles.length
        sprite = Sprite.new(@viewport)
        tiles.push(sprite, 0)
      else
        sprite = tiles[count]
        tiles[count + 1] = 0
      end
      sprite.visible = @visible
      sprite.x = xpos
      sprite.y = ypos
      getRegularTile(sprite, id)
      if @priorities[id] == 0 || !@priorities[id]
        spriteZ = 0
      else
        spriteZ = ypos + @priorities[id] * 32 + 32
      end
      sprite.z = spriteZ
      count += 2
    else
      if count >= tiles.length
        sprite = Sprite.new(@viewport)
        tiles.push(sprite, 1)
      else
        sprite = tiles[count]
        tiles[count + 1] = 1
      end
      sprite.visible = @visible
      sprite.x = xpos
      sprite.y = ypos
      getAutotile(sprite, id)
      if @priorities[id] == 0 || !@priorities[id]
        spriteZ = 0
      else
        spriteZ = ypos + @priorities[id] * 32 + 32
      end
      sprite.z = spriteZ
      count += 2
    end
    return count
  end

  def refresh_tileset
    i = 0 ; len = @regularTileInfo.length
    while i < len
      if @regularTileInfo[i]
        @regularTileInfo[i].dispose
        @regularTileInfo[i] = nil
      end
      i += 1
    end
    @regularTileInfo.clear
    @priotiles.clear
    ysize = @map_data.ysize
    xsize = @map_data.xsize
    zsize = @map_data.zsize
    if xsize > 100 || ysize > 100
      @fullyrefreshed = false
    else
      for z in 0...zsize
        for y in 0...ysize
          for x in 0...xsize
            id = @map_data[x, y, z]
            next if id == 0 || !@priorities[id]
            next if @priorities[id] == 0
            @priotiles.push([x, y, z, id])
          end
        end
      end
      @fullyrefreshed = true
    end
  end
 
  def refresh_flash
    if @flash_data && !@flash
      @flash = Sprite.new(viewport)
      @flash.visible = true
      @flash.z = 1
      @flash.blend_type = 1
      @flash.bitmap = Bitmap.new(@viewport.rect.width * 2,
      @viewport.rect.height * 2)
      @firsttimeflash = true
    elsif !@flash_data && @flash
      @flash.bitmap.dispose if @flash.bitmap
      @flash.dispose
      @flash = nil
      @firsttimeflash = false
    end
  end

  def refresh_autotiles
    i=0 ; len=@autotileInfo.length
    while i < len
      if @autotileInfo[i]
        @autotileInfo[i].dispose
        @autotileInfo[i] = nil
      end
      i += 1
    end
    i = 0 ; len = @autosprites.length
    while i < len
      if @autosprites[i]
        @autosprites[i].dispose
        @autosprites[i] = nil
      end
      i += 2
    end
    @autosprites.clear
    @autotileInfo.clear
    @prioautotiles.clear
    hasanimated = false
    for i in 0...7
      numframes = autotileNumFrames(48 * (i + 1))
      hasanimated = true if numframes >= 2
      @framecount[i] = numframes
    end
    if hasanimated
      ysize = @map_data.ysize
      xsize = @map_data.xsize
      zsize = @map_data.zsize
      if xsize > 100 || ysize > 100
        @fullyrefreshedautos = false
      else
        for y in 0...ysize
          for x in 0...xsize
            haveautotile = false
            for z in 0...zsize
              id = @map_data[x, y, z]
              next if id == 0 || id >= 384
              next if @priorities[id] != 0 || !@priorities[id]
              next if @framecount[id / 48 - 1] < 2
              haveautotile = true
              break
            end
            @prioautotiles.push([x, y]) if haveautotile
          end
        end
        @fullyrefreshedautos = true
      end
    else
      @fullyrefreshedautos = true
    end
  end

  def map_data=(value)
    @map_data = value
    @tilesetChanged = true
  end

  def refreshFlashSprite
    return if !@flash || @flash_data.nil?
    ptX = @ox - @oxFlash
    ptY = @oy - @oyFlash
    if !@firsttimeflash && !@usedsprites &&
      ptX >= 0 && ptX + @viewport.rect.width <= @flash.bitmap.width &&
      ptY >= 0 && ptY + @viewport.rect.height <= @flash.bitmap.height
      @flash.ox = 0
      @flash.oy = 0
      @flash.src_rect.set(ptX.round, ptY.round,
      @viewport.rect.width, @viewport.rect.height)
      return
    end
    width = @flash.bitmap.width
    height = @flash.bitmap.height
    bitmap = @flash.bitmap
    ysize = @map_data.ysize
    xsize = @map_data.xsize
    zsize = @map_data.zsize
    @firsttimeflash = false
    @oxFlash = @ox - (width >> 2)
    @oyFlash = @oy - (height >> 2)
    @flash.ox = 0
    @flash.oy = 0
    @flash.src_rect.set(width >> 2, height >> 2,
    @viewport.rect.width, @viewport.rect.height)
    @flash.bitmap.clear
    @oxFlash = @oxFlash.floor
    @oyFlash = @oyFlash.floor
    xStart = (@oxFlash >> 5)
    xStart = 0 if xStart < 0
    yStart = (@oyFlash >> 5)
    yStart = 0 if yStart < 0
    xEnd = xStart + (width >> 5) + 1
    yEnd = yStart + (height >> 5) + 1
    xEnd = xsize if xEnd >= xsize
    yEnd = ysize if yEnd >= ysize
    if xStart < xEnd && yStart < yEnd
      yrange = yStart...yEnd
      xrange = xStart...xEnd
      tmpcolor = Color.new(0, 0, 0, 0)
      for y in yrange
        ypos = (y << 5) - @oyFlash
        for x in xrange
          xpos = (x << 5) - @oxFlash
          id = @flash_data[x, y, 0]
          r = (id >> 8) & 15
          g = (id >> 4) & 15
          b = (id) & 15
          tmpcolor.set(r * 16, g * 16, b * 16)
          bitmap.fill_rect(xpos, ypos, 32, 32, tmpcolor)
        end
      end
    end
  end

  def refreshLayer0(autotiles=false)
    ptX = @ox - @oxLayer0
    ptY = @oy - @oyLayer0
    if !autotiles && !@firsttime && !@usedsprites &&
      ptX >= 0 && ptX + @viewport.rect.width <= @layer0.bitmap.width &&
      ptY >= 0 && ptY + @viewport.rect.height <= @layer0.bitmap.height
      if @layer0clip
        @layer0.ox = 0
        @layer0.oy = 0
        @layer0.src_rect.set(ptX.round, ptY.round,
        @viewport.rect.width, @viewport.rect.height)
      else
        @layer0.ox = ptX.round
        @layer0.oy = ptY.round
        @layer0.src_rect.set(0, 0, @layer0.bitmap.width, @layer0.bitmap.height)
      end
      return true
    end
    width = @layer0.bitmap.width
    height = @layer0.bitmap.height
    bitmap = @layer0.bitmap
    ysize = @map_data.ysize
    xsize = @map_data.xsize
    zsize = @map_data.zsize
    if autotiles
      return true if @fullyrefreshedautos && @prioautotiles.length == 0
      return true if !shown?
      xStart = (@oxLayer0 >> 5)
      xStart = 0 if xStart < 0
      yStart = (@oyLayer0 >> 5)
      yStart = 0 if yStart < 0
      xEnd = xStart + (width >> 5) + 1
      yEnd = yStart + (height >> 5) + 1
      xEnd = xsize if xEnd > xsize
      yEnd = ysize if yEnd > ysize
      return true if xStart >= xEnd || yStart >= yEnd
      trans = Color.new(0, 0, 0, 0)
      temprect = Rect.new(0, 0, 0, 0)
      tilerect = Rect.new(0, 0, 32, 32)
      range = 0...zsize
      overallcount = 0
      count = 0
      if !@fullyrefreshedautos
        for y in yStart..yEnd
          for x in xStart..xEnd
            haveautotile = false
            for z in range
              id = @map_data[x, y, z]
              next if id < 48 || id >= 384
              next if @priorities[id] != 0 || !@priorities[id]
              next if @framecount[id / 48 - 1] < 2
              haveautotile = true
              break
            end
            next if !haveautotile
            overallcount += 1
            xpos = (x << 5) - @oxLayer0
            ypos = (y << 5) - @oyLayer0
            bitmap.fill_rect(xpos, ypos, 0, 0, trans) if overallcount <= 2000
            for z in range
              id = @map_data[x, y, z]
              next if id < 48 || @priorities[id] != 0 || !@priorities[id]
              if overallcount > 2000
                count = addTile(@autosprites, count, xpos, ypos, id)
                next
              elsif id >= 384
                temprect.set((id - 384) % 8 * 32, (id - 384) / 8 * 32, 32, 32)
                bitmap.blt(xpos, ypos, @tileset, temprect)
              else
                tilebitmap = @autotileInfo[id]
                if !tilebitmap
                  anim = autotileFrame(id)
                  next if anim < 0
                  tilebitmap = Bitmap.new(32, 32)
                  bltAutotile(tilebitmap, 0, 0, id, anim)
                  @autotileInfo[id] = tilebitmap
                end
                bitmap.blt(xpos,ypos,tilebitmap,tilerect)
              end
            end
          end
        end
      else
        for tile in @prioautotiles
          x = tile[0]
          y = tile[1]
          next if x < xStart || x > xEnd
          next if y < yStart || y > yEnd
          overallcount += 1
          xpos = (x << 5) - @oxLayer0
          ypos = (y << 5) - @oyLayer0
          bitmap.fill_rect(xpos, ypos, 0, 0, trans) if overallcount <= 2000
          for z in range
            id = @map_data[x, y, z]
            next if id < 48 || @priorities[id] != 0 || !@priorities[id]
            if overallcount > 2000
              count = addTile(@autosprites, count, xpos, ypos, id)
              next
            elsif id >= 384
              temprect.set((id - 384) % 8 * 32, (id - 384) / 8 * 32, 32, 32)
              bitmap.blt(xpos, ypos, @tileset, temprect)
            else
              tilebitmap = @autotileInfo[id]
              if !tilebitmap
                anim = autotileFrame(id)
                next if anim < 0
                tilebitmap = Bitmap.new(32, 32)
                bltAutotile(tilebitmap, 0, 0, id, anim)
                @autotileInfo[id] = tilebitmap
              end
              bitmap.blt(xpos, ypos, tilebitmap, tilerect)
            end
          end
        end
      end
      Graphics.frame_reset if overallcount > 2000
      @usedsprites = false
      return true
    end
    return false if @usedsprites
    @firsttime = false
    @oxLayer0 = @ox - (width >> 2)
    @oyLayer0 = @oy - (height >> 2)
    if @layer0clip
      @layer0.ox = 0
      @layer0.oy = 0
      @layer0.src_rect.set(width >> 2, height >> 2,
      @viewport.rect.width, @viewport.rect.height)
    else
      @layer0.ox = (width >> 2)
      @layer0.oy = (height >> 2)
    end
    @layer0.bitmap.clear
    @oxLayer0 = @oxLayer0.floor
    @oyLayer0 = @oyLayer0.floor
    xStart = (@oxLayer0 >> 5)
    xStart = 0 if xStart < 0
    yStart = (@oyLayer0 >> 5)
    yStart = 0 if yStart < 0
    xEnd = xStart + (width >> 5) + 1
    yEnd = yStart + (height >> 5) + 1
    xEnd = xsize if xEnd >= xsize
    yEnd = ysize if yEnd >= ysize
    if xStart < xEnd && yStart < yEnd
      tmprect = Rect.new(0, 0, 0, 0)
      yrange = yStart...yEnd
      xrange = xStart...xEnd
      for z in 0...zsize
        for y in yrange
          ypos = (y << 5) - @oyLayer0
          for x in xrange
            xpos = (x << 5) - @oxLayer0
            id = @map_data[x, y, z]
            next if id == 0 || @priorities[id] != 0 || !@priorities[id]
            if id >= 384
              tmprect.set((id - 384) % 8 * 32, (id - 384) / 8 * 32, 32, 32)
              bitmap.blt(xpos, ypos, @tileset, tmprect)
            else
              frame = autotileFrame(id)
              bltAutotile(bitmap, xpos, ypos, id, frame)
            end
          end
        end
      end
      Graphics.frame_reset
    end
    return true
  end

  def getResizeFactor
    return $ResizeFactor ? $ResizeFactor : 1.0
  end
 
  def ox=(val)
    val = (val * getResizeFactor).to_i
    val = (val / getResizeFactor).to_i
    wasshown = self.shown?
    @ox = val.floor
    @nowshown = (!wasshown && self.shown?)
  end
 
  def oy=(val)
    val = (val * getResizeFactor).to_i
    val = (val / getResizeFactor).to_i
    wasshown = self.shown?
    @oy = val.floor
    @nowshown = (!wasshown && self.shown?)
  end
 
  def visible=(val)
    wasshown = @visible
    @visible = val
    @nowshown = (!wasshown && val)
  end
 
  def refresh(autotiles=false)
    @oldOx = @ox
    @oldOy = @oy
    usesprites = false
    if @layer0
      @layer0.visible = @visible
      usesprites = !refreshLayer0(autotiles)
      return if autotiles && !usesprites
    else
      usesprites = true
    end
    refreshFlashSprite
    vpx = @viewport.rect.x
    vpy = @viewport.rect.y
    vpr = @viewport.rect.width + vpx
    vpb = @viewport.rect.height + vpy
    xsize = @map_data.xsize
    ysize = @map_data.ysize
    minX = (@ox / 32) - 1
    maxX = ((@ox + @viewport.rect.width) / 32) + 1
    minY = (@oy / 32) - 1
    maxY = ((@oy + @viewport.rect.height) / 32) + 1
    minX = 0 if minX < 0
    minX = xsize - 1 if minX >= xsize
    maxX = 0 if maxX < 0
    maxX = xsize - 1 if maxX >= xsize
    minY = 0 if minY < 0
    minY = ysize - 1 if minY >= ysize
    maxY = 0 if maxY < 0
    maxY = ysize - 1 if maxY >= ysize
    count = 0
    if minX < maxX && minY < maxY
      @usedsprites = usesprites || @usedsprites
      if @layer0
        @layer0.visible = false if usesprites
      end
      if @fullyrefreshed
        for prio in @priotiles
          next if prio[0] < minX || prio[0] > maxX
          next if prio[1] < minY || prio[1] > maxY
          id = prio[3]
          xpos = (prio[0] << 5) - @ox
          ypos = (prio[1] << 5) - @oy
          count = addTile(@tiles, count, xpos, ypos, id)
        end
      else
        for z in 0...@map_data.zsize
          for y in minY..maxY
            for x in minX..maxX
              id = @map_data[x, y, z]
              next if id == 0 || !@priorities[id]
              next if @priorities[id] == 0
              xpos = (x << 5) - @ox
              ypos = (y << 5) - @oy
              count = addTile(@tiles, count, xpos, ypos, id)
            end
          end
        end
      end
    end
    if count < @tiles.length
      bigchange = (count <= (@tiles.length * 2 / 3)) &&
      (@tiles.length * 2 / 3) > 25
      j = count ; len = @tiles.length
      while j < len
        sprite = @tiles[j]
        @tiles[j + 1] =- 1
        if bigchange
          sprite.dispose
          @tiles[j] = nil
          @tiles[j + 1] = nil
        elsif !@tiles[j].disposed?
          sprite.visible = false if sprite.visible
        end
        j += 2
      end
      @tiles.compact! if bigchange
    end
  end
end

# end


Como puede que no os interese reescribir el tilemap por defecto en vuestro juego (incrementa algo el lag, además puede que ya uséis otro), he añadido la opción de ponerlo como reescritura a parte solo para el mini-mapa, pero sin que afecte al mapa normal. Para hacerlo id al principio de todo del script, buscar la línea # module Poccil y quitáis el # e id a la última línea de todas buscad la línea # end y quitáis el #. Si ya usáis la reescritura de tilemap de Poccil o bien una modificación de esa misma, dejadla igual.

Posteriormente poned éste otro script, que es el Spriteset Minimap.

Código:
#==============================================================================
# ** [XP] Spriteset Minimap v1.0
#------------------------------------------------------------------------------
# Autor: Wecoc (requiere el Tilemap Rewrite de Poccil)
#==============================================================================

#==============================================================================
# ** RPG::Cache
#==============================================================================

module RPG::Cache
  def self.tileset(filename)
    self.load_bitmap("Graphics/Tilesets/", filename) rescue nil
  end
  def self.autotile(filename)
    self.load_bitmap("Graphics/Autotiles/", filename) rescue nil
  end
  def self.minimap(filename)
    self.load_bitmap("Graphics/Pictures/Minimap/", filename) rescue nil
  end
  def self.minimap_tile(filename, tile_id, hue)
    key = [filename, tile_id, hue]
    if not @cache.include?(key) or @cache[key].disposed?
      @cache[key] = Bitmap.new(8, 8)
      if self.minimap(filename) != nil
        # Cargar de la carpeta Minimap
        x = (tile_id - 384) % 8 * 8
        y = (tile_id - 384) / 8 * 8
        rect = Rect.new(x, y, 8, 8)
        @cache[key].blt(0, 0, self.minimap(filename), rect)
        @cache[key].hue_change(hue)
      else
        # Cargar del propio Tileset
        x = (tile_id - 384) % 8 * 32
        y = (tile_id - 384) / 8 * 32
        rect = Rect.new(x, y, 32, 32)
        dest_rect = Rect.new(0, 0, 8, 8)
        @cache[key].stretch_blt(dest_rect, self.tileset(filename), rect)
        @cache[key].hue_change(hue)
      end
    end
    @cache[key]
  end
end

#==============================================================================
# ** Game_System
#==============================================================================

class Game_System
  attr_accessor :minimap_visible
  attr_accessor :minimap_map_tone
  alias minimap_ini initialize unless $@
  def initialize
    minimap_ini
    @minimap_visible  = true
    @minimap_map_tone = true
  end
end

#==============================================================================
# ** Game_Character
#==============================================================================

class Game_Character
 
  attr_accessor :mm_character_name
  attr_accessor :mm_character_hue
  attr_accessor :mm_opacity
  attr_accessor :mm_blend_type
  attr_accessor :mm_direction
  attr_accessor :mm_pattern
  attr_accessor :mm_animation_id
  attr_accessor :mm_transparent
  attr_accessor :mm_walk_anime
  attr_accessor :mm_step_anime
  attr_accessor :mm_direction_fix
  attr_accessor :mm_always_on_top
 
  alias minimap_ini initialize unless $@
  def initialize
    minimap_ini
    @mm_character_name = ""
    @mm_character_hue = 0
    @mm_opacity = 255
    @mm_blend_type = 0
    @mm_direction = 2
    @mm_pattern = 0
    @mm_animation_id = 0
    @mm_transparent = false
    @mm_walk_anime = true
    @mm_step_anime = false
    @mm_direction_fix = false
    @mm_always_on_top = false
    @mm_anime_count = 0
    @mm_stop_count = 0
  end
 
  alias minimap_straighten straighten unless $@
  def straighten
    minimap_straighten
    if @mm_walk_anime or @mm_step_anime
      @mm_pattern = 0
    end
    @mm_anime_count = 0
  end
 
  def unlock
    return unless @locked
    @locked = false
    unless @direction_fix
      if @prelock_direction != 0
        @direction = @prelock_direction
        @mm_direction = @prelock_direction
      end
    end
  end
 
  def update
    if jumping?
      update_jump
    elsif moving?
      update_move
    else
      update_stop
    end
    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
    if @mm_anime_count > 18 - @move_speed * 2
      if not @mm_step_anime and @mm_stop_count > 0
        @mm_pattern = @original_pattern
      else
        @mm_pattern = (@mm_pattern + 1) % 4
      end
      @mm_anime_count = 0
    end
    if @wait_count > 0
      @wait_count -= 1
      return
    end
    if @move_route_forcing
      move_type_custom
      return
    end
    if @starting or lock?
      return
    end
    if @stop_count > (40 - @move_frequency * 2) * (6 - @move_frequency)
      case @move_type
      when 1  # Random
        move_type_random
      when 2  # Approach
        move_type_toward_player
      when 3  # Custom
        move_type_custom
      end
    end
  end
 
  alias minimap_update_move update_move unless $@
  def update_move
    minimap_update_move
    if @mm_walk_anime
      @mm_anime_count += 1.5
    elsif @mm_step_anime
      @mm_anime_count += 1
    end
  end
 
  alias minimap_update_stop update_stop unless $@
  def update_stop
    minimap_update_stop
    if @mm_step_anime
      @mm_anime_count += 1
    elsif @mm_pattern != @original_pattern
      @mm_anime_count += 1.5
    end
    unless @starting or lock?
      @mm_stop_count += 1
    end
  end
 
  alias minimap_steps increase_steps unless $@
  def increase_steps
    minimap_steps
    @mm_stop_count = 0
  end
 
  alias minimap_jump jump unless $@
  def jump(x_plus, y_plus)
    minimap_jump(x_plus, y_plus)
    new_x = @x + x_plus
    new_y = @y + y_plus
    if (x_plus == 0 and y_plus == 0) or passable?(new_x, new_y, 0)
      @mm_stop_count = 0
    end
  end
 
  alias minimap_turn_down turn_down unless $@
  def turn_down
    minimap_turn_down
    unless @mm_direction_fix
      @mm_direction = 2
      @mm_stop_count = 0
    end
  end

  alias minimap_turn_left turn_left unless $@
  def turn_left
    minimap_turn_left
    unless @mm_direction_fix
      @mm_direction = 4
      @mm_stop_count = 0
    end
  end
 
  alias minimap_turn_right turn_right unless $@
  def turn_right
    minimap_turn_right
    unless @mm_direction_fix
      @mm_direction = 6
      @mm_stop_count = 0
    end
  end 
 
  alias minimap_turn_up turn_up unless $@
  def turn_up
    minimap_turn_up
    unless @mm_direction_fix
      @mm_direction = 8
      @mm_stop_count = 0
    end
  end 
end

#==============================================================================
# ** Sprite_Character_Minimap
#==============================================================================

class Sprite_Character_Minimap < RPG::Sprite
 
  attr_accessor :character
 
  def initialize(viewport, character = nil)
    super(viewport)
    @character = character
    update
  end

  def update
    super
    if @tile_id != @character.tile_id or
      @character_name != @character.mm_character_name or
      @character_hue != @character.mm_character_hue
      @character_name = @character.mm_character_name
      @character_hue = @character.mm_character_hue
      self.bitmap = RPG::Cache.character(@character_name, @character_hue)
      @cw = bitmap.width / 4
      @ch = bitmap.height / 4
      self.ox = @cw / 2
      self.oy = @ch
    end
    self.visible = (not @character.mm_transparent)
    sx = @character.mm_pattern * @cw
    sy = (@character.mm_direction - 2) / 2 * @ch
    self.src_rect.set(sx, sy, @cw, @ch)
    self.x = @character.screen_x / 4
    self.y = @character.screen_y / 4
    if @character.mm_always_on_top
      self.z = 999
    else
      self.z = @character.screen_z(@ch) / 4
    end
    self.opacity = @character.mm_opacity
    self.blend_type = @character.mm_blend_type
    if @character.mm_animation_id != 0
      animation = $data_animations[@character.mm_animation_id]
      animation(animation, true)
      @character.mm_animation_id = 0
    end
  end
end

#==============================================================================
# ** Spriteset_Minimap
#==============================================================================

class Spriteset_Minimap
  attr_reader :viewport
  def initialize
    @viewport = Viewport.new(0, 0, 160, 120)
    @tilemap = Tilemap_Minimap.new(@viewport)
    if RPG::Cache.minimap($game_map.tileset_name) != nil
      @tilemap.tileset = RPG::Cache.minimap($game_map.tileset_name)
    elsif RPG::Cache.tileset($game_map.tileset_name) != nil
      bitmap = RPG::Cache.tileset($game_map.tileset_name)
      tileset = Bitmap.new(bitmap.width / 4, bitmap.height / 4)
      tileset.stretch_blt(tileset.rect, bitmap, bitmap.rect)
      @tilemap.tileset = tileset
    else
      @tilemap.tileset = nil
    end
    for i in 0..6
      autotile_name = $game_map.autotile_names[i]
      if RPG::Cache.minimap(autotile_name) != nil
        @tilemap.autotiles[i] = RPG::Cache.minimap(autotile_name)
      elsif RPG::Cache.autotile(autotile_name) != nil
        bitmap = RPG::Cache.autotile(autotile_name)
        autotile = Bitmap.new(bitmap.width / 4, bitmap.height / 4)
        autotile.stretch_blt(autotile.rect, bitmap, bitmap.rect)
        @tilemap.autotiles[i] = autotile
      else
        @tilemap.autotiles[i] = nil
      end
    end
    @tilemap.map_data = $game_map.data
    @tilemap.priorities = $game_map.priorities

    @character_sprites = []
    for i in $game_map.events.keys.sort
      sprite = Sprite_Character_Minimap.new(@viewport, $game_map.events[i])
      @character_sprites.push(sprite)
    end
    @character_sprites.push(Sprite_Character_Minimap.new(@viewport,
    $game_player))

    update
  end

  def dispose
    @tilemap.tileset.dispose
    for i in 0..6
      @tilemap.autotiles[i].dispose
    end
    @tilemap.dispose
    for sprite in @character_sprites
      sprite.dispose
    end
    @viewport.dispose
  end

  def update
    @tilemap.ox = $game_map.display_x.to_f / 16
    @tilemap.oy = $game_map.display_y.to_f / 16
    @tilemap.update
    for sprite in @character_sprites
      sprite.update
    end
    if $game_system.minimap_map_tone
      @viewport.tone = $game_screen.tone
    else
      @viewport.tone = Tone.new(0,0,0,0)
    end
    @viewport.update
  end
end

#==============================================================================
# ** Scene_Map
#==============================================================================

class Scene_Map
  def main
    @spriteset = Spriteset_Map.new
   
    @minimap = Spriteset_Minimap.new
    @minimap.viewport.rect.x = 32
    @minimap.viewport.rect.y = 32
    @minimap.viewport.z = 9999999
    @minimap_back = Sprite.new
    @minimap_back.bitmap = Bitmap.new(160, 120)
    @minimap_back.bitmap.fill_rect(0, 0, 160, 120, Color.new(0, 0, 0, 48))
    @minimap_back.x = @minimap.viewport.rect.x
    @minimap_back.y = @minimap.viewport.rect.y
    @minimap_back.z = @minimap.viewport.z - 1
   
    @message_window = Window_Message.new
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @spriteset.dispose
    @minimap.dispose
    @minimap_back.dispose
    @message_window.dispose
    if $scene.is_a?(Scene_Title)
      Graphics.transition
      Graphics.freeze
    end
  end
 
  def update
    loop do
      $game_map.update
      $game_system.map_interpreter.update
      $game_player.update
      $game_system.update
      $game_screen.update
      unless $game_temp.player_transferring
        break
      end
      transfer_player
      if $game_temp.transition_processing
        break
      end
    end
    @spriteset.update
    @minimap.update
    @minimap_back.update
    @minimap.viewport.visible = $game_system.minimap_visible
    @minimap_back.visible = $game_system.minimap_visible
    @message_window.update
    if $game_temp.gameover
      $scene = Scene_Gameover.new
      return
    end
    if $game_temp.to_title
      $scene = Scene_Title.new
      return
    end
    if $game_temp.transition_processing
      $game_temp.transition_processing = false
      if $game_temp.transition_name == ""
        Graphics.transition(20)
      else
        Graphics.transition(40, "Graphics/Transitions/" +
          $game_temp.transition_name)
      end
    end
    if $game_temp.message_window_showing
      return
    end
    if $game_player.encounter_count == 0 and $game_map.encounter_list != []
      unless $game_system.map_interpreter.running? or
            $game_system.encounter_disabled
        n = rand($game_map.encounter_list.size)
        troop_id = $game_map.encounter_list[n]
        if $data_troops[troop_id] != nil
          $game_temp.battle_calling = true
          $game_temp.battle_troop_id = troop_id
          $game_temp.battle_can_escape = true
          $game_temp.battle_can_lose = false
          $game_temp.battle_proc = nil
        end
      end
    end
    if Input.trigger?(Input::B)
      unless $game_system.map_interpreter.running? or
            $game_system.menu_disabled
        $game_temp.menu_calling = true
        $game_temp.menu_beep = true
      end
    end
    if $DEBUG and Input.press?(Input::F9)
      $game_temp.debug_calling = true
    end
    unless $game_player.moving?
      if $game_temp.battle_calling
        call_battle
      elsif $game_temp.shop_calling
        call_shop
      elsif $game_temp.name_calling
        call_name
      elsif $game_temp.menu_calling
        call_menu
      elsif $game_temp.save_calling
        call_save
      elsif $game_temp.debug_calling
        call_debug
      end
    end
  end
end

#==============================================================================
# ** Tilemap_Minimap
#==============================================================================

Klass = (defined?(Poccil) != nil) ? Poccil::Tilemap : Tilemap
class Tilemap_Minimap < Klass
  def shown?
    return false if !@visible
    ysize = @map_data.ysize
    xsize = @map_data.xsize
    xStart = (@ox / 8) - 1 ; xEnd = ((@ox + @viewport.rect.width)  / 8) + 1
    yStart = (@oy / 8) - 1 ; yEnd = ((@oy + @viewport.rect.height) / 8) + 1
    xStart = 0 if xStart < 0
    xStart = xsize - 1 if xStart >= xsize
    xEnd = 0 if xEnd < 0
    xEnd = xsize - 1 if xEnd >= xsize
    yStart = 0 if yStart < 0
    yStart = ysize - 1 if yStart >= ysize
    yEnd = 0 if yEnd < 0
    yEnd = ysize - 1 if yEnd >= ysize
    return (xStart < xEnd && yStart < yEnd)
  end
 
  def bltAutotile(bitmap, x, y, id, frame)
    return if frame < 0
    autotile = @autotiles[id / 48 - 1]
    return if !autotile
    if autotile.height == 8
      anim = frame * 8
      src_rect = Rect.new(anim, 0, 8, 8)
      bitmap.blt(x, y, autotile, src_rect)
    else
      anim = frame * 24
      id %= 48
      tiles = Autotiles[id>>3][id&7]
      src = Rect.new(0, 0, 0, 0)
      for i in 0...4
        tile_position = tiles[i] - 1
        src.set(tile_position % 6 * 4 + anim,
        tile_position / 6 * 4, 4, 4)
        bitmap.blt(i % 2 * 4 + x, i / 2 * 4 + y, autotile, src)
      end
    end
  end
 
  def autotileNumFrames(id)
    autotile = @autotiles[id / 48 - 1]
    return 0 if !autotile || autotile.disposed?
    frames = 1
    if autotile.height == 8
      frames = autotile.width / 8
    else
      frames = autotile.width / 24
    end
    return frames
  end
 
  def autotileFrame(id)
    autotile = @autotiles[id / 48 - 1]
    return -1 if !autotile || autotile.disposed?
    frames = 1
    if autotile.height == 8
      frames = autotile.width / 8
    else
      frames = autotile.width / 24
    end
    return (Graphics.frame_count / Animated_Autotiles_Frames) % frames
  end
 
  def getAutotile(sprite, id)
    anim = autotileFrame(id)
    return if anim < 0
    bitmap = @autotileInfo[id]
    if !bitmap
      bitmap = Bitmap.new(8, 8)
      bltAutotile(bitmap, 0, 0, id, anim)
      @autotileInfo[id] = bitmap
    end
    if !sprite.equal?(bitmap) || sprite.bitmap != bitmap
      sprite.bitmap = bitmap
    end
  end
 
  def getRegularTile(sprite, id)
    if false
      if !sprite.equal?(@tileset) || sprite.bitmap != @tileset
        sprite.bitmap = @tileset
      end
      sprite.src_rect.set((id - 384) % 8 * 8, (id - 384) / 8 * 8, 8, 8)
    else
      bitmap = @regularTileInfo[id]
      if !bitmap
        bitmap = Bitmap.new(8, 8)
        rect = Rect.new((id - 384) % 8 * 8, (id - 384) / 8 * 8, 8, 8)
        bitmap.blt(0, 0, @tileset, rect)
        @regularTileInfo[id] = bitmap
      end
      if !sprite.equal?(bitmap) || sprite.bitmap != bitmap
        sprite.bitmap = bitmap
      end
    end
  end

  def addTile(tiles, count, xpos, ypos, id)
    if id >= 384
      if count >= tiles.length
        sprite = Sprite.new(@viewport)
        tiles.push(sprite, 0)
      else
        sprite = tiles[count]
        tiles[count + 1] = 0
      end
      sprite.visible = @visible
      sprite.x = xpos
      sprite.y = ypos
      getRegularTile(sprite, id)
      if @priorities[id] == 0 || !@priorities[id]
        spriteZ = 0
      else
        spriteZ = ypos + @priorities[id] * 32 + 32
      end
      sprite.z = spriteZ
      count += 2
    else
      if count >= tiles.length
        sprite = Sprite.new(@viewport)
        tiles.push(sprite, 1)
      else
        sprite = tiles[count]
        tiles[count + 1] = 1
      end
      sprite.visible = @visible
      sprite.x = xpos
      sprite.y = ypos
      getAutotile(sprite, id)
      if @priorities[id] == 0 || !@priorities[id]
        spriteZ = 0
      else
        spriteZ = ypos + @priorities[id] * 32 + 32
      end
      sprite.z = spriteZ
      count += 2
    end
    return count
  end

  def refreshLayer0(autotiles=false)
    ptX = @ox - @oxLayer0
    ptY = @oy - @oyLayer0
    if !autotiles && !@firsttime && !@usedsprites &&
      ptX >= 0 && ptX + @viewport.rect.width <= @layer0.bitmap.width &&
      ptY >= 0 && ptY + @viewport.rect.height <= @layer0.bitmap.height
      if @layer0clip
        @layer0.ox = 0
        @layer0.oy = 0
        @layer0.src_rect.set(ptX.round, ptY.round,
        @viewport.rect.width, @viewport.rect.height)
      else
        @layer0.ox = ptX.round
        @layer0.oy = ptY.round
        @layer0.src_rect.set(0, 0, @layer0.bitmap.width, @layer0.bitmap.height)
      end
      return true
    end
    width = @layer0.bitmap.width
    height = @layer0.bitmap.height
    bitmap = @layer0.bitmap
    ysize = @map_data.ysize
    xsize = @map_data.xsize
    zsize = @map_data.zsize
    if autotiles
      return true if @fullyrefreshedautos && @prioautotiles.length == 0
      return true if !shown?
      xStart = (@oxLayer0 >> 5)
      xStart = 0 if xStart < 0
      yStart = (@oyLayer0 >> 5)
      yStart = 0 if yStart < 0
      xEnd = xStart + (width >> 5) * 4 + 1
      yEnd = yStart + (height >> 5) * 4 + 1
      xEnd = xsize if xEnd > xsize
      yEnd = ysize if yEnd > ysize
      return true if xStart >= xEnd || yStart >= yEnd
      trans = Color.new(0, 0, 0, 0)
      temprect = Rect.new(0, 0, 0, 0)
      tilerect = Rect.new(0, 0, 8, 8)
      range = 0...zsize
      overallcount = 0
      count = 0
      if !@fullyrefreshedautos
        for y in yStart..yEnd
          for x in xStart..xEnd
            haveautotile = false
            for z in range
              id = @map_data[x, y, z]
              next if id < 48 || id >= 384
              next if @priorities[id] != 0 || !@priorities[id]
              next if @framecount[id / 48 - 1] < 2
              haveautotile = true
              break
            end
            next if !haveautotile
            overallcount += 1
            xpos = ((x << 5) / 4) - @oxLayer0
            ypos = ((y << 5) / 4) - @oyLayer0
            bitmap.fill_rect(xpos, ypos, 0, 0, trans) if overallcount <= 2000
            for z in range
              id = @map_data[x, y, z]
              next if id < 48 || @priorities[id] != 0 || !@priorities[id]
              if overallcount > 2000
                count = addTile(@autosprites, count, xpos, ypos, id)
                next
              elsif id >= 384
                temprect.set((id - 384) % 8 * 8, (id - 384) / 8 * 8, 8, 8)
                bitmap.blt(xpos, ypos, @tileset, temprect)
              else
                tilebitmap = @autotileInfo[id]
                if !tilebitmap
                  anim = autotileFrame(id)
                  next if anim < 0
                  tilebitmap = Bitmap.new(8, 8)
                  bltAutotile(tilebitmap, 0, 0, id, anim)
                  @autotileInfo[id] = tilebitmap
                end
                bitmap.blt(xpos,ypos,tilebitmap,tilerect)
              end
            end
          end
        end
      else
        for tile in @prioautotiles
          x = tile[0]
          y = tile[1]
          next if x < xStart || x > xEnd
          next if y < yStart || y > yEnd
          overallcount += 1
          xpos = ((x << 5) / 4) - @oxLayer0
          ypos = ((y << 5) / 4) - @oyLayer0
          bitmap.fill_rect(xpos, ypos, 0, 0, trans) if overallcount <= 2000
          for z in range
            id = @map_data[x, y, z]
            next if id < 48 || @priorities[id] != 0 || !@priorities[id]
            if overallcount > 2000
              count = addTile(@autosprites, count, xpos, ypos, id)
              next
            elsif id >= 384
              temprect.set((id - 384) % 8 * 8, (id - 384) / 8 * 8, 8, 8)
              bitmap.blt(xpos, ypos, @tileset, temprect)
            else
              tilebitmap = @autotileInfo[id]
              if !tilebitmap
                anim = autotileFrame(id)
                next if anim < 0
                tilebitmap = Bitmap.new(8, 8)
                bltAutotile(tilebitmap, 0, 0, id, anim)
                @autotileInfo[id] = tilebitmap
              end
              bitmap.blt(xpos, ypos, tilebitmap, tilerect)
            end
          end
        end
      end
      Graphics.frame_reset if overallcount > 2000
      @usedsprites = false
      return true
    end
    return false if @usedsprites
    @firsttime = false
    @oxLayer0 = @ox - (width >> 2)
    @oyLayer0 = @oy - (height >> 2)
    if @layer0clip
      @layer0.ox = 0
      @layer0.oy = 0
      @layer0.src_rect.set(width >> 2, height >> 2,
      @viewport.rect.width, @viewport.rect.height)
    else
      @layer0.ox = (width >> 2)
      @layer0.oy = (height >> 2)
    end
    @layer0.bitmap.clear
    @oxLayer0 = @oxLayer0.floor
    @oyLayer0 = @oyLayer0.floor
    xStart = (@oxLayer0 >> 5)
    xStart = 0 if xStart < 0
    yStart = (@oyLayer0 >> 5)
    yStart = 0 if yStart < 0
    xEnd = xStart + (width >> 5) * 4 + 1
    yEnd = yStart + (height >> 5) * 4 + 1
    xEnd = xsize if xEnd >= xsize
    yEnd = ysize if yEnd >= ysize
    if xStart < xEnd && yStart < yEnd
      tmprect = Rect.new(0, 0, 0, 0)
      yrange = yStart...yEnd
      xrange = xStart...xEnd
      for z in 0...zsize
        for y in yrange
          ypos = ((y << 5) / 4) - @oyLayer0
          for x in xrange
            xpos = ((x << 5) / 4) - @oxLayer0
            id = @map_data[x, y, z]
            next if id == 0 || @priorities[id] != 0 || !@priorities[id]
            if id >= 384
              tmprect.set((id - 384) % 8 * 8, (id - 384) / 8 * 8, 8, 8)
              bitmap.blt(xpos, ypos, @tileset, tmprect)
            else
              frame = autotileFrame(id)
              bltAutotile(bitmap, xpos, ypos, id, frame)
            end
          end
        end
      end
      Graphics.frame_reset
    end
    return true
  end

  def getResizeFactor
    return 0.25
  end
 
  def refresh(autotiles=false)
    @oldOx = @ox
    @oldOy = @oy
    usesprites = false
    if @layer0
      @layer0.visible = @visible
      usesprites = !refreshLayer0(autotiles)
      return if autotiles && !usesprites
    else
      usesprites = true
    end
    refreshFlashSprite
    vpx = @viewport.rect.x
    vpy = @viewport.rect.y
    vpr = @viewport.rect.width + vpx
    vpb = @viewport.rect.height + vpy
    xsize = @map_data.xsize
    ysize = @map_data.ysize
    minX = (@ox / 8) - 1
    maxX = ((@ox + @viewport.rect.width) / 8) + 1
    minY = (@oy / 8) - 1
    maxY = ((@oy + @viewport.rect.height) / 8) + 1
    minX = 0 if minX < 0
    minX = xsize - 1 if minX >= xsize
    maxX = 0 if maxX < 0
    maxX = xsize - 1 if maxX >= xsize
    minY = 0 if minY < 0
    minY = ysize - 1 if minY >= ysize
    maxY = 0 if maxY < 0
    maxY = ysize - 1 if maxY >= ysize
    count = 0
    if minX < maxX && minY < maxY
      @usedsprites = usesprites || @usedsprites
      if @layer0
        @layer0.visible = false if usesprites
      end
      if @fullyrefreshed
        for prio in @priotiles
          next if prio[0] < minX || prio[0] > maxX
          next if prio[1] < minY || prio[1] > maxY
          id = prio[3]
          xpos = ((prio[0] << 5) / 4) - @ox
          ypos = ((prio[1] << 5) / 4) - @oy
          count = addTile(@tiles, count, xpos, ypos, id)
        end
      else
        for z in 0...@map_data.zsize
          for y in minY..maxY
            for x in minX..maxX
              id = @map_data[x, y, z]
              next if id == 0 || !@priorities[id]
              next if @priorities[id] == 0
              xpos = ((x << 5) / 4) - @ox
              ypos = ((y << 5) / 4) - @oy
              count = addTile(@tiles, count, xpos, ypos, id)
            end
          end
        end
      end
    end
    if count < @tiles.length
      bigchange = (count <= (@tiles.length * 2 / 3)) &&
      (@tiles.length * 2 / 3) > 25
      j = count ; len = @tiles.length
      while j < len
        sprite = @tiles[j]
        @tiles[j + 1] =- 1
        if bigchange
          sprite.dispose
          @tiles[j] = nil
          @tiles[j + 1] = nil
        elsif !@tiles[j].disposed?
          sprite.visible = false if sprite.visible
        end
        j += 2
      end
      @tiles.compact! if bigchange
    end
  end
end


Más adelante explicaré lo básico para personalizarlo (y tengo alguna qué otra sorpresa preparada) pero de momento ya podéis probarlo y trastearlo.
Nota: No cambiéis nada del script de Tilemap ni del último apartado (Tilemap_Minimap) del Spriteset Minimap.
avatar
Wecoc
Administrador
Administrador



Créditos 9218

Gracias : 493

Volver arriba Ir abajo

RPG Maker XP Re: [XP] Spriteset Minimap

Mensaje por Marshmello el 2017-08-21, 21:28

Lo he probado y parece funcionar bien, ¿pero es normal que ni el personaje ni los eventos aparezcan en el minimapa? xD

Spoiler:

Muy buen script, por cierto. Parece ser el más original en su tipo.


_________________
"I'm so alone... Trying to find my way back home to you..."
PREMIOS:
avatar
Marshmello
Moderador
Moderador



Créditos 1214

Gracias : 81

Volver arriba Ir abajo

RPG Maker XP Re: [XP] Spriteset Minimap

Mensaje por Wecoc el 2017-08-21, 21:59

Marshmello: Es totalmente normal, ahora ya explicaré por qué. Gracias por probarlo.

Personalización del script

1) Formato y carpeta de los charas del mini-mapa

Por defecto los charas del mini-mapa funcionan exactamente como un chara normal. Eso, a diferencia de otros scripts de mini-mapa que usan gráfico único (como un punto de color) permite cosas mucho más personalizables, desde el mismo punto pero con animación, hasta mini-sprites varios. Pero... puede que no os interese, depende del tipo de mini-mapa, claro.

En ese caso buscad éstas líneas:

Código:
      self.bitmap = RPG::Cache.character(@character_name, @character_hue)
      @cw = bitmap.width / 4
      @ch = bitmap.height / 4


La primera define desde donde se carga la imagen, por ejemplo puede usarse RPG::Cache.picture o RPG::Cache.minimap (nueva carpeta Pictures/Minimap), etc. No todos aceptan el parámetro "hue" (tono) así que hay que vigilar con eso; mi recomendación es continuar usando la carpeta Characters excepto si hay una razón de peso para usar otra.

Las siguientes líneas son las que definen el número de "frames" tanto horizontalmente como verticalmente, solo hay que cambiar esos 4.

2) Autotiles animados o no animados

Puede que interese que los autotiles del minimapa nunca estén animados, aunque los del mapa sí lo estén. En ese caso hay que ir dentro de Tilemap_Minimap, hacia el final del script, y dentro entre los métodos que ya hay definidos añadir ésto:

Código:
  def update
    if @autotiles.changed
      refresh_autotiles
      repaintAutotiles
    end
    if @flashChanged
      refresh_flash
    end
    if @tilesetChanged
      refresh_tileset
    end
    if @flash
      @flash.opacity = FlashOpacity[(Graphics.frame_count / 2) % 6]
    end
    if !(@oldOx==@ox && @oldOy==@oy && !@tilesetChanged && !@autotiles.changed)
      refresh
    end
    if @nowshown
      repaintAutotiles
      refresh(true)
    end
    @nowshown = false
    @autotiles.changed = false
    @tilesetChanged = false
  end


3) Posición del mini-mapa e imagen del fondo

Hay que buscar éstas líneas:

Código:
    @minimap.viewport.rect.x = 32
    @minimap.viewport.rect.y = 32


Esos 32 corresponden a la X e Y del mini-mapa.
Justo debajo se define un gráfico llamado @minimap_back que por defecto ocupa exactamente lo mismo que el mini-mapa y es negro translúcido.
Puede que interese usar otro gráfico con bordes y tal, como en otros scripts de mini-mapa; simplemente se define ahí. Si tenéis dudas de cómo hacerlo decídmelo.


Uso del script

1) Activar y desactivar el mini-mapa

$game_system.minimap_visible = true

Eso en cualquier parte del juego activa el mapa, si pones false lo desactiva.
Por defecto está activado, si se busca en el script ésta línea:

Código:
@minimap_visible  = true


Y se cambia a false, por defecto estará desactivado.

2) Opción para que el mini-mapa tenga el mismo tono de pantalla que el mapa

$game_system.minimap_map_tone = true

Eso en cualquier parte del juego hace que use el tono de mapa para el mini-mapa, si pones false no lo usa.
Por defecto está activado, si se busca en el script ésta línea:

Código:
@minimap_map_tone = true


Y se cambia a false, por defecto estará desactivado.

3) Controlar mini-eventos

Se hace partiendo del $game_player o de $game_map.events[ID]. Hay varios parámetros que puedes cambiarle, con éste formato:
(player o evento).(parámetro) = (valor)

Paralelamente se puede cambiar desde Mover evento usando el comando Script, en ese caso el formato será:
@(formato) = (valor)

Aquí pongo los parámetros aunque podéis verlo en el script, apartado Game_Character.

Parámetros:
Nombre: mm_character_name
Tono: mm_character_hue
Opacidad: mm_opacity
Paleta: mm_blend_type
Dirección: mm_direction
Frame: mm_pattern
ID animación: mm_animation_id
Opción "Transparente": mm_transparent
Frames al andar: mm_walk_anime
Frames al estar parado: mm_step_anime
Dirección fija: mm_direction_fix
Prioridad alta: mm_always_on_top

En general son los mismos que tiene el chara normal pero con mm_ (de mini map) delante.

Ejemplo:

Hay modos de simplificarse la vida con ésto, por ejemplo se puede crear un atajo usando el comando "Notas" como hacen otros scripts, es uno de los trucos que explicaré más adelante.

4) Gráfico de tileset y autotiles

Una de las mayores mejoras del script es que permite hacer un gráfico tileset solo para el mini-mapa. Ese gráfico debe llamarse exactamente como el tileset o autotile normal a cargar, pero debe estar dentro de la nueva carpeta Pictures/Minimap.

El formato del nuevo gráfico es el del tileset/autotile pero ya reducido de modo que cada tile hace 8 x 8 píxeles.

Ejemplo:

Óbviamente la gracia de ésto es personalizarlo de modo que no se parezca a la versión reducida del tileset sinó algo totalmente nuevo, ya sea algo mucho más básico (casi como pasable/no pasable), no mostrar algunos tiles... Personalmente recomiendo que no os compliquéis la vida, dejadlo simple, así también es más entendedor. Y que no os dé miedo hacer pixelart, debería ser mucho más simple que hacer tiles de tamaño normal xD Uno de los problemas de usar mini-mapas basados solo en la pasabilidad es que cuando hay algo de solo 1 tile no pasable (un tronco cortado, un jarrón roto...) a veces nos interesaría que NO saliera en el mini-mapa pero no hay modo de hacerlo, ahora sí se puede, solo dejas el tile como vacío y pones como no pasables solo los que realmente te interesa (paredes, columnas...)

Eso es solo lo básico, más adelante explicaré algunas mejoras, pero solo con ésto y algo de imaginación deberíais poder hacer ya algunos mapas más inventivos que los que suele haber en muchos juegos.
avatar
Wecoc
Administrador
Administrador



Créditos 9218

Gracias : 493

Volver arriba Ir abajo

RPG Maker XP Re: [XP] Spriteset Minimap

Mensaje por Contenido patrocinado


Contenido patrocinado


Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


Permisos de este foro:
No puedes responder a temas en este foro.