Charlie's Mini-Map Extended - Printable Version+- Save-Point (https://www.save-point.org)
+-- Forum: Material Development (https://www.save-point.org/forum-8.html)
+--- Forum: Scripts Database (https://www.save-point.org/forum-39.html)
+---- Forum: RPGMaker XP (RGSS) Engine (https://www.save-point.org/forum-116.html)
+---- Thread:
Charlie's Mini-Map Extended (/thread-8066.html)Pages:
1
2
Charlie's Mini-Map Extended - DerVVulfman - 06-05-2020
Charlie's Mini-Map Extended
Version 2.1
Based on the 'Passability Mini-map by Charlie Fleed v 0.4.4"
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
endCredits 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.
Charlie's Mini-Map Extended - DerVVulfman - 06-05-2020
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
endThe 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
endRE: Charlie's Mini-Map Extended - kyonides - 06-05-2020
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).lengthI 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.lengthRE: Charlie's Mini-Map Extended - DerVVulfman - 06-05-2020
(06-05-2020, 03:47 AM)kyonides Wrote: 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.
RE: Charlie's Mini-Map Extended - kyonides - 06-05-2020
Wulfo Wrote: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?
RE: Charlie's Mini-Map Extended - DerVVulfman - 06-05-2020
(06-05-2020, 08:10 PM)kyonides Wrote: 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 itActually, 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.
.
(06-05-2020, 08:10 PM)kyonides Wrote: 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.
RE: Charlie's Mini-Map Extended - DerVVulfman - 06-10-2020
BUMP
to version 1.1
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.
RE: Charlie's Mini-Map Extended - DerVVulfman - 06-10-2020
BUMP
to version 1.2
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!
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!
RE: Charlie's Mini-Map Extended - DerVVulfman - 06-13-2020
BUMP
to version 1.3
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?
RE: Charlie's Mini-Map Extended - DerVVulfman - 06-16-2020
BUMP
to version 1.4
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.
