Charlie's Mini-Map Extended

[DerVVulfman]

Charlie's Mini-Map Extended
Version 2.1
Based on the 'Passability Mini-map by Charlie Fleed v 0.4.4"

Introduction
Plenty and in the script.


Cached Folders:
Of the graphics used by the script, the Event's sprites and the mini-map's optional background image are stored within the Graphics\PassObjs folder.  Both this and the Graphics\Passmaps folder can be encrypted with the rest of your encrypted/compressed game.


Map-Size Limitations:
The size of the generated/used map is limited to the maximum image size that RPGMaker XP can use. Under normal circumstances, you should have absolutely no problem as the maximum size is roughly 12,000 x 12,000 pixel size. But the system, if used with the BIG MAPS system by DerVVulfman, you will be limited. The largest minimap you can generate can cover a 'Big Map' that is 2,500 tiles across and 2,500 tiles deep. That is a big map, certainly larger than the default 500x500 size you're normally limited. But it is a limit none-the-less.

Part 1: Header and Configuration

Code:

#==============================================================================
# ** Charlie's Mini-Map Config
#    Based on the 'Passability Mini-map by Charlie Fleed v 0.4.4"
#------------------------------------------------------------------------------
#    by DerVVulfman
#    version 2.1
#    09-01-2020 (mm/dd/yyyy)
#    RGSS / RPGMaker XP
#==============================================================================
#
#                     INSTRUCTIONS and CONFIGURATION
#
#==============================================================================
#
#  A fair amount of the mechanics of the system had been altered,  though the
#  way it functions is much the same.   It now uses an updated version of the
#  ZLib and Bitmap.make_png methods.  And the configuration values are now in
#  within a new PassMap module.
#
#  Of major changes, is how the system recognizes certain events,  no longer
#  having separate methods to distinguish 'Enemy' and 'Teleport' events from
#  others within a custom list.  All event objects, including the Player it-
#  self, are now defined in a MAP_Events hash.
#
#  Of much more importance, the generated minimaps can now be cached into an
#  encrypted/compressed project.  This way, a game developer can very easily
#  replace the hum drum maps  with beautiful renders  of his/her own without
#  worry of them being lost.
#
#  Also, the Zoom feature has been altered.   While the Zoom setting (origi-
#  nally set by MAP_ZOOM) controls the magnification of the minimap,  it did
#  not allow different magnifications  for different maps.  Now the zoom can
#  be set within the name  of the map itself,  it being  a numeric value set
#  within brackets like:  FortBlaga [CF2].  The CF stands for Charlie Fleed,
#  and separates it from being mistaken for codes used by other systems.
#
#------------------------------------------------------------------------------
#
#  Instructions:
#
#  Minimaps are generated and stored within the Graphics\PassMap folder.
#  All others, sprites or backgrounds are in the Graphics\PassObjs folder.
#
#  Use the commands show_passmap and hide_passmap to make the minimap appear
#  and disappear, the last setting will be saved within your savefile.
#
#  The system allows you to have a pre-determined default zoom setting. But
#  you can have custom minimap zoom settings per map. You do this by entering
#  the numeric value in a set of brackets, currently formatted as [CF#].
#  The CF within the brackets is a configurable setting, the CF being the
#  initials of Charlie Fleed. High numeric values may be recommended for large
#  scaled maps, though more map content outside the visible viewport may be
#  revealed.  Decimal values are permitted, such as 0.5. But the entry can
#  not be '0' or less than zero.
#
#  You may also designate maps that never have a minimap, this by entering
#  a setting such as [MMap Off] within the map's name.  The MMap Off text
#  is also something you can configure.
#
#  Key names for events may be placed  within the event's name,  or entered
#  within a comment as the first entry in the event's List of Commands.  IF
#  the key name is used within a comment,  the contents  of the comment may
#  only be the key name. However, the event's name is flexible and may hold
#  additional text besides the mini-map object key (such as "Enemy Beowulf"
#  if the list of minimap events has an MAP_Events["Enemy"] entry.
#
#  If an event has a 'No Map' comment in its List of Commands,  it is hidden
#  from the minimap.  However,  this is page dependent.  If a switch changes
#  the event's page to one without the comment, it may be revealed.
#
#------------------------------------------------------------------------------
#
#  Sprites:
#
#  In general, the event-based objects drawn in the minimap may be either
#  colored rectangles, or actual bitmap sprites which you may supply by
#  placing them within your Graphics\PassObjs folder.  It is recommended
#  that these be small graphics, roughly 8x8px. A single object, usually
#  something like a colored circle, square, triangle or something that
#  will stand out.
#
#  These sprites do not change in appearance other than vanishing from the
#  screen if the event is erased or a suitable code or page-change happens.
#  However, it is possible to depict the facing direction of a sprite.
#
#  Sprites may depict four facing directions, but the graphic for the sprite
#  must be available.  This sprite graphic will be 4 times wider than it is
#  in height, With this image, you can draw four different images of equal
#  size within, the first image facing up, the second left, the third right
#  and the fourth image facing down.
#
#  For those familiar with Selwyn's Passable Minimap, it is the same basic
#  set of circumstances for the Player sprite. However, this option is ex-
#  tended towards all events with this system.
#
#==============================================================================

