Files
LonaRPG-Online-Games/ModScripts/multiplayer/14_autosave.rb
T

2113 lines
71 KiB
Ruby
Raw Normal View History

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