Quellcode

#==========================================================================
# ? [XP/VX] ? Neo Save System VI edited
#---------------------------------------------------------------------------
# ? 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 Woratana.
#---------------------------------------------------------------------------
# ? Converted to XP by LiTTleDRAgo
#---------------------------------------------------------------------------
# ? 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
#
# For XP :
# Put face into folder Graphics/Faces/ and name them into Actor{id}.png
#	ex = Actor1.png
# the faceset must 80x80
#
# Put Iconset.png in VX RTP and put it into folder Graphics/System
#
# Don't forget this script need screenshot.dll
#
#===========================================================================
 
VX = defined?(Window_BattleMessage)
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.
 
  CENTER_NAME = true
  # Set this to true will make Actor name center-aligned,
  # if false will become left-aligned
 
  # If you use the screenshot method this does not matter.
  SWAP_TILE = false # Make this false if you don't use the swap_tile script
  SWAP_TILE_SWITCH = 0 # 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 = false # Changes scene to map instead of remaining in Save screen.
 
  MAX_SAVE_SLOT = 20 # Max save slots.
  SLOT_NAME = 'Datei {id}'
 
  # Name of the slot (show in save slots list), use {id} for slot ID.
  SAVE_FILE_NAME = VX ? 'Save{id}.rvdata' : 'Save{id}.rxdata'
  # Save file name, you can also change its file type from .rvdata to other.
 
  # Use {id} for save slot ID.
  SAVE_PATH = 'Save/' # 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 = 'Leer' # 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 = 'Spielzeit: '
  GOLD_TEXT = 'Gold: '
  LOCATION_TEXT = 'Region: '
  LV_TEXT = 'Stufe: '
 
  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 = false # 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 = nil #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 = 'überschreiben' # Text to confirm to save file.
  SFC_Text_Cancel = 'abbrechen' # 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
  	if VX
    	@screen.call(0, 0, Graphics.width, Graphics.height, filename, 
    	self.handel, typid)
  	else
    	@screen.call(0, 0, 640, 480, filename, self.handel,typid)
  	end
	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
 
unless VX
  #==============================================================================
  # ** Vocab
  #------------------------------------------------------------------------------
  #  This module defines terms and messages. It defines some data as constant
  # variables. Terms in the database are obtained from $data_system.
  #==============================================================================
  DataSystem = load_data("Data/System.rxdata")
  module Vocab
 
	SaveMessage 	= "Speichern"
	LoadMessage 	= "Laden"
	File        	= "Datei"
 
	def self.gold
  	return DataSystem.words.gold
	end
  end
 
  #===============================================================================
  # * Sound Module * 
  #  This is a module used by RPG Maker VX - it has been modified to process XP
  #  sound commands.  
  #===============================================================================
  module Sound
 
	def self.play_cursor() $game_system.se_play($data_system.cursor_se) end
	def self.play_decision() $game_system.se_play($data_system.decision_se) end
	def self.play_cancel() $game_system.se_play($data_system.cancel_se) end
	def self.play_buzzer() $game_system.se_play($data_system.buzzer_se) end
	def self.play_equip() $game_system.se_play($data_system.equip_se)end
	def self.play_save() $game_system.se_play($data_system.save_se)  end
	def self.play_load() $game_system.se_play($data_system.load_se)  end
 
	end
 
  module Graphics
 
	def self.width()	640  end
	def self.height()	480  end
 
  end
 
  class Bitmap
	#--------------------------------------------------------------------------
	# * Clear Rectangle
	# by poccil
	#--------------------------------------------------------------------------
	def clear_rect(*arg)
  	if arg.length == 4
    	fill_rect(arg[0], arg[1], arg[2], arg[3], Color.new(0,0,0,0))  	
  	elsif arg.length == 1
    	fill_rect(arg[0], Color.new(0,0,0,0))
  	else
    	raise ArgumentError.new
  	end
	end
  end
 
  #==============================================================================
  # ** Cache
  #------------------------------------------------------------------------------
  #  This module loads each of graphics, creates a Bitmap object, and retains it.
  # To speed up load times and conserve memory, this module holds the created
  # Bitmap object in the internal hash, allowing the program to return
  # preexisting objects when the same bitmap is requested again.
  #==============================================================================
  module Cache
	#--------------------------------------------------------------------------
	# * Get Face Graphic
	# 	filename : Filename
	#--------------------------------------------------------------------------
	def self.face(f) load_bitmap("Graphics/Faces/", f)  end
	#--------------------------------------------------------------------------
	# * Get System Graphic
	# 	filename : Filename
	#--------------------------------------------------------------------------
	def self.system(f)  load_bitmap("Graphics/System/", f)  end
	#--------------------------------------------------------------------------
	# * Clear Cache
	#--------------------------------------------------------------------------
	def self.clear
  	@cache = {} if @cache == nil
  	@cache.clear
  	GC.start
	end
	#--------------------------------------------------------------------------
	# * Load Bitmap
	#--------------------------------------------------------------------------
	def self.load_bitmap(folder_name, filename, hue = 0)
  	@cache = {} if @cache == nil
  	path = folder_name + filename
  	if not @cache.include?(path) or @cache[path].disposed?
    	if filename.empty?
      	@cache[path] = Bitmap.new(32, 32)
    	else
      	@cache[path] = Bitmap.new(path)
    	end
  	end
  	if hue == 0
    	return @cache[path]
  	else
    	key = [path, hue]
    	if not @cache.include?(key) or @cache[key].disposed?
      	@cache[key] = @cache[path].clone
      	@cache[key].hue_change(hue)
    	end
    	return @cache[key]
  	end
	end
  end
 
