[RPG VX] NEWS Neo Save System VI

#==========================================================================
# ? [VX] ? Neo Save System VI ? ?
#---------------------------------------------------------------------------
# ? Author: Woratana [woratana@hotmail.com]
# ? Thaiware RPG Maker Community
# ? Last Updated:
# ? Version: III -> VI (By Helladen)
# ? Screenshot image credit Andreas21, and Cybersam
# ? Commerical usage ask Wortana.
#---------------------------------------------------------------------------
# ? Log VI:
# - Cleaned up comments and code format.
# - Added corresponding map variables system to MAP_NO_NAME.
# - Added where you can use premade images that use a map's name.
#---------------------------------------------------------------------------
# ? Log V:
# - Screenshot support for those who want tone/weather/sprites.
# - Added an option to stay in save screen after you save the game.
#---------------------------------------------------------------------------
# ? Log IV:
# - New addition for hiding map names. You can control the switch to
#  allow MAP_NO_NAME_LIST to work or not.
# - Revised some of the settings and script organization.
# - Added an option to disable the vocab::Gold text right of the number.
# - Added an option to use default opacity or not.
# - Swap tile compatibility support.
#---------------------------------------------------------------------------
# ? Log III:
# - Changed back to draw tile map for save image, don't need any image.
# - For drawing tile map, the characters won't show on the tile map.
#---------------------------------------------------------------------------
# ? Log II:
# - Screenshot DLL is not work with Vista Aero, so I remove it
#  and use image for each map instead of screenshot.
# - Actor's level in last version (V.1) is incorrect.
#---------------------------------------------------------------------------
# ? Features:
# - Unlimited save slots, you can choose max save slot
# - Many configuration options
# - Swap tile support
# - You can use image for scene's background
# - Choose your save file's name, and folder to store save files
# - Choose to show only information you want
# - Editable text for information's title
# - Draw tile map for map that player is currently on.
# - Remove text you don't want from map's name (e.g. tags for special script)
# - Choose map that you don't want to show the name on
# - Include save confirmation window before overwrite old save
#===========================================================================

