2113 lines
71 KiB
Ruby
2113 lines
71 KiB
Ruby
# 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
|