Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #==========================================================================
- # ? [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 = 'SLOT {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 = '' # 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 = 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 = 'Lanjutkan 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
- 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 = "Save ke File yang mana?"
- LoadMessage = "Load file yang mana?"
- File = "File"
- 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_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
- #======================================================================
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement