Files
LonaRPG-Online-Games/ModScripts/multiplayer/14_autosave.rb
T
2026-10-29 21:59:06 +04:00

2114 lines
71 KiB
Ruby
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# encoding: UTF-8
#==============================================================================
# LonaRPG Multiplayer - 14_autosave.rb
# Unified durable cloud save
# Version: 2.7.1 (2026-10-07)
#------------------------------------------------------------------------------
# This file is the single owner of ONLINE SAVE WRITES.
# It intentionally does NOT change clan/slavery/server gameplay plugins.
#
# Save model (checkpoint-only, v2.7.1):
# * always save a FULL sync_state snapshot, never a partial skill-only save;
# * durable cloud writes happen only on checkpoints: map change, disconnect /
# title / reconnect flush, New Game / sync_unlocked, quest_commit, manual
# save, ClanEstate / bank / NoerHome / doom, and explicit slavery sync API;
# * continuous dirty_probe + per-field story/switch/inventory spam is ignored
# (no state_changed / event_* cloud packets) to avoid 1 Hz microfreezes;
# * body meters (arousal, lactation_level, dirt, mood, sat, …) are kept in
# trimmed stats and in a compact body fallback when the wire limit bites;
# * high-priority checkpoints bypass the min-send interval so map/exit flush
# is not delayed behind a recent prior send;
# * early TutorialOP snapshots are valid even when learned @skills is empty;
# * after Game_Interpreter#new_game_setup grants starter skills/hotkeys, save
# again immediately, so the later complete snapshot replaces the early one;
# * checkpoint jobs are coalesced and durably ACKed by OnlineSaveFix 1.1.0
# using reason=cloudv2_<seq>_<reason>;
# * while one snapshot waits for ACK, newer checkpoint jobs stay queued;
# * no Graphics.update is called from WebSocket.parse / ACK callbacks.
#==============================================================================
return if defined?($mp_save14_v250_loaded) && $mp_save14_v250_loaded
$mp_save14_v250_loaded = true
#==============================================================================
# Legacy runtime guards preserved from the previous 14_autosave.rb.
# They are unrelated to cloud persistence but removing them would reintroduce
# old startup/dynamic-event crashes that this file had already been shielding.
#==============================================================================
if defined?(Game_Player) && Game_Player.instance_methods.include?(:light_check)
class Game_Player
unless method_defined?(:mp_save14_light_check_original)
alias mp_save14_light_check_original light_check
def light_check(*args)
actor = (self.actor rescue nil)
return if actor.nil?
mp_save14_light_check_original(*args)
rescue
end
end
end
end
if defined?(Game_Map) && Game_Map.instance_methods.include?(:refresh)
class Game_Map
unless method_defined?(:mp_save14_refresh_original)
alias mp_save14_refresh_original refresh
def refresh(*args)
instance_variable_set(:@common_events, []) if (instance_variable_get(:@common_events) rescue nil).nil?
instance_variable_set(:@events, {}) if (instance_variable_get(:@events) rescue nil).nil?
mp_save14_refresh_original(*args)
rescue
@need_refresh = false rescue nil
end
end
end
end
if defined?(Game_Map) && Game_Map.instance_methods.include?(:reset_events)
class Game_Map
unless method_defined?(:mp_save14_reset_events_original)
alias mp_save14_reset_events_original reset_events
def reset_events(nap=true, reset_strong=true)
nap_refresh = []
(@events || {}).keys.each do |i|
event = (@events || {})[i]
next if event.nil?
if reset_strong
begin
if !event.foreign_event && event.reset_strong
map_ev = (@map && @map.events) ? @map.events[i] : nil
if map_ev
@events[i] = Game_Event.new(@map_id, map_ev)
next
end
event.foreign_event = true rescue nil
event.reset_strong = false rescue nil
end
rescue
end
end
begin
if event.foreign_event && ((!event.respond_to?(:nappable?)) || !event.nappable?)
@events.delete(i)
next
end
rescue
end
if nap
begin
if (event.respond_to?(:nappable?) && event.nappable?) || !event.foreign_event
event.nap_reset
nap_refresh << i
end
rescue
end
end
end
nap_refresh.each do |i|
ev = (@events || {})[i]
ev.nap_refresh if ev
rescue
end
rescue
mp_save14_reset_events_original(nap, reset_strong) rescue nil
end
end
end
end
#==============================================================================
# Arena policy - preserve the project's existing no-save-in-arena rule.
#==============================================================================
unless defined?(MP_ArenaFlag)
module MP_ArenaFlag
module_function
def arena_json_path
begin
return File.expand_path("../arena.json", __dir__)
rescue
end
begin
return File.join(Dir.pwd, "ModScripts", "arena.json")
rescue
end
File.join("ModScripts", "arena.json")
end
def arena_mode
begin
runtime = $mp_arena_runtime_flag
return runtime.to_i unless runtime.nil?
rescue
end
begin
path = arena_json_path
return 0 unless File.exist?(path)
txt = if defined?(Ruby310Compat) && Ruby310Compat.respond_to?(:read_text_file)
Ruby310Compat.read_text_file(path).to_s
else
File.binread(path).to_s
end
m = txt.match(/"arena"\s*:\s*(-?\d+)/)
return m[1].to_i if m
m = txt.match(/arena\s*[:=]\s*(-?\d+)/i)
return m[1].to_i if m
rescue
end
0
end
def arena_active?
arena_mode.to_i == 1
rescue
false
end
end
end
#==============================================================================
# Autosave HUD. It is shown only when a durable cloud packet was actually sent
# and hidden on ACK/error/timeout. No forced render from network callbacks.
#==============================================================================
module MP_AutosaveHUD
module_function
@vp = nil
@owned_vp = nil
@owns_viewport = false
@spr = nil
@bmp = nil
def map_scene?
return false unless defined?(SceneManager) && defined?(Scene_Map)
return false unless SceneManager.respond_to?(:scene_is?)
SceneManager.scene_is?(Scene_Map)
rescue
false
end
def load_bitmap
begin
return Bitmap.new("Graphics/Online/autosave")
rescue
end
begin
return Bitmap.new("Graphics/Online/autosave.png")
rescue
end
nil
end
def fps_overlay
return nil unless defined?(LonaFPSDisplay) && LonaFPSDisplay.respond_to?(:overlay_viewport)
vp = LonaFPSDisplay.overlay_viewport
return nil if vp.nil? || vp.disposed?
vp
rescue
nil
end
def fallback_viewport
if @owned_vp && !@owned_vp.disposed?
return @owned_vp
end
@owned_vp = Viewport.new(0, 0, Graphics.width, Graphics.height)
@owned_vp.z = 200_000
@owns_viewport = true
@owned_vp
rescue
nil
end
def release_owned_viewport(except)
return unless @owns_viewport && @owned_vp
return if except && @owned_vp.equal?(except)
begin
@owned_vp.dispose if !@owned_vp.disposed?
rescue
end
@owned_vp = nil
@owns_viewport = false
end
def detach_sprite
return if @spr.nil?
begin
if !@spr.disposed?
@spr.bitmap = nil rescue nil
@spr.dispose
end
rescue
end
@spr = nil
end
def ensure_hud
return false unless map_scene?
vp = fps_overlay || fallback_viewport
return false if vp.nil? || vp.disposed?
if @spr && !@spr.disposed? && @spr.viewport.equal?(vp)
@vp = vp
return true
end
detach_sprite
release_owned_viewport(vp)
@vp = vp
@owns_viewport = @owned_vp && @owned_vp.equal?(vp)
@bmp = load_bitmap if @bmp.nil? || @bmp.disposed?
return false if @bmp.nil? || @bmp.disposed?
@spr = Sprite.new(vp)
@spr.bitmap = @bmp
@spr.z = 10
@spr.ox = (@bmp.width / 2) rescue 0
@spr.oy = 0
@spr.visible = false
update_position
true
rescue
detach_sprite
false
end
def update_position
return unless @spr && !@spr.disposed?
@spr.x = (Graphics.width / 2) rescue 0
@spr.y = 6
rescue
end
def show
@want_visible = true
return false unless ensure_hud
update_position
@spr.visible = true if @spr && !@spr.disposed?
true
rescue
false
end
def hide
@want_visible = false
@spr.visible = false if @spr && !@spr.disposed?
true
rescue
false
end
def update
unless map_scene?
hide
return
end
return unless @want_visible || (@spr && !@spr.disposed?)
ensure_hud
if @want_visible && @spr && !@spr.disposed?
@spr.visible = true
end
update_position
rescue
end
def dispose
detach_sprite
release_owned_viewport(nil)
begin
@bmp.dispose if @bmp && !@bmp.disposed?
rescue
end
@spr = nil
@vp = nil
@bmp = nil
end
end
#==============================================================================
# Unified durable save scheduler.
#==============================================================================
module MP_Save14
VERSION = "2.7.1"
# Server plugin OnlineSaveFix 1.1.0 accepts v2 reasons in this exact shape.
REASON_PREFIX = "cloudv2"
# Checkpoint-only mode: ignore continuous dirty/event spam; keep map/exit/
# quest/economy checkpoints. Full snapshot is still rebuilt before each send.
CHECKPOINT_ONLY = true
EVENT_DELAY_FR = 8
MAP_DELAY_FR = 2
DIRTY_PROBE_FR = 30
MIN_SEND_INTERVAL_FR = 24
ACK_TIMEOUT_FR = 360
RETRY_DELAY_FR = 20
BOOTSTRAP_RETRY_FR = 60
FINAL_WAIT_TICKS = 180
# The encrypted server reports maxLineBytes=131072. Keep headroom for framing.
MAX_WIRE_BYTES = 120_000
STORY_MAX_DEPTH = 8
STORY_MAX_ARRAY = 4096
STORY_MAX_HASH = 8192
STORY_MAX_STRING = 16384
STORY_SKIP = Object.new
@next_seq = 1
@pending = nil
@inflight = nil
@last_ack = ""
@last_send_frame = -100_000
@last_probe_frame = -100_000
@last_update_frame = -1
@last_observed_sig = nil
@last_committed_sig = nil
@bootstrap_retry_frame = -100_000
@blocking_wait = false
@disconnecting = false
@full_story_enabled = true
@full_story_patch_installed = false
@late_adapters_installed = false
@immediate_sync_adapter_installed = false
@live_sync_adapter_installed = false
@cloud_only_adapter_installed = false
@local_new_game = false
@local_new_game_source = ""
@last_lock_log_frame = -100_000
# Quest scripts can mutate dozens of story/inventory fields while their
# dialogue Fiber is alive. Saving every individual mutation creates a wall
# of queue/log work and, worse, can persist an intermediate quest state.
# Treat guild worker / quest-board scripts as one atomic save transaction.
@quest_tx_depth = 0
@quest_tx_dirty = false
@quest_tx_label = ""
@quest_tx_changes = 0
@last_quest_commit_frame = -100_000
@clock_epoch = 0
@clock_last_raw = nil
@clock_last_logical = 0
class << self
def log(tag, text="")
msg = "[SAVE14] #{tag} #{text}".strip
puts msg rescue nil
begin
if defined?(MPStateInfra) && MPStateInfra.respond_to?(:log_line)
MPStateInfra.log_line("save14_#{tag}", text.to_s)
end
rescue
end
end
# Graphics.frame_count is reset by DataManager.setup_new_game. Use a logical
# monotonic frame so timers cannot freeze after New Game.
def frame
raw = Graphics.frame_count.to_i
if @clock_last_raw.nil?
@clock_last_raw = raw
@clock_last_logical = raw
return raw
end
if raw < @clock_last_raw.to_i
@clock_epoch = @clock_epoch.to_i + @clock_last_raw.to_i + 1
log("frame_rewind", "#{@clock_last_raw}->#{raw} epoch=#{@clock_epoch}")
end
@clock_last_raw = raw
logical = @clock_epoch.to_i + raw
logical = @clock_last_logical.to_i if logical < @clock_last_logical.to_i
@clock_last_logical = logical
logical
rescue
@clock_last_logical = @clock_last_logical.to_i + 1
@clock_last_logical
end
def arena_active?
defined?(MP_ArenaFlag) && MP_ArenaFlag.respond_to?(:arena_active?) && MP_ArenaFlag.arena_active?
rescue
false
end
def connected?
defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
rescue
false
end
# MPStateInfra deliberately suppresses live sync while it builds a temporary
# blank base for cloud restore / applies a remote bootstrap. Those mutations
# are NOT local gameplay and must never become cloud saves.
def sync_suppressed?
return false unless defined?(MPStateInfra) && MPStateInfra.respond_to?(:suppress_sync?)
!!MPStateInfra.suppress_sync?
rescue
false
end
def local_new_game?
!!@local_new_game
rescue
false
end
# A normal TitleMenu New Game is allowed to replace the current cloud
# character. If the connection is still sitting in bootstrap_mode:load,
# acknowledge that bootstrap without applying it, so the server can send
# sync_unlocked and accept the first new-game sync_state.
def begin_local_new_game(source="new_game")
@local_new_game = true
@local_new_game_source = sanitize_reason(source)
log("new_game_begin", "source=#{@local_new_game_source}")
release_bootstrap_for_local_new_game
true
rescue => e
log("new_game_begin_error", "#{e.class}: #{e.message}")
false
end
def release_bootstrap_for_local_new_game
return false unless @local_new_game
return false unless connected?
return true if bootstrap_unlocked?
return false unless defined?(WebSocket)
mode = WebSocket.instance_variable_get(:@bootstrap_mode).to_s rescue ""
return false if mode.empty?
begin
WebSocket.instance_variable_set(:@bootstrap_applied, true)
rescue
end
ok = false
begin
ok = !!WebSocket._bootstrap_send_loaded_ack if WebSocket.respond_to?(:_bootstrap_send_loaded_ack)
rescue
ok = false
end
log("new_game_bootstrap_ack", "mode=#{mode} ok=#{ok}")
ok
rescue => e
log("new_game_bootstrap_error", "#{e.class}: #{e.message}")
false
end
def finish_local_new_game
@local_new_game = false
@local_new_game_source = ""
true
rescue
false
end
def bootstrap_unlocked?
return false unless connected?
return !!WebSocket.bootstrap_sync_unlocked? if WebSocket.respond_to?(:bootstrap_sync_unlocked?)
true
rescue
false
end
def game_objects_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
actor = nil
begin
actor = $game_player.actor if $game_player.respond_to?(:actor)
rescue
actor = nil
end
begin
actor = $game_party.leader if actor.nil? && $game_party.respond_to?(:leader)
rescue
end
!actor.nil?
rescue
false
end
# A load keeps a blank stand-in until apply_bootstrap_state. Uploading that
# stand-in replaces the real notes, calendar, trait points and intimate
# history. A real New Game is allowed through only when the server is not
# waiting to restore an existing character.
def saved_character_loaded?
return false unless defined?(WebSocket)
applied = false
mode = ""
begin
applied = !!WebSocket.instance_variable_get(:@bootstrap_applied)
mode = WebSocket.instance_variable_get(:@bootstrap_mode).to_s
rescue
return false
end
return false if mode == "load" && !applied
return true if local_new_game?
return false if mode.empty? && !applied
true
rescue
false
end
def snapshot_ready?
return false if arena_active?
return false unless connected?
return false unless bootstrap_unlocked?
return false unless saved_character_loaded?
return false unless game_objects_ready?
return false unless defined?(WebSocket) && WebSocket.respond_to?(:_live_sync_build_packet)
true
rescue
false
end
def sanitize_reason(reason)
s = reason.to_s.downcase.strip
s = "state" if s.empty?
s = s.sub(/\Acloudv2_\d+_/, "")
s = s.sub(/\Acloud_/, "")
s = s.gsub(/[^a-z0-9_]+/, "_")
s = s.gsub(/_+/, "_")
s = s[0, 36]
s = "state" if s.nil? || s.empty?
s
rescue
"state"
end
# Разрешённые причины durable-записи. Остальные request() глотаются:
# gameplay hooks и dirty_probe больше не шлют полный sync_state каждый тик.
def checkpoint_reason?(reason)
return true unless CHECKPOINT_ONLY
r = sanitize_reason(reason)
return true if r == "disconnect" || r.include?("shutdown") || r.include?("return_title")
return true if r == "manual" || r.include?("manual_save")
return true if r == "quest_commit"
return true if r == "new_game_ready" || r == "new_game_created" || r == "setup_new_game" || r == "new_character"
return true if r == "map_enter" || r == "map_start" || r == "sync_unlocked"
return true if r == "bootstrap" || r.start_with?("bootstrap_")
return true if r.start_with?("clan_estate")
return true if r.start_with?("noer_home")
return true if r.include?("bank_storage")
return true if r == "doom"
return true if r.start_with?("corpse_")
# Явные API MP_ServerSyncSave / MP_AutoSave / slavery (не probe).
return true if r == "server_sync" || r == "autosave"
return true if r.start_with?("mp_slave_")
false
rescue
false
end
def wire_reason(seq, reason)
"#{REASON_PREFIX}_#{seq.to_i}_#{sanitize_reason(reason)}"
end
def transport_ok?(result)
return result if result == true || result == false
return false if result.nil?
result.to_i >= 0
rescue
false
end
def reset_session(mode="", preserve_local_new_game=false)
MP_AutosaveHUD.hide rescue nil
keep_pending = preserve_local_new_game && @local_new_game ? @pending : nil
@next_seq = 1
@pending = keep_pending
@inflight = nil
@last_ack = ""
@last_send_frame = -100_000
@last_probe_frame = -100_000
@last_observed_sig = nil
@last_committed_sig = nil
@bootstrap_retry_frame = -100_000
log("session", "reset mode=#{mode} preserve_new_game=#{!!keep_pending}")
true
rescue
false
end
def quest_script_path?(path)
text = path.to_s.tr('\\', '/')
return false unless text.start_with?('Data/HCGframes/event/')
base = File.basename(text) rescue text
return true if base =~ /GuildEmpolyee\.rb\z/i
return true if base =~ /QuestBoard\.rb\z/i
false
rescue
false
end
def quest_transaction_active?
@quest_tx_depth.to_i > 0
rescue
false
end
def quest_begin(label='quest')
if @quest_tx_depth.to_i <= 0
@quest_tx_depth = 0
@quest_tx_dirty = true # Save once even for nested/in-place Hash mutations.
@quest_tx_label = File.basename(label.to_s) rescue label.to_s
@quest_tx_changes = 0
log('quest_begin', @quest_tx_label)
end
@quest_tx_depth = @quest_tx_depth.to_i + 1
true
rescue => e
log('quest_begin_error', "#{e.class}: #{e.message}")
false
end
def quest_mark_dirty(reason=nil)
return false unless quest_transaction_active?
@quest_tx_dirty = true
@quest_tx_changes = @quest_tx_changes.to_i + 1
true
rescue
false
end
def quest_absorbable_reason?(reason)
r = sanitize_reason(reason)
return true if r.start_with?('event_')
return true if r == 'state_changed' || r == 'initial_state'
return true if r == 'autosave' || r == 'server_sync'
return true if r == 'guild_worker_progress'
return true if r == 'manual_quest_story_captured'
return true if r == 'cloud_manual_quest_story_captu'
false
rescue
false
end
def quest_end(label='quest')
return false if @quest_tx_depth.to_i <= 0
@quest_tx_depth = @quest_tx_depth.to_i - 1
return true if @quest_tx_depth.to_i > 0
dirty = !!@quest_tx_dirty
saved_label = @quest_tx_label.to_s
changes = @quest_tx_changes.to_i
@quest_tx_dirty = false
@quest_tx_label = ''
@quest_tx_changes = 0
log('quest_end', "#{saved_label} changes=#{changes} dirty=#{dirty}")
quest_commit(saved_label) if dirty
true
rescue => e
@quest_tx_depth = 0
@quest_tx_dirty = false
log('quest_end_error', "#{e.class}: #{e.message}")
false
end
# One full durable snapshot after the whole quest interaction. No blocking
# Graphics.update loop here: enqueue/send once and let the normal ACK path
# finish asynchronously, so the guild employee cannot freeze the UI.
def quest_commit(label='quest')
now = frame
return true if @last_quest_commit_frame.to_i == now
@last_quest_commit_frame = now
log('quest_commit', label.to_s)
request('quest_commit', 0, true)
update(true)
true
rescue => e
log('quest_commit_error', "#{e.class}: #{e.message}")
false
end
def reason_priority(reason)
r = sanitize_reason(reason)
return 100 if r == "disconnect" || r.include?("shutdown") || r.include?("return_title")
return 90 if r == "manual" || r.include?("manual_save")
return 85 if r == "quest_commit"
return 80 if r == "new_game_ready"
return 70 if r == "new_game_created"
return 60 if r == "map_enter" || r == "map_start" || r == "sync_unlocked" || r == "bootstrap"
return 20 if r.start_with?("event_")
return 10 if r == "state_changed" || r == "initial_state"
30
rescue
30
end
def request(reason="state", delay=EVENT_DELAY_FR, hud=true)
return false if arena_active?
return false if sync_suppressed?
base = sanitize_reason(reason)
# Во время квест-транзакции помечаем dirty даже для event_*, чтобы
# quest_commit в конце всё равно ушёл одним полным слепком.
if quest_transaction_active? && quest_absorbable_reason?(base)
quest_mark_dirty(base)
return true
end
unless checkpoint_reason?(base)
return true
end
now = frame
due = now + [delay.to_i, 0].max
job = {
:reason => base,
:due => due,
:hud => !!hud,
:requested => now
}
if @pending
# Never let a lower-priority job rename an important New Game/manual
# commit. The packet is still rebuilt from the newest live state.
old_reason = @pending[:reason].to_s
if reason_priority(old_reason) > reason_priority(base)
job[:reason] = old_reason
end
job[:due] = [@pending[:due].to_i, due].min
job[:hud] = !!(@pending[:hud] || hud)
end
@pending = job
log("queue", "reason=#{base} kept=#{job[:reason]} due=#{job[:due]} inflight=#{!!@inflight}")
true
rescue => e
log("queue_error", "#{e.class}: #{e.message}")
false
end
def pending?
!!@pending || !!@inflight
rescue
false
end
def last_ack
@last_ack.to_s
rescue
""
end
def next_seq
seq = @next_seq.to_i
seq = 1 if seq <= 0
@next_seq = seq + 1
seq
rescue
@next_seq = 2
1
end
def current_map_id
return 0 unless defined?($game_map) && $game_map
$game_map.map_id.to_i
rescue
0
end
def send_map_and_position
begin
map_id = current_map_id
if map_id > 0 && WebSocket.respond_to?(:send_line)
line = WebSocket.respond_to?(:map_packet_for_server) ? WebSocket.map_packet_for_server(map_id) : "map:#{map_id}"
WebSocket.send_line(line)
end
rescue
end
begin
if WebSocket.respond_to?(:live_sync_position_now)
WebSocket.live_sync_position_now("save14", true)
elsif defined?($game_player) && $game_player && WebSocket.respond_to?(:send_line)
pos = "#{$game_player.x}:#{$game_player.y}:#{$game_player.direction}"
WebSocket.send_line("pos:#{pos}")
end
rescue
end
end
def packet_signature(packet)
s = packet.to_s
crc = 0
begin
crc = Zlib.crc32(s)
rescue
crc = s.hash
end
"#{s.bytesize rescue s.size}:#{crc}"
rescue
""
end
def validate_base_packet(packet)
parts = packet.to_s.split(":", -1)
return [false, "fields=#{parts.length}"] unless parts.length >= 16 && parts[0].to_s == "sync_state"
# Empty learned skills ARE VALID on early TutorialOP. Do not reject p[9].
return [false, "stats_empty"] if parts[10].to_s.empty?
return [false, "player_empty"] if parts[12].to_s.empty?
[true, ""]
rescue => e
[false, "#{e.class}:#{e.message}"]
end
def build_base_packet(allow_full_story=true)
return nil unless defined?(WebSocket) && WebSocket.respond_to?(:_live_sync_build_packet)
old_full = @full_story_enabled
@full_story_enabled = !!allow_full_story
built = WebSocket._live_sync_build_packet rescue nil
return nil unless built && built[0]
packet = built[0].to_s
ok, why = validate_base_packet(packet)
unless ok
log("snapshot_wait", why)
return nil
end
packet
ensure
@full_story_enabled = old_full unless old_full.nil?
end
def build_wire_packet(seq, reason)
base = build_base_packet(true)
return [nil, nil] if base.nil?
wire = wire_reason(seq, reason)
packet = base + ":reason=#{wire}"
bytes = packet.bytesize rescue packet.size
# Full story capture is best effort. If it cannot fit transport framing,
# rebuild with the stock body collector instead of dropping the save.
if bytes > MAX_WIRE_BYTES && @full_story_patch_installed
log("full_story_fallback", "bytes=#{bytes} limit=#{MAX_WIRE_BYTES}")
base = build_base_packet(false)
return [nil, nil] if base.nil?
packet = base + ":reason=#{wire}"
bytes = packet.bytesize rescue packet.size
end
# A packet that never leaves keeps the last server row. That row is the
# one where trait points, notes and the intimate menu are already empty.
# Drop the bulky body/bank so the stats field, which holds those three,
# still reaches the server.
if bytes > MAX_WIRE_BYTES
fitted = fit_oversize_packet(packet)
if fitted
log("packet_shrunk", "bytes=#{bytes} fitted=#{fitted.bytesize rescue 0} limit=#{MAX_WIRE_BYTES}")
packet = fitted
bytes = packet.bytesize rescue packet.size
base = packet.sub(/:reason=.*\z/, "")
end
end
if bytes > MAX_WIRE_BYTES
log("packet_too_large", "bytes=#{bytes} limit=#{MAX_WIRE_BYTES}; save kept pending")
return [nil, nil]
end
[packet, packet_signature(base)]
rescue => e
log("build_error", "#{e.class}: #{e.message}")
[nil, nil]
end
def fit_oversize_packet(packet)
parts = packet.to_s.split(":", -1)
return nil if parts.length < 16 || parts[0].to_s != "sync_state"
# reason is appended as the final field. Body is the field before it.
reason_index = parts.length - 1
body_index = reason_index - 1
bank_index = 13 if parts.length > 14
parts[body_index] = compact_story_hex(70_000)
trial = parts.join(":")
if (trial.bytesize rescue trial.size) > MAX_WIRE_BYTES
# Не обнуляем body полностью: оставляем компактные body meters
# (arousal / lactation_level / dirt…), иначе при перезаходе они теряются.
meters = compact_meters_body_hex(12_000)
parts[body_index] = meters.to_s.empty? ? "" : meters
trial = parts.join(":")
end
if bank_index && (trial.bytesize rescue trial.size) > MAX_WIRE_BYTES
parts[bank_index] = ""
trial = parts.join(":")
end
if (trial.bytesize rescue trial.size) > MAX_WIRE_BYTES
meters = compact_meters_body_hex(4_000)
parts[body_index] = meters
trial = parts.join(":")
end
size = trial.bytesize rescue trial.size
return nil if size > MAX_WIRE_BYTES
return nil if parts[10].to_s.empty?
trial
rescue
nil
end
def compact_story_hex(limit)
return "" unless defined?(WebSocket) && WebSocket.respond_to?(:_live_sync_blob_from_object)
ledger = collect_progression_ledger
story = ledger["story_stats"]
if story.is_a?(Hash)
slim = {}
story.each do |key, value|
name = key.to_s
next if name == "LonaPaletteStudio"
next if value.to_s.length > 2000
slim[name] = value
end
ledger["story_stats"] = slim
end
WebSocket._live_sync_blob_from_object(ledger, limit.to_i, "body_fit").to_s
rescue
""
end
# Компактный body только с need/body meters — запасной путь при wire limit.
def compact_meters_body_hex(limit=12_000)
return "" unless defined?(WebSocket) && WebSocket.respond_to?(:_live_sync_blob_from_object)
actor = nil
begin
actor = $game_player.actor if $game_player && $game_player.respond_to?(:actor)
rescue
actor = nil
end
return "" if actor.nil?
meters = {}
keys = if defined?(WebSocket::LIVE_SYNC_BODY_METER_KEYS)
WebSocket::LIVE_SYNC_BODY_METER_KEYS
else
%w[arousal lactation_level urinary_level defecate_level dirt mood sat sta health baby_health pee_request poo_request itch_level]
end
begin
act_stat = actor.instance_variable_get(:@actStat)
table = act_stat.stat if act_stat && act_stat.respond_to?(:stat)
if table.is_a?(Hash)
keys.each do |key|
raw = table[key]
next if raw.nil?
meters[key] = raw
end
end
rescue
end
return "" if meters.empty?
payload = { "schema" => 2, "body_stats" => meters }
WebSocket._live_sync_blob_from_object(payload, limit.to_i, "body_meters").to_s
rescue
""
end
def show_hud
MP_AutosaveHUD.show if defined?(MP_AutosaveHUD)
rescue
end
def hide_hud
MP_AutosaveHUD.hide if defined?(MP_AutosaveHUD)
rescue
end
def send_pending_now
return false unless @pending
return false if @inflight
if quest_transaction_active? && reason_priority(@pending[:reason]) < 90
return false
end
return false unless snapshot_ready?
now = frame
return false if now < @pending[:due].to_i
job = @pending
# Map/exit/bootstrap checkpoints must not wait behind MIN_SEND_INTERVAL —
# иначе метры тела на перезаходе остаются от прошлого урезанного сейва.
prio = reason_priority(job[:reason])
unless prio >= 60 || (now - @last_send_frame.to_i) >= MIN_SEND_INTERVAL_FR
return false
end
seq = next_seq
packet, sig = build_wire_packet(seq, job[:reason])
unless packet
# The state may still be initializing, or the packet may temporarily be
# too large. Keep the newest job and retry rather than discarding it.
@pending[:due] = now + RETRY_DELAY_FR
return false
end
send_map_and_position
show_hud if job[:hud]
result = WebSocket.send_line(packet) rescue nil
unless transport_ok?(result)
hide_hud if job[:hud]
@pending[:due] = now + RETRY_DELAY_FR
log("send_failed", "reason=#{job[:reason]} result=#{result.inspect}")
return false
end
wire = wire_reason(seq, job[:reason])
@pending = nil
@inflight = {
:seq => seq,
:wire => wire,
:reason => job[:reason],
:hud => job[:hud],
:sent => now,
:sig => sig
}
@last_send_frame = now
@last_observed_sig = sig unless sig.nil? || sig.empty?
log("sent", "seq=#{seq} reason=#{job[:reason]} map=#{current_map_id} bytes=#{packet.bytesize rescue packet.size}")
true
rescue => e
log("send_error", "#{e.class}: #{e.message}")
false
end
def mark_ack(wire)
token = wire.to_s.strip
@last_ack = token
current = @inflight
unless current && current[:wire].to_s == token
log("ack_other", token) if token.start_with?(REASON_PREFIX + "_")
return false
end
@last_committed_sig = current[:sig]
@inflight = nil
hide_hud if current[:hud]
log("ack", "seq=#{current[:seq]} reason=#{current[:reason]}")
if current[:reason].to_s == "new_game_ready" || current[:reason].to_s == "new_game_created"
finish_local_new_game
end
# If new state accumulated while this save waited for ACK, update() sends
# it as soon as the rate interval permits.
true
rescue => e
log("ack_error", "#{e.class}: #{e.message}")
false
end
def mark_error(wire, code="save_failed")
token = wire.to_s.strip
current = @inflight
if current && current[:wire].to_s == token
@inflight = nil
hide_hud if current[:hud]
request(current[:reason], RETRY_DELAY_FR, current[:hud])
end
log("server_error", "#{token} #{code}")
true
rescue
false
end
def retry_bootstrap_ack
return if bootstrap_unlocked?
return unless connected?
return unless defined?(WebSocket) && WebSocket.respond_to?(:_bootstrap_send_loaded_ack)
mode = WebSocket.instance_variable_get(:@bootstrap_mode).to_s rescue ""
return if mode.empty?
applied = !!(WebSocket.instance_variable_get(:@bootstrap_applied) rescue false)
if @local_new_game && !applied
begin
WebSocket.instance_variable_set(:@bootstrap_applied, true)
WebSocket.instance_variable_set(:@bootstrap_ack_sent, false)
applied = true
rescue
end
end
return unless applied
now = frame
return if (now - @bootstrap_retry_frame.to_i) < BOOTSTRAP_RETRY_FR
@bootstrap_retry_frame = now
begin
# If the ACK packet itself was lost, stock code otherwise never retries.
WebSocket.instance_variable_set(:@bootstrap_ack_sent, false)
ok = WebSocket._bootstrap_send_loaded_ack
log("bootstrap_ack_retry", "mode=#{mode} ok=#{ok}")
rescue => e
log("bootstrap_ack_error", "#{e.class}: #{e.message}")
end
end
# Meters that move on their own. They must not open a cloud snapshot.
# lactation_level / urinary_level / defecate_level — реальные ключи actStat.
# "lactation" — legacy shorthand; баф Lactation (state) сюда не относится.
VOLATILE_ACTOR_STATS = %w[
health sta sat mood dirt arousal hp mp tp mhp mmp
baby_health lactation lactation_level defecation micturition
urinary_level defecate_level semen itch_level
pee poo pee_request poo_request
].each_with_object({}) { |name, table| table[name] = true }
def volatile_actor_stat?(name)
VOLATILE_ACTOR_STATS[name.to_s] == true
rescue
false
end
def skip_durable_reason?(reason)
text = reason.to_s
return true if text == "hp_set"
return true if text.start_with?("set_stat:") && volatile_actor_stat?(text.sub("set_stat:", ""))
false
rescue
false
end
def mix_signature(crc, value)
case value
when Hash
value.keys.map { |key| key.to_s }.sort.each do |key|
crc = Zlib.crc32(key, crc)
raw = value[key]
if raw.nil? && key.to_i.to_s == key
raw = value[key.to_i]
end
if raw.nil?
begin
raw = value[key.to_sym]
rescue
raw = nil
end
end
crc = mix_signature(crc, raw)
end
crc
when Array
value.each { |entry| crc = mix_signature(crc, entry) }
crc
else
Zlib.crc32(value.to_s, crc)
end
rescue
crc
end
# Identity of data that should survive a reconnect. Health, stamina, map
# coordinates and state timers are left out so they cannot schedule a save.
def durable_signature
return nil unless defined?(WebSocket)
actor = ($game_player.actor if $game_player && $game_player.respond_to?(:actor))
return nil if actor.nil?
crc = 0
crc = mix_signature(crc, actor.level.to_i) if actor.respond_to?(:level)
crc = mix_signature(crc, actor.trait_point.to_i) if actor.respond_to?(:trait_point)
exp = actor.instance_variable_get(:@exp) rescue nil
crc = mix_signature(crc, exp) if exp.is_a?(Hash)
%w[combat_trait scoutcraft_trait wisdom_trait survival_trait constitution_trait].each do |key|
next unless actor.respond_to?(key)
crc = mix_signature(crc, key)
crc = mix_signature(crc, actor.send(key).to_i)
end
# Permanent reputation only. Displayed morality and morality_plus include
# temporary state and equipment modifiers that refresh rebuilds.
if actor.respond_to?(:morality_lona)
crc = mix_signature(crc, "morality_lona")
crc = mix_signature(crc, actor.morality_lona)
end
if actor.respond_to?(:record_lona_title)
crc = mix_signature(crc, "record_lona_title")
crc = mix_signature(crc, actor.record_lona_title)
end
skills = actor.instance_variable_get(:@skills) rescue nil
crc = mix_signature(crc, skills) if skills.is_a?(Array)
crc = mix_signature(crc, WebSocket._live_sync_coin3_count) if WebSocket.respond_to?(:_live_sync_coin3_count)
if WebSocket.respond_to?(:_live_sync_collect_items)
crc = mix_signature(crc, WebSocket._live_sync_collect_items)
crc = mix_signature(crc, WebSocket._live_sync_collect_weapons)
crc = mix_signature(crc, WebSocket._live_sync_collect_armors)
end
if WebSocket.respond_to?(:_live_sync_collect_equips)
crc = mix_signature(crc, WebSocket._live_sync_collect_equips(actor))
end
# Quick-use ext-1..ext-5 (actor.ext_items) — иначе смена слотов не в CRC.
begin
if actor.respond_to?(:ext_items)
raw = actor.ext_items
crc = mix_signature(crc, "ext_items")
crc = mix_signature(crc, raw.is_a?(Array) ? raw.map { |v| v.nil? ? "" : v.to_s } : [])
end
rescue
end
crc = mix_signature(crc, collect_progression_ledger)
if WebSocket.respond_to?(:_live_sync_collect_journal)
crc = mix_signature(crc, WebSocket._live_sync_collect_journal(actor))
end
crc.to_s
rescue => e
log("durable_sig_error", "#{e.class}: #{e.message}")
nil
end
def dirty_probe
# Checkpoint-only: полный CRC по story/inventory каждый ~0.5с давал
# микрофризы даже без отправки пакета. Не сканируем и не ставим в очередь.
return if CHECKPOINT_ONLY
return if quest_transaction_active?
return unless snapshot_ready?
now = frame
return if (now - @last_probe_frame.to_i) < DIRTY_PROBE_FR
@last_probe_frame = now
sig = durable_signature
return if sig.nil? || sig.empty?
if @last_observed_sig.nil?
@last_observed_sig = sig
request("initial_state", 0, true) unless @inflight || @pending
return
end
return if sig == @last_observed_sig
@last_observed_sig = sig
request("state_changed", EVENT_DELAY_FR, true)
rescue => e
log("probe_error", "#{e.class}: #{e.message}")
end
def update(force=false)
install_late_adapters
now = frame
return if !force && @last_update_frame.to_i == now
@last_update_frame = now
MP_AutosaveHUD.update rescue nil
return if arena_active?
release_bootstrap_for_local_new_game if @local_new_game && !bootstrap_unlocked?
retry_bootstrap_ack unless bootstrap_unlocked?
if @inflight
if (now - @inflight[:sent].to_i) >= ACK_TIMEOUT_FR
timed = @inflight
@inflight = nil
hide_hud if timed[:hud]
log("ack_timeout", "seq=#{timed[:seq]} reason=#{timed[:reason]}")
request(timed[:reason], RETRY_DELAY_FR, timed[:hud])
end
end
dirty_probe if bootstrap_unlocked? && !CHECKPOINT_ONLY
send_pending_now if @pending && !@inflight
true
rescue => e
log("update_error", "#{e.class}: #{e.message}")
false
end
def pump_network_once
begin
WebSocket.update if defined?(WebSocket) && WebSocket.respond_to?(:update)
rescue
end
update(true)
rescue
end
def save_and_wait(reason="manual", timeout_ticks=FINAL_WAIT_TICKS, hud=true)
return false unless snapshot_ready?
return false if @blocking_wait
@blocking_wait = true
begin
request(reason, 0, hud)
# Сразу пытаемся отправить, не дожидаясь следующего Scene_Map#update.
send_pending_now if @pending && !@inflight
ticks = 0
while pending? && connected? && ticks < timeout_ticks.to_i
pump_network_once
Graphics.update rescue nil
Input.update rescue nil
sleep(0.003) rescue nil
ticks += 1
end
ok = !pending?
log("flush_timeout", "reason=#{reason} ticks=#{ticks}") unless ok
hide_hud unless ok
ok
ensure
@blocking_wait = false
end
rescue => e
@blocking_wait = false
log("flush_error", "#{e.class}: #{e.message}")
false
end
# Неблокирующий форс-чекпоинт: очередь + немедленная попытка send.
def flush_now(reason="map_enter", hud=true)
request(reason, 0, hud)
send_pending_now if @pending && !@inflight
true
rescue => e
log("flush_now_error", "#{e.class}: #{e.message}")
false
end
#----------------------------------------------------------------------
# Full story capture
#----------------------------------------------------------------------
def full_story_enabled?
!!@full_story_enabled
rescue
false
end
def story_source
story = defined?($story_stats) ? $story_stats : nil
return nil if story.nil?
begin
data = story.data if story.respond_to?(:data)
return data if data.is_a?(Hash)
rescue
end
story.is_a?(Hash) ? story : nil
rescue
nil
end
def story_safe_value(value, depth=0, seen=nil)
return STORY_SKIP if depth.to_i > STORY_MAX_DEPTH
return value if value.nil? || value.is_a?(Numeric) || value == true || value == false
return value.to_s if value.is_a?(Symbol)
if value.is_a?(String)
text = value.dup
begin
text.force_encoding("UTF-8")
text = text.encode("UTF-8", :invalid => :replace, :undef => :replace) unless text.valid_encoding?
rescue
end
return text[0, STORY_MAX_STRING]
end
seen ||= {}
oid = value.object_id rescue nil
return STORY_SKIP if oid && seen[oid]
seen[oid] = true if oid
begin
if value.is_a?(Array)
out = []
value.first(STORY_MAX_ARRAY).each do |entry|
safe = story_safe_value(entry, depth.to_i + 1, seen)
out << safe unless safe.equal?(STORY_SKIP)
end
return out
end
if value.is_a?(Hash)
out = {}
count = 0
value.each do |raw_key, raw_value|
break if count >= STORY_MAX_HASH
key = raw_key.to_s
next if key.empty?
safe = story_safe_value(raw_value, depth.to_i + 1, seen)
next if safe.equal?(STORY_SKIP)
out[key] = safe
count += 1
end
return out
end
ensure
seen.delete(oid) if oid
end
STORY_SKIP
rescue
STORY_SKIP
end
def volatile_story_key?(key)
# Server-authoritative clock phase. 01_time.rb rewrites this from the
# incoming time: packet every 2 seconds; it is not player progression and
# must not dirty the durable cloud snapshot continuously.
key.to_s == "OverMapEvent_DateCount"
rescue
false
end
def collect_full_story
src = story_source
return {} unless src && src.respond_to?(:each)
out = {}
src.each do |raw_key, raw_value|
key = raw_key.to_s
next if key.empty?
next if volatile_story_key?(key)
value = story_safe_value(raw_value, 0, {})
out[key] = value unless value.equal?(STORY_SKIP)
end
out
rescue
{}
end
# Native RPG saves persist these three containers alongside Story_Stats.
# Several map/event quests use them for intermediate pages and counters, so
# restoring only $story_stats can make a half-completed mission restart.
def collect_game_switches
out = {}
obj = defined?($game_switches) ? $game_switches : nil
data = obj ? obj.instance_variable_get(:@data) : nil
return out unless data.is_a?(Array)
data.each_with_index { |value, index| out[index.to_s] = true if value == true }
out
rescue
{}
end
def collect_game_variables
out = {}
obj = defined?($game_variables) ? $game_variables : nil
data = obj ? obj.instance_variable_get(:@data) : nil
return out unless data.is_a?(Array)
data.each_with_index do |value, index|
next if value.nil? || value == 0
safe = story_safe_value(value, 0, {})
out[index.to_s] = safe unless safe.equal?(STORY_SKIP)
end
out
rescue
{}
end
def collect_game_self_switches
out = []
obj = defined?($game_self_switches) ? $game_self_switches : nil
data = obj ? obj.instance_variable_get(:@data) : nil
return out unless data.is_a?(Hash)
data.each do |key, value|
next unless value == true && key.is_a?(Array) && key.length >= 3
out << [key[0].to_i, key[1].to_i, key[2].to_s]
end
out
rescue
[]
end
# A compact, self-contained copy of every native quest-progress container.
# It is embedded into stats_blob as well as body_blob. stats_blob belongs to
# the atomic character row, so it cannot be paired with an older body reply
# when several cloud_body_res packets from one login arrive out of order.
def collect_progression_ledger
{
"schema" => 1,
"story_stats" => collect_full_story,
"game_switches" => collect_game_switches,
"game_variables" => collect_game_variables,
"game_self_switches" => collect_game_self_switches
}
rescue
{ "schema" => 1 }
end
def merge_full_story(base)
obj = base.is_a?(Hash) ? base.dup : { "schema" => 3 }
ledger = collect_progression_ledger
full = ledger["story_stats"]
unless full.empty?
existing = obj["story_stats"]
if existing.is_a?(Hash)
merged = existing.dup
full.each { |k, v| merged[k] = v }
obj["story_stats"] = merged
else
obj["story_stats"] = full
end
end
switches = ledger["game_switches"]
variables = ledger["game_variables"]
self_switches = ledger["game_self_switches"]
obj["game_switches"] = switches unless switches.empty?
obj["game_variables"] = variables unless variables.empty?
obj["game_self_switches"] = self_switches unless self_switches.empty?
obj["schema"] = 5
obj
rescue
base
end
def install_full_story_patch
return true if @full_story_patch_installed
return false unless defined?(WebSocket) && WebSocket.respond_to?(:_live_sync_collect_body)
sc = class << WebSocket; self; end
unless sc.method_defined?(:mp_save14_collect_body_original)
sc.send(:alias_method, :mp_save14_collect_body_original, :_live_sync_collect_body)
end
sc.send(:define_method, :_live_sync_collect_body) do |actor|
base = mp_save14_collect_body_original(actor)
if defined?(MP_Save14) && MP_Save14.full_story_enabled?
MP_Save14.merge_full_story(base)
else
base
end
end
@full_story_patch_installed = true
log("adapter", "full story snapshot enabled")
true
rescue => e
log("adapter_error", "full_story #{e.class}: #{e.message}")
false
end
#----------------------------------------------------------------------
# One save-write owner. 21_sync.rb is still the serializer and gameplay
# event source, but all direct full-state SAVE calls are routed through the
# durable queue here. PlayerSync/position remain live gameplay traffic.
#----------------------------------------------------------------------
def install_live_sync_adapter
return true if @live_sync_adapter_installed
return false unless defined?(WebSocket)
return false unless WebSocket.respond_to?(:live_sync_send_now)
sc = class << WebSocket; self; end
unless sc.method_defined?(:mp_save14_live_sync_send_original)
sc.send(:alias_method, :mp_save14_live_sync_send_original, :live_sync_send_now)
end
sc.send(:define_method, :live_sync_send_now) do |reason=nil, with_playersync=true, with_position=false|
text = reason.to_s
text = "state" if text.empty?
# ClanEstate uses sync_state not only as persistence traffic but also as
# an acknowledgement channel for its authoritative inventory ledger.
# A successful withdraw is returned as pendingDelta and the server
# intentionally rejects the next state-changing estate request until the
# client has echoed the applied inventory in sync_state. v2.2 routed
# every live_sync_send_now call into the durable queue, delaying that
# protocol ACK and causing apply_pending_inventory loops in the chest.
#
# Preserve the original immediate sync semantics only for ClanEstate
# protocol reasons, then ALSO enqueue the durable snapshot. This keeps
# 14_autosave as the durable-save owner without breaking ClanEstate's
# transaction handshake.
clan_protocol_sync = text.start_with?("cloud_clan_estate")
if clan_protocol_sync
begin
mp_save14_live_sync_send_original(text, with_playersync, with_position)
rescue => e
MP_Save14.log("compat_error", "clan immediate sync #{e.class}: #{e.message}") rescue nil
end
else
begin
live_sync_position_now(text, false) if with_position && respond_to?(:live_sync_position_now)
rescue
end
begin
send_playersync_full(text, true) if with_playersync && respond_to?(:send_playersync_full)
rescue
end
end
return true if MP_Save14.skip_durable_reason?(text)
MP_Save14.request(text, 0, true)
true
end
if WebSocket.respond_to?(:live_sync_flush_final)
unless sc.method_defined?(:mp_save14_live_sync_flush_original)
sc.send(:alias_method, :mp_save14_live_sync_flush_original, :live_sync_flush_final)
end
sc.send(:define_method, :live_sync_flush_final) do |reason=nil|
text = reason.to_s
text = "disconnect" if text.empty?
MP_Save14.save_and_wait(text, MP_Save14::FINAL_WAIT_TICKS, true)
end
end
@live_sync_adapter_installed = true
log("adapter", "direct live sync saves redirected to durable queue")
true
rescue => e
log("adapter_error", "live_sync #{e.class}: #{e.message}")
false
end
#----------------------------------------------------------------------
# Compatibility with existing CloudOnly loader. It may stay installed for
# cloud LOAD/bootstrap, but every SAVE entry point is redirected here.
#----------------------------------------------------------------------
def install_cloud_only_adapter
return true if @cloud_only_adapter_installed
return false unless defined?(MPCloudOnlySave)
sc = class << MPCloudOnlySave; self; end
sc.send(:define_method, :request) do |reason="cloud_map_enter", delay=0|
d = delay.to_i
d = MP_Save14::EVENT_DELAY_FR if d < 0
MP_Save14.request(reason, d, true)
end
sc.send(:define_method, :send_now) do |reason="cloud_manual", force_position=true|
MP_Save14.request(reason, 0, true)
true
end
sc.send(:define_method, :send_tracked_now) do |reason="cloud_manual", force_position=true|
MP_Save14.request(reason, 0, true)
true
end
sc.send(:define_method, :update) { MP_Save14.update }
sc.send(:define_method, :mark_ack) { |reason| MP_Save14.mark_ack(reason) }
sc.send(:define_method, :last_ack) { MP_Save14.last_ack }
sc.send(:define_method, :pending?) { MP_Save14.pending? }
@cloud_only_adapter_installed = true
log("adapter", "MPCloudOnlySave writes redirected to 14_autosave")
true
rescue => e
log("adapter_error", "cloud_only #{e.class}: #{e.message}")
false
end
# 21_sync and 100000_InstantRealtimeSave already know when inventory,
# skills, stats, HP, equipment, traits, etc. changed. Their deferred event
# hook is converted into one durable FULL snapshot request.
def install_immediate_sync_adapter
return true if @immediate_sync_adapter_installed
return false unless defined?(MPImmediateLiveSync) && MPImmediateLiveSync.respond_to?(:defer)
sc = class << MPImmediateLiveSync; self; end
unless sc.method_defined?(:mp_save14_defer_original)
sc.send(:alias_method, :mp_save14_defer_original, :defer)
end
sc.send(:define_method, :defer) do |reason=nil|
text = reason.to_s
text = "event" if text.empty?
MP_Save14.request("event_#{text}", MP_Save14::EVENT_DELAY_FR, true)
end
@immediate_sync_adapter_installed = true
log("adapter", "MPImmediateLiveSync dirty events redirected to durable save")
true
rescue => e
log("adapter_error", "immediate_sync #{e.class}: #{e.message}")
false
end
def install_late_adapters
install_full_story_patch unless @full_story_patch_installed
install_live_sync_adapter unless @live_sync_adapter_installed
install_cloud_only_adapter unless @cloud_only_adapter_installed
install_immediate_sync_adapter unless @immediate_sync_adapter_installed
@late_adapters_installed = @full_story_patch_installed &&
@live_sync_adapter_installed &&
@immediate_sync_adapter_installed
true
rescue
false
end
end
end
#==============================================================================
# Compatibility API for the rest of the multiplayer code.
# Existing clan/slavery/state-infra code can keep asking for MP_AutoSave or
# MP_ServerSyncSave; both now mean the same durable full snapshot in this file.
#==============================================================================
module MP_AutoSave
module_function
def request_save(reason="autosave")
# Явный API-чекпоинт (не dirty_probe). reason сохраняем для логов/whitelist.
MP_Save14.request(reason, MP_Save14::EVENT_DELAY_FR, true)
rescue
false
end
def on_after_transfer(old_map_id, new_map_id)
old_id = old_map_id.to_i rescue 0
new_id = new_map_id.to_i rescue 0
return false if new_id <= 0 || new_id == old_id
MP_Save14.flush_now("map_enter", true)
rescue
false
end
def do_save
MP_Save14.request("autosave", 0, true)
true
rescue
false
end
def update
MP_Save14.update
rescue
false
end
end
module MP_ServerSyncSave
module_function
def request_selected_slot_save(reason="server_sync")
MP_Save14.request(reason, MP_Save14::EVENT_DELAY_FR, true)
rescue
false
end
def safe_to_save_now?
MP_Save14.snapshot_ready?
rescue
false
end
def do_save
MP_Save14.request("server_sync", 0, true)
true
rescue
false
end
def update
MP_Save14.update
rescue
false
end
end
#==============================================================================
# Direct story/quest persistence hook. Story_Stats is the game's main per-player
# progression table and can be changed by plain []= without going through the
# inventory/actor hooks in 21_sync.rb. Every such change marks a durable full
# snapshot dirty; multiple changes in one event are coalesced into one packet.
#==============================================================================
if defined?(Story_Stats) && Story_Stats.method_defined?(:[]=)
class Story_Stats
unless method_defined?(:mp_save14_story_set_original)
alias mp_save14_story_set_original []=
def []=(key, value)
old_value = nil
begin
old_value = self[key]
rescue
end
result = mp_save14_story_set_original(key, value)
begin
volatile = defined?(MP_Save14) && MP_Save14.respond_to?(:volatile_story_key?) && MP_Save14.volatile_story_key?(key)
MP_Save14.request("event_story", MP_Save14::EVENT_DELAY_FR, true) if defined?(MP_Save14) && !volatile && old_value != value
rescue
end
result
end
end
end
end
# Event commands may store mission stages outside Story_Stats. Mark the same
# durable full snapshot dirty when those native containers change. Bootstrap
# restoration writes their backing collections directly, so remote load never
# re-enters these gameplay hooks.
if defined?(Game_Switches) && Game_Switches.method_defined?(:[]=)
class Game_Switches
unless method_defined?(:mp_save14_switch_set_original)
alias mp_save14_switch_set_original []=
def []=(key, value)
old_value = self[key] rescue false
result = mp_save14_switch_set_original(key, value)
begin
MP_Save14.request("event_switch", MP_Save14::EVENT_DELAY_FR, true) if defined?(MP_Save14) && old_value != value
rescue
end
result
end
end
end
end
if defined?(Game_Variables) && Game_Variables.method_defined?(:[]=)
class Game_Variables
unless method_defined?(:mp_save14_variable_set_original)
alias mp_save14_variable_set_original []=
def []=(key, value)
old_value = self[key] rescue 0
result = mp_save14_variable_set_original(key, value)
begin
MP_Save14.request("event_variable", MP_Save14::EVENT_DELAY_FR, true) if defined?(MP_Save14) && old_value != value
rescue
end
result
end
end
end
end
if defined?(Game_SelfSwitches) && Game_SelfSwitches.method_defined?(:[]=)
class Game_SelfSwitches
unless method_defined?(:mp_save14_self_switch_set_original)
alias mp_save14_self_switch_set_original []=
def []=(key, value)
old_value = self[key] rescue false
result = mp_save14_self_switch_set_original(key, value)
begin
MP_Save14.request("event_self_switch", MP_Save14::EVENT_DELAY_FR, true) if defined?(MP_Save14) && old_value != value
rescue
end
result
end
end
end
end
#==============================================================================
# Manual save entry point: online Save always means a durable cloud snapshot.
# 100007_CloudOnlySave may wrap this later for cloud-load compatibility; its
# write calls are redirected back to MP_Save14 by the late adapter above.
#==============================================================================
if defined?(DataManager) && DataManager.respond_to?(:save_game)
class << DataManager
unless method_defined?(:mp_save14_save_game_original)
alias mp_save14_save_game_original save_game
def save_game(index=0)
return false unless defined?(MP_Save14)
MP_Save14.request("manual_save", 0, true)
true
rescue
false
end
end
end
end
#==============================================================================
# Core hooks available when multiplayer/14_autosave.rb is loaded.
#==============================================================================
if defined?(WebSocket)
module WebSocket
class << self
# Reliable bootstrap_loaded: only mark sent if transport accepted it.
if method_defined?(:_bootstrap_send_loaded_ack) && !method_defined?(:mp_save14_bootstrap_ack_original)
alias mp_save14_bootstrap_ack_original _bootstrap_send_loaded_ack
def _bootstrap_send_loaded_ack
return false unless @connected
return true if @live_sync_unlocked
result = send_line("bootstrap_loaded") rescue nil
ok = defined?(MP_Save14) ? MP_Save14.transport_ok?(result) : (!result.nil? && result.to_i >= 0)
@bootstrap_ack_sent = !!ok
ok
rescue
@bootstrap_ack_sent = false
false
end
end
if method_defined?(:set_bootstrap_mode) && !method_defined?(:mp_save14_set_bootstrap_mode_original)
alias mp_save14_set_bootstrap_mode_original set_bootstrap_mode
def set_bootstrap_mode(mode)
keep_new_game = defined?(MP_Save14) && MP_Save14.local_new_game?
MP_Save14.reset_session(mode, keep_new_game) if defined?(MP_Save14)
result = mp_save14_set_bootstrap_mode_original(mode)
MP_Save14.release_bootstrap_for_local_new_game if keep_new_game && defined?(MP_Save14)
result
end
end
if method_defined?(:parse) && !method_defined?(:mp_save14_parse_original)
alias mp_save14_parse_original parse
def parse(msg)
line = msg.to_s
if line =~ /\Acloud_save_ok:(cloudv2_\d+_[a-z0-9_]+)\s*\z/i
MP_Save14.mark_ack($1) if defined?(MP_Save14)
return
elsif line =~ /\Acloud_save_error:(cloudv2_\d+_[a-z0-9_]+):([^\r\n]+)\s*\z/i
MP_Save14.mark_error($1, $2) if defined?(MP_Save14)
return
end
result = mp_save14_parse_original(msg)
if line.strip == "sync_unlocked" && defined?(MP_Save14)
# Do not send from inside the network parser. Queue only; the normal
# WebSocket/Scene_Map update immediately after parse performs send.
if MP_Save14.local_new_game?
MP_Save14.request("new_game_created", 0, true) unless MP_Save14.pending?
else
MP_Save14.request("sync_unlocked", 0, true) unless MP_Save14.pending?
end
end
result
end
end
if method_defined?(:update) && !method_defined?(:mp_save14_ws_update_original)
alias mp_save14_ws_update_original update
def update(*args, &block)
result = mp_save14_ws_update_original(*args, &block)
MP_Save14.update if defined?(MP_Save14)
result
end
end
if method_defined?(:disconnect) && !method_defined?(:mp_save14_disconnect_original)
alias mp_save14_disconnect_original disconnect
def disconnect(*args, &block)
unless @mp_save14_disconnect_active
@mp_save14_disconnect_active = true
begin
# A transport-error disconnect can be invoked from WebSocket.update
# itself. Never recursively pump the socket here. Queue and perform
# one best-effort send only if the channel is still writable.
if defined?(MP_Save14) && MP_Save14.snapshot_ready?
MP_Save14.request("disconnect", 0, true)
MP_Save14.update(true)
end
ensure
@mp_save14_disconnect_active = false
end
end
mp_save14_disconnect_original(*args, &block)
end
end
end
end
end
#==============================================================================
# New Game hooks.
# Important: setup_new_game does NOT yet grant Lona's permanent starter skills.
# They are granted later by Game_Interpreter#new_game_setup. Both phases save.
#==============================================================================
if defined?(DataManager) && DataManager.respond_to?(:setup_new_game)
class << DataManager
unless method_defined?(:mp_save14_setup_new_game_original)
alias mp_save14_setup_new_game_original setup_new_game
def setup_new_game(*args, &block)
suppressed = defined?(MP_Save14) && MP_Save14.sync_suppressed?
result = mp_save14_setup_new_game_original(*args, &block)
begin
# Scene_MapTitle builds a disposable title actor with setup_new_game(false).
# CloudOnly builds temporary restore bases under MPStateInfra suppression.
# Neither is a real player New Game and neither may overwrite cloud state.
title_only = (!args.empty? && args[0] == false)
unless suppressed || title_only
MP_Save14.begin_local_new_game("setup_new_game") if defined?(MP_Save14)
MP_Save14.request("new_game_created", 0, true) if defined?(MP_Save14)
end
rescue
end
result
end
end
end
end
# Scene_MapTitle's normal New Game path does not call DataManager.setup_new_game;
# it reuses the title objects, moves them to TutorialOP, then enters Scene_Map.
# Hook the actual menu command so ONLINE New Game can unlock the bootstrap gate.
if defined?(TitleMenu) && TitleMenu.method_defined?(:handlerCmdNewGame)
class TitleMenu
unless method_defined?(:mp_save14_handler_new_game_original)
alias mp_save14_handler_new_game_original handlerCmdNewGame
def handlerCmdNewGame(*args, &block)
result = mp_save14_handler_new_game_original(*args, &block)
begin
if defined?(MP_Save14)
MP_Save14.begin_local_new_game("title_new_game")
MP_Save14.request("new_game_created", 0, true)
end
rescue
end
result
end
end
end
end
if defined?(Game_Interpreter) && Game_Interpreter.method_defined?(:new_game_setup)
class Game_Interpreter
unless method_defined?(:mp_save14_new_game_setup_original)
alias mp_save14_new_game_setup_original new_game_setup
def new_game_setup(*args, &block)
result = mp_save14_new_game_setup_original(*args, &block)
begin
actor = ($game_player.actor rescue nil)
actor.instance_variable_set(:@mp_learned_skills_version, 1) if actor
rescue
end
begin
if defined?(MP_Save14) && !MP_Save14.sync_suppressed?
MP_Save14.begin_local_new_game("new_game_setup") unless MP_Save14.local_new_game?
MP_Save14.request("new_game_ready", 0, true)
end
rescue
end
result
end
end
end
end
#==============================================================================
# Atomic quest-script transactions.
#
# HCG quest scripts run inside the interpreter Fiber and may yield for dialogue
# over many frames. Keep the transaction open across those yields, suppressing
# per-field/per-item save spam. When the script actually finishes, persist one
# newest full snapshot. This covers all guild employees and all QuestBoard
# scripts without modifying the original quest files.
#==============================================================================
class Object
begin
has_save14_load_script = private_method_defined?(:load_script) || method_defined?(:load_script)
rescue
has_save14_load_script = false
end
if has_save14_load_script &&
!private_method_defined?(:mp_save14_quest_load_script_original) &&
!method_defined?(:mp_save14_quest_load_script_original)
alias mp_save14_quest_load_script_original load_script
def load_script(path)
if defined?(MP_Save14) && MP_Save14.quest_script_path?(path)
MP_Save14.quest_begin(path)
begin
mp_save14_quest_load_script_original(path)
ensure
MP_Save14.quest_end(path)
end
else
mp_save14_quest_load_script_original(path)
end
end
private :load_script
end
end
#==============================================================================
# Map lifecycle hooks.
#==============================================================================
if defined?(Scene_Map)
class Scene_Map
if method_defined?(:start) && !method_defined?(:mp_save14_scene_start_original)
alias mp_save14_scene_start_original start
def start(*args, &block)
result = mp_save14_scene_start_original(*args, &block)
begin
# map_start — чекпоинт: сразу в очередь с коротким delay и force-send.
MP_Save14.flush_now("map_start", true) if defined?(MP_Save14)
rescue
end
result
end
end
if method_defined?(:update) && !method_defined?(:mp_save14_scene_update_original)
alias mp_save14_scene_update_original update
def update(*args, &block)
result = mp_save14_scene_update_original(*args, &block)
begin
MP_Save14.update if defined?(MP_Save14)
rescue
end
result
end
end
end
end
if defined?(Game_Player) && Game_Player.method_defined?(:perform_transfer)
class Game_Player
unless method_defined?(:mp_save14_transfer_original)
alias mp_save14_transfer_original perform_transfer
def perform_transfer(*args, &block)
old_map = ($game_map ? $game_map.map_id.to_i : 0) rescue 0
result = mp_save14_transfer_original(*args, &block)
begin
new_map = ($game_map ? $game_map.map_id.to_i : 0) rescue 0
if new_map > 0 && new_map != old_map && defined?(MP_Save14)
# Сразу после смены карты — полный слепок с актуальными meters.
MP_Save14.flush_now("map_enter", true)
end
rescue
end
result
end
end
end
end
MP_Save14.log("loaded", "v#{MP_Save14::VERSION}; checkpoint-only + body-meter flush protection + atomic quest transactions + ClanEstate inventory ACK compatibility active") rescue nil