# 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__; # * 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