module Wora_NSS Wora_NSS
  #==========================================================================
  # * START NEO SAVE SYSTEM - SETUP
  #--------------------------------------------------------------------------
  OPACITY_DEFAULT = true # This will use the default opacity for windows.
  # Please note that this will affect both opacitys below.
 
  NSS_WINDOW_OPACITY = 255 # All windows' opacity (Lowest 0 - 255 Highest).
 
  # You can change this to 0 in case you want to use image for background.
  NSS_IMAGE_BG = '' # Background image file name, it must be in folder picture
  #              use '' for no background.
  NSS_IMAGE_BG_OPACITY = 255 # Opacity for background image.
 
  # If you use the screenshot method this does not matter.
  SWAP_TILE = true # Make this false if you don't use the swap_tile script
  SWAP_TILE_SWITCH = 84 # The switch needs to be the same as your swap tile
  #                 switch, but if SWAP_TILE is false it does not matter.
 
  # If this is true it will screenshot the map, if false it will draw it.
  SCREENSHOT_IMAGE = true # Drawing the map is good because it doesn't require
  # a .DLL or images for the screenshot, and it will have tone and
  # weather. If you are using SwapXT and this value is false you need to turn
  # on swap tile.
 
  # Do you want to use your own custom images for each map via map name.
  PREMADE_IMAGE = false # If this is true it sets its priority over
  #                 screenshots/etc.
 
  # Image type for screenshot '.bmp', or '.jpg', or '.png'.
  IMAGE_FILETYPE = '.png'
 
  # If this is true then the scene will not change when you save the game.
  SCENE_CHANGE = true # Changes scene to map instead of remaining in Save screen.

  MAX_SAVE_SLOT = 20 # Max save slots.
  SLOT_NAME = 'SLOT {id}'
 
  # Name of the slot (show in save slots list), use {id} for slot ID.
  SAVE_FILE_NAME = 'Save {id}.rvdata'
  # Save file name, you can also change its file type from .rvdata to other.
 
  # Use {id} for save slot ID.
  SAVE_PATH = '' # Path to store save file, e.g. 'Save/' or '' (for game folder).
  SAVED_SLOT_ICON = 133 # Icon Index for saved slot.
 
  EMPTY_SLOT_ICON = 141 # Icon Index for empty slot.
  EMPTY_SLOT_TEXT = 'Empty' # Text to show for empty slot's data.
 
  DRAW_GOLD = true # Draw Gold.
  DRAW_PLAYTIME = true # Draw playtime.
  DRAW_LOCATION = true # Draw location.
  DRAW_FACE = true # Draw actor's face.
  DRAW_LEVEL = true # Draw actor's level.
  DRAW_NAME = true # Draw actor's name.
  DRAW_TEXT_GOLD = false # Draw the vocab::Gold text to the right of the number.
 
  PLAYTIME_TEXT = 'Play Time: '
  GOLD_TEXT = 'Gold: '
  LOCATION_TEXT = 'Location: '
  LV_TEXT = 'Lv. '
 
  MAP_NAME_TEXT_SUB = %w{}
  # Text that you want to remove from map name,
  # e.g. %w{[LN] [DA]} will remove text '[LN]' and '[DA]' from map name.
 
  # Do we want to use corresponding variables for each map number in MAP_NO_NAME_LIST?
  MAP_NO_NAME_VARIABLE = true # You just apply the value one to the variable which
                       # is the map number to change it from MAP_NO_NAME.
 
  MAP_NO_NAME_LIST = [2] # ID of Map that will not show map name, e.g. [1,2,3].
  MAP_NO_NAME = '???' # What you will use to call the map in the no name list.

  # This is a switch that can activate or deactivate maps from being displayed as
  # MAP_NO_NAME. If it is off then maps will return back to normal.
  MAP_NO_NAME_SWITCH = 95 # This switch has to be on for MAP_NO_NAME_LIST to work.
 
  MAP_BORDER = Color.new(0,0,0,200) # Map image border color (R,G,B,Opacity).
  FACE_BORDER = Color.new(0,0,0,200) # Face border color.
 
  # Save confirmation window
  SFC_Text_Confirm = 'Confirm to save' # Text to confirm to save file.
  SFC_Text_Cancel = 'Cancel' # Text to cancel to save.
  SFC_Window_Width = 200 # Width of Confirmation Window.
  SFC_Window_X_Offset = 0 # Move Confirmation Window horizontally.
  SFC_Window_Y_Offset = 0 # Move Confirmation Window vertically.
 
  #-------------------------------------------------------------------------
  # END NEO SAVE SYSTEM - SETUP (Edit below at your own risk)
  #=========================================================================
 
  #-------------------------------------------------------------
  # Screenshot V2 by Andreas21 and Cybersam
  #-------------------------------------------------------------
  @screen = Win32API.new 'screenshot', 'Screenshot', %w(l l l l p l l), ''
  @readini = Win32API.new 'kernel32', 'GetPrivateProfileStringA', %w(p p p p l p), 'l'
  @findwindow = Win32API.new 'user32', 'FindWindowA', %w(p p), 'l'
  module_function
 
  def self.shot(file_name)
   case IMAGE_FILETYPE
     when '.bmp'; typid = 0
     when '.jpg'; typid = 1
     when '.png'; typid = 2
   end
   
   # Get Screenshot
   filename = file_name + IMAGE_FILETYPE
   @screen.call(0, 0, Graphics.width, Graphics.height, filename, self.handel,
   typid)
  end
 
  def self.handel
   game_name = "\0" * 256
   @readini.call('Game','Title','',game_name,255,".\\Game.ini")
   game_name.delete!("\0")
   
   return @findwindow.call('RGSS Player',game_name)
  end
end