end
 
#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  This is a superclass of all windows in the game.
#==============================================================================
 
class Window_Base_Neo < Window
  #--------------------------------------------------------------------------
  # * Constants
  #--------------------------------------------------------------------------
  WLH = 24              	# Window Line Height
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	x  	: window x-coordinate
  # 	y  	: window y-coordinate
  # 	width  : window width
  # 	height : window height
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height)
	super()
	unless VX
  	@windowskin_name = $game_system.windowskin_name
  	self.windowskin = RPG::Cache.windowskin(@windowskin_name)
	else
  	self.windowskin = Cache.system("Window")
	end
	self.x = x
	self.y = y
	self.width = width
	self.height = height
	self.z = 100
	self.back_opacity = 200
	self.opacity = 255
	create_contents
	@opening = false
	@closing = false
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
	self.contents.dispose
	super
  end
  #--------------------------------------------------------------------------
  # * Create Window Contents
  #--------------------------------------------------------------------------
  def create_contents
	self.contents.dispose if self.contents
	self.contents = Bitmap.new(width - 32, height - 32)
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	super
	if @opening
  	self.opacity += 48
  	@opening = false if self.opacity >= 255
	elsif @closing
  	self.opacity -= 48
  	@closing = false if self.opacity <= 0
	end
  end
  #--------------------------------------------------------------------------
  # * Open Window
  #--------------------------------------------------------------------------
  def open
	@opening = true if self.opacity < 255
	@closing = false
  end
  #--------------------------------------------------------------------------
  # * Close Window
  #--------------------------------------------------------------------------
  def close
	@closing = true if self.opacity > 0
	@opening = false
  end
  #--------------------------------------------------------------------------
  # * Get Text Color
  # 	n : text color number (0-7)
  #--------------------------------------------------------------------------
  def text_color(n)
	case n
	when 0 then Color.new(255, 255, 255, 255)
	when 1 then Color.new(128, 128, 255, 255)
	when 2 then Color.new(255, 128, 128, 255)
	when 3 then Color.new(128, 255, 128, 255)
	when 4 then Color.new(128, 255, 255, 255)
	when 5 then Color.new(255, 128, 255, 255)
	when 6 then Color.new(255, 255, 128, 255)
	when 7 then Color.new(192, 192, 192, 255)
	else
  	normal_color
	end
  end
  #--------------------------------------------------------------------------
  # * Get Normal Text Color
  #--------------------------------------------------------------------------
  def normal_color() text_color(0) end
  #--------------------------------------------------------------------------
  # * Get System Text Color
  #--------------------------------------------------------------------------
  def system_color() Color.new(192, 224, 255, 255)  end
  #--------------------------------------------------------------------------
  # * Draw number with currency unit
  # 	value : Number (gold, etc)
  # 	x 	: draw spot x-coordinate
  # 	y 	: draw spot y-coordinate
  # 	width : Width
  #--------------------------------------------------------------------------
  def draw_currency_value(value, x, y, width)
	cx = contents.text_size(Vocab::gold).width
	self.contents.font.color = normal_color
	self.contents.draw_text(x, y, width-cx-2, WLH, value, 2)
	self.contents.font.color = system_color
	self.contents.draw_text(x, y, width, WLH, Vocab::gold, 2)
  end
  #--------------------------------------------------------------------------
  # * Draw Icon
  # 	icon_index : Icon number
  # 	x 	: draw spot x-coordinate
  # 	y 	: draw spot y-coordinate
  # 	enabled	: Enabled flag. When false, draw semi-transparently.
  #--------------------------------------------------------------------------
  def draw_icon(icon_index, x, y, enabled = true)
	bitmap = Cache.system("Iconset")
	rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
	self.contents.blt(x, y, bitmap, rect, enabled ? 255 : 128)
  end
  #--------------------------------------------------------------------------
  # * Draw Face Graphic
  # 	face_name  : Face graphic filename
  # 	face_index : Face graphic index
  # 	x 	: draw spot x-coordinate
  # 	y 	: draw spot y-coordinate
  # 	size   	: Display size
  #--------------------------------------------------------------------------
  def draw_face(face_name, face_index, x, y, size = 96)
	bitmap = Cache.face(face_name)rescue Cache.face('')
	rect = Rect.new(0, 0, 0, 0)
	if VX
  	rect.x = face_index % 4 * 96 + (96 - size) / 2
  	rect.y = face_index / 4 * 96 + (96 - size) / 2
	else
  	rect.x = 0 
  	rect.y = 0 
	end
	rect.width = size
	rect.height = size
	self.contents.blt(x, y, bitmap, rect)
	bitmap.dispose
  end