module PassMap
  # --------------------------------------------------------------------------
  MAP_Events = {} # Do Not Touch
  # --------------------------------------------------------------------------

  
  # APPEARANCE
  # ==========
  # This handles the default placement and size of the minimap window
  # including its opacity and default zoom-out scaling of the map.
  #
    MAP_X         = 16    # X-Coordinates
    MAP_Y         = 368   # Y-Coordinates
    MAP_H         = 96    # Height (in pixels)
    MAP_W         = 128   # Width (in pixels)
    OPACITY       = 250   # General Opacity (0-255)
    ZOOM          = 0.625 # Zoom Out
                          #  * Higher values zooms out/shrinks the map more
                          #  * Can be floating point values like 0.5
                          #  * Cannot be 0 or negative values


  # MAP POSITION SHIFTING
  # =====================
  # The system has a feature that lets the mini-map shift from one edge of
  # the screen to another if the player gets too close to the edge of the
  # map, a feature perhaps desired if the mini-map may be hampering the
  # visibility of the actual game screen itself.
  #
    HORIZ_SHIFT = true    # Shift position based on player's horizontal position
    VERT_SHIFT  = false   # Shift position based on player's vertical position
    DIST_SHIFT  = 2       # Allowed number of tiles from center before shift


  # ANTI-LAG VIEWPORT
  # =================
  # The system has a rudimentary anti-lag to prevent the slowdown of the
  # system if there are hundreds of events in your map.  This feature sets
  # an area where your events may be updated, basically along the lines of
  # the tile-size of your viewpoort.  This tile size is typically the default
  # (typically a 20x15 tile window), The system includes a buffer to allow
  # updating beyond this range. Larger buffer settings may slow down the
  # system.
  #
    HORIZONTAL          = 20      # Tiles across in the game window
    VERTICAL            = 15      # Tiles high in game window
    BUFFER              = 2       # Extra tiles outside the game window


  # BACKGROUND
  # ==========
  # This handles the background image shown behind the rendered mini-
  # map. The background image is stored within the PassObjs folder,
  # this assuming one is set
  #
    BACK_IMAGE    = "passmap bg"  # Use "" if no background used
    BACK_OPACITY  = 255           # Background Image opacity (0-255)


  # GENERATED TILES
  # ====================  
  # This handles the colors of the initial passable minimap that is
  # generated and saved in your 'Passmaps' folder
  #
    BLOCKED_TILE_COLOR  = Color.new(0,0,0,255)        # Black (cannot cross)
    PASSABLE_TILE_COLOR = Color.new(200,200,200,255)  # Pale White (can cross)


  # HIDE MINIMAP OPTIONS
  # ====================
  # This defines how you can show or hide the minimap. It determines if the
  # message system hides it or if it can be hidden by an RMXP switch.  This
  # assumes you are not using the above mentioned 'hide_passmap' command.
  #
    MESSAGES      = true    # Does Message System hide Minimap
    VISIBLE_START = true   # Is the minimap on at game start?  ****
    SWITCH_ON     = true    # Does an RMXP switch hide Minimap
    SWITCH_ID     = 12      # ID of RMXP switch that hides
    
    #  SwitchStart turns on/off the inherit visibility  of the mini-map
    #  which may be controlled by the 'hide_passmap' and 'show_passmap'
    #  script calls.  If this visibility is set to false and turned off,
    #  the SWITCH_ON / SWITCH_ID entries will have no effect. This visi-
    #  bility must be turned on and engaged for the 'Switch' options to
    #  be effective.
    
  # MINIMAP MAP NAME OPTIONS
  # ========================
  # This defines overriding features for your minimaps per each individual
  # map.  These are flags which you may embed within the map's name, and
  # will override all other options.  Within the actual map name, these
  # must be kept within brackets [].
  #
    MM_HIDE       = 'MMap Off'    # Maps with this do not have minimaps
    MM_ZOOM       = 'CF'          # Maps with this and a numeric value
                                  # will have a pre-adjusted zoom.
    
  # EVENT LISTS
  # ===========
  # This defines the way events are rendered within the minimap. Each entry
  # is specific tag used by events.  This tag may be the name of an event
  # (ie the name in the top-left corner of the event editor), or it may be
  # the first comment in the event's list of commands.
  #
  # Of special note, you do define the player in this list (the first entry).
  # And it is compatible with Near Fantastica's SBABS Allies system which
  # uses an 'Ally' key.
  #
  # Each entry has three parameters:  Image, Color, TileSize
  # Images are small graphics (like 8x8px) stored in the PassObjs folder.
  # Colors are defined with the Color class.
  # TileSize is a numeric value from 2 to 16, a value which determines the
  # size of a rectangle drawn on the map.
  #
  # If an image is used, the Color and TileSize are ignored. But either way,
  # the size of the image/block is the same regardless of the 'zoom'factor
  # of the map.
  #                           Image       Color                    TSize
  # =====================     ==========  ======================   =====
    MAP_Events["Player"]   =  ["TheDude", Color.new(0,0,255,255),   4 ]
    MAP_Events["NPC"]      =  ["",        Color.new(0,128,255,255), 4 ]
    MAP_Events["Ally"]     =  ["",        Color.new(0,128,255,255), 8 ]
    MAP_Events["Chest"]    =  ["",        Color.new(250,128,0),     8 ]
    MAP_Events["Enemy"]    =  ["Enemy",   Color.new(255,0,0,255),   4 ]
    MAP_Events["Fred"]     =  ["",        Color.new(0,255,0,255),   4 ]
  
  
end

Part 2: The Main Engine

Code:

#==============================================================================
# ** Charlie's Mini-Map Extended
#    Based on the 'Passability Mini-map by Charlie Fleed v 0.4.4"
#------------------------------------------------------------------------------
#    by DerVVulfman
#    version 2.1
#    09-01-2020 (mm/dd/yyyy)
#    RGSS / RPGMaker XP
#==============================================================================
#
#                              MAIN ENGINE
#
#==============================================================================



#==============================================================================
# ** Zlib    
#------------------------------------------------------------------------------
#  This module handles data compression, its library having been written by
#  Jean-loup Gailly and Mark Adler.
#==============================================================================

module Zlib
  #============================================================================
  # ** Png_File    
  #----------------------------------------------------------------------------
  #  This class performs generation of PNG formatted bitmap image files
  #============================================================================

  class Png_File < GzipWriter
    #--------------------------------------------------------------------------
    # * Make PNG
    #     bitmap : bitmap being created
    #     mode   : mode (0=safe / 1=rapid)
    #--------------------------------------------------------------------------
    def make_png(bitmap, mode = 0)
      # Save Bitmap & Mode
      @bitmap, @mode = bitmap, mode
      # Create & Save PNG
      self.write(make_header)
      self.write(make_ihdr)
      self.write(make_idat)
      self.write(make_iend)
    end
    #--------------------------------------------------------------------------
    # * Make Header
    #--------------------------------------------------------------------------
    def make_header
      return [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a].pack('C*')
    end
    #--------------------------------------------------------------------------
    # * Make IHDR
    #--------------------------------------------------------------------------
    def make_ihdr
      ih_size               = [13].pack("N")
      ih_sign               = 'IHDR'
      ih_width              = [@bitmap.width].pack('N')
      ih_height             = [@bitmap.height].pack('N')
      ih_bit_depth          = [8].pack('C')
      ih_color_type         = [6].pack('C')
      ih_compression_method = [0].pack('C')
      ih_filter_method      = [0].pack('C')
      ih_interlace_method   = [0].pack('C')
      string = ih_sign + ih_width + ih_height + ih_bit_depth + ih_color_type +
               ih_compression_method + ih_filter_method + ih_interlace_method
      ih_crc = [Zlib.crc32(string)].pack('N')
      return ih_size + string + ih_crc
    end
    #--------------------------------------------------------------------------
    # * Make IDAT
    #--------------------------------------------------------------------------
    def make_idat
      header  = "\x49\x44\x41\x54"
      data    = @mode == 0 ? make_bitmap_data0 : make_bitmap_data1
      data    = Zlib::Deflate.deflate(data, 8)
      crc     = [Zlib.crc32(header + data)].pack('N')
      size    = [data.length].pack('N')
      return size + header + data + crc
    end
    #--------------------------------------------------------------------------
    # * Make Bitmap Data 0
    #--------------------------------------------------------------------------
    def make_bitmap_data0
      gz = Zlib::GzipWriter.open('hoge.gz')
      t_Fx = 0
      w = @bitmap.width
      h = @bitmap.height
      data = []
      for y in 0...h
        data.push(0)
        for x in 0...w
          t_Fx += 1
          if t_Fx % 10000 == 0
            Graphics.update
          end
          if t_Fx % 100000 == 0
            s = data.pack("C*")
            gz.write(s)
            data.clear
          end
          color = @bitmap.get_pixel(x, y)
          red   = color.red
          green = color.green
          blue  = color.blue
          alpha = color.alpha
          data.push(red)
          data.push(green)
          data.push(blue)
          data.push(alpha)
        end
      end
      s = data.pack("C*")
      gz.write(s)
      gz.close  
      data.clear
      gz = Zlib::GzipReader.open('hoge.gz')
      data = gz.read
      gz.close
      File.delete('hoge.gz')
      return data
    end
    #--------------------------------------------------------------------------
    # * Make Bitmap Data Mode 1
    #--------------------------------------------------------------------------
    def make_bitmap_data1
      w = @bitmap.width
      h = @bitmap.height
      data = []
      for y in 0...h
        data.push(0)
        for x in 0...w
          color = @bitmap.get_pixel(x, y)
          red   = color.red
          green = color.green
          blue  = color.blue
          alpha = color.alpha
          data.push(red)
          data.push(green)
          data.push(blue)
          data.push(alpha)
        end
      end
      return data.pack("C*")
    end
    #--------------------------------------------------------------------------
    # * Make IEND
    #--------------------------------------------------------------------------
    def make_iend
      ie_size = [0].pack('N')
      ie_sign = 'IEND'
      ie_crc  = [Zlib.crc32(ie_sign)].pack('N')
      return ie_size + ie_sign + ie_crc
    end
  end