class Scene_File < Scene_Base
  include Wora_NSS
  attr_reader :window_slotdetail
 
  #-------------------------------------------------------------------------
  # * Start processing
  #-------------------------------------------------------------------------
  def start
   super
   
   create_menu_background
   
   if NSS_IMAGE_BG != ''
     @bg = Sprite.new
     @bg.bitmap = Cache.picture(NSS_IMAGE_BG)
     @bg.opacity = NSS_IMAGE_BG_OPACITY
   end
   
   @help_window = Window_Help.new
   command = []
   
   (1..MAX_SAVE_SLOT).each do |i|
     command << SLOT_NAME.clone.gsub!(/\{ID\}/i) { i.to_s }
   end
   
   @window_slotdetail = Window_NSS_SlotDetail.new
   @window_slotlist = Window_SlotList.new(160, command)
   @window_slotlist.y = @help_window.height
   @window_slotlist.height = Graphics.height - @help_window.height
   
   if !OPACITY_DEFAULT
     @help_window.opacity = NSS_WINDOW_OPACITY
     @window_slotdetail.opacity = @window_slotlist.opacity = NSS_WINDOW_OPACITY
   end

   # Create folder for save file
   if SAVE_PATH != ''
     Dir.mkdir(SAVE_PATH) if !FileTest.directory?(SAVE_PATH)
   end
   
   if @saving
     @index = $game_temp.last_file_index
     @help_window.set_text(Vocab::SaveMessage)
   else
     @index = self.latest_file_index
     @help_window.set_text(Vocab::LoadMessage)
    
     (1..MAX_SAVE_SLOT).each do |i|
      @window_slotlist.draw_item(i-1, false) if !@window_slotdetail.file_exist?(i)
     end
   end
   
   @window_slotlist.index = @index
   
   # Draw information
   @last_slot_index = @window_slotlist.index
   @window_slotdetail.draw_data(@last_slot_index + 1)
  end
 
  #-------------------------------------------------------------------------- 
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
   super
   
   dispose_menu_background
   
   unless @bg.nil?
     @bg.bitmap.dispose
     @bg.dispose
   end
   
   @window_slotlist.dispose
   @window_slotdetail.dispose
   @help_window.dispose
  end
 
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
   super
   
   if !@confirm_window.nil?
     @confirm_window.update
    
     if Input.trigger?(Input::C)
      if @confirm_window.index == 0
        determine_savefile
        @confirm_window.dispose
        @confirm_window = nil
      else
        Sound.play_cancel
        @confirm_window.dispose
        @confirm_window = nil
      end
     elsif Input.trigger?(Input::B)
      Sound.play_cancel
      @confirm_window.dispose
      @confirm_window = nil
     end
   else
     update_menu_background
     @window_slotlist.update
    
     if @window_slotlist.index != @last_slot_index
      @last_slot_index = @window_slotlist.index
      @window_slotdetail.draw_data(@last_slot_index + 1)
     end
    
     @help_window.update
     update_savefile_selection
   end
  end
 
  #--------------------------------------------------------------------------
  # * Update Save File Selection
  #--------------------------------------------------------------------------
  def update_savefile_selection
   if Input.trigger?(Input::C)
     if @saving and @window_slotdetail.file_exist?(@last_slot_index + 1)
      Sound.play_decision
      text1 = SFC_Text_Confirm
      text2 = SFC_Text_Cancel
      @confirm_window = Window_Command.new(SFC_Window_Width,[text1,text2])
      @confirm_window.x = ((544 - @confirm_window.width) / 2) + SFC_Window_X_Offset
      @confirm_window.y = ((416 - @confirm_window.height) / 2) + SFC_Window_Y_Offset
     else
      determine_savefile
     end
   elsif Input.trigger?(Input::B)
     Sound.play_cancel
     return_scene
   end
  end
 
  #--------------------------------------------------------------------------
  # * Execute Save
  #--------------------------------------------------------------------------
  def do_save
   if SCREENSHOT_IMAGE
     File.rename(SAVE_PATH + 'temp' + IMAGE_FILETYPE,
     make_filename(@last_slot_index).gsub(/\..*$/){ '_ss' } + IMAGE_FILETYPE) 
   end 
   
   file = File.open(make_filename(@last_slot_index), "wb")
   write_save_data(file)
   file.close 
   
   # Alter the scene after the saving is done
   if SCENE_CHANGE
     $scene = Scene_Map.new
   else
     $scene = Scene_File.new(true, false, false)
   end
  end
 
  #--------------------------------------------------------------------------
  # * Execute Load
  #--------------------------------------------------------------------------
  def do_load
   file = File.open(make_filename(@last_slot_index), "rb")
   read_save_data(file)
   file.close
   $scene = Scene_Map.new
   RPG::BGM.fade(1500)
   Graphics.fadeout(60)
   Graphics.wait(40)
   @last_bgm.play
   @last_bgs.play
  end
 
  #--------------------------------------------------------------------------
  # * Confirm Save File
  #--------------------------------------------------------------------------
  def determine_savefile
   if @saving
     Sound.play_save
     do_save
   else
     if @window_slotdetail.file_exist?(@last_slot_index + 1)
      Sound.play_load
      do_load
     else
      Sound.play_buzzer
      return
     end
   end
   
   $game_temp.last_file_index = @last_slot_index
  end
 
  #--------------------------------------------------------------------------
  # * Create Filename
  #    file_index : save file index (0-3)
  #--------------------------------------------------------------------------
  def make_filename(file_index)
   return SAVE_PATH + SAVE_FILE_NAME.gsub(/\{ID\}/i) { (file_index + 1).to_s }
  end
 
  #--------------------------------------------------------------------------
  # * Select File With Newest Timestamp
  #--------------------------------------------------------------------------
  def latest_file_index
   latest_index = 0
   latest_time = Time.at(0)
   
   (1..MAX_SAVE_SLOT).each do |i|
     file_name = make_filename(i - 1)
     next if !@window_slotdetail.file_exist?(i)
     file_time = File.mtime(file_name)
    
     if file_time > latest_time
      latest_time = file_time
      latest_index = i - 1
     end
   end
   
   return latest_index
  end

