Chaos Project

#==============================================================================
# ** Map Screenshot Maker
#------------------------------------------------------------------------------
# SephirothSpawn
# Version 1.1
# 2007-07-21
# SDK : Version 2.0+, Part I
#------------------------------------------------------------------------------
# * Version History :
#
#   Version 1 ---------------------------------------------------- (2007-07-20)
#    Version 1.1 ------------------------------------------------- (2007-07-21)
#     - Update : Made it so it saves multiple png files for bigger maps.
#    Version 1.1.1 -Brew -------------------- (25Mar08)
#     - Fixed sprite position. Added 'Q' button option with autoname
#       'mapname'.png, removed SDK dependence.
#------------------------------------------------------------------------------
# * Requirements :
#
#   Method & Class Library (2.1+)
#------------------------------------------------------------------------------
# * Description :
#
#   This script was designed to allow you to make a single screenshot of your
#   entire map. In constructions a still image of the tilemap, panorama, fog,
#   event and player sprites, weather, picture sprites and the timer. It then
#   exports the files to a filename you specify, and saves it in PNG format.
#------------------------------------------------------------------------------
# * Instructions :
#
#   Place The Script Below Scene_Debug and Above Main.
#
#   To make a screenshot, use: MapScreenshotMaker.take(filename)
#   Or hit the 'Q' button while on a map.
#
#------------------------------------------------------------------------------
# * Syntax :
#
#   Taking Map Screenshot
#    - MapScreenshotMaker.take(filename, dir)
#
#   You do not need to specify filename, as it defaults to a 'Test.png'
#   You do not need to specify dir, as it defaults to 'Graphics/Saved Images'
#   The extension .png does not need to be included in the filename.
#------------------------------------------------------------------------------
# * Special Thanks :
#
#   Prexus, for requesting and beta testing
#==============================================================================

#------------------------------------------------------------------------------
# * SDK Log Script
#------------------------------------------------------------------------------
#SDK.log('Map Screenshot Maker', 'SephirothSpawn', 1.1, '2007-07-21')
#SDK.check_requirements(2.0, [], {'Method & Class Library' => 2.1})

#------------------------------------------------------------------------------
# * Begin SDK Enable Test
#------------------------------------------------------------------------------
#if SDK.enabled?('Map Screenshot Maker')
 
#==============================================================================
# ** Spriteset_Map
#==============================================================================
begin
class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader :tilemap
  attr_reader :panorama
  attr_reader :fog
  attr_reader :character_sprites
  attr_reader :weather
  attr_reader :picture_sprites
  attr_reader :timer_sprite
end

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

class Scene_Map
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader :spriteset
 
  alias screenshot_update update
 
  def initialize
    $data_mapinfo = load_data("Data/MapInfos.rxdata")
  end
 
  def update
    if Input.trigger?(Input::L)
      #make filename from map name
      filename = $data_mapinfo[$game_map.map_id].name
      #take the shot
      MapScreenshotMaker.take(filename)
      #show message that it finished
      print "Saved " + filename + ".png"
    end
    screenshot_update
  end
end

#==============================================================================
# ** RPG::Weather
#==============================================================================

class RPG::Weather
  #--------------------------------------------------------------------------
  # * Bitmap
  #--------------------------------------------------------------------------
  def bitmap
    # Create Bitmap
    bitmap = Bitmap.new(640, 480)
    # Pass Through @sprites
    @sprites.each do |sprite|
      next unless sprite.visible
      next if sprite.bitmap.nil?
      bitmap.blt(sprite.x, sprite.y, sprite.bitmap, sprite.bitmap.rect)
    end
    # Return Bitmap
    return bitmap
  end
end

#==============================================================================
# ** MapScreenshotMaker
#==============================================================================

module MapScreenshotMaker
  #--------------------------------------------------------------------------
  # * Max Image Size
  #--------------------------------------------------------------------------
  Max_Image_Size = nil
  #--------------------------------------------------------------------------
  # * Take
  #--------------------------------------------------------------------------
