1071 lines
34 KiB
Ruby
1071 lines
34 KiB
Ruby
# 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
|