class Window_SlotList < Window_Command
  #--------------------------------------------------------------------------
  # * Draw Item
  #--------------------------------------------------------------------------
  def draw_item(index, enabled = true)
   rect = item_rect(index)
   rect.x += 4
   rect.width -= 8
   icon_index = 0
   self.contents.clear_rect(rect)
   
   if $scene.window_slotdetail.file_exist?(index + 1)
     icon_index = Wora_NSS::SAVED_SLOT_ICON
   else
     icon_index = Wora_NSS::EMPTY_SLOT_ICON
   end
   
   if !icon_index.nil?
     rect.x -= 4
     draw_icon(icon_index, rect.x, rect.y, enabled) # Draw Icon
     rect.x += 26
     rect.width -= 20
   end
   
   self.contents.clear_rect(rect)
   self.contents.font.color = normal_color
   self.contents.font.color.alpha = enabled ? 255 : 128
   self.contents.draw_text(rect, @commands[index])
  end
 
  def cursor_down(wrap = false)
   if @index < @item_max - 1 or wrap
     @index = (@index + 1) % @item_max
   end
  end

  def cursor_up(wrap = false)
   if @index > 0 or wrap
     @index = (@index - 1 + @item_max) % @item_max
   end
  end
end

class Window_NSS_SlotDetail < Window_Base
  include Wora_NSS
 
  def initialize
   super(160, 56, 384, 360)
   
   @data = []
   @exist_list = []
   @bitmap_list = {}
   @map_name = []
  end
 
  def dispose
   dispose_tilemap
   super
  end

  def draw_data(slot_id)
   contents.clear # 352, 328
   dispose_tilemap
   
   load_save_data(slot_id) if @data[slot_id].nil?
     if @exist_list[slot_id]
      save_data = @data[slot_id]
      contents.fill_rect(0,30,352,152, MAP_BORDER)
      
      if PREMADE_IMAGE
        bitmap = get_bitmap("Graphics/Save/" + @data[slot_id]['map_name'] + IMAGE_FILETYPE)
        rect = Rect.new((Graphics.width-348)/2,(Graphics.height-156)/2,348,156)
        contents.blt(2,32,bitmap,rect)
      elsif SCREENSHOT_IMAGE and save_data['ss']
        bitmap = get_bitmap(save_data['ss_path'])
        rect = Rect.new((Graphics.width-348)/2,(Graphics.height-156)/2,348,156)
        contents.blt(2,32,bitmap,rect)
      elsif SWAP_TILE and $game_switches[SWAP_TILE_SWITCH]
        create_swaptilemap(save_data['gamemap'].data, save_data['gamemap'].display_x,
        save_data['gamemap'].display_y)
      else
        create_tilemap(save_data['gamemap'].data, save_data['gamemap'].display_x,
        save_data['gamemap'].display_y)
      end
      
      if DRAW_GOLD
        gold_textsize = contents.text_size(save_data['gamepar'].gold).width
        goldt_textsize = contents.text_size(GOLD_TEXT).width 
        contents.font.color = system_color
        contents.draw_text(0, 0, goldt_textsize, WLH, GOLD_TEXT)
        contents.font.color = normal_color
        contents.draw_text(goldt_textsize, 0, gold_textsize, WLH, save_data['gamepar'].gold) 
      
        if DRAW_TEXT_GOLD
         contents.draw_text(goldt_textsize + gold_textsize, 0, 200, WLH, Vocab::gold)

        else
         gold_textsize = 0
         goldt_textsize = 0            
        end
      end
    
      if DRAW_PLAYTIME
        hour = save_data['total_sec'] / 60 / 60
        min = save_data['total_sec'] / 60 % 60
        sec = save_data['total_sec'] % 60
        time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
        pt_textsize = contents.text_size(PLAYTIME_TEXT).width
        ts_textsize = contents.text_size(time_string).width
        contents.font.color = system_color
        contents.draw_text(contents.width - ts_textsize - pt_textsize, 0,
        pt_textsize, WLH, PLAYTIME_TEXT)
        contents.draw_text(goldt_textsize + gold_textsize,0,200,WLH, Vocab::gold)
        contents.font.color = normal_color
        contents.draw_text(0, 0, contents.width, WLH, time_string, 2)
      end
      
      if DRAW_LOCATION
        lc_textsize = contents.text_size(LOCATION_TEXT).width
        mn_textsize = contents.text_size(save_data['map_name']).width
        contents.font.color = system_color
        contents.draw_text(0, 190, contents.width, WLH, LOCATION_TEXT)
        contents.font.color = normal_color
        contents.draw_text(lc_textsize, 190, contents.width, WLH, save_data['map_name'])
      end
      
      # Draw level & name
      save_data['gamepar'].members.each_index do |i|
        actor = save_data['gameactor'][save_data['gamepar'].members[i].id]
        face_x_base = (i*80) + (i*8)
        face_y_base = 216
        lvn_y_plus = 10
        lv_textsize = contents.text_size(actor.level).width
        lvt_textsize = contents.text_size(LV_TEXT).width
       
      if DRAW_FACE
        contents.fill_rect(face_x_base, face_y_base, 84, 84, FACE_BORDER)
        draw_face(actor.face_name, actor.face_index, face_x_base + 2,
        face_y_base + 2, 80)
      end
      
      if DRAW_LEVEL
        contents.font.color = system_color
        contents.draw_text(face_x_base + 2 + 80 - lv_textsize - lvt_textsize,
        face_y_base + 2 + 80 - WLH + lvn_y_plus, lvt_textsize, WLH, LV_TEXT)
        contents.font.color = normal_color
        contents.draw_text(face_x_base + 2 + 80 - lv_textsize,
        face_y_base + 2 + 80 - WLH + lvn_y_plus, lv_textsize, WLH, actor.level)
      end
      
      if DRAW_NAME
        contents.draw_text(face_x_base, face_y_base + 2 + 80 + lvn_y_plus - 6, 84,
        WLH, actor.name, 1)
      end
     end
   else
     contents.draw_text(0,0, contents.width, contents.height - WLH, EMPTY_SLOT_TEXT, 1)
   end
  end
 
  def load_save_data(slot_id)
   file_name = make_filename(slot_id)
   
   if file_exist?(slot_id) or FileTest.exist?(file_name)
     @exist_list[slot_id] = true
     @data[slot_id] = {}
    
     # Start load data
     file = File.open(file_name, "r")
     @data[slot_id]['time'] = file.mtime
     @data[slot_id]['char'] = Marshal.load(file)
     @data[slot_id]['frame'] = Marshal.load(file)
     @data[slot_id]['last_bgm'] = Marshal.load(file)
     @data[slot_id]['last_bgs'] = Marshal.load(file)
     @data[slot_id]['gamesys'] = Marshal.load(file)
     @data[slot_id]['gamemes'] = Marshal.load(file)
     @data[slot_id]['gameswi'] = Marshal.load(file)
     @data[slot_id]['gamevar'] = Marshal.load(file)
     @data[slot_id]['gameselfvar'] = Marshal.load(file)
     @data[slot_id]['gameactor'] = Marshal.load(file)
     @data[slot_id]['gamepar'] = Marshal.load(file)
     @data[slot_id]['gametro'] = Marshal.load(file)
     @data[slot_id]['gamemap'] = Marshal.load(file)
     @data[slot_id]['total_sec'] = @data[slot_id]['frame'] / Graphics.frame_rate
    
     # Save the image
     if SCREENSHOT_IMAGE
      @data[slot_id]['ss_path'] = file_name.gsub(/\..*$/){'_ss'} + IMAGE_FILETYPE
      @data[slot_id]['ss'] = FileTest.exist?(@data[slot_id]['ss_path'])
     end
    
     @data[slot_id]['map_name'] = get_mapname(@data[slot_id]['gamemap'].map_id)
     file.close
   else
     @exist_list[slot_id] = false
     @data[slot_id] = -1
   end
  end

  def make_filename(file_index)
   return SAVE_PATH + SAVE_FILE_NAME.gsub(/\{ID\}/i) { (file_index).to_s }
  end
 
  def file_exist?(slot_id)
   return @exist_list[slot_id] if !@exist_list[slot_id].nil?
   
   @exist_list[slot_id] = FileTest.exist?(make_filename(slot_id))
   
   return @exist_list[slot_id]
  end
 
  def get_bitmap(path)
   if !@bitmap_list.include?(path)
     @bitmap_list[path] = Bitmap.new(path)
   end
   
   return @bitmap_list[path]
  end
 
  def get_mapname(map_id)
   if @map_data.nil?
     @map_data = load_data("Data/MapInfos.rvdata")
   end
 
   if @map_name[map_id].nil?
     if MAP_NO_NAME_LIST.include?(map_id) and $game_switches[MAP_NO_NAME_SWITCH]
      if $game_variables[map_id] == 0 or !MAP_NO_NAME_VARIABLE
        @map_name[map_id] = MAP_NO_NAME
      else
        @map_name[map_id] = @map_data[map_id].name
      end 
     else
      @map_name[map_id] = @map_data[map_id].name
     end
   
     MAP_NAME_TEXT_SUB.each_index do |i|
      @map_name[map_id].sub!(MAP_NAME_TEXT_SUB[i], '')
      @mapname = @map_name[map_id]
     end
   end
   
   return @map_name[map_id]
  end 
 
  def create_tilemap(map_data, ox, oy)
   @viewport = Viewport.new(self.x + 2 + 16, self.y + 32 + 16, 348,156)
   @viewport.z = self.z
   @tilemap = Tilemap.new(@viewport)
   @tilemap.bitmaps[0] = Cache.system("TileA1")
   @tilemap.bitmaps[1] = Cache.system("TileA2")
   @tilemap.bitmaps[2] = Cache.system("TileA3")
   @tilemap.bitmaps[3] = Cache.system("TileA4")
   @tilemap.bitmaps[4] = Cache.system("TileA5")
   @tilemap.bitmaps[5] = Cache.system("TileB")
   @tilemap.bitmaps[6] = Cache.system("TileC")
   @tilemap.bitmaps[7] = Cache.system("TileD")
   @tilemap.bitmaps[8] = Cache.system("TileE")
   @tilemap.map_data = map_data
   @tilemap.ox = ox / 8 + 99
   @tilemap.oy = oy / 8 + 90
  end
 
  def create_swaptilemap(map_data, ox, oy)
   @viewport = Viewport.new(self.x + 2 + 16, self.y + 32 + 16, 348,156)
   @viewport.z = self.z
   @tilemap = Tilemap.new(@viewport)
   
   tile1 = Cache_Swap_Tiles.swap($tileA1 + ".png") rescue nil
   tile2 = Cache_Swap_Tiles.swap($tileA2 + ".png") rescue nil
   tile3 = Cache_Swap_Tiles.swap($tileA3 + ".png") rescue nil
   tile4 = Cache_Swap_Tiles.swap($tileA4 + ".png") rescue nil
   tile5 = Cache_Swap_Tiles.swap($tileA5 + ".png") rescue nil
   tile6 = Cache_Swap_Tiles.swap($tileB + ".png") rescue nil
   tile7 = Cache_Swap_Tiles.swap($tileC + ".png") rescue nil
   tile8 = Cache_Swap_Tiles.swap($tileD + ".png") rescue nil
   tile9 = Cache_Swap_Tiles.swap($tileE + ".png") rescue nil
   
   if $tileA1 != nil
     @tilemap.bitmaps[0] = tile1
   else
     @tilemap.bitmaps[0] = Cache.system("TileA1")
   end

   if $tileA2 != nil
     @tilemap.bitmaps[1] = tile2
   else
     @tilemap.bitmaps[1] = Cache.system("TileA2")
   end

   if $tileA3 != nil
     @tilemap.bitmaps[2] = tile3 
   else
     @tilemap.bitmaps[2] = Cache.system("TileA3")
   end 

   if $tileA4 != nil
     @tilemap.bitmaps[3] = tile4
   else
     @tilemap.bitmaps[3] = Cache.system("TileA4")
   end

   if $tileA5 != nil
     @tilemap.bitmaps[4] = tile5 
   else
     @tilemap.bitmaps[4] = Cache.system("TileA5")
   end

   if $tileB != nil
     @tilemap.bitmaps[5] = tile6
   else
     @tilemap.bitmaps[5] = Cache.system("TileB") 
   end 

   if $tileC != nil
     @tilemap.bitmaps[6] = tile7
   else
     @tilemap.bitmaps[6] = Cache.system("TileC")
   end 

   if $tileD != nil
     @tilemap.bitmaps[7] = tile8
   else
     @tilemap.bitmaps[7] = Cache.system("TileD") 
   end

   if $tileE != nil
     @tilemap.bitmaps[8] = tile9
   else
     @tilemap.bitmaps[8] = Cache.system("TileE") 
   end
 
   @tilemap.map_data = map_data
   @tilemap.ox = ox / 8 + 99
   @tilemap.oy = oy / 8 + 90
  end
   
  def dispose_tilemap
   unless @tilemap.nil?
     @tilemap.dispose
     @tilemap = nil
     end
   end
  end
end

class Scene_Title < Scene_Base
  def check_continue
   file_name = Wora_NSS::SAVE_PATH + Wora_NSS::SAVE_FILE_NAME.gsub(/\{ID\}/i) { '*' }
   @continue_enabled = (Dir.glob(file_name).size > 0)
  end
end

class Scene_Map < Scene_Base
  alias wora_nss_scemap_ter terminate
 
  def terminate
   Wora_NSS.shot(Wora_NSS::SAVE_PATH + 'temp')
   wora_nss_scemap_ter
  end
end
#======================================================================
# END - NEO SAVE SYSTEM by Woratana and Helladen
#======================================================================