# encoding: UTF-8 return if defined?($mp_cloud_only_save_loaded) && $mp_cloud_only_save_loaded $mp_cloud_only_save_loaded = true # Online save/load policy: # - no local SaveXX.rvdata2 writes # - no local SaveXX.rvdata2 loads # - cloud snapshots are sent to the Java server via sync_state:...:reason=cloud_* module MPCloudOnlySave MIN_DELAY_FR = 20 ACK_WAIT_FR = 90 MAX_WAIT_FR = 1800 NEW_OVERMAP_RETRY_FRAMES = 120 NEW_OVERMAP_MAX_FAILURES = 4 NEW_OVERMAP_FALLBACK_MAP_ID = 2 NEW_OVERMAP_FALLBACK_X = 32 NEW_OVERMAP_FALLBACK_Y = 96 @pending = false @delay = 0 @waited = 0 @reason = "cloud_manual" @last_map_id = 0 @last_ack = "" @waiting_ack = false @ack_reason = "" @ack_wait = 0 module_function def enabled? true end def log(tag, message) if defined?(MPStateInfra) && MPStateInfra.respond_to?(:log_line) MPStateInfra.log_line("cloud_save_#{tag}", message.to_s) end rescue end def sanitize_reason(reason) text = reason.to_s.strip.downcase text = "cloud_manual" if text.empty? text = text.gsub(/[^a-z0-9_]+/, "_") text = "cloud_#{text}" unless text.start_with?("cloud_") text[0, 48] rescue "cloud_manual" end def connected? defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected? rescue false end def arena_active? defined?(MP_ArenaFlag) && MP_ArenaFlag.respond_to?(:arena_active?) && MP_ArenaFlag.arena_active? rescue false end def scene_ready? return false unless defined?($game_map) && $game_map return false unless defined?($game_player) && $game_player return false unless defined?($game_party) && $game_party return false unless defined?($game_system) && $game_system if defined?(SceneManager) && defined?(Scene_Map) begin current_scene = SceneManager.scene return false if current_scene.nil? if defined?(Scene_MapTitle) && current_scene.is_a?(Scene_MapTitle) return false end map_scene = current_scene.is_a?(Scene_Map) rescue false map_backed = $game_map && $game_player && $game_party && $game_system return false unless map_scene || map_backed rescue end end begin return false if $game_player.respond_to?(:transfer?) && $game_player.transfer? rescue end events = ($game_map.instance_variable_get(:@events) rescue nil) common_events = ($game_map.instance_variable_get(:@common_events) rescue nil) events.is_a?(Hash) && common_events.is_a?(Array) rescue false end def sync_allowed?(reason) unless connected? log("blocked", "#{sanitize_reason(reason)} not_connected") return false end if arena_active? log("blocked", "#{sanitize_reason(reason)} arena_active") return false end if defined?(MPStateInfra) begin if MPStateInfra.respond_to?(:suppress_sync?) && MPStateInfra.suppress_sync? log("blocked", "#{sanitize_reason(reason)} suppress_sync") return false end rescue end begin if MPStateInfra.respond_to?(:live_sync_allowed?) && !MPStateInfra.live_sync_allowed?(reason) unlocked = (defined?(WebSocket) && WebSocket.respond_to?(:bootstrap_sync_unlocked?) ? WebSocket.bootstrap_sync_unlocked? : nil) rescue nil log("blocked", "#{sanitize_reason(reason)} live_sync_not_allowed unlocked=#{unlocked.inspect}") return false end rescue end end if waiting_for_server_cloud? log("blocked", "#{sanitize_reason(reason)} waiting_server_bootstrap") return false end true rescue false end def request(reason="cloud_map_enter", delay=MIN_DELAY_FR) @pending = true @delay = [delay.to_i, 0].max @waited = 0 @reason = sanitize_reason(reason) @waiting_ack = false @ack_reason = "" @ack_wait = 0 log("request", "#{@reason} delay=#{@delay}") true rescue false end def pending? !!@pending rescue false end def packet_player_blob(packet) parts = packet.to_s.split(":", 14) return "" if parts.size < 13 parts[12].to_s rescue "" end def log_cloud_packet(reason, packet) clean = sanitize_reason(reason) blob = packet_player_blob(packet) if blob.to_s.empty? log("player_blob", "#{clean} empty") return end msg = "#{clean} len=#{blob.length}" begin if defined?(WebSocket) && WebSocket.respond_to?(:bootstrap_decode_json_blob) parsed = WebSocket.bootstrap_decode_json_blob(blob) if parsed.is_a?(Hash) roster = parsed["slot_RosterArray"] roster_len = roster.respond_to?(:length) ? roster.length : 0 msg += " keys=#{parsed.keys.length}" msg += " map=#{parsed['map_id'].inspect} x=#{parsed['x'].inspect} y=#{parsed['y'].inspect}" msg += " roster_len=#{roster_len} roster_cur=#{parsed['slot_RosterCurrent'].inspect}" msg += " h0=#{parsed['slot_hotkey_0'].inspect} h1=#{parsed['slot_hotkey_1'].inspect} h2=#{parsed['slot_hotkey_2'].inspect} h3=#{parsed['slot_hotkey_3'].inspect} h4=#{parsed['slot_hotkey_4'].inspect}" else msg += " decoded=nil" end end rescue => e msg += " decode_error=#{e.class}" end log("player_blob", msg) rescue end def cloud_packet(reason) return nil unless defined?(WebSocket) return nil unless WebSocket.respond_to?(:_live_sync_build_packet) built = WebSocket._live_sync_build_packet rescue nil return nil unless built && built[0] packet = built[0].to_s return nil if packet.empty? log_cloud_packet(reason, packet) packet.include?(":reason=") ? packet : "#{packet}:reason=#{sanitize_reason(reason)}" rescue nil end def send_current_map return false unless defined?(WebSocket) && WebSocket.respond_to?(:send_line) return false unless defined?($game_map) && $game_map map_id = $game_map.map_id.to_i rescue 0 return false if map_id <= 0 line = WebSocket.respond_to?(:map_packet_for_server) ? WebSocket.map_packet_for_server(map_id) : "map:#{map_id}" WebSocket.send_line(line) @last_map_id = map_id true rescue false end def send_current_position return false unless defined?(WebSocket) if WebSocket.respond_to?(:live_sync_position_now) return !!WebSocket.live_sync_position_now("cloud_save", true) end return false unless WebSocket.respond_to?(:send_line) return false unless defined?($game_player) && $game_player movement = ($game_player.movement.to_s rescue "") pos = "#{$game_player.x}:#{$game_player.y}:#{$game_player.direction}" pos += ":#{movement}" unless movement.empty? WebSocket.send_line("pos:#{pos}") true rescue false end def send_now(reason="cloud_manual", force_position=true) reason = sanitize_reason(reason) return false unless sync_allowed?(reason) unless scene_ready? log("blocked", "#{reason} scene_not_ready") return false end begin MPStateInfra.ensure_character_uuid if defined?(MPStateInfra) && MPStateInfra.respond_to?(:ensure_character_uuid) rescue end send_current_map send_current_position if force_position packet = cloud_packet(reason) if packet.nil? || packet.empty? log("blocked", "#{reason} empty_packet") return false end res = WebSocket.send_line(packet) ok = !res.nil? && res.to_i >= 0 packet_size = begin packet.bytesize rescue begin packet.size rescue 0 end end log(ok ? "sent" : "send_failed", "#{reason} bytes=#{packet_size} result=#{res.inspect}") if ok && defined?(WebSocket) now = Time.now.to_f rescue 0.0 begin WebSocket.instance_variable_set(:@live_sync_last_sig, packet) WebSocket.instance_variable_set(:@live_sync_last_at, now) WebSocket.instance_variable_set(:@live_sync_last_force_at, now) WebSocket.instance_variable_set(:@live_sync_last_probe_at, now) rescue end begin if defined?(MPImmediateLiveSync) && MPImmediateLiveSync.respond_to?(:clear_deferred_if_map_sync) MPImmediateLiveSync.clear_deferred_if_map_sync(reason) end rescue end end ok rescue false end def send_tracked_now(reason="cloud_manual", force_position=true) reason = sanitize_reason(reason) @last_ack = "" ok = send_now(reason, force_position) if ok @pending = false @waiting_ack = true @ack_reason = reason @ack_wait = 0 else log("tracked_failed", reason) end ok rescue log("exception", "#{reason} send_tracked_now") false end def update if @waiting_ack if @last_ack.to_s == @ack_reason.to_s @waiting_ack = false @pending = false @waited = 0 return end @ack_wait += 1 return if @ack_wait < ACK_WAIT_FR @waited += ACK_WAIT_FR if @waited >= MAX_WAIT_FR @waiting_ack = false @pending = false @ack_wait = 0 log("ack_timeout", @ack_reason) return end @waiting_ack = false @pending = true @delay = MIN_DELAY_FR log("retry", @ack_reason) end return unless @pending if @delay.to_i > 0 @delay -= 1 return end unless scene_ready? && sync_allowed?(@reason) @waited += 1 if @waited >= MAX_WAIT_FR log("give_up", @reason) @pending = false end return end send_tracked_now(@reason, true) rescue log("exception", "update") @pending = false @waiting_ack = false end def mark_ack(reason) clean = sanitize_reason(reason) @last_ack = clean log("ack", clean) if @waiting_ack && @ack_reason.to_s == clean @waiting_ack = false @pending = false @waited = 0 @ack_wait = 0 end rescue end def last_ack @last_ack rescue "" end def progress_available? defined?(MPGameLoadProgress) && MPGameLoadProgress.respond_to?(:begin_load) && MPGameLoadProgress.respond_to?(:update) rescue false end def progress_begin(label) return false unless progress_available? unless MPGameLoadProgress.respond_to?(:active?) && MPGameLoadProgress.active? MPGameLoadProgress.begin_load(label) end true rescue false end def progress_update(progress, label=nil) return false unless progress_available? progress_begin(label || "Загрузка данных с сервера...") MPGameLoadProgress.update(progress, label) true rescue false end def progress_finish(label) return false unless defined?(MPGameLoadProgress) && MPGameLoadProgress.respond_to?(:finish) MPGameLoadProgress.finish(label) true rescue begin MPGameLoadProgress.dispose if defined?(MPGameLoadProgress) && MPGameLoadProgress.respond_to?(:dispose) rescue end false end def progress_fail(label) return false unless defined?(MPGameLoadProgress) && MPGameLoadProgress.respond_to?(:fail) MPGameLoadProgress.fail(label) true rescue begin MPGameLoadProgress.dispose if defined?(MPGameLoadProgress) && MPGameLoadProgress.respond_to?(:dispose) rescue end false end def bootstrap_mode return "" unless defined?(WebSocket) begin return WebSocket.instance_variable_get(:@bootstrap_mode).to_s rescue "" end end def cloud_bootstrap_state return nil unless defined?(WebSocket) begin return WebSocket.bootstrap_peek_state if WebSocket.respond_to?(:bootstrap_peek_state) rescue end begin return WebSocket.instance_variable_get(:@bootstrap_state_pending) rescue nil end end def new_overmap_server_state?(state=nil) state = cloud_bootstrap_state if state.nil? return false unless state.is_a?(Hash) map_id = state["map_id"].to_i x = state["x"].nil? ? -1 : state["x"].to_i y = state["y"].nil? ? -1 : state["y"].to_i map_id > 0 && x >= 0 && y >= 0 rescue false end def retry_new_overmap_from_server(failure_number) return false unless bootstrap_mode == "new" return true if new_overmap_server_state? return false unless defined?(WebSocket) && WebSocket.respond_to?(:send_my_nickname) WebSocket.send_my_nickname(true) log("new_overmap_retry", "failure=#{failure_number.to_i}/#{NEW_OVERMAP_MAX_FAILURES}") true rescue false end def queue_new_overmap_fallback return false unless bootstrap_mode == "new" return true if new_overmap_server_state? return false unless defined?(WebSocket) && WebSocket.respond_to?(:queue_bootstrap_state) state = { "map_id" => NEW_OVERMAP_FALLBACK_MAP_ID, "x" => NEW_OVERMAP_FALLBACK_X, "y" => NEW_OVERMAP_FALLBACK_Y, "direction" => 2, "server_spawn_only" => true, "overmap_fallback" => true } WebSocket.queue_bootstrap_state(state) log("new_overmap_fallback", "failures=#{NEW_OVERMAP_MAX_FAILURES} map=#{NEW_OVERMAP_FALLBACK_MAP_ID} x=#{NEW_OVERMAP_FALLBACK_X} y=#{NEW_OVERMAP_FALLBACK_Y}") true rescue false end def bootstrap_applied? return false unless defined?(WebSocket) begin return !!WebSocket.instance_variable_get(:@bootstrap_applied) rescue false end end def server_bootstrap_ready? mode = bootstrap_mode state = cloud_bootstrap_state if mode == "new" return false unless state.is_a?(Hash) if defined?(MPStateInfra) && MPStateInfra.respond_to?(:server_spawn_payload?) return true if MPStateInfra.server_spawn_payload?(state) end return true unless state["map_id"].to_i <= 0 || state["x"].to_i < 0 || state["y"].to_i < 0 end if state.is_a?(Hash) if defined?(MPStateInfra) && MPStateInfra.respond_to?(:bootstrap_valid_for_blank_restore?) return !!MPStateInfra.bootstrap_valid_for_blank_restore?(state) end return true end false rescue false end def waiting_for_server_cloud? mode = bootstrap_mode return !bootstrap_applied? if mode == "new" return false if bootstrap_applied? return true if mode == "" return true if mode == "load" false rescue false end def setup_blank_cloud_base(tag="cloud_only_base") return false unless defined?(DataManager) && DataManager.respond_to?(:setup_new_game) progress_update(0.58, "Подготовка игры под данные сервера...") if defined?(MPStateInfra) && MPStateInfra.respond_to?(:with_sync_suppressed) MPStateInfra.with_sync_suppressed(tag) { DataManager.setup_new_game } else DataManager.setup_new_game end progress_update(0.68, "Временная основа готова...") true rescue false end def prepare_cloud_load_base state = cloud_bootstrap_state mode = bootstrap_mode if mode == "load" unless state.is_a?(Hash) MPStateInfra.log_line("cloud_restore_wait", "server bootstrap_state is not ready") rescue nil return false end if defined?(MPStateInfra) && MPStateInfra.respond_to?(:bootstrap_valid_for_blank_restore?) return false unless MPStateInfra.bootstrap_valid_for_blank_restore?(state) MPStateInfra.log_line("cloud_restore", "server bootstrap is ready; creating temporary base") rescue nil end return setup_blank_cloud_base("cloud_only_restore_after_server") elsif state.is_a?(Hash) if defined?(MPStateInfra) && MPStateInfra.respond_to?(:bootstrap_valid_for_blank_restore?) return false unless MPStateInfra.bootstrap_valid_for_blank_restore?(state) MPStateInfra.log_line("cloud_restore", "server bootstrap is ready; creating temporary base") rescue nil end return setup_blank_cloud_base("cloud_only_restore_after_server") elsif mode == "new" MPStateInfra.log_line("cloud_restore", "server requested new cloud character") rescue nil return setup_blank_cloud_base("cloud_only_new_after_server") end MPStateInfra.log_line("cloud_restore_wait", "waiting bootstrap_mode from server") rescue nil false rescue => e MPStateInfra.log_line("cloud_restore_failed", "#{e.class}: #{e.message}") rescue nil false end end if defined?(WebSocket) module WebSocket class << self if method_defined?(:parse) && !method_defined?(:mp_cloud_only_parse_without_ack) alias mp_cloud_only_parse_without_ack parse def parse(msg) if msg.to_s =~ /^cloud_save_ok:(.*)$/ MPCloudOnlySave.mark_ack($1) if defined?(MPCloudOnlySave) return end mp_cloud_only_parse_without_ack(msg) end end if method_defined?(:apply_bootstrap_state) && !method_defined?(:mp_cloud_only_apply_bootstrap_without_ack) alias mp_cloud_only_apply_bootstrap_without_ack apply_bootstrap_state def apply_bootstrap_state(state) ok = mp_cloud_only_apply_bootstrap_without_ack(state) if ok begin @bootstrap_applied = true _bootstrap_send_loaded_ack if respond_to?(:_bootstrap_send_loaded_ack) rescue end end ok end end def cloud_save_now(reason="cloud_manual") return false unless defined?(MPCloudOnlySave) MPCloudOnlySave.send_tracked_now(reason, true) rescue false end if method_defined?(:update) && !method_defined?(:mp_cloud_only_update_without_cloud_tick) alias mp_cloud_only_update_without_cloud_tick update def update(*args, &block) result = mp_cloud_only_update_without_cloud_tick(*args, &block) MPCloudOnlySave.update if defined?(MPCloudOnlySave) result end end if method_defined?(:disconnect) && !method_defined?(:mp_cloud_only_disconnect_without_cloud_save) alias mp_cloud_only_disconnect_without_cloud_save disconnect def disconnect(*args, &block) begin MPCloudOnlySave.send_now("cloud_disconnect", true) if defined?(MPCloudOnlySave) rescue end mp_cloud_only_disconnect_without_cloud_save(*args, &block) end end end end end if defined?(Scene_OnlineAutoLoad) class Scene_OnlineAutoLoad unless method_defined?(:mp_cloud_only_update_without_server_wait) alias mp_cloud_only_update_without_server_wait update end unless method_defined?(:mp_cloud_only_load_first_slot_without_cloud) alias mp_cloud_only_load_first_slot_without_cloud load_first_slot end def update(*args, &block) unless defined?(MPCloudOnlySave) && MPCloudOnlySave.enabled? return mp_cloud_only_update_without_server_wait(*args, &block) end begin super(*args, &block) rescue end return if @mp_server_select_autoload_done @mp_cloud_only_bootstrap_wait ||= 0 @mp_cloud_only_bootstrap_wait += 1 @mp_cloud_only_new_mode_wait ||= 0 @mp_cloud_only_new_overmap_failures ||= 0 @mp_cloud_only_progress_started ||= false mode = MPCloudOnlySave.bootstrap_mode state = MPCloudOnlySave.cloud_bootstrap_state ready = MPCloudOnlySave.server_bootstrap_ready? if mode == "new" @mp_cloud_only_new_mode_wait += 1 if MPCloudOnlySave.new_overmap_server_state?(state) @mp_cloud_only_new_overmap_failures = 0 else next_failure_frame = (@mp_cloud_only_new_overmap_failures + 1) * MPCloudOnlySave::NEW_OVERMAP_RETRY_FRAMES if @mp_cloud_only_new_mode_wait >= next_failure_frame @mp_cloud_only_new_overmap_failures += 1 if @mp_cloud_only_new_overmap_failures >= MPCloudOnlySave::NEW_OVERMAP_MAX_FAILURES MPCloudOnlySave.queue_new_overmap_fallback else MPCloudOnlySave.retry_new_overmap_from_server(@mp_cloud_only_new_overmap_failures) end state = MPCloudOnlySave.cloud_bootstrap_state ready = MPCloudOnlySave.server_bootstrap_ready? end end ready = false if !state.is_a?(Hash) && @mp_cloud_only_new_mode_wait < 20 else @mp_cloud_only_new_mode_wait = 0 @mp_cloud_only_new_overmap_failures = 0 end wait_progress = 0.08 + [@mp_cloud_only_bootstrap_wait.to_f / 900.0, 1.0].min * 0.36 wait_label = if mode == "load" state.is_a?(Hash) ? "Проверка сохранения с сервера..." : "Получение сохранения с сервера..." elsif mode == "new" state.is_a?(Hash) ? "Получение стартовых данных с сервера..." : "Сервер готовит нового персонажа..." else "Ожидание ответа сервера..." end unless @mp_cloud_only_progress_started @mp_cloud_only_progress_started = true MPCloudOnlySave.progress_begin("Загрузка данных с сервера...") MPCloudOnlySave.progress_update(0.05, "Подключение к серверу...") end if @mp_cloud_only_bootstrap_wait == 1 || (@mp_cloud_only_bootstrap_wait % 15) == 0 || ready MPCloudOnlySave.progress_update(ready ? [wait_progress, 0.48].max : wait_progress, wait_label) end if @mp_cloud_only_bootstrap_wait == 1 begin notify_network("Waiting cloud save from server...") rescue end begin MPStateInfra.log_line("cloud_restore_wait", "strict wait started mode=#{mode.inspect}") if defined?(MPStateInfra) rescue end end unless ready if (@mp_cloud_only_bootstrap_wait % 300) == 0 begin notify_network("Waiting cloud save from server...") rescue end begin MPStateInfra.log_line("cloud_restore_wait", "mode=#{mode.inspect} frames=#{@mp_cloud_only_bootstrap_wait}") if defined?(MPStateInfra) rescue end end return end MPCloudOnlySave.progress_update(0.52, "Серверные данные получены...") unless load_first_slot begin notify_error("Cloud save is not ready.") rescue end MPCloudOnlySave.progress_fail("Не удалось подготовить игру.") begin MPStateInfra.log_line("cloud_restore_failed", "server ready but temporary base failed mode=#{mode.inspect}") if defined?(MPStateInfra) rescue end WebSocket.disconnect rescue nil @mp_server_select_autoload_done = true SceneManager.goto(Scene_MapTitle) return end bootstrap_state = nil begin if state.is_a?(Hash) && defined?(WebSocket) && WebSocket.respond_to?(:consume_bootstrap_state) bootstrap_state = WebSocket.consume_bootstrap_state end rescue bootstrap_state = nil end bootstrap_applied = false if bootstrap_state.is_a?(Hash) MPCloudOnlySave.progress_update(0.76, "Применение данных сервера...") begin bootstrap_applied = !!WebSocket.apply_bootstrap_state(bootstrap_state) if defined?(WebSocket) && WebSocket.respond_to?(:apply_bootstrap_state) rescue bootstrap_applied = false end unless bootstrap_applied begin notify_error("Cloud save apply failed.") rescue end MPCloudOnlySave.progress_fail("Ошибка применения данных сервера.") begin MPStateInfra.log_line("cloud_restore_failed", "apply_bootstrap_state returned false") if defined?(MPStateInfra) rescue end WebSocket.disconnect rescue nil @mp_server_select_autoload_done = true SceneManager.goto(Scene_MapTitle) return end elsif mode == "new" begin WebSocket._bootstrap_send_loaded_ack if defined?(WebSocket) && WebSocket.respond_to?(:_bootstrap_send_loaded_ack) rescue end MPCloudOnlySave.progress_update(0.76, "Новый облачный персонаж готов...") else begin notify_error("Cloud save is missing.") rescue end MPCloudOnlySave.progress_fail("Сервер не прислал сохранение.") begin MPStateInfra.log_line("cloud_restore_failed", "mode=#{mode.inspect} but bootstrap_state missing after wait") if defined?(MPStateInfra) rescue end WebSocket.disconnect rescue nil @mp_server_select_autoload_done = true SceneManager.goto(Scene_MapTitle) return end if bootstrap_applied begin MPCloudOnlySave.request("cloud_bootstrap_loaded", 1) rescue end begin if defined?(MP_ServerSyncSave) && MP_ServerSyncSave.respond_to?(:request_selected_slot_save) in_arena_mode = defined?(MP_ArenaFlag) && MP_ArenaFlag.respond_to?(:arena_active?) && MP_ArenaFlag.arena_active? MP_ServerSyncSave.request_selected_slot_save unless in_arena_mode end rescue end begin map_interpreter = nil if $game_map begin map_interpreter = $game_map.interpreter if $game_map.respond_to?(:interpreter) rescue map_interpreter = nil end if map_interpreter.nil? begin map_interpreter = $game_map.instance_variable_get(:@interpreter) rescue map_interpreter = nil end end end map_interpreter.clear if map_interpreter && map_interpreter.respond_to?(:clear) rescue end begin if $game_player $game_player.instance_variable_set(:@move_route_forcing, false) $game_player.instance_variable_set(:@wait_count, 0) end rescue end begin $game_temp.clear_common_event if $game_temp && $game_temp.respond_to?(:clear_common_event) rescue end elsif mode == "new" begin MPCloudOnlySave.request("cloud_new_character", MPCloudOnlySave::MIN_DELAY_FR) rescue end end MPCloudOnlySave.progress_update(0.90, "Подготовка карты...") begin if bootstrap_applied notify_success("Cloud save loaded.") else notify_success("New cloud character created.") end rescue end $game_system.on_after_load rescue nil $game_map.autoplay rescue nil $game_player.refresh rescue nil MPCloudOnlySave.progress_finish(bootstrap_applied ? "Данные сервера загружены." : "Новый облачный персонаж создан.") @mp_server_select_autoload_done = true SceneManager.goto(Scene_Map) end def load_first_slot if defined?(MPCloudOnlySave) && MPCloudOnlySave.enabled? return MPCloudOnlySave.prepare_cloud_load_base end mp_cloud_only_load_first_slot_without_cloud end end end if defined?(DataManager) module DataManager class << self if method_defined?(:save_game) && !method_defined?(:mp_cloud_only_save_game_without_cloud) alias mp_cloud_only_save_game_without_cloud save_game def save_game(index) return false unless defined?(MPCloudOnlySave) return false unless MPCloudOnlySave.connected? ok = MPCloudOnlySave.send_tracked_now("cloud_manual_save", true) MPCloudOnlySave.request("cloud_manual_save", 1) unless ok ok || MPCloudOnlySave.pending? end end if method_defined?(:save_custom_without_header) && !method_defined?(:mp_cloud_only_save_custom_without_cloud) alias mp_cloud_only_save_custom_without_cloud save_custom_without_header def save_custom_without_header(tmpName) return false unless defined?(MPCloudOnlySave) return false unless MPCloudOnlySave.connected? reason = "cloud_custom_#{tmpName}" ok = MPCloudOnlySave.send_tracked_now(reason, true) MPCloudOnlySave.request(reason, 1) unless ok ok || MPCloudOnlySave.pending? end end if method_defined?(:doomModeSave) && !method_defined?(:mp_cloud_only_doom_save_without_cloud) alias mp_cloud_only_doom_save_without_cloud doomModeSave def doomModeSave return false unless defined?(MPCloudOnlySave) return false unless MPCloudOnlySave.connected? ok = MPCloudOnlySave.send_tracked_now("cloud_doom", true) MPCloudOnlySave.request("cloud_doom", 1) unless ok ok || MPCloudOnlySave.pending? end end if method_defined?(:load_game) && !method_defined?(:mp_cloud_only_load_game_without_local_block) alias mp_cloud_only_load_game_without_local_block load_game def load_game(index) false end end if method_defined?(:load_game_without_rescue) && !method_defined?(:mp_cloud_only_load_without_rescue_without_local_block) alias mp_cloud_only_load_without_rescue_without_local_block load_game_without_rescue def load_game_without_rescue(index) false end end if method_defined?(:doomModeLoad) && !method_defined?(:mp_cloud_only_doom_load_without_local_block) alias mp_cloud_only_doom_load_without_local_block doomModeLoad def doomModeLoad false end end if method_defined?(:customModeLoad) && !method_defined?(:mp_cloud_only_custom_load_without_local_block) alias mp_cloud_only_custom_load_without_local_block customModeLoad def customModeLoad(tmpName) false end end if method_defined?(:load_doom_without_rescue) && !method_defined?(:mp_cloud_only_load_doom_without_local_block) alias mp_cloud_only_load_doom_without_local_block load_doom_without_rescue def load_doom_without_rescue false end end if method_defined?(:load_custom_without_rescue) && !method_defined?(:mp_cloud_only_load_custom_without_local_block) alias mp_cloud_only_load_custom_without_local_block load_custom_without_rescue def load_custom_without_rescue(tmpName) false end end if method_defined?(:load_header) && !method_defined?(:mp_cloud_only_load_header_without_local_block) alias mp_cloud_only_load_header_without_local_block load_header def load_header(index) nil end end if method_defined?(:load_header_without_rescue) && !method_defined?(:mp_cloud_only_load_header_raw_without_local_block) alias mp_cloud_only_load_header_raw_without_local_block load_header_without_rescue def load_header_without_rescue(index) nil end end if method_defined?(:saveFileExistsRGSS?) && !method_defined?(:mp_cloud_only_save_exists_without_local_block) alias mp_cloud_only_save_exists_without_local_block saveFileExistsRGSS? def saveFileExistsRGSS? false end end if method_defined?(:saveFileExistsRGSS_slot?) && !method_defined?(:mp_cloud_only_slot_exists_without_local_block) alias mp_cloud_only_slot_exists_without_local_block saveFileExistsRGSS_slot? def saveFileExistsRGSS_slot?(slot) false end end end end end if defined?(MP_AutoSave) module MP_AutoSave class << self unless method_defined?(:mp_cloud_only_do_save_without_cloud) alias mp_cloud_only_do_save_without_cloud do_save end def do_save return false unless defined?(MPCloudOnlySave) MPCloudOnlySave.send_tracked_now("cloud_map_enter", true) || MPCloudOnlySave.request("cloud_map_enter", 1) end end end end if defined?(MP_ServerSyncSave) module MP_ServerSyncSave class << self unless method_defined?(:mp_cloud_only_do_save_without_cloud) alias mp_cloud_only_do_save_without_cloud do_save end def do_save return false unless defined?(MPCloudOnlySave) MPCloudOnlySave.send_tracked_now("cloud_bootstrap", true) || MPCloudOnlySave.request("cloud_bootstrap", 1) end end end end if defined?(Scene_Map) class Scene_Map unless method_defined?(:mp_cloud_only_start_without_cloud_save) alias mp_cloud_only_start_without_cloud_save start end def start(*args, &block) result = mp_cloud_only_start_without_cloud_save(*args, &block) MPCloudOnlySave.request("cloud_map_enter", MPCloudOnlySave::MIN_DELAY_FR) if defined?(MPCloudOnlySave) result end unless method_defined?(:mp_cloud_only_update_without_cloud_save) alias mp_cloud_only_update_without_cloud_save update end def update(*args, &block) result = mp_cloud_only_update_without_cloud_save(*args, &block) MPCloudOnlySave.update if defined?(MPCloudOnlySave) result end end end if defined?(Game_Player) class Game_Player if method_defined?(:perform_transfer) && !method_defined?(:mp_cloud_only_perform_transfer_without_cloud_save) alias mp_cloud_only_perform_transfer_without_cloud_save perform_transfer def perform_transfer(*args) old_map = ($game_map ? $game_map.map_id.to_i : 0) rescue 0 result = mp_cloud_only_perform_transfer_without_cloud_save(*args) begin new_map = ($game_map ? $game_map.map_id.to_i : 0) rescue 0 if new_map > 0 && new_map != old_map MPCloudOnlySave.request("cloud_map_enter", MPCloudOnlySave::MIN_DELAY_FR) if defined?(MPCloudOnlySave) end rescue end result end end end end