end



#==============================================================================
# ** Bitmap
#------------------------------------------------------------------------------
#  The bitmap class. Bitmaps are expressions of so-called graphics.  Sprites
#  (Sprite) and other objects must be used to display bitmaps on the screen.
#==============================================================================

class Bitmap
  #-------------------------------------------------------------------------
  # * Name      : Make PNG
  #   Info      : Saves Bitmap to File
  #   Author    : Wheeler (Initial Date: 2006-11-28)
  #   Found     : http://www.66rpg.com/htm/news624.htm (Chinese - Now 404)
  #   Call Info : Zero to Three Arguments
  #               Name : Name of filenam
  #               Path : Directory in Game Folder
  #               Mode : Mode of Writing
  #-------------------------------------------------------------------------
  def make_png(name = 'like', path = '', mode = 0)
    Dir.make_dir(path) if path != ''
    Zlib::Png_File.open('temp.gz')   { |gz| gz.make_png(self, mode) }
    Zlib::GzipReader.open('temp.gz') { |gz| $read = gz.read }
    f = File.open(path + name + '.png', 'wb')
    f.write($read)
    f.close
    File.delete('temp.gz')
  end
end



#==============================================================================
# ** RPG::MapInfo
#------------------------------------------------------------------------------
#  Data class for map information.
#==============================================================================

class RPG::MapInfo
  #--------------------------------------------------------------------------
  # * Obtain map name without additional bracket code
  #--------------------------------------------------------------------------
  def name
    return @name.gsub(/\[.*\]/) {""}
  end
  #--------------------------------------------------------------------------
  # * Obtain map name - include all prefix code
  #--------------------------------------------------------------------------
  def name_cfpmm
    return @name
  end
end



#==============================================================================
# ** RPG::Cache
#------------------------------------------------------------------------------
#  The module that loads each of RPGXP's graphic formats, creates a Bitmap
#  object, and retains it.
#==============================================================================

module RPG::Cache
  #------------------------------------------------------------------------
  # * Passable Minimap Maps
  #     filename : filename of the cached bitmap
  #------------------------------------------------------------------------
  def self.passmaps(filename)
    begin
      self.load_bitmap("Graphics/Passmaps/", filename)
    end
  end
  #------------------------------------------------------------------------
  # * Passable Minimap Backgrounds
  #     filename : filename of the cached bitmap
  #------------------------------------------------------------------------
  def self.passobjs(filename)
    begin
      self.load_bitmap("Graphics/PassObjs/", filename)
    end
  end  
end



#==============================================================================
# ** Game_Temp
#------------------------------------------------------------------------------
#  This class handles temporary data that is not included with save data.
#  Refer to "$game_temp" for the instance of this class.
#==============================================================================

class Game_Temp
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :redraw_passmap           # Redraw pass map trigger
  attr_accessor :refresh_passmap          # Refresh pass map trigger
  attr_accessor :scene_visible            # Scene map visibility flag
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias game_temp_passmap_cf_initialize initialize
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    # Original call
    game_temp_passmap_cf_initialize
    # New variables
    @redraw_passmap   = false
    @refresh_passmap  = false
    @scene_visible    = false
  end
end



#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
#  This class handles data surrounding the system. Backround music, etc.
#  is managed here as well. Refer to "$game_system" for the instance of
#  this class.
#==============================================================================

class Game_System
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :minimap_visible          # Minimap visibility flag
  attr_accessor :minimap_opacity          # Minimap opacity setting
  attr_accessor :minimap_map_off          # Minimap disabled on map
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias game_system_passmap_cf_initialize initialize
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    # Original call
    game_system_passmap_cf_initialize
    # New variables
    @minimap_visible  = PassMap::VISIBLE_START
    @minimap_opacity  = PassMap::OPACITY
  end
end