end
#==============================================================================
# ** Window_Selectable
#------------------------------------------------------------------------------
#  This window contains cursor movement and scroll functions.
#==============================================================================
 
class Window_Selectable_Neo < Window_Base_Neo
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :item_max             	# item count
  attr_reader   :column_max           	# digit count
  attr_reader   :index                	# cursor position
  attr_reader   :help_window          	# help window
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	x   	: window X coordinate
  # 	y   	: window Y coordinate
  # 	width   : window width
  # 	height  : window height
  # 	spacing : width of empty space when items are arranged horizontally
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height, spacing = 32)
	@item_max = 1
	@column_max = 1
	@index = -1
	@spacing = spacing
	super(x, y, width, height)
  end
  #--------------------------------------------------------------------------
  # * Create Window Contents
  #--------------------------------------------------------------------------
  def create_contents
	self.contents.dispose if self.contents
	self.contents = Bitmap.new(width - 32, [height - 32, row_max * WLH].max)
  end
  #--------------------------------------------------------------------------
  # * Set Cursor Position
  # 	index : new cursor position
  #--------------------------------------------------------------------------
  def index=(index)
	@index = index
	update_cursor
	call_update_help
  end
  #--------------------------------------------------------------------------
  # * Get Row Count
  #--------------------------------------------------------------------------
  def row_max()(@item_max + @column_max - 1) / @column_max  end
  #--------------------------------------------------------------------------
  # * Get Top Row
  #--------------------------------------------------------------------------
  def top_row() self.oy / WLH end
  #--------------------------------------------------------------------------
  # * Set Top Row
  # 	row : row shown on top
  #--------------------------------------------------------------------------
  def top_row=(row)
	row = 0 if row < 0
	row = row_max - 1 if row > row_max - 1
	self.oy = row * WLH
  end
  #--------------------------------------------------------------------------
  # * Get Number of Rows Displayable on 1 Page
  #--------------------------------------------------------------------------
  def page_row_max() (self.height - 32) / WLH  end
  #--------------------------------------------------------------------------
  # * Get Number of Items Displayable on 1 Page
  #--------------------------------------------------------------------------
  def page_item_max() page_row_max * @column_max  end
  #--------------------------------------------------------------------------
  # * Get bottom row
  #--------------------------------------------------------------------------
  def bottom_row() top_row + page_row_max - 1  end
  #--------------------------------------------------------------------------
  # * Set bottom row
  # 	row : Row displayed at the bottom
  #--------------------------------------------------------------------------
  def bottom_row=(row) self.top_row = row - (page_row_max - 1) end
  #--------------------------------------------------------------------------
  # * Get rectangle for displaying items
  # 	index : item number
  #--------------------------------------------------------------------------
  def item_rect(index)
	rect = Rect.new(0, 0, 0, 0)
	rect.width = (contents.width + @spacing) / @column_max - @spacing
	rect.height = WLH
	rect.x = index % @column_max * (rect.width + @spacing)
	rect.y = index / @column_max * WLH
	return rect
  end
  #--------------------------------------------------------------------------
  # * Set Help Window
  # 	help_window : new help window
  #--------------------------------------------------------------------------
  def help_window=(help_window)
	@help_window = help_window
	call_update_help
  end
  #--------------------------------------------------------------------------
  # * Determine if cursor is moveable
  #--------------------------------------------------------------------------
  def cursor_movable?
	return false if (not visible or not active)
	return false if (index < 0 or index > @item_max or @item_max == 0)
	return false if (@opening or @closing)
	return true
  end
  #--------------------------------------------------------------------------
  # * Move cursor down
  # 	wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def cursor_down(wrap = false)
	if (@index < @item_max - @column_max) or (wrap and @column_max == 1)
  	@index = (@index + @column_max) % @item_max
	end
  end
  #--------------------------------------------------------------------------
  # * Move cursor up
  # 	wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def cursor_up(wrap = false)
	if (@index >= @column_max) or (wrap and @column_max == 1)
  	@index = (@index - @column_max + @item_max) % @item_max
	end
  end
  #--------------------------------------------------------------------------
  # * Move cursor right
  # 	wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def cursor_right(wrap = false)
	if (@column_max >= 2) and
   	(@index < @item_max - 1 or (wrap and page_row_max == 1))
  	@index = (@index + 1) % @item_max
	end
  end
  #--------------------------------------------------------------------------
  # * Move cursor left
  # 	wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def cursor_left(wrap = false)
	if (@column_max >= 2) and
   	(@index > 0 or (wrap and page_row_max == 1))
  	@index = (@index - 1 + @item_max) % @item_max
	end
  end
  #--------------------------------------------------------------------------
  # * Move cursor one page down
  #--------------------------------------------------------------------------
  def cursor_pagedown
	if top_row + page_row_max < row_max
  	@index = [@index + page_item_max, @item_max - 1].min
  	self.top_row += page_row_max
	end
  end
  #--------------------------------------------------------------------------
  # * Move cursor one page up
  #--------------------------------------------------------------------------
  def cursor_pageup
	if top_row > 0
  	@index = [@index - page_item_max, 0].max
  	self.top_row -= page_row_max
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	super
	if cursor_movable?
  	last_index = @index
  	if Input.repeat?(Input::DOWN)
    	cursor_down(Input.trigger?(Input::DOWN))
  	end
  	if Input.repeat?(Input::UP)
    	cursor_up(Input.trigger?(Input::UP))
  	end
  	if Input.repeat?(Input::RIGHT)
    	cursor_right(Input.trigger?(Input::RIGHT))
  	end
  	if Input.repeat?(Input::LEFT)
    	cursor_left(Input.trigger?(Input::LEFT))
  	end
  	if Input.repeat?(Input::R)
    	cursor_pagedown
  	end
  	if Input.repeat?(Input::L)
    	cursor_pageup
  	end
  	if @index != last_index
    	Sound.play_cursor
  	end
	end
	update_cursor
	call_update_help
  end
  #--------------------------------------------------------------------------
  # * Update cursor
  #--------------------------------------------------------------------------
  def update_cursor
	if @index < 0               	# If the cursor position is less than 0
  	self.cursor_rect.empty    	# Empty cursor
	else                        	# If the cursor position is 0 or more
  	row = @index / @column_max	# Get current row
  	if row < top_row          	# If before the currently displayed
    	self.top_row = row      	# Scroll up
  	end
  	if row > bottom_row       	# If after the currently displayed
    	self.bottom_row = row   	# Scroll down
  	end
  	rect = item_rect(@index)  	# Get rectangle of selected item
  	rect.y -= self.oy         	# Match rectangle to scroll position
  	self.cursor_rect = rect   	# Refresh cursor rectangle
	end
  end
  #--------------------------------------------------------------------------
  # * Call help window update method
  #--------------------------------------------------------------------------
  def call_update_help
	if self.active and @help_window != nil
   	update_help
	end
  end
  #--------------------------------------------------------------------------
  # * Update help window (contents are defined by the subclasses)
  #--------------------------------------------------------------------------
  def update_help()  end