#  def self.take(filename = 'Map Screenshot', dir = 'Graphics/Saved Images/')
  def self.take(filename = 'Map Screenshot', dir = '')
    # Return If Not Map Scene
    return unless $scene.is_a?(Scene_Map)
    # Gets Spriteset
    spriteset = $scene.spriteset
    # Create Bitmap
    bitmap = Bitmap.new($game_map.width * 32, $game_map.height * 32)
    # Draw Chracter Sprites
    self.draw_character_sprites(bitmap, spriteset, 'sprite.z >= -1000')
    # Draw Panorama
    if spriteset.panorama.visible
      if spriteset.panorama.bitmap != nil
        b = spriteset.panorama.bitmap
        opacity = spriteset.panorama.opacity
        x_times = (bitmap.rect.width / b.rect.width.to_f)
        x_times = x_times.ceil == x_times.to_i ?
          x_times.to_i : x_times.to_i + 1
        y_times = (bitmap.rect.width / b.rect.width.to_f)
        y_times = y_times.ceil == y_times.to_i ?
          y_times.to_i : y_times.to_i + 1
        self.tile_bitmap(bitmap, b, x_times, y_times, opacity)
      end
    end
    # Draw Chracter Sprites
    c = '!sprite.z.between?(-1000, -1)'
    self.draw_character_sprites(bitmap, spriteset, c)
    # Draw Layer 1
    self.draw_tilemap_layer(bitmap, spriteset, 0)
    # Draw Chracter Sprites
    c = '!sprite.z.between?(0, 149)'
    self.draw_character_sprites(bitmap, spriteset, c)
    # Draw Layer 2
    self.draw_tilemap_layer(bitmap, spriteset, 1)
    # Draw Chracter Sprites
    c = '!sprite.z.between?(150, 299)'
    self.draw_character_sprites(bitmap, spriteset, c)
    # Draw Layer 3
    self.draw_tilemap_layer(bitmap, spriteset, 2)
    # Draw Chracter Sprites
    c = '!sprite.z.between?(300, 999)'
    self.draw_character_sprites(bitmap, spriteset, c)
    # Draw Weather Sprite
    x_times = (bitmap.rect.width / 640.0)
    x_times = x_times.ceil == x_times.to_i ? x_times.to_i : x_times.to_i + 1
    y_times = (bitmap.rect.width / 480.0)
    y_times = y_times.ceil == y_times.to_i ? y_times.to_i : y_times.to_i + 1
    self.tile_bitmap(bitmap, spriteset.weather.bitmap, x_times, y_times)
    # Draw Chracter Sprites
    c = '!sprite.z.between?(1000, 2999)'
    self.draw_character_sprites(bitmap, spriteset, c)
    # Draw Fog Sprite
    if spriteset.fog.visible
      if spriteset.fog.bitmap != nil
        b = spriteset.fog.bitmap
        opacity = spriteset.fog.opacity
        x_times = (bitmap.rect.width / b.rect.width.to_f)
        x_times = x_times.ceil == x_times.to_i ?
          x_times.to_i : x_times.to_i + 1
        y_times = (bitmap.rect.width / b.rect.width.to_f)
        y_times = y_times.ceil == y_times.to_i ?
          y_times.to_i : y_times.to_i + 1
        self.tile_bitmap(bitmap, b, x_times, y_times, opacity)
      end
    end
    # Draw Chracter Sprites
    self.draw_character_sprites(bitmap, spriteset, 'sprite.z < 3000')
    # Draw Picture Sprites
    self.draw_picture_sprites(bitmap, spriteset, 'sprite.z >= 500')
    # Draw Sprite Timer
    if spriteset.timer_sprite.visible
      if spriteset.timer_sprite.bitmap != nil
        self.blt(spriteset.timer_sprite.x, spriteset.timer_sprite.y,
          spriteset.timer_sprite.bitmap, spriteset.timer_sprite.opacity)
      end
    end
    # Draw Picture Sprite
    self.draw_picture_sprites(bitmap, spriteset, 'sprite.z < 500')
    # Save Bitmap
    if Max_Image_Size != nil && (bitmap.rect.width  > Max_Image_Size ||
       bitmap.rect.height > Max_Image_Size)
      # Gets X & Y Max Times
      x_times = (bitmap.rect.width / Max_Image_Size.to_f)
      x_times = x_times.ceil == x_times.to_i ?
        x_times.to_i : x_times.to_i + 1
      y_times = (bitmap.rect.width / Max_Image_Size.to_f)
      y_times = y_times.ceil == y_times.to_i ?
        y_times.to_i : y_times.to_i + 1
      # Split Up Bitmap Into Sections
      for x in 0...x_times
        for y in 0...y_times
          # Get src rect
          src_rect = Rect.new(x * Max_Image_Size, y * Max_Image_Size,
            [bitmap.rect.width  - x * Max_Image_Size, Max_Image_Size].min,
            [bitmap.rect.height - y * Max_Image_Size, Max_Image_Size].min)
          # Creates New Bitmap
          b = Bitmap.new(src_rect.width, src_rect.height)
          b.blt(0, 0, bitmap, src_rect)
          # Saves Bitmap
          b.make_png("#{filename}_#{x}-#{y}", dir)
          # Update Graphics Module
          Graphics.update
        end
      end
    # If Within Max Size
    else
      # Saves Bitmap
      bitmap.make_png(filename, dir)
    end
  end
  #--------------------------------------------------------------------------
  # * Tile Bitmap
  #--------------------------------------------------------------------------
  def self.tile_bitmap(main, sub, x_times, y_times, a = 255)
    for x in 0...x_times
      for y in 0...y_times
        main.blt(x * sub.rect.width, y * sub.rect.height, sub, sub.rect, a)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Character Sprites
  #--------------------------------------------------------------------------
  def self.draw_character_sprites(bitmap, spriteset, c)
    # Pass Through Character Sprites
    spriteset.character_sprites.each do |sprite|
      # Skip If Not Visible or Nil Bitmap
      next if sprite.visible == false || sprite.bitmap.nil?
      # Skip If Condition
      next if (eval c)
      # Draw Sprite On Bitmap
      xoff = sprite.bitmap.width / 8 - ($game_map.display_x / 4)
      yoff = sprite.bitmap.height / 4 - ($game_map.display_y / 4)
      bitmap.blt(sprite.x - xoff, sprite.y - yoff, sprite.bitmap, sprite.src_rect,
        sprite.opacity)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Picture Sprites
  #--------------------------------------------------------------------------
  def self.draw_picture_sprites(bitmap, spriteset, c)
    # Pass Through Character Sprites
    spriteset.picture_sprites.each do |sprite|
      # Skip If Not Visible or Nil Bitmap
      next if sprite.visible == false || sprite.bitmap.nil?
      # Skip If Condition
      next if (eval c)
      # Draw Sprite On Bitmap
      bitmap.blt(sprite.x, sprite.y, sprite.bitmap, sprite.src_rect,
        sprite.opacity)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Tilemap Layer
  #--------------------------------------------------------------------------
  def self.draw_tilemap_layer(bitmap, spriteset, layer)
    # Get Map Data & Priorities
    map_data   = $game_map.data
    priorities = $game_map.priorities
    tileset    = $game_map.tileset_name
    autotiles  = $game_map.autotile_names
    # Passes Through Layers
    for z in 0...map_data.zsize
      # Passes Through X Coordinates
      for x in 0...map_data.xsize
        # Passes Through Z Coordinates
        for y in 0...map_data.ysize
          # Collects Tile ID
          id = map_data[x, y, z]
          # Skip if 0 tile
          next if id == 0
          # Get Tile Priority
          p = priorities[id]
          # Cap Priority to Layer 3
          p = 2 if p > 2
          # Next If P isn't layer id
          next if p != layer
          # Draw Tile
          if id < 384
            # Gets Autotile Filename
            filename = autotiles[id / 48 - 1]
            # Reconfigure Tile ID
            id %= 48
            # Gets Generated Autotile Bitmap Section
            b = RPG::Cache.autotile_tile(filename, id, 0)
            # Draw Tile
            bitmap.blt(x * 32, y * 32, b, Rect.new(0, 0, 32, 32))
          # Draw Normal Tile
          else
            # Gets Tile Bitmap
            b = RPG::Cache.tile(tileset, id, 0)
            # Draws Tile
            bitmap.blt(x * 32, y * 32, b, Rect.new(0, 0, 32, 32))
          end
        end
      end
    end
  end   
