Files
LonaRPG-Online-Games/ModScripts/100007_CloudOnlySave.rb
T

1071 lines
34 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# 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