#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  This class handles the map. It includes scrolling and passable determining
#  functions. Refer to "$game_map" for the instance of this class.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :minimap_zoom             # zoom effect
  #--------------------------------------------------------------------------
  # * Alias Settings
  #--------------------------------------------------------------------------
  alias game_map_passmap_cf_setup setup
  #--------------------------------------------------------------------------
  # * Setup
  #     map_id : map ID
  #--------------------------------------------------------------------------
  def setup(map_id)
    # Create zoom, allowing zoom per map
    @minimap_zoom = PassMap::ZOOM
    test = setup_zoom_test(map_id)
    @minimap_zoom = test unless test.nil?
    setup_minimap_off(map_id)
    # Original call
    game_map_passmap_cf_setup(map_id)
    # New variables
    $game_temp.refresh_passmap  = true
  end
  #--------------------------------------------------------------------------
  # * Setup Charlie Fleed Map On/Off
  #     map_id : map ID
  #--------------------------------------------------------------------------
  def setup_minimap_off(map_id)
    map_data = load_data("Data/MapInfos.rxdata")[map_id]
    $game_system.minimap_map_off=map_data.name_cfpmm.include?(PassMap::MM_HIDE)
  end
  #--------------------------------------------------------------------------
  # * Setup Charlie Fleed Map Zoom
  #     map_id : map ID
  #--------------------------------------------------------------------------
  def setup_zoom_test(map_id)
    map_data = load_data("Data/MapInfos.rxdata")[map_id]
    map_data.name_cfpmm =~ /\[#{PassMap::MM_ZOOM}(.*?)\]/
    name3 = $1
    return nil if name3.nil?
    name3 = name3.to_f
    # Ensure no invalid value
    name3 = 1.0 if name3 <= 0
    return name3
  end
end



#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
#  This class deals with events. It handles functions including event page
#  switching via condition determinants, and running parallel process events.
#  It's used within the Game_Map class.
#==============================================================================

class Game_Event < Game_Character
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :event                    # event
  #--------------------------------------------------------------------------
  # * If a minimap event
  #--------------------------------------------------------------------------
  def minimap_tested?(comparestring)
    # Exit if no map
    return false if no_map?
    # Confirm if event's name matches
    return true if @event.name =~ comparestring
    # Cycle through events
    for p in @event.pages
      for command in p.list
        next unless command.code == 108
        return true if command.parameters[0] == comparestring
      end
    end
    return false
  end
  #--------------------------------------------------------------------------
  # * If flagged for no visibility on map
  #--------------------------------------------------------------------------
  def no_map?
    # Show no map if no event page content
    return true if @page.nil?
    # Cycle through event page
    for command in @page.list
      # Skip unless a comment exists
      next unless command.code == 108
      # Show no map if comment shows blocked
      return true if command.parameters[0] == "No Map"
    end
    # Snow map exists
    return false
  end
end



#==============================================================================
# ** Map_Objects
#------------------------------------------------------------------------------
#  This class deals with minimap objects. It handles rendering of map events
#  on the minimap itself, recognizing both the Game_Event and Game_Player
#  class and optionally the Game_Ally class if it exists within the game.
#  It is used within the Passability_Map class
#==============================================================================

class Map_Objects < Sprite
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    @valid_objects = []
    # Push Events
    for object in $game_map.events.values
      next if object.nil?
      # If a keyword Events
      for key in PassMap::MAP_Events.keys
        @valid_objects.push(object) if object.minimap_tested?(key)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Dispose if it exists
    update_erase
    # Define config values used
    zoom = $game_map.minimap_zoom
    # Determine bitmap area
    self.bitmap   = Bitmap.new(4 * $game_map.width/zoom,
                               4 * $game_map.height/zoom)
    # Determine player position
    @player_x     = (4 * $game_player.real_x / 128.0) / zoom
    @player_y     = (4 * $game_player.real_y/ 128.0) / zoom
    # Determine avg size of tile
    tilesize      = 4 / zoom
    # Player center determinant
    self.ox       = [[0 ,
                    @player_x - self.viewport.rect.width/ 2 + tilesize/2].max,
                    4 * $game_map.width / zoom - self.viewport.rect.width].min
    self.oy       = [[0,
                    @player_y - self.viewport.rect.height / 2].max,
                    4 * $game_map.height / zoom - self.viewport.rect.height].min
    # Draw Events on map
    update_event_objects
    update_event_allies
    update_event_player
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Erase Events
  #--------------------------------------------------------------------------  
  def update_erase
    self.bitmap.dispose unless self.bitmap.nil?
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Handle Specific Events
  #--------------------------------------------------------------------------  
  def update_event_objects
    # Zoom and Tile Size
    zoom = $game_map.minimap_zoom
    tilesize  = 4 / zoom
    # Limited Viewport Params
    horiz = (PassMap::HORIZONTAL + PassMap::BUFFER) * 6
    vert  = (PassMap::VERTICAL + PassMap::BUFFER) * 6
    # Cycle through all events on the map
    for object in @valid_objects
      # Skip non-existant objects
      next if object.nil?
      # Acquire position
      object_x  = (4 * object.real_x / 128.0) / zoom
      object_y  = (4 * object.real_y / 128.0) / zoom      
      next if object_x < @player_x - horiz
      next if object_x > @player_x + horiz
      next if object_y < @player_y - vert
      next if object_y > @player_y + vert
      # Acquire facing direction
      dir = object.direction
      # If a keyword matches
      for key in PassMap::MAP_Events.keys
        next unless object.minimap_tested?(key)
        # Perform event drawing update
        update_event(object_x, object_y, dir, key)
        # Break from loop and go to next event
        break
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Handle Allies
  #--------------------------------------------------------------------------
  def update_event_allies
    # Zoom and Tile Size
    zoom = $game_map.minimap_zoom
    tilesize  = 4 / zoom
    # Limited Viewport Params
    horiz = (PassMap::HORIZONTAL + PassMap::BUFFER) * zoom
    vert  = (PassMap::VERTICAL + PassMap::BUFFER) * zoom
    # Define key for player
    key       = "Ally"
    return unless PassMap::MAP_Events.has_key?(key)
    # Only if NF Allies detected
    return if $game_allies.nil?
    # Cycle through all NF allies on map
    for ally in $game_allies.values
      # Skip of no ally
      next if ally.nil?
      # Acquire position
      object_x  = (4 * ally.real_x / 128.0) / zoom
      object_y  = (4 * ally.real_y / 128.0) / zoom      
      next if object_x < @player_x - horiz
      next if object_x > @player_x + horiz
      next if object_y < @player_y - vert
      next if object_y > @player_y + vert
      # Acquire facing direction
      dir = object.direction
      # Perform event drawing update
      update_event(object_x, object_y, dir, key)
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Handle Player
  #     object_x : player x-position
  #     object_y : player y-position
  #--------------------------------------------------------------------------
  def update_event_player
    # Define key for player
    key       = "Player"
    return unless PassMap::MAP_Events.has_key?(key)
    # Acquire facing direction
    dir = $game_player.direction
    # Perform event drawing update
    update_event(@player_x, @player_y, dir, key)
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Handle Basic Event Drawing
  #     object_x : object x-position
  #     object_y : object y-position
  #     dir      : object facing direction
  #     key      : key
  #--------------------------------------------------------------------------
  def update_event(object_x, object_y, dir, key)
    # Acquire settings
    image     = PassMap::MAP_Events[key][0]
    tile_clr  = PassMap::MAP_Events[key][1]
    fill_size = PassMap::MAP_Events[key][2]
    # Fill size stays between 2 to 16
    fill_size = [16, ([2,  fill_size].max)].min
    unless image.nil? or image == ""
      # Blit image
      bitmap = RPG::Cache.passobjs(image)
      # If a 4-way directional sprite
      if bitmap.width == bitmap.height * 4
        map_4blit(object_x, object_y, dir, bitmap )
      # Otherwise if a single block sprite
      else
        map_1blit(object_x, object_y, bitmap)
      end
    else
      map_fill(object_x, object_y, tile_clr, fill_size)
    end    
  end
  #--------------------------------------------------------------------------
  # * Blit Sprite on map (4-Way version
  #     object_x : x-coordinates on minimap
  #     object_y : y-coordinates on minimap
  #     dir      : Facing Direction
  #     bitmap   : bitmap image
  #--------------------------------------------------------------------------
  def map_4blit(object_x, object_y, dir, bitmap )
    # Zoom and Tile Size
    zoom = $game_map.minimap_zoom
    tilesize  = 4 / zoom
    # Bitmap Width (1/4th the height)
    width = bitmap.width / 4
    # Get Frame of 4-frame sprite
    x_pos = (dir / 2 - 1) * bitmap.height
    # Create new bitmap rectangle, using settings
    bit_rect = Rect.new(x_pos, 0, width, bitmap.height)
    x = ([0, object_x - 0.5 * width].max) + (tilesize/2)
    y = ([0, object_y - 0.5 * bitmap.height].max)
    # Blit Sprite on Map
    self.bitmap.blt(x, y, bitmap, bit_rect, 128)
  end
  #--------------------------------------------------------------------------
  # * Blit Sprite on map
  #     object_x : x-coordinates on minimap
  #     object_y : y-coordinates on minimap
  #     bitmap   : bitmap image
  #--------------------------------------------------------------------------
  def map_1blit(object_x, object_y, bitmap)
    # Zoom and Tile Size
    zoom = $game_map.minimap_zoom
    tilesize  = 4 / zoom
    # Set position
    x = ([0, object_x - 0.5 * bitmap.width].max) + (tilesize / 2)
    y = ([0, object_y - 0.5 * bitmap.height].max)
    # Blit Sprite on Map
    self.bitmap.blt(x,y, bitmap, bitmap.rect, 128)      
  end
  #--------------------------------------------------------------------------
  # * Fill Rectangle on map
  #     object_x  : x-coordinates on minimap
  #     object_y  : y-coordinates on minimap
  #     color     : bitmap image
  #     fill_size : pixel size of filled block
  #--------------------------------------------------------------------------
  def map_fill(object_x, object_y, color, fill_size)
    # Zoom and Tile Size
    zoom = $game_map.minimap_zoom
    tilesize  = 4 / zoom
    # Set position
    x = ([0, object_x - 0.5 * fill_size].max) + (tilesize / 2)
    y = ([0, object_y - 0.5 * fill_size].max)
    # Fill Rectangle on Map
    self.bitmap.fill_rect(x, y, fill_size, fill_size, color)
  end
  #--------------------------------------------------------------------------
  # * Get Height
  #--------------------------------------------------------------------------
  def height
    zoom = $game_map.minimap_zoom
    return [ 4 * $game_map.height / zoom, self.viewport.rect.height ].min
  end
  #--------------------------------------------------------------------------
  # * Get Width
  #--------------------------------------------------------------------------
  def width
    zoom = $game_map.minimap_zoom
    return [ 4 * $game_map.width / zoom, self.viewport.rect.width ].min
  end
end



#==============================================================================
# ** Passability_Map
#------------------------------------------------------------------------------
#  This class actively renders the minimap utilizing game map passage data,
#  and brings it together with events rendered by the Map_Objects class.
#  It is used within the Scene_Map class.
#==============================================================================

class Passability_Map < Sprite
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :objects                  # Map Objects
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     viewport  : viewport
  #--------------------------------------------------------------------------
  def initialize(viewport)
    super(viewport)
    # Do not initialize if map excluded
    return if $game_system.minimap_map_off    
    # Acquire Event Object on map
    @objects  = Map_Objects.new(viewport)
    # Set Minimap Opacity
    self.opacity  = $game_system.minimap_opacity
    # Determine Minimap visibility
    self.visible  = cf_passmap_viewport_visible
  end
  #--------------------------------------------------------------------------
  # * Create a new minimap and make cached png file
  #--------------------------------------------------------------------------
  def renew
    @map  = Bitmap.new( 4 * $game_map.width, 4 * $game_map.height)
    for x in 0...$game_map.width
      Graphics.update
      for y in 0...$game_map.height
        temp = 0
        @map.fill_rect(x * 4, y * 4, 4, 4, PassMap::PASSABLE_TILE_COLOR)
        if !$game_map.passable?(x, y, 2) # DOWN
          @map.fill_rect(x*4, y*4+3, 4, 1, PassMap::BLOCKED_TILE_COLOR)
          temp += 1
        end
        if !$game_map.passable?(x, y, 4) # LEFT
          @map.fill_rect(x*4, y*4, 1, 4, PassMap::BLOCKED_TILE_COLOR)
          temp += 1
        end
        if !$game_map.passable?(x, y, 6) # RIGHT
          @map.fill_rect(x*4+3, y*4, 1, 4, PassMap::BLOCKED_TILE_COLOR)
          temp += 1
        end
        if !$game_map.passable?(x, y, 8) # UP
          @map.fill_rect(x*4, y*4, 4, 1, PassMap::BLOCKED_TILE_COLOR)
          temp += 1
        end
        if temp == 4
          @map.fill_rect(x*4+1, y*4+1, 2, 2, PassMap::BLOCKED_TILE_COLOR)
        end
      end
    end
    # Create named PNG file from bitmap created
    @map.make_png(@name_map)
  end    
  #--------------------------------------------------------------------------
  # * Draw minimap and visually load
  #--------------------------------------------------------------------------
  def redraw
    # Zoom and Tile Size
    zoom = $game_map.minimap_zoom
    # Hide until drawn
    self.visible = false
    # Execute Map renewal
    renew
    # Define the size and set the minimap bitmap
    self.bitmap = Bitmap.new(@map.width / zoom, @map.height / zoom)
    self.bitmap.stretch_blt(self.bitmap.rect, @map, @map.rect, 255)
    # Handle reveal
    self.visible = cf_passmap_viewport_visible
  end
  #------------------------------------------------------------------------
  # * Refresh
  #------------------------------------------------------------------------
  def refresh
    # Do not refresh if map excluded
    return if $game_system.minimap_map_off    
    # Zoom
    zoom = $game_map.minimap_zoom
    # Create the Passmap Folder if it doesn't exist
    begin
      Dir.mkdir 'Graphics/Passmaps'
    rescue
      # Do nothing.
    end
    # Test if big map if Big Map system in project
    map_key = nil
    if Game_Map.method_defined? :old_big_event
      map_key = BigMaps.map_test($game_map.map_id)
    end
    # If a normal map
    if map_key.nil?
      # Load normal map name and cache loading name
      @name_map = "Graphics/Passmaps/pass_map_" + $game_map.map_id.to_s
      loadname  = "pass_map_" + $game_map.map_id.to_s
    else
      # Load bigmap map name and cache loading name
      @name_map = "Graphics/Passmaps/pass_map_" + map_key
      loadname  = "pass_map_" + map_key
    end
    # Load the cached minimap if it exists
    begin
      @map = RPG::Cache.passmaps(loadname)
    rescue
      renew
    end
    # Define the size and set the minimap bitmap
    self.bitmap = Bitmap.new( @map.width/zoom, @map.height/zoom )
    self.bitmap.stretch_blt(self.bitmap.rect, @map, @map.rect)
    # Refresh map objects
    @objects.refresh
  end  
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Do not update if map excluded
    return if $game_system.minimap_map_off    
    # Zoom and Tile Size
    zoom      = $game_map.minimap_zoom
    tilesize  = 4 / zoom    
    # Exit unless map exists
    return if @map.nil?
    # Handle Visinility
    self.visible = cf_passmap_viewport_visible
    # Set Object Visibility to match
    @objects.visible = self.visible
    # Exit if not visible
    return if not self.visible
    # Acquire player coords
    player_x  =  (4 * $game_player.real_x / 128.0) / zoom
    player_y  =  (4 * $game_player.real_y / 128.0) / zoom
    # Set minimap center
    self.ox   = [[0, player_x - self.viewport.rect.width / 2 + tilesize/2].max,
                  @map.width / zoom - self.viewport.rect.width].min
    self.oy   = [[0, player_y - self.viewport.rect.height / 2 + tilesize/2].max,
                  @map.height / zoom - self.viewport.rect.height].min
    # Update event objects
    @objects.update
    # Set minimap opacity
    self.opacity      = $game_system.minimap_opacity
    # Set object event opacity
    @objects.opacity  = self.opacity
  end
  #--------------------------------------------------------------------------
  # * Minimap Visibility
  #--------------------------------------------------------------------------
  def cf_passmap_viewport_visible
    # Map tag override
    return false if $game_system.minimap_map_off
    # Remaining optional on/off systems
    return ($game_system.minimap_visible and
      ((not PassMap::MESSAGES) or (not $game_temp.message_window_showing)) and
      ((not PassMap::SWITCH_ON) or (not $game_switches[PassMap::SWITCH_ID])))
  end  
  #--------------------------------------------------------------------------
  # * Get Height
  #--------------------------------------------------------------------------
  def height
    zoom = $game_map.minimap_zoom
    return [@map.height / zoom, self.viewport.rect.height].min
  end
  #--------------------------------------------------------------------------
  # * Get Width
  #--------------------------------------------------------------------------
  def width
    zoom = $game_map.minimap_zoom
    return [@map.width / zoom, self.viewport.rect.width].min
  end  
end



#==============================================================================
# ** Interpreter
#------------------------------------------------------------------------------
#  This interpreter runs event commands. This class is used within the
#  Game_System class and the Game_Event class.
#==============================================================================

class Interpreter
  #--------------------------------------------------------------------------
  # * Redraw Passmap Command (actively recreats & overwrites previous render)
  #--------------------------------------------------------------------------
  def redraw_passmap
    $game_temp.redraw_passmap = true
  end
  #--------------------------------------------------------------------------
  # * Hide Passmap Command
  #--------------------------------------------------------------------------
  def hide_passmap
    $game_system.minimap_visible = false
    return
  end
  #--------------------------------------------------------------------------
  # * Show Passmap Command
  #--------------------------------------------------------------------------
  def show_passmap
    $game_system.minimap_visible = true
    return
  end
end



#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs map screen processing.
#==============================================================================

class Scene_Map
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :map                      # Field Map
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias scene_map_passmap_cf_main main
  alias scene_map_passmap_cf_update update
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Passable Minimap Initialization
    cf_passmap_initialize
    # Original call
    scene_map_passmap_cf_main
    # Passable Minimap Disposal
    cf_passmap_dispose
  end
  #--------------------------------------------------------------------------
  # * Main Processing : Passable Minimap Initialization
  #--------------------------------------------------------------------------
  def cf_passmap_initialize
    # Configured values
    map_x = PassMap::MAP_X
    map_y = PassMap::MAP_Y
    map_h = PassMap::MAP_H
    map_w = PassMap::MAP_W
    # Generate Viewport
    generate_viewport(map_x, map_y, map_h, map_w)
  end
  #--------------------------------------------------------------------------
  # * Main Processing : Generate MiniMap Viewport
  #--------------------------------------------------------------------------
  def generate_viewport(map_x, map_y, map_h, map_w)
    # Do not perform if map has no minimap
    if $game_system.minimap_map_off    
      @map.objects.update_erase unless @map.nil?
      return
    end
    # Dispose of old viewport
    cf_passmap_dispose
    Graphics.update
    # Create the viewport
    @map_viewport         = Viewport.new(map_x, map_y, map_w, map_h)
    @map_viewport.z       = 9999
    @map_viewport.visible = cf_passmap_viewport_visible
    @map                  = Passability_Map.new(@map_viewport)
    @map.refresh
    # Exit unless there is a background image
    return if PassMap::BACK_IMAGE.nil?
    return if PassMap::BACK_IMAGE == ""
    # Set Background Viewport
    @map_bg_viewport = Viewport.new(map_x - 8, map_y - 8,
                                    @map.width + 16, @map.height + 16)
    @map_bg_viewport.z  = 9998
    # Set Background visible
    @map_bg_viewport.visible  = cf_passmap_viewport_visible
    # Create background image, including scale  
    @map_bg         = Sprite.new(@map_bg_viewport)
    @map_bg.bitmap  = RPG::Cache.passobjs(PassMap::BACK_IMAGE)
    @map_bg.opacity = PassMap::BACK_OPACITY
    @map_bg.zoom_x  = 1.0 * (@map_bg_viewport.rect.width)/@map_bg.bitmap.width
    @map_bg.zoom_y  = 1.0 * (@map_bg_viewport.rect.height)/@map_bg.bitmap.height
    # Refresh map and background
    cf_passmap_update_refresh(map_x, map_y)
    # Update game screen
    Graphics.update
  end
  #--------------------------------------------------------------------------
  # * Main Processing : Passable Minimap Disposal
  #--------------------------------------------------------------------------
  def cf_passmap_dispose
    # Dispose of minimap background
    if PassMap::BACK_IMAGE != ""
      @map_bg.dispose           unless @map_bg.nil?
      @map_bg_viewport.dispose  unless @map_bg_viewport.nil?
    end
    # Dispose of minimap
    @map.dispose                unless @map.nil?
    @map_viewport.dispose       unless @map_viewport.nil?
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Ensure visible
    $game_temp.scene_visible = true
    # Original call
    scene_map_passmap_cf_update
    # Determine if restart
    restart = false
    if @oldmap_id != $game_map.map_id
      restart = true
      @oldmap_id = $game_map.map_id
    end
    # Verify Minimap placement
    cf_passmap_placement(restart)
    # Passable Minimap processing
    cf_passmap_update
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Passable Minimap placement based on player on map
  #--------------------------------------------------------------------------
  def cf_passmap_placement(restart=false)
    # Set test values
    map_width     = $game_map.width
    map_height    = $game_map.height
    map_x         = PassMap::MAP_X
    map_y         = PassMap::MAP_Y
    dist          = PassMap::DIST_SHIFT
    # Assume no repositioning
    reposition = restart
    # Handle Vertical Shift
    if PassMap::HORIZ_SHIFT == true
      # If defaulted to the left side
      if PassMap::MAP_X  < 320
        # Shift to right if near left edge of map
        if $game_player.x < (10 - dist)
          map_x = 640 - ( PassMap::MAP_X + PassMap::MAP_W )
          @ignore_x = false
        # Shift to left if near left edge of map
        elsif ($game_player.x - dist ) >= (map_width - 10)
          @ignore_x = false
        else
          @ignore_x = true
        end
      end
      # If defaulted to the right side
      if  PassMap::MAP_X >= 320
        # Shift to left if near right edge of map
        if ($game_player.x - dist) >= (map_width - 10 )
          map_x = 640 - ( PassMap::MAP_X + PassMap::MAP_W )
          @ignore_x = false
        # Shift to right if near right edge of map
        elsif $game_player.x < (10 - dist)  
          @ignore_x = false
        else
          @ignore_x = true
        end
      end
    end
    # Handle Vertical Shift
    if PassMap::VERT_SHIFT == true
      # If defaulted to the top side
      if PassMap::MAP_Y < 240
        # Shift to bottom if near top edge
        if $game_player.y < 7 - dist
          map_y = 480 - ( PassMap::MAP_Y + PassMap::MAP_H )
          @ignore_y = false
        # Shift to top edge if near bottom
        elsif ($game_player.y - dist) >= (map_height - 7)
          @ignore_y = false
        else
          @ignore_y = true
        end
      end
      # If defaulted to the bottom
      if PassMap::MAP_Y >= 240
        # Shift to bottom if near top edge
        if ($game_player.y - dist) >= (map_height - 7)
          map_y = 480 - ( PassMap::MAP_Y + PassMap::MAP_H )
          @ignore_y = false
        # Shift to top edge if near bottom
        elsif $game_player.y < 7 - dist
          @ignore_y = false
        else
          @ignore_y = true
        end
      end
    end    
    # Test if change performed
    unless @ignore_x == true
      if @old_x != map_x
        @old_x = map_x            unless map_x.nil?
        @old_x = PassMap::MAP_X   if @old_x.nil?
        reposition = true
      end
    end
    unless @ignore_y == true
      if @old_y != map_y
        @old_y = map_y
        @old_y = map_y            unless map_y.nil?
        @old_y = PassMap::MAP_Y   if @old_y.nil?
        reposition = true
      end
    end
    # Exit unless change is performed
    return unless reposition == true
    # Configured values
    map_h = PassMap::MAP_H
    map_w = PassMap::MAP_W
    # Generate Viewport
    generate_viewport(map_x, map_y, map_h, map_w)
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Passable Minimap processing
  #--------------------------------------------------------------------------
  def cf_passmap_update
    # Hide if current map excluded
    if $game_system.minimap_map_off
      return if @map.nil?
      @map.visible = false
      @map_bg_viewport.visible = false
      return
    end
    # With minimap on, initialize system if not already done
    return cf_passmap_initialize if @map.nil?
    # Make sure Mini-Map Visible
    @map_viewport.visible = cf_passmap_viewport_visible
    # Make background visible if it exists
    if PassMap::BACK_IMAGE != ""
      @map_bg_viewport.visible = cf_passmap_viewport_visible
    end
    # Redraw map if necessary
    if $game_temp.redraw_passmap
      @map.redraw
      $game_temp.redraw_passmap = false
    end
    # refresh map if necessary
    if $game_temp.refresh_passmap
      # Process refresh including background
      cf_passmap_update_refresh
      $game_temp.refresh_passmap = false
    end
    # Update the map
    @map.update  
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Passable Minimap refresh
  #     x : x-position of border
  #     y : y-position of border
  #--------------------------------------------------------------------------
  def cf_passmap_update_refresh(x=nil, y=nil)
    # Make sure border is properly moved.
    if @old_x != x
      @old_x = x              unless x.nil?
      @old_x = PassMap::MAP_X if @old_x.nil?
    end
    if @old_y != y
      @old_y = y              unless y.nil?
      @old_y = PassMap::MAP_Y if @old_y.nil?
    end
    # Refresh as normal
    @map.refresh
    # Exit unless there is a background
    return if PassMap::BACK_IMAGE == ""
    # Define Rect
    rect_w = @map.width  + 16
    rect_h = @map.height + 16
    rect_x = @old_x - 8
    rect_y = @old_y - 8
    # Set rect
    @map_bg_viewport.rect.width   = rect_w
    @map_bg_viewport.rect.height  = rect_h
    @map_bg_viewport.rect.x       = rect_x
    @map_bg_viewport.rect.y       = rect_y
    # Set background Zoom
    @map_bg.zoom_x = 1.0 * (@map_bg_viewport.rect.width)/@map_bg.bitmap.width
    @map_bg.zoom_y = 1.0 * (@map_bg_viewport.rect.height)/@map_bg.bitmap.height
  end
  #--------------------------------------------------------------------------
  # * Minimap Visibility
  #--------------------------------------------------------------------------
  def cf_passmap_viewport_visible
    # Map tag override
    return false if $game_system.minimap_map_off
    return false if !$game_temp.scene_visible
    # Remaining optional on/off systems
    return ($game_system.minimap_visible and
      ((not PassMap::MESSAGES) or (not $game_temp.message_window_showing)) and
      ((not PassMap::SWITCH_ON) or (not $game_switches[PassMap::SWITCH_ID])))
  end
end

Credits and Thanks

Obvious thanks to Charlie Fleed for the original version.  Credits also go to Wheeler for the original November 2006 system that generates PNG files, his identity at the time unknown.

[DerVVulfman]

Patches
Well, I couldn't just stop there. I had to make a little ... extra.
Use The Charlie Mini-Map / Dynamic Maps Patch if this script is in use with Dynamic Maps Expanded.

For those who use Spriteset shots of the map as a background to various systems, be they menus or Battlebacks that have the map visible, this patch hides the mini-map itself. It is for use with Charlie's Mini-Map Extended ver 1.8+.

Spriteset Patch

Code:

#==============================================================================
# ** Spriteset Patch for Charlie's Mini-Map Extended
#------------------------------------------------------------------------------
#     Basically, this is a patch for anyone who wishes to display the map
#     behind a menu screen and do not wish to have the mini-map to appear
#     overtop, possibly blocking some of the menu objects.
#
#     This is an example or model, and can be adjusted accordingly.
#
#==============================================================================


#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs map screen processing.
#==============================================================================

class Scene_Map
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias charlie_hide_minimap_call_battle call_battle
  alias charlie_hide_minimap_call_shop call_shop
  alias charlie_hide_minimap_call_name call_name
  alias charlie_hide_minimap_call_menu call_menu
  alias charlie_hide_minimap_call_save call_save
  alias charlie_hide_minimap_call_debug call_debug
  #--------------------------------------------------------------------------
  # * Battle Call
  #--------------------------------------------------------------------------
  def call_battle
    # Perform the original call
    charlie_hide_minimap_call_battle
    # Disable 'scene visible' temp flag, hiding mini-map
    $game_temp.scene_visible = false
  end
  #--------------------------------------------------------------------------
  # * Shop Call
  #--------------------------------------------------------------------------
  def call_shop
    # Perform the original call
    charlie_hide_minimap_call_shop
    # Disable 'scene visible' temp flag, hiding mini-map
    $game_temp.scene_visible = false
  end
  #--------------------------------------------------------------------------
  # * Name Input Call
  #--------------------------------------------------------------------------
  def call_name
    # Perform the original call
    charlie_hide_minimap_call_name
    # Disable 'scene visible' temp flag, hiding mini-map
    $game_temp.scene_visible = false
  end
  #--------------------------------------------------------------------------
  # * Menu Call
  #--------------------------------------------------------------------------
  def call_menu
    # Perform the original call
    charlie_hide_minimap_call_menu
    # Disable 'scene visible' temp flag, hiding mini-map
    $game_temp.scene_visible = false
  end
  #--------------------------------------------------------------------------
  # * Save Call
  #--------------------------------------------------------------------------
  def call_save
    # Perform the original call
    charlie_hide_minimap_call_save
    # Disable 'scene visible' temp flag, hiding mini-map
    $game_temp.scene_visible = false
  end
  #--------------------------------------------------------------------------
  # * Debug Call
  #--------------------------------------------------------------------------
  def call_debug
    # Perform the original call
    charlie_hide_minimap_call_debug
    # Disable 'scene visible' temp flag, hiding mini-map
    $game_temp.scene_visible = false
  end
end

The below script is not really for the game, but for use by YOU when making minimaps for distribution. It doesn't change the system, but it does tell you how far along the maps are when being generated.

Progress Display Window

Code:

#==============================================================================
# ** Game_Temp
#------------------------------------------------------------------------------
#  This class handles temporary data that is not included with save data.
#  Refer to "$game_temp" for the instance of this class.
#==============================================================================

class Game_Temp
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :aavisible                # Visibility for Progress Window
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  alias charlieprogress_initialize initialize
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    # Original call
    charlieprogress_initialize
    # Set Value at atart
    @aavisible = false
  end
end



#==============================================================================
# ** Window_Progress
#------------------------------------------------------------------------------
#  This window displays amount of gold.
#==============================================================================

class Window_Progress < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(240, 208, 160, 64)
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh("",0)
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh(headertext="", percent=0)
    self.contents.clear
    self.contents.font.color = normal_color
    text = headertext + ":  " + (percent.to_s) + "%"
    cx = contents.text_size(text).width
    self.contents.draw_text(4, 0, 120, 32, text, 2)
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    if $game_temp.aavisible == true
      self.opacity = 255
      self.back_opacity = 255
      self.contents_opacity  = 255
    else
      self.opacity = 0
      self.back_opacity = 0
      self.contents_opacity  = 0
    end
  end
end



#==============================================================================
# ** Zlib    
#------------------------------------------------------------------------------
#  This module handles data compression, its library having been written by
#  Jean-loup Gailly and Mark Adler.
#==============================================================================

module Zlib
  #============================================================================
  # ** Png_File    
  #----------------------------------------------------------------------------
  #  This class performs generation of PNG formatted bitmap image files
  #============================================================================

  class Png_File < GzipWriter
    #--------------------------------------------------------------------------
    # * Make Bitmap Data 0
    #--------------------------------------------------------------------------
    def make_bitmap_data0
      gz = Zlib::GzipWriter.open('hoge.gz')
      t_Fx = 0
      w = @bitmap.width
      h = @bitmap.height
      data = []
      for y in 0...h
        
      percy =  ( y * 100) / h
      $scene.progress.refresh("Map", percy)        
        
        data.push(0)
        for x in 0...w
          t_Fx += 1
          if t_Fx % 10000 == 0
            Graphics.update
          end
          if t_Fx % 100000 == 0
            s = data.pack("C*")
            gz.write(s)
            data.clear
          end
          color = @bitmap.get_pixel(x, y)
          red = color.red
          green = color.green
          blue = color.blue
          alpha = color.alpha
          data.push(red)
          data.push(green)
          data.push(blue)
          data.push(alpha)
        end
      end
      s = data.pack("C*")
      gz.write(s)
      gz.close  
      data.clear
      gz = Zlib::GzipReader.open('hoge.gz')
      data = gz.read
      gz.close
      File.delete('hoge.gz')
      return data
    end    
  end
end


#==============================================================================
# ** Passability_Map
#------------------------------------------------------------------------------
#  This class actively renders the minimap utilizing game map passage data,
#  and brings it together with events rendered by the Map_Objects class.
#  It is used within the Scene_Map class.
#==============================================================================

class Passability_Map < Sprite
  #--------------------------------------------------------------------------
  # * Create a new minimap and make cached png file
  #--------------------------------------------------------------------------
  def renew
    # Make Visible
    $game_temp.aavisible = true
    $scene.progress.refresh("Data", 0)
    $scene.progress.update
    
    @map  = Bitmap.new( 4 * $game_map.width, 4 * $game_map.height)
    for x in 0...$game_map.width
      # Generate Percent
      percy =  ( x * 100) / $game_map.width
      $scene.progress.refresh("Data", percy)
      
      Graphics.update
      refreshflag = false
      for y in 0...$game_map.height
        if refreshflag == false
          if y > ($game_map.height/2)
            refreshflag = true
            Graphics.update
          end
        end
        temp=0
        @map.fill_rect(x*4,y*4,4,4,PassMap::PASSABLE_TILE_COLOR)
        if !$game_map.passable?(x,y,2) # DOWN
          @map.fill_rect(x*4,y*4+3,4,1,PassMap::BLOCKED_TILE_COLOR)
          temp+=1
        end
        if !$game_map.passable?(x,y,4) # LEFT
          @map.fill_rect(x*4,y*4,1,4,PassMap::BLOCKED_TILE_COLOR)
          temp+=1
        end
        if !$game_map.passable?(x,y,6) # RIGHT
          @map.fill_rect(x*4+3,y*4,1,4,PassMap::BLOCKED_TILE_COLOR)
          temp+=1
        end
        if !$game_map.passable?(x,y,8) # UP
          @map.fill_rect(x*4,y*4,4,1,PassMap::BLOCKED_TILE_COLOR)
          temp+=1
        end
        if temp==4
          @map.fill_rect(x*4+1,y*4+1,2,2,PassMap::BLOCKED_TILE_COLOR)
        end
      end
    end
    # Create named PNG file from bitmap created
    @map.make_png(@name_map)
    
    # Turn off visibility
    $game_temp.aavisible = false
    
  end  
end


#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs map screen processing.
#==============================================================================

class Scene_Map
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :progress                  # Field Map
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias scene_map_passmap_cf_progress_main main
  alias scene_map_passmap_cf_progress_update update
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    #Passable Minimap Initialization
    @progress = Window_Progress.new
    # Original call
    scene_map_passmap_cf_progress_main
    # Passable Minimap Disposal
    @progress.dispose
  end
  
  def update
    @progress.update unless @progress.nil?
    # Original call
    scene_map_passmap_cf_progress_update
  end
end

[kyonides]

Code:

def setup_zoom_test(map_id)
    name      = load_data("Data/MapInfos.rxdata")[map_id].name_cfpmm
    name_len  = (load_data("Data/MapInfos.rxdata")[map_id].name).length

I think it should be...

Code:

def setup_zoom_test(map_id)
    infos = load_data("Data/MapInfos.rxdata")[map_id]
    name      = infos.name_cfpmm
    name_len  = infos.name.length

[DerVVulfman]

I think it should be...

"Just because you can doesn’t mean you should." - Marloes deVries
"Let us redefine progress to mean that just because we can do a thing, it does not necessarily mean we must do that thing." - President of the Federation (Star Trek IV: The Undiscovered Country)

In that, there is neither a syntax nor logical error within that code. The correction you are proposing is purely your preferential coding practice, and your suggestion neither corrects an error nor change the end result in any way.

Now, something about the actual mini-map script I should say. Generating a map takes time. Small maps take nearly no time at all. Generating mediocre maps of 75 x 100 tiles may be noticeable. A grandiose 500x500 tile map will certainly pause the screen for a moment. And if we're talking a BIG MAPS chained series of maps? Whoo boy!

When it saves a generated map, the resulting png file saved within the Graphics\Passmaps folder will have the ID number of the map attached. This is not true for BIG MAPS maps. Instead, it uses the key of the map series. My script shows the development of a 3x3 map set with a key of 'F'. Well, that means the generated mini-map will instead have the 'F' in its filename instead of a numeric map ID.

This, I felt should be known for anyone wishing to do touch-up on their maps.

[kyonides]

In that, there is neither a syntax nor logical error within that code. The correction you are proposing is purely your preferential coding practice, and your suggestion neither corrects an error nor change the end result in any way.

Nope, it's not just coding practice but a good method to let others learn what you're doing and why you're doing it. (Plus it's the Ruby way since Rubyists don't tend to method chain stuff like you did twice.) I thought you cared about teaching the younglings about that kind of stuff so following my example is beneficial for them. I humbly ask you to reconsider it.

Does the script save a real size map or a miniature? O_o?

[DerVVulfman]

I thought you cared about teaching the younglings about that kind of stuff so following my example is beneficial for them. I humbly ask you to reconsider it

Actually, I do care about teaching younger scripters, which is why I follow certain guidelines which includes providing detailed comments throughout the code, that and providing various styles of entry. In certain sections, I do provide examples of splitting methods into smaller blocks, and in others I do not. However, it is funny that someone who loathes receiving advice when they have a bug likes to appear in another's thread for criticism when no coding error appears.
.

Does the script save a real size map or a miniature? O_o?

It provides a scaled down version of the map. In the instance of a map of 1600x1600 tiles in size (or 51200px x 51200px), the map is rendered as a 6400x6400 image.

[DerVVulfman]

BUMP
to version 1.1

I altered the feature that lets you select individual zoom settings per map, and now added a feature where you can tag maps that never have mini-maps.

I also changed the initial setup of the system, allowing the game developer to specify if the minimaps are visible by default or turned off by default.  Either way, you may still use the script calls of 'hide_passmaps' and 'show_passmaps' to hide/show the mini-map.

Just a friendly reminder, this visibility option takes precedent over the RMXP Switch On/Off option.

[DerVVulfman]

BUMP
to version 1.2

Now added to the system is the ability to have your event sprites in the minimap depict a facing direction!

Typically, you would have sprites in your game such as a round red circle within a 6x6 pixel image having the name of 'Enemy'. A simple image to be sure, and one that doesn't care about the event's facing direction. But now, you can make another type of sprite.

You can make an event (such as the player) display its facing direction by assigning it a sprite graphic that is 4-times wider than its height. This allows the sprite to have 4 equal-sized frames, each denoting a facing direction. The first frame depicts the event facing up, the second left, the third right and the fourth facing down.

This is basically the same kind of system used by Selwyn's Mini-Map which he used for the player sprite. But the mechanics for event sprites is global. So you may set it up for the Player, Enemies, NPCs, a cat, a dog, that fern in the vase over there... whatever.

So now the choice is yours. You can set the player to have a single-framed sprite, the enemies to be 4-framed, the treasure chest to be single framed...

Have fun!

[DerVVulfman]

BUMP
to version 1.3

The patch I wrote so the Charlie Mini-Map system can work with BIG MAPS is now fully integrated into the code.  It auto-detects and works fine as long as this script is BELOW the BIG MAP system.

Also, I noted that there is a maximum size limit for any map (or BigMap).  No map larger than 2500x2500 in tiles can be handled.  Heh, that's pretty large anyway.

And finally, the patch in the main page is now a user's tool.  Paste it into your demo when making the mini-maps and it will tell you your progress for that particular map, first as it obtains the map data and then generating the actual map image.


Hey, it beats not knowing, right?

[DerVVulfman]

BUMP
to version 1.4

EXCELSIOR!!!

If you had a lot of events on your map, your minimap initially tracked every single one of them.  And this could have slowed down your game.  Anti-Lag systems affect maps and the map spriteset system, but they do not affect mini-maps which process such within their own systems.

But now, Charlie's Mini-Map Extended has a built-in anti-lag to handle massive amounts of map events.  This anti-lag even works with BIG MAPS and can eliminate lag even when handling 4000 events. 

This is a major breakthrough for anyone who wishes to fill their maps with events of all types and were worried about game slowdown.

Enjoy!

Now to enjoy some ramen.