end

class Bitmap
  #-------------------------------------------------------------------------
  # * Name      : Make PNG
  #   Info      : Saves Bitmap to File
  #   Author    : ??? - http://www.66rpg.com/htm/news624.htm
  #   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

#==============================================================================
# ** Modules.Zlib
#------------------------------------------------------------------------------
# Description:
# ------------
# Adds PNG_File class to save Bitmap's to PNG Files
# 
# Class List:
# -----------
# Png_File
#==============================================================================
module Zlib
  #============================================================================
  # ** Png_File     
  #============================================================================

  class Png_File < GzipWriter
    #--------------------------------------------------------------------------
    # * Make PNG
    #--------------------------------------------------------------------------
    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 =

• .pack('C')
        ih_filter_method      =
• .pack('C')
        ih_interlace_method   =
• .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,
        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 =
• .pack('N')
        ie_sign = 'IEND'
        ie_crc  = [Zlib.crc32(ie_sign)].pack('N')
        return ie_size + ie_sign + ie_crc
      end
    end
  end
  
  #==============================================================================
  # ** RPG::Cache
  #==============================================================================
  
  module RPG::Cache
    #--------------------------------------------------------------------------
    # * Auto-Tiles
    #--------------------------------------------------------------------------
    Autotiles = [
      [[27, 28, 33, 34], [ 5, 28, 33, 34], [27,  6, 33, 34], [ 5,  6, 33, 34],
       [27, 28, 33, 12], [ 5, 28, 33, 12], [27,  6, 33, 12], [ 5,  6, 33, 12]],
      [[27, 28, 11, 34], [ 5, 28, 11, 34], [27,  6, 11, 34], [ 5,  6, 11, 34],
       [27, 28, 11, 12], [ 5, 28, 11, 12], [27,  6, 11, 12], [ 5,  6, 11, 12]],
      [[25, 26, 31, 32], [25,  6, 31, 32], [25, 26, 31, 12], [25,  6, 31, 12],
       [15, 16, 21, 22], [15, 16, 21, 12], [15, 16, 11, 22], [15, 16, 11, 12]],
      [[29, 30, 35, 36], [29, 30, 11, 36], [ 5, 30, 35, 36], [ 5, 30, 11, 36],
       [39, 40, 45, 46], [ 5, 40, 45, 46], [39,  6, 45, 46], [ 5,  6, 45, 46]],
      [[25, 30, 31, 36], [15, 16, 45, 46], [13, 14, 19, 20], [13, 14, 19, 12],
       [17, 18, 23, 24], [17, 18, 11, 24], [41, 42, 47, 48], [ 5, 42, 47, 48]],
      [[37, 38, 43, 44], [37,  6, 43, 44], [13, 18, 19, 24], [13, 14, 43, 44],
       [37, 42, 43, 48], [17, 18, 47, 48], [13, 18, 43, 48], [ 1,  2,  7,  8]]
    ]
    #--------------------------------------------------------------------------
    # * Autotile Cache
    #
    #   @autotile_cache = {
    #     filename => { [autotile_id, frame_id, hue] => bitmap, ... },
    #     ...
    #    }
    #--------------------------------------------------------------------------
    @autotile_cache = {}
    #--------------------------------------------------------------------------
    # * Autotile Tile
    #--------------------------------------------------------------------------
    def self.autotile_tile(filename, tile_id, hue = 0, frame_id = nil)
      # Gets Autotile Bitmap
      autotile = self.autotile(filename)
      # Configures Frame ID if not specified
      if frame_id.nil?
        # Animated Tiles
        frames = autotile.width / 96
        # Configures Animation Offset
        fc = Graphics.frame_count / 16
        frame_id = (fc) % frames * 96
      end
      # Creates list if already not created
      @autotile_cache[filename] = {} unless @autotile_cache.has_key?(filename)
      # Gets Key
      key = [tile_id, frame_id, hue]
      # If Key Not Found
      unless @autotile_cache[filename].has_key?(key)
        # Reconfigure Tile ID
        tile_id %= 48
        # Creates Bitmap
        bitmap = Bitmap.new(32, 32)
        # Collects Auto-Tile Tile Layout
        tiles = Autotiles[tile_id / 8][tile_id % 8]
        # Draws Auto-Tile Rects
        for i in 0...4
          tile_position = tiles - 1
          src_rect = Rect.new(tile_position % 6 * 16 + frame_id,
            tile_position / 6 * 16, 16, 16)
          bitmap.blt(i % 2 * 16, i / 2 * 16, autotile, src_rect)
        end
        # Saves Autotile to Cache
        @autotile_cache[filename][key] = bitmap
        # Change Hue
        @autotile_cache[filename][key].hue_change(hue)
      end
      # Return Autotile
      return @autotile_cache[filename][key]
    end
    #-------------------------------------------------------------------------
    # * Name      : Gradient
    #   Info      : Loads A Gradient Bar
    #   Author    : Trickster
    #   Call Info : One to Two Arguments
    #               String filename of Bar to load
    #               Integer hue - hue displacement
    #   Comment   : Files are to be located in Graphics/Gradients
    #-------------------------------------------------------------------------
    def self.gradient(filename, hue = 0)
      self.load_bitmap("Graphics/Gradients/", filename, hue)
    end
  end
  #--------------------------------------------------------------------------
  # * End SDK Enable Test
  #--------------------------------------------------------------------------
  #end
  end