end
#==============================================================================
# ** Window_Command
#------------------------------------------------------------------------------
#  This window deals with general command choices.
#==============================================================================
 
class Window_Command_Neo < Window_Selectable_Neo
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :commands             	# command
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	width  	: window width
  # 	commands   : command string array
  # 	column_max : digit count (if 2 or more, horizontal selection)
  # 	row_max	: row count (0: match command count)
  # 	spacing	: blank space when items are arrange horizontally
  #--------------------------------------------------------------------------
  def initialize(width, commands, column_max = 1, row_max = 0, spacing = 32)
	if row_max == 0
  	row_max = (commands.size + column_max - 1) / column_max
	end
	super(0, 0, width, row_max * WLH + 32, spacing)
	@commands = commands
	@item_max = commands.size
	@column_max = column_max
	refresh
	self.index = 0
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
	self.contents.clear
	for i in 0...@item_max
  	draw_item(i)
	end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  # 	index   : item number
  # 	enabled : enabled flag. When false, draw semi-transparently.
  #--------------------------------------------------------------------------
  def draw_item(index, enabled = true)
	rect = item_rect(index)
	rect.x += 4
	rect.width -= 8
	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
end
#==============================================================================
# ** Scene_File
#------------------------------------------------------------------------------
#  This is a superclass for the save screen and load screen.
#==============================================================================
class Scene_File 
  include Wora_NSS
  attr_reader :window_slotdetail
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	start                     	# Start processing
	perform_transition        	# Perform transition
	Input.update              	# Update input information
	loop do
  	Graphics.update         	# Update game screen
  	Input.update            	# Update input information
  	update                  	# Update frame
  	break if $scene != self 	# When screen is switched, interrupt loop
	end
	Graphics.update
	Graphics.freeze           	# Prepare transition
	terminate                 	# Termination processing
  end
  #--------------------------------------------------------------------------
  # * Execute Transition
  #--------------------------------------------------------------------------
  def perform_transition()   Graphics.transition(10)  end
  #--------------------------------------------------------------------------
  # * Create Snapshot for Using as Background of Another Screen
  #--------------------------------------------------------------------------
  def snapshot_for_background
	$game_temp.background_bitmap.dispose
	$game_temp.background_bitmap = Graphics.snap_to_bitmap
	$game_temp.background_bitmap.blur
  end
  #--------------------------------------------------------------------------
  # * Create Background for Menu Screen
  #--------------------------------------------------------------------------
  def create_menu_background
	@menuback_sprite = Sprite.new
	@menuback_sprite.bitmap = $game_temp.background_bitmap
	@menuback_sprite.color.set(16, 16, 16, 128)
	update_menu_background
  end
  #--------------------------------------------------------------------------
  # * Dispose of Background for Menu Screen
  #--------------------------------------------------------------------------
  def dispose_menu_background()   @menuback_sprite.dispose  end
  #--------------------------------------------------------------------------
  # * Update Background for Menu Screen
  #--------------------------------------------------------------------------
  def update_menu_background() end
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
	create_menu_background
	if NSS_IMAGE_BG != ''
  	@bg = Sprite.new
  	if VX
    	@bg.bitmap = Cache.picture(NSS_IMAGE_BG)
  	else
    	@bg.bitmap = RPG::Cache.picture(NSS_IMAGE_BG)
  	end
  	@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
	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
	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
    	@confirm_window.z = 9999
  	else
    	determine_savefile
  	end
	elsif Input.trigger?(Input::B)
  	Sound.play_cancel
  	return_scene
	end
  end
  #--------------------------------------------------------------------------
  # * Return to Original Screen
  #--------------------------------------------------------------------------
  def return_scene
	if @from_title || $game_temp.call_from_title
  	$game_temp.call_from_title = false
  	$scene = Scene_Title.new
	elsif @from_event || $game_temp.call_from_event
  	$game_temp.call_from_event = false
  	$scene = Scene_Map.new
	else
  	$scene = Scene_Menu.new(4)
	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   
	$game_temp.call_from_title = false
	$game_temp.call_from_event = false
	# Alter the scene after the saving is done
	if SCENE_CHANGE
  	$scene = Scene_Map.new
	else
  	if VX
    	$scene = Scene_File.new(true, false, false)
  	else
    	$scene = Scene_Save.new
  	end
	end
  end
  #--------------------------------------------------------------------------
  # * Execute Load
  #--------------------------------------------------------------------------
  def do_load
	file = File.open(make_filename(@last_slot_index), "rb")
	read_save_data(file)
	file.close
	unless VX 
  	$game_system.bgm_play($game_system.playing_bgm)
  	$game_system.bgs_play($game_system.playing_bgs)
	end
	$scene = Scene_Map.new
	if VX
  	RPG::BGM.fade(1500) 
  	Graphics.fadeout(60)
  	Graphics.wait(40)
  	@last_bgm.play
  	@last_bgs.play
	end
	$game_temp.call_from_title = false
	$game_temp.call_from_event = false
  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_Neo
  #--------------------------------------------------------------------------
  # * 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_Neo
  include Wora_NSS
 
  def initialize
  if VX
	super(160, 56, 384, 360)
  else
	super(160, 65, 480, 415)
  end
 
	@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]
	if VX
  	contents.fill_rect(0,30,352,152, MAP_BORDER)
	else
  	contents.fill_rect(0,30,458,160, MAP_BORDER)
	end
		if PREMADE_IMAGE
		  bitmap = get_bitmap("Graphics/Save/" + @data[slot_id]['map_name'] + IMAGE_FILETYPE)
  	if VX
			rect = Rect.new((Graphics.width-348)/2,(Graphics.height-156)/2,348,156)
  	else
    	rect = Rect.new((640-348)/2,(480-156)/2,448,156)
  	end  	
		  contents.blt(2,32,bitmap,rect)
		elsif SCREENSHOT_IMAGE and save_data['ss']
		  bitmap = get_bitmap(save_data['ss_path'])
  	if VX
    	rect = Rect.new((Graphics.width-348)/2,(Graphics.height-156)/2,348,156)
  	else
    	rect = Rect.new((640-348)/2,(480-156)/2,448,156)
  	end
		  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.to_s).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.to_s)  
 
		  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
  	y = VX ? 190 : 190+35
		  contents.draw_text(0, y, contents.width, WLH, LOCATION_TEXT)
		  contents.font.color = normal_color
		  contents.draw_text(lc_textsize, y, contents.width, WLH, save_data['map_name'])
		end
 
		# Draw level & name
	game_party = VX ? save_data['gamepar'].members : save_data['gamepar'].actors
 
	game_party.each_index do |i|
		  actor = save_data['gameactor'][game_party[i].id]
		  face_x_base = (i*80) + (i*(8+ (VX ? 0 : 18)))
  	face_x_base = (i*80) + (i*(8+18))  # ADD
		  face_y_base = 216
		  face_y_base += 40 if !VX
		  lvn_y_plus = 10
		  lv_textsize = contents.text_size(actor.level.to_s).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)
  	unless VX
    	draw_face('Actor'+actor.id.to_s, 1, face_x_base + 2, face_y_base + 2, 80)
  	else
    	draw_face(actor.face_name, actor.face_index, face_x_base + 2,
    	face_y_base + 2, 80)
  	end
		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.to_s)
		end
 
		if DRAW_NAME
		  contents.draw_text(face_x_base, face_y_base + 2 + 80 + lvn_y_plus - 6, 84,
		  WLH, actor.name, CENTER_NAME ? 1 : 4)
		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)
  	if VX
    	@data[slot_id]['last_bgm'] = Marshal.load(file)
    	@data[slot_id]['last_bgs'] = Marshal.load(file)
  	end
  	@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?
  	if VX
    	@map_data = load_data("Data/MapInfos.rvdata")
  	else
    	@map_data = load_data("Data/MapInfos.rxdata")
  	end
	end
	if @map_name[map_id].nil?
  	if MAP_NO_NAME_LIST.include?(map_id) && MAP_NO_NAME_SWITCH &&
    	(!$game_switches.nil? && $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 rescue ''
  	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
	return unless VX
	@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
	return unless VX
	@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
#==============================================================================
# ** Scene_Save
#------------------------------------------------------------------------------
#  This class performs save screen processing.
#==============================================================================
class Scene_Save < Scene_File
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
	@saving = true
	super('') 
  end
end
#==============================================================================
# ** Scene_Load
#------------------------------------------------------------------------------
#  This class performs load screen processing.
#==============================================================================
class Scene_Load < Scene_File
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
	@saving = false
	super('')
  end
end
#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  This class performs title screen processing.
#==============================================================================
name = VX ? "< Scene_Base" : ""
eval_text = "
class Scene_Title #{name}
  #--------------------------------------------------------------------------
  # * Check Continue
  #--------------------------------------------------------------------------
  def check_continue
	unless @checked
  	@checked = true
  	file_name = Wora_NSS::SAVE_PATH + Wora_NSS::SAVE_FILE_NAME.gsub(/\{ID\}/i) { '*' }
  	@continue_enabled = (Dir.glob(file_name).size > 0)
  	return @checked = true if VX
  	if @continue_enabled 
    	@command_window.index = 1
    	@command_window.draw_item(1, Color.new(255, 255, 255, 255))
  	else
    	@command_window.index = 0
    	@command_window.disable_item(1)
  	end
	end
  end
  unless VX
	#--------------------------------------------------------------------------
	# * Update Frame
	#--------------------------------------------------------------------------
	alias update_nss update
	def update
  	check_continue
  	update_nss
	end
	#--------------------------------------------------------------------------
	# * Command: Continue
	#--------------------------------------------------------------------------
	alias command_continue_nss command_continue
	def command_continue
  	$game_temp      	= Game_Temp.new
  	$game_temp.call_from_title = true
  	command_continue_nss
	end
  end
end
 
#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs map screen processing.
#==============================================================================
class Scene_Map #{name}
  if VX
	#--------------------------------------------------------------------------
	# * Terminate
	#--------------------------------------------------------------------------
	alias wora_nss_scemap_ter terminate
	def terminate
  	Wora_NSS.shot(Wora_NSS::SAVE_PATH + 'temp')
  	wora_nss_scemap_ter
	end
  else
	#--------------------------------------------------------------------------
	# * Main
	#--------------------------------------------------------------------------
	alias wora_nss_scemap_ter main
	def main
  	wora_nss_scemap_ter
  	Wora_NSS.shot(Wora_NSS::SAVE_PATH + 'temp')
	end
	#--------------------------------------------------------------------------
	# * Save Call
	#--------------------------------------------------------------------------
	alias wora_nss_scemap_callsave call_save
	def call_save
  	$game_temp.save_calling = false
  	$game_temp.call_from_event = true
  	wora_nss_scemap_callsave
	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
  attr_accessor :background_bitmap,:call_from_event,:call_from_title
end
eval(eval_text)
 
#======================================================================
# END - NEO SAVE SYSTEM by Woratana and Helladen
#======================================================================