diff --git a/Data/Map098.rxdata b/Data/Map098.rxdata index d36e12240..cd71d88ff 100644 Binary files a/Data/Map098.rxdata and b/Data/Map098.rxdata differ diff --git a/Data/MapInfos.rxdata b/Data/MapInfos.rxdata index 289f728e2..739264120 100644 Binary files a/Data/MapInfos.rxdata and b/Data/MapInfos.rxdata differ diff --git a/Data/Scripts/001_Settings.rb b/Data/Scripts/001_Settings.rb index 280ad5377..0f890e946 100644 --- a/Data/Scripts/001_Settings.rb +++ b/Data/Scripts/001_Settings.rb @@ -6,7 +6,7 @@ module Settings # The version of your game. It has to adhere to the MAJOR.MINOR.PATCH format. GAME_VERSION = '5.0.0' - GAME_VERSION_NUMBER = "5.0.36.3" + GAME_VERSION_NUMBER = "5.0.36.4" POKERADAR_LIGHT_ANIMATION_RED_ID = 17 POKERADAR_LIGHT_ANIMATION_GREEN_ID = 18 diff --git a/Data/Scripts/050_AddOns/Autosave.rb b/Data/Scripts/050_AddOns/Autosave.rb index d74ea88bb..d44a8c3ea 100644 --- a/Data/Scripts/050_AddOns/Autosave.rb +++ b/Data/Scripts/050_AddOns/Autosave.rb @@ -19,9 +19,10 @@ def pbSetPokemonCenter end def Kernel.Autosave + Game.auto_save #showSaveIcon() - pbSave(false) - #hideSaveIcon() + # pbSave(false) + # #hideSaveIcon() end diff --git a/Data/Scripts/050_AddOns/MultiSaves.rb b/Data/Scripts/050_AddOns/MultiSaves.rb new file mode 100644 index 000000000..b1151d9e8 --- /dev/null +++ b/Data/Scripts/050_AddOns/MultiSaves.rb @@ -0,0 +1,709 @@ +# # Auto Multi Save by http404error +# # For Pokemon Essentials v19.1 +# +# # Description: +# # Adds multiple save slots and the abliity to auto-save. +# # Included is code to autosave every 30 overworld steps. Feel free to edit or delete it (it's right at the top). +# # On the Load screen you can use the left and right buttons while "Continue" is selected to cycle through files. +# # When saving, you can quickly save to the same slot you loaded from, or pick another slot. +# # Battle Challenges are NOT supported. +# +# # Customization: +# # I recommend altering your pause menu to quit to the title screen or load screen instead of exiting entirely. +# # -> For instance, just change the menu text to "Quit to Title" and change `$scene = nil` to `$scene = pbCallTitle`. +# # Call Game.auto_save whenever you want. +# # -> Autosaving during an event script will correctly resume event execution when you load the game. +# # -> I haven't investigated if it might be possible to autosave on closing the window with the X or Alt-F4 yet. +# # You can rename the slots to your liking, or change how many there are. +# # In some cases, you might want to remove the option to save to a different slot than the one you loaded from. +# +# # Notes: +# # On the first Load, the old Game.rxdata will be copied to the first slot in MANUAL_SLOTS. It won't have a known save time though. +# # The interface to `Game.save` has been changed. +# # Due to the slots, alters the save backup system in the case of save corruption/crashes - backups will be named Backup000.rxdata and so on. +# # Heavily modifies the SaveData module and Save and Load screens. This may cause incompatibility with some other plugins or custom game code. +# # Not everything here has been tested extensively, only what applies to normal usage of my game. Please let me know if you run into any problems. +# +# # Future development ideas: +# # There isn't currently support for unlimited slots but it wouldn't be too hard. +# # Letting the user name their slots seems cool. +# # It would be nice if there was a sliding animation for switching files on that load screen. :) +# # It would be nice if the file select arrows used nicer animated graphics, kind of like the Bag. +# # Maybe auto-save slots should act like a queue instead of cycling around. +# +# # Autosave every 30 steps +# # Events.onStepTaken += proc { +# # $Trainer.autosave_steps = 0 if !$Trainer.autosave_steps +# # $Trainer.autosave_steps += 1 +# # if $Trainer.autosave_steps >= 30 +# # echo("Autosaving...") +# # $Trainer.autosave_steps = 0 +# # Game.auto_save +# # echoln("done.") +# # end +# # } +# +# #=============================================================================== +# # +# #=============================================================================== +# module SaveData +# # You can rename these slots or change the amount of them +# # They change the actual save file names though, so it would take some extra work to use the translation system on them. +# AUTO_SLOTS = [ +# 'Auto 1', +# 'Auto 2' +# ] +# MANUAL_SLOTS = [ +# 'File A', +# 'File B', +# 'File C', +# 'File D', +# 'File E', +# 'File F', +# 'File G', +# 'File H' +# ] +# +# # For compatibility with games saved without this plugin +# OLD_SAVE_SLOT = 'Game' +# +# SAVE_DIR = if File.directory?(System.data_directory) +# System.data_directory +# else +# '.' +# end +# +# def self.each_slot +# (AUTO_SLOTS + MANUAL_SLOTS).each { |f| yield f } +# end +# +# def self.get_full_path(file) +# return "#{SAVE_DIR}/#{file}.rxdata" +# end +# +# def self.get_backup_file_path +# backup_file = "Backup000" +# while File.file?(self.get_full_path(backup_file)) +# backup_file.next! +# end +# return self.get_full_path(backup_file) +# end +# +# # Given a list of save file names and a file name in it, return the next file after it which exists +# # If no other file exists, will just return the same file again +# def self.get_next_slot(file_list, file) +# old_index = file_list.find_index(file) +# ordered_list = file_list.rotate(old_index + 1) +# ordered_list.each do |f| +# return f if File.file?(self.get_full_path(f)) +# end +# # should never reach here since the original file should always exist +# return file +# end +# # See self.get_next_slot +# def self.get_prev_slot(file_list, file) +# return self.get_next_slot(file_list.reverse, file) +# end +# +# # Returns nil if there are no saves +# # Returns the first save if there's a tie for newest +# # Old saves from previous version don't store their saved time, so are treated as very old +# def self.get_newest_save_slot +# newest_time = Time.at(0) # the Epoch +# newest_slot = nil +# self.each_slot do |file_slot| +# full_path = self.get_full_path(file_slot) +# next if !File.file?(full_path) +# temp_save_data = self.read_from_file(full_path) +# save_time = temp_save_data[:player].last_time_saved || Time.at(1) +# if save_time > newest_time +# newest_time = save_time +# newest_slot = file_slot +# end +# end +# # Port old save +# if newest_slot.nil? && File.file?(self.get_full_path(OLD_SAVE_SLOT)) +# file_copy(self.get_full_path(OLD_SAVE_SLOT), self.get_full_path(MANUAL_SLOTS[0])) +# return MANUAL_SLOTS[0] +# end +# return newest_slot +# end +# +# # @return [Boolean] whether any save file exists +# def self.exists? +# self.each_slot do |slot| +# full_path = SaveData.get_full_path(slot) +# return true if File.file?(full_path) +# end +# return false +# end +# +# # This is used in a hidden function (ctrl+down+cancel on title screen) or if the save file is corrupt +# # Pass nil to delete everything, or a file path to just delete that one +# # @raise [Error::ENOENT] +# def self.delete_file(file_path=nil) +# if file_path +# File.delete(file_path) if File.file?(file_path) +# else +# self.each_slot do |slot| +# full_path = self.get_full_path(slot) +# File.delete(full_path) if File.file?(full_path) +# end +# end +# end +# +# # Moves a save file from the old Saved Games folder to the new +# # location specified by {MANUAL_SLOTS[0]}. Does nothing if a save file +# # already exists in {MANUAL_SLOTS[0]}. +# def self.move_old_windows_save +# return if self.exists? +# game_title = System.game_title.gsub(/[^\w ]/, '_') +# home = ENV['HOME'] || ENV['HOMEPATH'] +# return if home.nil? +# old_location = File.join(home, 'Saved Games', game_title) +# return unless File.directory?(old_location) +# old_file = File.join(old_location, 'Game.rxdata') +# return unless File.file?(old_file) +# File.move(old_file, MANUAL_SLOTS[0]) +# end +# +# # Runs all possible conversions on the given save data. +# # Saves a backup before running conversions. +# # @param save_data [Hash] save data to run conversions on +# # @return [Boolean] whether conversions were run +# def self.run_conversions(save_data) +# validate save_data => Hash +# conversions_to_run = self.get_conversions(save_data) +# return false if conversions_to_run.none? +# File.open(SaveData.get_backup_file_path, 'wb') { |f| Marshal.dump(save_data, f) } +# echoln "Backed up save to #{SaveData.get_backup_file_path}" +# echoln "Running #{conversions_to_run.length} conversions..." +# conversions_to_run.each do |conversion| +# echo "#{conversion.title}..." +# conversion.run(save_data) +# echoln ' done.' +# end +# echoln '' if conversions_to_run.length > 0 +# save_data[:essentials_version] = Essentials::VERSION +# save_data[:game_version] = Settings::GAME_VERSION +# return true +# end +# end +# +# #=============================================================================== +# # +# #=============================================================================== +# class PokemonLoad_Scene +# def pbChoose(commands, continue_idx) +# @sprites["cmdwindow"].commands = commands +# loop do +# Graphics.update +# Input.update +# pbUpdate +# if Input.trigger?(Input::USE) +# return @sprites["cmdwindow"].index +# elsif @sprites["cmdwindow"].index == continue_idx +# @sprites["leftarrow"].visible=true +# @sprites["rightarrow"].visible=true +# if Input.trigger?(Input::LEFT) +# return -3 +# elsif Input.trigger?(Input::RIGHT) +# return -2 +# end +# else +# @sprites["leftarrow"].visible=false +# @sprites["rightarrow"].visible=false +# end +# end +# end +# +# def pbStartScene(commands, show_continue, trainer, frame_count, map_id) +# @commands = commands +# @sprites = {} +# @viewport = Viewport.new(0, 0, Graphics.width, Graphics.height) +# @viewport.z = 99998 +# addBackgroundOrColoredPlane(@sprites,"background","loadbg",Color.new(248,248,248),@viewport) +# +# @sprites["leftarrow"] = AnimatedSprite.new("Graphics/Pictures/leftarrow",8,40,28,2,@viewport) +# @sprites["leftarrow"].x=10 +# @sprites["leftarrow"].y=140 +# @sprites["leftarrow"].play +# +# #@sprites["leftarrow"].visible=true +# +# @sprites["rightarrow"] = AnimatedSprite.new("Graphics/Pictures/rightarrow",8,40,28,2,@viewport) +# @sprites["rightarrow"].x = 460 +# @sprites["rightarrow"].y = 140 +# @sprites["rightarrow"].play +# #@sprites["rightarrow"].visible=true +# +# y = 16*2 +# for i in 0...commands.length +# @sprites["panel#{i}"] = PokemonLoadPanel.new(i,commands[i], +# (show_continue) ? (i==0) : false,trainer,frame_count,map_id,@viewport) +# @sprites["panel#{i}"].x = 24*2 +# @sprites["panel#{i}"].y = y +# @sprites["panel#{i}"].pbRefresh +# y += (show_continue && i==0) ? 112*2 : 24*2 +# end +# @sprites["cmdwindow"] = Window_CommandPokemon.new([]) +# @sprites["cmdwindow"].viewport = @viewport +# @sprites["cmdwindow"].visible = false +# end +# +# end +# +# #=============================================================================== +# # +# #=============================================================================== +# class PokemonLoadScreen +# def initialize(scene) +# @scene = scene +# @selected_file = SaveData.get_newest_save_slot +# end +# +# # @param file_path [String] file to load save data from +# # @return [Hash] save data +# def load_save_file(file_path) +# save_data = SaveData.read_from_file(file_path) +# unless SaveData.valid?(save_data) +# if File.file?(file_path + ".bak") +# pbMessage(_INTL("The save file is corrupt. A backup will be loaded.")) +# save_data = load_save_file(file_path + ".bak") +# else +# self.prompt_save_deletion(file_path) +# return {} +# end +# end +# return save_data +# end +# +# # Called if save file is invalid. +# # Prompts the player to delete the save files. +# def prompt_save_deletion(file_path) +# pbMessage(_INTL("A save file is corrupt, or is incompatible with this game.")) +# self.delete_save_data(file_path) if pbConfirmMessageSerious( +# _INTL("Do you want to delete that save file? The game will exit afterwards either way.") +# ) +# exit +# end +# +# # nil deletes all, otherwise just the given file +# def delete_save_data(file_path=nil) +# begin +# SaveData.delete_file(file_path) +# pbMessage(_INTL("The save data was deleted.")) +# rescue SystemCallError +# pbMessage(_INTL("The save data could not be deleted.")) +# end +# end +# +# def pbStartLoadScreen +# copyKeybindings() +# save_file_list = SaveData::AUTO_SLOTS + SaveData::MANUAL_SLOTS +# first_time = true +# loop do # Outer loop is used for switching save files +# if @selected_file +# @save_data = load_save_file(SaveData.get_full_path(@selected_file)) +# else +# @save_data = {} +# end +# commands = [] +# cmd_continue = -1 +# cmd_new_game = -1 +# cmd_options = -1 +# cmd_language = -1 +# cmd_mystery_gift = -1 +# cmd_debug = -1 +# cmd_quit = -1 +# show_continue = !@save_data.empty? +# new_game_plus = show_continue && (@save_data[:player].new_game_plus_unlocked || $DEBUG) +# +# if show_continue +# commands[cmd_continue = commands.length] = "#{@selected_file}" +# if @save_data[:player].mystery_gift_unlocked +# commands[cmd_mystery_gift = commands.length] = _INTL('Mystery Gift') # Honestly I have no idea how to make Mystery Gift work well with this. +# end +# end +# +# commands[cmd_new_game = commands.length] = _INTL('New Game') +# if new_game_plus +# commands[cmd_new_game_plus = commands.length] = _INTL('New Game +') +# end +# commands[cmd_options = commands.length] = _INTL('Options') +# commands[cmd_language = commands.length] = _INTL('Language') if Settings::LANGUAGES.length >= 2 +# commands[cmd_debug = commands.length] = _INTL('Debug') if $DEBUG +# commands[cmd_quit = commands.length] = _INTL('Quit Game') +# cmd_left = -3 +# cmd_right = -2 +# +# map_id = show_continue ? @save_data[:map_factory].map.map_id : 0 +# @scene.pbStartScene(commands, show_continue, @save_data[:player], +# @save_data[:frame_count] || 0, map_id) +# @scene.pbSetParty(@save_data[:player]) if show_continue +# if first_time +# @scene.pbStartScene2 +# first_time = false +# else +# @scene.pbUpdate +# end +# +# loop do # Inner loop is used for going to other menus and back and stuff (vanilla) +# command = @scene.pbChoose(commands, cmd_continue) +# pbPlayDecisionSE if command != cmd_quit +# +# case command +# when cmd_continue +# @scene.pbEndScene +# Game.load(@save_data) +# return +# when cmd_new_game +# @scene.pbEndScene +# Game.start_new +# return +# when cmd_new_game_plus +# @scene.pbEndScene +# Game.start_new(@save_data[:bag],@save_data[:storage_system],@save_data[:player]) +# @save_data[:player].new_game_plus_unlocked=true +# return +# when cmd_mystery_gift +# pbFadeOutIn { pbDownloadMysteryGift(@save_data[:player]) } +# when cmd_options +# pbFadeOutIn do +# scene = PokemonOption_Scene.new +# screen = PokemonOptionScreen.new(scene) +# screen.pbStartScreen(true) +# end +# when cmd_language +# @scene.pbEndScene +# $PokemonSystem.language = pbChooseLanguage +# pbLoadMessages('Data/' + Settings::LANGUAGES[$PokemonSystem.language][1]) +# if show_continue +# @save_data[:pokemon_system] = $PokemonSystem +# File.open(SaveData.get_full_path(@selected_file), 'wb') { |file| Marshal.dump(@save_data, file) } +# end +# $scene = pbCallTitle +# return +# when cmd_debug +# pbFadeOutIn { pbDebugMenu(false) } +# when cmd_quit +# pbPlayCloseMenuSE +# @scene.pbEndScene +# $scene = nil +# return +# when cmd_left +# @scene.pbCloseScene +# @selected_file = SaveData.get_prev_slot(save_file_list, @selected_file) +# break # to outer loop +# when cmd_right +# @scene.pbCloseScene +# @selected_file = SaveData.get_next_slot(save_file_list, @selected_file) +# break # to outer loop +# else +# pbPlayBuzzerSE +# end +# end +# end +# end +# end +# +# #=============================================================================== +# # +# #=============================================================================== +# class PokemonSave_Scene +# def pbUpdateSlotInfo(slottext) +# pbDisposeSprite(@sprites, "slotinfo") +# @sprites["slotinfo"]=Window_AdvancedTextPokemon.new(slottext) +# @sprites["slotinfo"].viewport=@viewport +# @sprites["slotinfo"].x=0 +# @sprites["slotinfo"].y=160 +# @sprites["slotinfo"].width=228 if @sprites["slotinfo"].width<228 +# @sprites["slotinfo"].visible=true +# end +# end +# +# #=============================================================================== +# # +# #=============================================================================== +# class PokemonSaveScreen +# def doSave(slot) +# if Game.save(slot) +# pbMessage(_INTL("\\se[]{1} saved the game.\\me[GUI save game]\\wtnp[30]", $Trainer.name)) +# return true +# else +# pbMessage(_INTL("\\se[]Save failed.\\wtnp[30]")) +# return false +# end +# end +# +# # Return true if pause menu should close after this is done (if the game was saved successfully) +# def pbSaveScreen +# ret = false +# @scene.pbStartScreen +# if !$Trainer.save_slot +# # New Game - must select slot +# ret = slotSelect +# else +# choices = [ +# _INTL("Save to #{$Trainer.save_slot}"), +# _INTL("Save to another slot"), +# _INTL("Don't save") +# ] +# opt = pbMessage(_INTL('Would you like to save the game?'),choices,3) +# if opt == 0 +# pbSEPlay('GUI save choice') +# ret = doSave($Trainer.save_slot) +# elsif opt == 1 +# pbPlayDecisionSE +# ret = slotSelect +# else +# pbPlayCancelSE +# end +# end +# @scene.pbEndScreen +# return ret +# end +# +# # Call this to open the slot select screen +# # Returns true if the game was saved, otherwise false +# def slotSelect +# ret = false +# choices = SaveData::MANUAL_SLOTS +# choice_info = SaveData::MANUAL_SLOTS.map { |s| getSaveInfoBoxContents(s) } +# index = slotSelectCommands(choices, choice_info) +# if index >= 0 +# slot = SaveData::MANUAL_SLOTS[index] +# # Confirm if slot not empty +# if !File.file?(SaveData.get_full_path(slot)) || +# pbConfirmMessageSerious(_INTL("Are you sure you want to overwrite the save in #{slot}?")) # If the slot names were changed this grammar might need adjustment. +# pbSEPlay('GUI save choice') +# ret = doSave(slot) +# end +# end +# pbPlayCloseMenuSE if !ret +# return ret +# end +# +# # Handles the UI for the save slot select screen. Returns the index of the chosen slot, or -1. +# # Based on pbShowCommands +# def slotSelectCommands(choices, choice_info, defaultCmd=0) +# msgwindow = Window_AdvancedTextPokemon.new(_INTL("Which slot to save in?")) +# msgwindow.z = 99999 +# msgwindow.visible = true +# msgwindow.letterbyletter = true +# msgwindow.back_opacity = MessageConfig::WINDOW_OPACITY +# pbBottomLeftLines(msgwindow, 2) +# $game_temp.message_window_showing = true if $game_temp +# msgwindow.setSkin(MessageConfig.pbGetSpeechFrame) +# +# cmdwindow = Window_CommandPokemonEx.new(choices) +# cmdwindow.z = 99999 +# cmdwindow.visible = true +# cmdwindow.resizeToFit(cmdwindow.commands) +# pbPositionNearMsgWindow(cmdwindow,msgwindow,:right) +# cmdwindow.index=defaultCmd +# command=0 +# loop do +# @scene.pbUpdateSlotInfo(choice_info[cmdwindow.index]) +# Graphics.update +# Input.update +# cmdwindow.update +# msgwindow.update if msgwindow +# if Input.trigger?(Input::BACK) +# command = -1 +# break +# end +# if Input.trigger?(Input::USE) +# command = cmdwindow.index +# break +# end +# pbUpdateSceneMap +# end +# ret = command +# cmdwindow.dispose +# msgwindow.dispose +# $game_temp.message_window_showing = false if $game_temp +# Input.update +# return ret +# end +# +# # Show the player some data about their currently selected save slot for quick identification +# # This doesn't use player gender for coloring, unlike the default save window +# def getSaveInfoBoxContents(slot) +# full_path = SaveData.get_full_path(slot) +# if !File.file?(full_path) +# return _INTL("(empty)") +# end +# temp_save_data = SaveData.read_from_file(full_path) +# +# # Last save time +# time = temp_save_data[:player].last_time_saved +# if time +# date_str = time.strftime("%x") +# time_str = time.strftime(_INTL("%I:%M%p")) +# datetime_str = "#{date_str}#{time_str}
" +# else +# datetime_str = _INTL("(old save)") +# end +# +# # Map name +# map_str = pbGetMapNameFromId(temp_save_data[:map_factory].map.map_id) +# +# # Elapsed time +# totalsec = (temp_save_data[:frame_count] || 0) / Graphics.frame_rate +# hour = totalsec / 60 / 60 +# min = totalsec / 60 % 60 +# if hour > 0 +# elapsed_str = _INTL("Time{1}h {2}m
", hour, min) +# else +# elapsed_str = _INTL("Time{1}m
", min) +# end +# +# return "#{datetime_str}"+ # blue +# "#{map_str}"+ # green +# "#{elapsed_str}" +# end +# end +# +# #=============================================================================== +# # +# #=============================================================================== +# module Game +# # Fix New Game bug (if you saved during an event script) +# # This fix is from Essentials v20.1 Hotfixes 1.0.5 +# def self.start_new(ngp_bag = nil, ngp_storage = nil, ngp_trainer = nil) +# if $game_map && $game_map.events +# $game_map.events.each_value { |event| event.clear_starting } +# end +# $game_temp.common_event_id = 0 if $game_temp +# $PokemonTemp.begunNewGame = true +# pbMapInterpreter&.clear +# pbMapInterpreter&.setup(nil, 0, 0) +# $scene = Scene_Map.new +# SaveData.load_new_game_values +# $MapFactory = PokemonMapFactory.new($data_system.start_map_id) +# $game_player.moveto($data_system.start_x, $data_system.start_y) +# $game_player.refresh +# $PokemonEncounters = PokemonEncounters.new +# $PokemonEncounters.setup($game_map.map_id) +# $game_map.autoplay +# $game_map.update +# # +# # if ngp_bag != nil +# # $PokemonBag = ngp_clean_item_data(ngp_bag) +# # end +# if ngp_storage != nil +# $PokemonStorage = ngp_clean_pc_data(ngp_storage, ngp_trainer.party) +# end +# end +# +# # Loads bootup data from save file (if it exists) or creates bootup data (if +# # it doesn't). +# def self.set_up_system +# SaveData.move_old_windows_save if System.platform[/Windows/] +# save_slot = SaveData.get_newest_save_slot +# if save_slot +# save_data = SaveData.read_from_file(SaveData.get_full_path(save_slot)) +# else +# save_data = {} +# end +# if save_data.empty? +# SaveData.initialize_bootup_values +# else +# SaveData.load_bootup_values(save_data) +# end +# # Set resize factor +# pbSetResizeFactor([$PokemonSystem.screensize, 4].min) +# # Set language (and choose language if there is no save file) +# if Settings::LANGUAGES.length >= 2 +# $PokemonSystem.language = pbChooseLanguage if save_data.empty? +# pbLoadMessages('Data/' + Settings::LANGUAGES[$PokemonSystem.language][1]) +# end +# end +# +# # Saves the game. Returns whether the operation was successful. +# # @param save_file [String] the save file path +# # @param safe [Boolean] whether $PokemonGlobal.safesave should be set to true +# # @return [Boolean] whether the operation was successful +# # @raise [SaveData::InvalidValueError] if an invalid value is being saved +# def self.save(slot=nil, auto=false, safe: false) +# slot = $Trainer.save_slot if slot.nil? +# return false if slot.nil? +# +# file_path = SaveData.get_full_path(slot) +# $PokemonGlobal.safesave = safe +# $game_system.save_count += 1 +# $game_system.magic_number = $data_system.magic_number +# $Trainer.save_slot = slot unless auto +# $Trainer.last_time_saved = Time.now +# begin +# SaveData.save_to_file(file_path) +# Graphics.frame_reset +# rescue IOError, SystemCallError +# $game_system.save_count -= 1 +# return false +# end +# return true +# end +# +# # Overwrites the first empty autosave slot, otherwise the oldest existing autosave +# def self.auto_save +# oldest_time = nil +# oldest_slot = nil +# SaveData::AUTO_SLOTS.each do |slot| +# full_path = SaveData.get_full_path(slot) +# if !File.file?(full_path) +# oldest_slot = slot +# break +# end +# temp_save_data = SaveData.read_from_file(full_path) +# save_time = temp_save_data[:player].last_time_saved || Time.at(1) +# if oldest_time.nil? || save_time < oldest_time +# oldest_time = save_time +# oldest_slot = slot +# end +# end +# self.save(oldest_slot, true) +# end +# end +# +# #=============================================================================== +# # +# #=============================================================================== +# +# # Lol who needs the FileUtils gem? +# # This is the implementation from the original pbEmergencySave. +# def file_copy(src, dst) +# File.open(src, 'rb') do |r| +# File.open(dst, 'wb') do |w| +# while s = r.read(4096) +# w.write s +# end +# end +# end +# end +# +# # When I needed extra data fields in the save file I put them in Player because it seemed easier than figuring out +# # how to make a save file conversion, and I prefer to maintain backwards compatibility. +# class Player +# attr_accessor :last_time_saved +# attr_accessor :save_slot +# attr_accessor :autosave_steps +# end +# +# def pbEmergencySave +# oldscene = $scene +# $scene = nil +# pbMessage(_INTL("The script is taking too long. The game will restart.")) +# return if !$Trainer +# return if !$Trainer.save_slot +# current_file = SaveData.get_full_path($Trainer.save_slot) +# backup_file = SaveData.get_backup_file_path +# file_copy(current_file, backup_file) +# if Game.save +# pbMessage(_INTL("\\se[]The game was saved.\\me[GUI save game] The previous save file has been backed up.\\wtnp[30]")) +# else +# pbMessage(_INTL("\\se[]Save failed.\\wtnp[30]")) +# end +# $scene = oldscene +# end diff --git a/Data/System.rxdata b/Data/System.rxdata index 007975284..64487ec11 100644 Binary files a/Data/System.rxdata and b/Data/System.rxdata differ diff --git a/Data/Tilesets.rxdata b/Data/Tilesets.rxdata index c1c53755c..a11138c6c 100644 Binary files a/Data/Tilesets.rxdata and b/Data/Tilesets.rxdata differ