Files
LonaRPG-Online-Games/ModScripts/multiplayer/32_state_infra.rb
T

1255 lines
39 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# encoding: UTF-8
return if defined?($mp_state_infra_loaded) && $mp_state_infra_loaded
$mp_state_infra_loaded = true
begin
require 'json' unless defined?(JSON)
rescue Exception
end
begin
require 'digest'
rescue Exception
end
begin
require 'securerandom'
rescue Exception
end
module MPStateInfra
SCHEMA_VERSION = 2 unless const_defined?(:SCHEMA_VERSION)
STORY_SCHEMA_KEY = "mp_state_schema" unless const_defined?(:STORY_SCHEMA_KEY)
STORY_UUID_KEY = "mp_character_uuid" unless const_defined?(:STORY_UUID_KEY)
STORY_REV_KEY = "mp_state_revision" unless const_defined?(:STORY_REV_KEY)
STORY_DB_KEY = "mp_db_fingerprint" unless const_defined?(:STORY_DB_KEY)
STORY_LAST_OK_KEY = "mp_last_state_ok_at" unless const_defined?(:STORY_LAST_OK_KEY)
PERSISTENT_STORY_KEYS = [
"NoerHouseBought",
"LonaCraftHome_noer_shack",
"LonaCraftHome_noer_stonehouse",
"LonaCraftOnlineId",
"LonaCraftOnlineIds",
"LonaCraftChests",
"OverMapID",
"StartOverMapX",
"StartOverMapY",
"LastOverMapX",
"LastOverMapY",
"MPTraitBudgetFixV1"
] unless const_defined?(:PERSISTENT_STORY_KEYS)
LOG_DIR = File.join("UserData", "OnlineState") unless const_defined?(:LOG_DIR)
BACKUP_DIR = File.join(LOG_DIR, "backups") unless const_defined?(:BACKUP_DIR)
LOG_FILE = File.join(LOG_DIR, "state_audit.log") unless const_defined?(:LOG_FILE)
LOG_ENABLED = false unless const_defined?(:LOG_ENABLED)
module_function
@suppress_sync_depth = 0
@bootstrap_apply_depth = 0
@last_bootstrap_safe = true
@last_bootstrap_reason = ""
@adopt_remote_identity_once = false
@allow_blank_restore_apply_once = false
@db_fingerprint_cache_key = nil
@db_fingerprint_cache_value = nil
@pending_revision_delta = 0
def ensure_dir(path)
return if path.nil? || path.to_s == ""
return if Dir.exist?(path)
parts = path.to_s.gsub("\\", "/").split("/")
current = ""
parts.each do |part|
next if part.nil? || part == ""
current = current == "" ? part : File.join(current, part)
begin
Dir.mkdir(current) unless Dir.exist?(current)
rescue
end
end
rescue
end
def now_stamp
Time.now.strftime("%Y%m%d-%H%M%S") rescue Time.now.to_i.to_s
rescue
"time-unknown"
end
def log_line(tag, message)
# Audit logging is intentionally disabled.
false
end
def ensure_story
if defined?($story_stats) && $story_stats
if $story_stats.is_a?(Hash)
if defined?(Story_Stats)
old = $story_stats
$story_stats = Story_Stats.new
begin
$story_stats.data.merge!(old) if $story_stats.respond_to?(:data) && $story_stats.data.is_a?(Hash)
rescue
end
ensure_story_trade_hashes($story_stats)
return $story_stats.data if $story_stats.respond_to?(:data) && $story_stats.data.is_a?(Hash)
end
ensure_story_trade_hashes($story_stats)
return $story_stats
end
if $story_stats.respond_to?(:data)
data = $story_stats.data rescue nil
unless data.is_a?(Hash)
data = {}
begin
$story_stats.data = data if $story_stats.respond_to?(:data=)
rescue
end
end
ensure_story_trade_hashes($story_stats)
return data
end
end
if defined?(Story_Stats)
$story_stats = Story_Stats.new
ensure_story_trade_hashes($story_stats)
return $story_stats.data if $story_stats.respond_to?(:data) && $story_stats.data.is_a?(Hash)
end
$story_stats = {} unless defined?($story_stats) && $story_stats.is_a?(Hash)
ensure_story_trade_hashes($story_stats)
$story_stats
rescue
{}
end
# Nested story hashes must stay Hashes. Missing keys make Story_Stats#[]
# return 0, and nested ["key"] then crash with String into Integer
# (CharacterItems/Steal, record_killcount, HostageSaved, sex_record_*_count).
def ensure_story_trade_hashes(story)
return unless story
if story.respond_to?(:ensure_story_hashes!)
story.ensure_story_hashes!
return
end
if story.respond_to?(:ensure_hash!)
story.ensure_hash!("CharacterItems")
story.ensure_hash!("CharacterSteal")
if story.respond_to?(:ensure_count_hash!)
story.ensure_count_hash!("record_killcount")
story.ensure_count_hash!("HostageSaved")
story.ensure_count_hash!("sex_record_partner_count")
story.ensure_count_hash!("sex_record_race_count")
end
return
end
data = story
begin
data = story.data if story.respond_to?(:data) && story.data.is_a?(Hash)
rescue
end
return unless data.is_a?(Hash)
data["CharacterItems"] = {} unless data["CharacterItems"].is_a?(Hash)
data["CharacterSteal"] = {} unless data["CharacterSteal"].is_a?(Hash)
%w[record_killcount HostageSaved sex_record_partner_count sex_record_race_count].each do |key|
current = data[key]
next if current.is_a?(Hash) && current.default == 0
restored = Hash.new(0)
current.each { |entry_key, entry_value| restored[entry_key] = entry_value } if current.is_a?(Hash)
data[key] = restored
end
rescue
end
def generate_uuid
begin
return SecureRandom.uuid if defined?(SecureRandom) && SecureRandom.respond_to?(:uuid)
rescue
end
seed = "#{Time.now.to_f}:#{rand(0x7fffffff)}"
begin
seed += ":#{Process.pid}"
rescue
end
if defined?(Digest::SHA1)
"mp-" + Digest::SHA1.hexdigest(seed)
else
"mp-" + seed.gsub(/[^0-9A-Za-z]+/, "-")
end
rescue
"mp-" + rand(0x7fffffff).to_s
end
def ensure_character_uuid
story = ensure_story
uuid = story[STORY_UUID_KEY].to_s rescue ""
if uuid == ""
uuid = generate_uuid
story[STORY_UUID_KEY] = uuid
story[STORY_REV_KEY] = 0 if story[STORY_REV_KEY].nil?
log_line("identity", "created uuid=#{uuid}")
end
story[STORY_SCHEMA_KEY] = SCHEMA_VERSION
story[STORY_DB_KEY] = db_fingerprint
story[STORY_REV_KEY] = story[STORY_REV_KEY].to_i rescue 0
uuid
rescue
""
end
def table_fingerprint_part(table, name)
return "#{name}:nil" if table.nil?
count = 0
last_id = 0
parts = [name.to_s]
begin
table.each do |obj|
next if obj.nil?
count += 1
oid = obj.respond_to?(:id) ? obj.id.to_i : count
oname = obj.respond_to?(:name) ? obj.name.to_s : ""
last_id = oid if oid > last_id
parts << "#{oid}=#{oname}"
end
rescue
end
parts.unshift(count.to_s, last_id.to_s)
parts.join("|")
rescue
"#{name}:err"
end
def db_fingerprint
key = []
[[:i, (defined?($data_items) ? $data_items : nil)],
[:w, (defined?($data_weapons) ? $data_weapons : nil)],
[:a, (defined?($data_armors) ? $data_armors : nil)],
[:s, (defined?($data_skills) ? $data_skills : nil)]].each do |tag, table|
size = 0
last_name = ""
begin
size = table.size if table.respond_to?(:size)
last = nil
table.reverse_each { |obj| last = obj; break if obj } if table.respond_to?(:reverse_each)
last_name = last.name.to_s if last && last.respond_to?(:name)
rescue
end
key << "#{tag}:#{size}:#{last_name}"
end
cache_key = key.join("/")
return @db_fingerprint_cache_value if @db_fingerprint_cache_key == cache_key && @db_fingerprint_cache_value
raw = ""
raw << table_fingerprint_part((defined?($data_items) ? $data_items : nil), "items")
raw << table_fingerprint_part((defined?($data_weapons) ? $data_weapons : nil), "weapons")
raw << table_fingerprint_part((defined?($data_armors) ? $data_armors : nil), "armors")
raw << table_fingerprint_part((defined?($data_skills) ? $data_skills : nil), "skills")
value = if defined?(Digest::SHA1)
Digest::SHA1.hexdigest(raw)
else
raw.length.to_s
end
@db_fingerprint_cache_key = cache_key
@db_fingerprint_cache_value = value
value
rescue
"unknown"
end
def actor
begin
return $game_player.actor if defined?($game_player) && $game_player && $game_player.respond_to?(:actor)
rescue
end
begin
return $game_party.leader if defined?($game_party) && $game_party && $game_party.respond_to?(:leader)
rescue
end
nil
rescue
nil
end
def item_kind(obj)
return "none" if obj.nil?
begin
return "weapon" if defined?(RPG::Weapon) && obj.is_a?(RPG::Weapon)
rescue
end
begin
return "armor" if defined?(RPG::Armor) && obj.is_a?(RPG::Armor)
rescue
end
begin
return "weapon" if obj.respond_to?(:wtype_id) && !obj.wtype_id.nil?
rescue
end
begin
return "armor" if obj.respond_to?(:atype_id) && !obj.atype_id.nil?
rescue
end
begin
klass = obj.class.to_s.downcase
return "weapon" if klass.include?("weapon")
return "armor" if klass.include?("armor")
rescue
end
"item"
rescue
"item"
end
def data_item(kind, id)
item_id = id.to_i rescue 0
return nil if item_id <= 0
case kind.to_s.downcase
when "item"
return $data_items[item_id] if defined?($data_items) && $data_items
when "weapon"
return $data_weapons[item_id] if defined?($data_weapons) && $data_weapons
when "armor"
return $data_armors[item_id] if defined?($data_armors) && $data_armors
when "skill"
return $data_skills[item_id] if defined?($data_skills) && $data_skills
end
nil
rescue
nil
end
def item_count(obj)
return 0 if obj.nil?
begin
return $game_party.item_number(obj).to_i if defined?($game_party) && $game_party && $game_party.respond_to?(:item_number)
rescue
end
0
rescue
0
end
def local_collection_total(getter)
total = 0
begin
return 0 unless defined?($game_party) && $game_party && $game_party.respond_to?(getter)
arr = $game_party.send(getter)
arr.each { |obj| total += item_count(obj) } if arr.respond_to?(:each)
rescue
end
total
rescue
0
end
def local_skills_count(actor_obj = nil)
a = actor_obj || actor
ids = []
begin
if a && a.respond_to?(:skills)
a.skills.each do |skill|
next if skill.nil?
ids << skill.id.to_i if skill.respond_to?(:id)
end
end
rescue
end
begin
raw = a.instance_variable_get(:@skills) if a
raw.each { |sid| ids << sid.to_i if sid.to_i > 0 } if raw.is_a?(Array)
rescue
end
ids.uniq.size
rescue
0
end
def local_equips_count(actor_obj = nil)
a = actor_obj || actor
count = 0
begin
equips = a.equips if a && a.respond_to?(:equips)
if equips.is_a?(Hash)
equips.each_value { |eq| count += 1 unless eq.nil? }
elsif equips.respond_to?(:each)
equips.each { |eq| count += 1 unless eq.nil? }
end
rescue
end
count
rescue
0
end
def local_coin3_count
begin
if defined?(WebSocket) && WebSocket.respond_to?(:_live_sync_coin3_count)
return WebSocket._live_sync_coin3_count.to_i
end
rescue
end
item = nil
begin
item = $data_ItemName["ItemCoin3"] if defined?($data_ItemName) && $data_ItemName && $data_ItemName["ItemCoin3"]
rescue
item = nil
end
begin
item = $data_items[52] if item.nil? && defined?($data_items) && $data_items
rescue
end
return 0 if item.nil? || !$game_party || !$game_party.respond_to?(:item_number)
$game_party.item_number(item).to_i
rescue
0
end
def payload_coin3_count(items_hash)
return 0 unless items_hash.is_a?(Hash)
val = items_hash["52"]
val = items_hash[52] if val.nil?
[val.to_i, 0].max
rescue
0
end
def local_signature
a = actor
{
"uuid" => ensure_character_uuid,
"revision" => (ensure_story[STORY_REV_KEY].to_i rescue 0),
"schema" => SCHEMA_VERSION,
"level" => (a && a.respond_to?(:level) ? a.level.to_i : 0),
"gold" => local_coin3_count,
"items" => local_collection_total(:items),
"weapons" => local_collection_total(:weapons),
"armors" => local_collection_total(:armors),
"equips" => local_equips_count(a),
"skills" => local_skills_count(a)
}
rescue
{}
end
def local_meaningful_state?
sig = local_signature
return true if sig["items"].to_i > 0
return true if sig["weapons"].to_i > 0
return true if sig["armors"].to_i > 0
return true if sig["equips"].to_i > 0
return true if sig["skills"].to_i > 0
return true if sig["level"].to_i > 1
return true if sig["gold"].to_i > 0
false
rescue
false
end
def decode_json_blob(blob)
return blob if blob.is_a?(Hash)
if defined?(WebSocket) && WebSocket.respond_to?(:bootstrap_decode_json_blob)
decoded = WebSocket.bootstrap_decode_json_blob(blob)
return decoded if decoded.is_a?(Hash)
end
{}
rescue
{}
end
def decode_bank_json_blob(blob)
return blob if blob.is_a?(Hash) || blob.is_a?(Array)
if defined?(WebSocket) && WebSocket.respond_to?(:bootstrap_decode_json_blob)
decoded = WebSocket.bootstrap_decode_json_blob(blob)
return decoded if decoded.is_a?(Hash) || decoded.is_a?(Array)
end
{}
rescue
{}
end
def parse_blob(blob, numeric_values = true)
return blob if blob.is_a?(Hash)
if defined?(WebSocket) && WebSocket.respond_to?(:bootstrap_parse_blob)
parsed = WebSocket.bootstrap_parse_blob(blob, numeric_values)
return parsed if parsed.is_a?(Hash)
end
{}
rescue
{}
end
def payload_parts(state)
s = state.is_a?(Hash) ? state : {}
{
"items" => (s["items"].is_a?(Hash) ? s["items"] : parse_blob(s["items_blob"], true)),
"weapons" => (s["weapons"].is_a?(Hash) ? s["weapons"] : parse_blob(s["weapons_blob"], true)),
"armors" => (s["armors"].is_a?(Hash) ? s["armors"] : parse_blob(s["armors_blob"], true)),
"equips" => (s["equips"].is_a?(Hash) ? s["equips"] : parse_blob(s["equips_blob"], false)),
"skills_csv" => s["skills_csv"].to_s,
"stats_json" => (s["stats_json"].is_a?(Hash) ? s["stats_json"] : decode_json_blob(s["stats_blob"])),
"states_json" => (s["states_json"].is_a?(Hash) ? s["states_json"] : decode_json_blob(s["states_blob"])),
"player_json" => (s["player_json"].is_a?(Hash) ? s["player_json"] : decode_json_blob(s["player_blob"])),
"bank_json" => ((s["bank_json"].is_a?(Hash) || s["bank_json"].is_a?(Array)) ? s["bank_json"] : decode_bank_json_blob(s["bank_blob"]))
}
rescue
{}
end
def payload_total(hash)
total = 0
hash.each_value { |qty| total += qty.to_i if qty.to_i > 0 } if hash.is_a?(Hash)
total
rescue
0
end
def payload_skill_ids(csv)
ids = []
csv.to_s.split(",").each do |raw|
sid = raw.to_i rescue 0
ids << sid if sid > 0
end
ids.uniq
rescue
[]
end
def payload_bank_entries_count(bank_json)
entries = nil
if bank_json.is_a?(Array)
entries = bank_json
elsif bank_json.is_a?(Hash)
entries = bank_json["entries"]
entries = bank_json[:entries] if entries.nil?
end
return 0 unless entries.is_a?(Array)
total = 0
entries.each do |entry|
next unless entry.is_a?(Hash)
qty = entry["amount"]
qty = entry["qty"] if qty.nil?
qty = entry["count"] if qty.nil?
qty = entry[:amount] if qty.nil?
qty = entry[:qty] if qty.nil?
qty = entry[:count] if qty.nil?
total += qty.to_i if qty.to_i > 0
end
total
rescue
0
end
def remote_signature(state)
parts = payload_parts(state)
pj = parts["player_json"].is_a?(Hash) ? parts["player_json"] : {}
remote_gold = payload_coin3_count(parts["items"])
remote_gold = (state["gold"].to_i rescue 0) if remote_gold <= 0
{
"uuid" => pj[STORY_UUID_KEY].to_s,
"revision" => (pj[STORY_REV_KEY].to_i rescue 0),
"schema" => (pj[STORY_SCHEMA_KEY].to_i rescue 0),
"db" => pj[STORY_DB_KEY].to_s,
"level" => (state["level"].to_i rescue 0),
"gold" => remote_gold,
"items" => payload_total(parts["items"]),
"weapons" => payload_total(parts["weapons"]),
"armors" => payload_total(parts["armors"]),
"equips" => (parts["equips"].is_a?(Hash) ? parts["equips"].size : 0),
"skills" => payload_skill_ids(parts["skills_csv"]).size
}
rescue
{}
end
def validate_hash_ids(kind, hash, errors)
return unless hash.is_a?(Hash)
hash.each do |raw_id, raw_qty|
id = raw_id.to_i rescue 0
qty = raw_qty.to_i rescue 0
next if id <= 0 && qty <= 0
if id <= 0
errors << "#{kind} has invalid id=#{raw_id}"
next
end
next if qty <= 0
errors << "#{kind}##{id} missing in data" if data_item(kind, id).nil?
end
rescue => e
errors << "#{kind} validation failed #{e.class}"
end
def validate_skills(csv, errors)
payload_skill_ids(csv).each do |sid|
errors << "skill##{sid} missing in data" if data_item("skill", sid).nil?
end
rescue => e
errors << "skills validation failed #{e.class}"
end
def validate_equips(equips, errors)
return unless equips.is_a?(Hash)
a = actor
equips.each do |slot_key, token|
text = token.to_s
parts = text.split(",", 3)
raw_kind = parts[0].to_s.strip.downcase
raw_id = parts[1]
item_name = parts[2].to_s.strip
if raw_id.nil?
raw_id = raw_kind
raw_kind = ""
end
next if raw_kind == "none"
item_id = raw_id.to_i rescue 0
if item_id <= 0 && item_name == ""
errors << "equip slot #{slot_key} has empty token"
next
end
if item_id > 0 && ["weapon", "armor", "item"].include?(raw_kind)
item = data_item(raw_kind, item_id)
if item.nil?
errors << "equip slot #{slot_key} #{raw_kind}##{item_id} missing"
next
end
if defined?(WebSocket) && WebSocket.respond_to?(:_bootstrap_item_fits_slot?)
begin
errors << "equip slot #{slot_key} #{raw_kind}##{item_id} does not fit" unless WebSocket._bootstrap_item_fits_slot?(a, slot_key, item)
rescue
end
end
next
end
next if item_name != ""
errors << "equip slot #{slot_key} has no strict kind/id"
end
rescue => e
errors << "equips validation failed #{e.class}"
end
def validate_payload(state)
errors = []
return ["state is not a hash"] unless state.is_a?(Hash)
parts = payload_parts(state)
validate_hash_ids("item", parts["items"], errors)
validate_hash_ids("weapon", parts["weapons"], errors)
validate_hash_ids("armor", parts["armors"], errors)
validate_skills(parts["skills_csv"], errors)
validate_equips(parts["equips"], errors)
errors
rescue => e
["payload validation failed #{e.class}: #{e.message}"]
end
def server_spawn_payload?(state)
return false unless state.is_a?(Hash) && state["server_spawn_only"]
return false unless state.has_key?("map_id") && state.has_key?("x") && state.has_key?("y") && state.has_key?("direction")
map_id = state["map_id"].to_i
x = state["x"].to_i
y = state["y"].to_i
dir = state["direction"].to_i
map_id > 0 && x >= 0 && y >= 0 && [2, 4, 6, 8].include?(dir)
rescue
false
end
def destructive_errors(state)
errors = []
local = local_signature
remote = remote_signature(state)
local_inventory = local["items"].to_i + local["weapons"].to_i + local["armors"].to_i
remote_inventory = remote["items"].to_i + remote["weapons"].to_i + remote["armors"].to_i
if local_inventory > 0 && remote_inventory <= 0
errors << "incoming inventory is empty while local inventory has #{local_inventory}"
end
if local["skills"].to_i > 0 && remote["skills"].to_i <= 0
errors << "incoming skills are empty while local skills have #{local["skills"]}"
end
if local["equips"].to_i > 0 && remote["equips"].to_i <= 0
errors << "incoming equips are empty while local equips have #{local["equips"]}"
end
if local["level"].to_i > 1 && remote["level"].to_i > 0 && remote["level"].to_i + 2 < local["level"].to_i
errors << "incoming level #{remote["level"]} is far below local #{local["level"]}"
end
errors
rescue => e
["destructive check failed #{e.class}"]
end
def identity_errors(state)
errors = []
local_uuid = ensure_character_uuid.to_s
local_rev = ensure_story[STORY_REV_KEY].to_i rescue 0
remote = remote_signature(state)
remote_uuid = remote["uuid"].to_s
remote_rev = remote["revision"].to_i rescue 0
if remote_uuid != "" && remote_uuid != local_uuid
if @adopt_remote_identity_once
story = ensure_story
story[STORY_UUID_KEY] = remote_uuid
story[STORY_REV_KEY] = remote_rev
story[STORY_SCHEMA_KEY] = SCHEMA_VERSION
log_line("identity", "adopted remote uuid=#{remote_uuid} rev=#{remote_rev}")
else
errors << "character uuid mismatch local=#{local_uuid} remote=#{remote_uuid}"
end
elsif remote_uuid != "" && remote_rev > 0 && remote_rev + 1 < local_rev
d_errors = destructive_errors(state)
errors << "incoming revision #{remote_rev} older than local #{local_rev}" unless d_errors.empty?
end
errors
rescue => e
["identity check failed #{e.class}"]
end
def bootstrap_safe?(state, allow_blank_restore = false)
if server_spawn_payload?(state)
@last_bootstrap_safe = true
@last_bootstrap_reason = "server spawn"
return true
end
allow_blank_restore = true if @allow_blank_restore_apply_once
errors = validate_payload(state)
if errors.empty?
id_errors = identity_errors(state)
errors.concat(id_errors)
end
if errors.empty? && local_meaningful_state? && !allow_blank_restore
errors.concat(destructive_errors(state))
end
if errors.empty?
@last_bootstrap_safe = true
@last_bootstrap_reason = "ok"
true
else
@last_bootstrap_safe = false
@last_bootstrap_reason = errors.join("; ")
log_line("bootstrap_rejected", @last_bootstrap_reason)
@adopt_remote_identity_once = false
@allow_blank_restore_apply_once = false
false
end
rescue => e
@last_bootstrap_safe = false
@last_bootstrap_reason = "#{e.class}: #{e.message}"
log_line("bootstrap_rejected", @last_bootstrap_reason)
@adopt_remote_identity_once = false
@allow_blank_restore_apply_once = false
false
ensure
unless allow_blank_restore
@adopt_remote_identity_once = false
@allow_blank_restore_apply_once = false
end
end
def bootstrap_valid_for_blank_restore?(state)
if server_spawn_payload?(state)
@last_bootstrap_safe = true
@last_bootstrap_reason = "server spawn"
return true
end
errors = validate_payload(state)
remote = remote_signature(state)
parts = payload_parts(state)
remote_total = remote["items"].to_i + remote["weapons"].to_i + remote["armors"].to_i + remote["equips"].to_i + remote["skills"].to_i
remote_total += 1 if remote["level"].to_i > 1 || remote["gold"].to_i > 0
remote_total += 1 if state.is_a?(Hash) && (state["hp"].to_i > 0 || state["max_hp"].to_i > 0 || state["sta"].to_i > 0 || state["sat"].to_i > 0)
remote_total += 1 if parts["stats_json"].is_a?(Hash) && !parts["stats_json"].empty?
remote_total += 1 if parts["states_json"].is_a?(Hash) && !parts["states_json"].empty?
remote_total += 1 if parts["player_json"].is_a?(Hash) && !parts["player_json"].empty?
remote_total += 1 if payload_bank_entries_count(parts["bank_json"]) > 0
if remote_total <= 0
errors << "server state is empty; blank restore denied"
end
if errors.empty?
@adopt_remote_identity_once = true
@allow_blank_restore_apply_once = true
true
else
@last_bootstrap_safe = false
@last_bootstrap_reason = errors.join("; ")
log_line("blank_restore_denied", @last_bootstrap_reason)
false
end
rescue => e
@last_bootstrap_safe = false
@last_bootstrap_reason = "#{e.class}: #{e.message}"
log_line("blank_restore_denied", @last_bootstrap_reason)
@allow_blank_restore_apply_once = false
false
end
def suppress_sync?
@suppress_sync_depth.to_i > 0 || @bootstrap_apply_depth.to_i > 0
rescue
false
end
def with_sync_suppressed(reason = nil)
@suppress_sync_depth = @suppress_sync_depth.to_i + 1
log_line("sync_suppressed", reason.to_s) if reason
yield
ensure
@suppress_sync_depth = @suppress_sync_depth.to_i - 1
@suppress_sync_depth = 0 if @suppress_sync_depth < 0
end
def live_sync_allowed?(reason = nil)
return false if suppress_sync?
if defined?(WebSocket) && WebSocket.respond_to?(:bootstrap_sync_unlocked?)
begin
return false unless WebSocket.bootstrap_sync_unlocked?
rescue
end
end
true
rescue
true
end
def note_local_change(reason = nil)
return if suppress_sync?
@pending_revision_delta = @pending_revision_delta.to_i + 1
begin
MPImmediateLiveSync.defer(reason) if defined?(MPImmediateLiveSync) && MPImmediateLiveSync.respond_to?(:defer)
rescue
end
rescue
end
def flush_pending_local_changes
delta = @pending_revision_delta.to_i
return false if delta <= 0
story = ensure_story
ensure_character_uuid
story[STORY_REV_KEY] = story[STORY_REV_KEY].to_i + delta
story[STORY_SCHEMA_KEY] = SCHEMA_VERSION
story[STORY_DB_KEY] = db_fingerprint
@pending_revision_delta = 0
true
rescue
false
end
def copy_file(src, dst)
File.open(src, "rb") do |input|
File.open(dst, "wb") do |output|
loop do
chunk = input.read(64 * 1024)
break if chunk.nil? || chunk.empty?
output.write(chunk)
end
end
end
true
rescue
false
end
def selected_slot_index
begin
return OnlineServerRegistry.selected_slot_index.to_i if defined?(OnlineServerRegistry) && OnlineServerRegistry.respond_to?(:selected_slot_index)
rescue
end
0
rescue
0
end
def backup_selected_save(reason = "bootstrap")
return nil unless defined?(DataManager) && DataManager.respond_to?(:make_filename)
idx = selected_slot_index
path = DataManager.make_filename(idx) rescue nil
return nil if path.nil? || path.to_s == "" || !File.exist?(path)
ensure_dir(BACKUP_DIR)
base = File.basename(path)
dst = File.join(BACKUP_DIR, "#{base}.#{now_stamp}.#{reason}.bak")
if copy_file(path, dst)
log_line("backup", "slot=#{idx} src=#{path} dst=#{dst}")
dst
else
log_line("backup_failed", "slot=#{idx} src=#{path}")
nil
end
rescue => e
log_line("backup_failed", "#{e.class}: #{e.message}")
nil
end
def before_bootstrap_apply(state)
ensure_character_uuid
backup_selected_save("before-bootstrap")
log_line("bootstrap_before", "local=#{local_signature.inspect} remote=#{remote_signature(state).inspect}")
@bootstrap_apply_depth = @bootstrap_apply_depth.to_i + 1
rescue
@bootstrap_apply_depth = @bootstrap_apply_depth.to_i + 1
end
def after_bootstrap_apply(state, ok)
@bootstrap_apply_depth = @bootstrap_apply_depth.to_i - 1
@bootstrap_apply_depth = 0 if @bootstrap_apply_depth < 0
if ok
story = ensure_story
remote = remote_signature(state)
story[STORY_SCHEMA_KEY] = SCHEMA_VERSION
story[STORY_DB_KEY] = db_fingerprint
story[STORY_REV_KEY] = [story[STORY_REV_KEY].to_i, remote["revision"].to_i].max
story[STORY_LAST_OK_KEY] = Time.now.to_i rescue 0
@last_bootstrap_safe = true
@last_bootstrap_reason = "applied"
log_line("bootstrap_after", "ok local=#{local_signature.inspect}")
else
@last_bootstrap_safe = false
@last_bootstrap_reason = "apply returned false"
log_line("bootstrap_after", "failed local=#{local_signature.inspect}")
end
rescue => e
@bootstrap_apply_depth = 0
@last_bootstrap_safe = false
@last_bootstrap_reason = "#{e.class}: #{e.message}"
log_line("bootstrap_after", @last_bootstrap_reason)
ensure
@adopt_remote_identity_once = false
@allow_blank_restore_apply_once = false
end
def bootstrap_autosave_allowed?
!!@last_bootstrap_safe
rescue
false
end
def last_bootstrap_reason
@last_bootstrap_reason.to_s
rescue
""
end
def normalize_persistent_story_value(value)
return value.to_i if value.is_a?(Numeric)
text = value.to_s
return text.to_i if text =~ /\A-?\d+\z/
text
rescue
value
end
def inject_persistent_story_flags(out, story=nil)
out = {} unless out.is_a?(Hash)
story ||= ensure_story
return out unless story && story.respond_to?(:has_key?)
flags = out["story_flags"].is_a?(Hash) ? out["story_flags"] : {}
PERSISTENT_STORY_KEYS.each do |key|
next unless story.has_key?(key)
flags[key] = normalize_persistent_story_value(story[key])
end
out["story_flags"] = flags unless flags.empty?
out
rescue
out || {}
end
def inject_player_meta(out)
flush_pending_local_changes
ensure_character_uuid
story = ensure_story
out[STORY_SCHEMA_KEY] = SCHEMA_VERSION
out[STORY_UUID_KEY] = story[STORY_UUID_KEY].to_s
out[STORY_REV_KEY] = story[STORY_REV_KEY].to_i
out[STORY_DB_KEY] = db_fingerprint
inject_persistent_story_flags(out, story)
out
rescue
out
end
end
if defined?(WebSocket)
module WebSocket
class << self
unless method_defined?(:mp_state_infra_apply_bootstrap_state_without_guard)
alias mp_state_infra_apply_bootstrap_state_without_guard apply_bootstrap_state
end
def apply_bootstrap_state(state)
return false unless defined?(MPStateInfra)
return false unless MPStateInfra.bootstrap_safe?(state)
ok = false
MPStateInfra.before_bootstrap_apply(state)
begin
ok = !!mp_state_infra_apply_bootstrap_state_without_guard(state)
ensure
MPStateInfra.after_bootstrap_apply(state, ok)
end
ok
rescue => e
MPStateInfra.log_line("bootstrap_exception", "#{e.class}: #{e.message}") rescue nil
false
end
def bootstrap_peek_state
@bootstrap_state_pending
rescue
nil
end
unless method_defined?(:mp_state_infra_try_finish_bootstrap_without_guard)
alias mp_state_infra_try_finish_bootstrap_without_guard try_finish_bootstrap_handshake
end
def try_finish_bootstrap_handshake
return false unless @connected
return false unless @version_ok
mode = @bootstrap_mode.to_s
return false if mode == ""
if mode == "new"
return false unless @bootstrap_applied
return _bootstrap_send_loaded_ack
end
scene_ok = false
begin
scene_ok = gameplay_scene_active? if respond_to?(:gameplay_scene_active?)
rescue
scene_ok = false
end
begin
scene_ok = SceneManager.scene_is?(Scene_Map) if !scene_ok && defined?(SceneManager)
rescue
end
return false unless scene_ok
return _bootstrap_send_loaded_ack if @bootstrap_applied
return false if respond_to?(:bootstrap_body_ready?) && !bootstrap_body_ready?
return false unless bootstrap_state_ready?
state = consume_bootstrap_state
return false unless state.is_a?(Hash)
ok = apply_bootstrap_state(state)
return false unless ok
@bootstrap_applied = true
_bootstrap_send_loaded_ack
rescue => e
MPStateInfra.log_line("bootstrap_finish_failed", "#{e.class}: #{e.message}") rescue nil
false
end
if method_defined?(:_live_sync_collect_player_meta)
unless method_defined?(:mp_state_infra_collect_player_meta_without_identity)
alias mp_state_infra_collect_player_meta_without_identity _live_sync_collect_player_meta
end
def _live_sync_collect_player_meta(actor)
out = mp_state_infra_collect_player_meta_without_identity(actor)
out = {} unless out.is_a?(Hash)
MPStateInfra.inject_player_meta(out)
rescue
out || {}
end
end
if method_defined?(:_live_sync_equip_id)
unless method_defined?(:mp_state_infra_live_sync_equip_id_without_strict)
alias mp_state_infra_live_sync_equip_id_without_strict _live_sync_equip_id
end
def _live_sync_equip_id(eq)
return 0 if eq.nil?
begin
item_id = eq.id.to_i if eq.respond_to?(:id)
return item_id if item_id && item_id > 0
rescue
end
name = ""
begin
name = eq.item_name.to_s if eq.respond_to?(:item_name)
rescue
name = ""
end
begin
name = eq.name.to_s if name.to_s.strip == "" && eq.respond_to?(:name)
rescue
end
return 0 if name.to_s.strip == ""
kind = _live_sync_equip_kind(eq) rescue ""
table = case kind.to_s
when "weapon" then (defined?($data_weapons) ? $data_weapons : nil)
when "armor" then (defined?($data_armors) ? $data_armors : nil)
else nil
end
if table && table.respond_to?(:each)
table.each do |obj|
next if obj.nil?
begin
return obj.id.to_i if obj.respond_to?(:id) && obj.respond_to?(:name) && obj.name.to_s == name.to_s
rescue
end
end
end
0
rescue
0
end
end
if method_defined?(:_bootstrap_resolve_equip_item)
unless method_defined?(:mp_state_infra_resolve_equip_item_without_strict)
alias mp_state_infra_resolve_equip_item_without_strict _bootstrap_resolve_equip_item
end
def _bootstrap_resolve_equip_item(actor, slot_ref, kind, item_id, item_name = "")
iid = item_id.to_i rescue 0
raw_kind = kind.to_s.strip.downcase
stable_name = item_name.to_s.strip
# item_name is stable across database/mod load-order changes; runtime
# numeric IDs are not. Resolve the named object first so a musket (or
# any other equipment) cannot become a different item after relog.
if stable_name != ""
begin
named_item = _bootstrap_data_item_by_name(stable_name)
if !named_item.nil? && _bootstrap_item_fits_slot?(actor, slot_ref, named_item)
kind_ok = !respond_to?(:_bootstrap_item_kind_matches?) || _bootstrap_item_kind_matches?(named_item, raw_kind)
if kind_ok
begin
if iid > 0 && named_item.respond_to?(:id) && named_item.id.to_i != iid
MPStateInfra.log_line("bootstrap_equip_id_mismatch", "slot=#{slot_ref} #{raw_kind} stored_id=#{iid} name=#{stable_name} resolved_id=#{named_item.id}") if defined?(MPStateInfra) && MPStateInfra.respond_to?(:log_line)
end
rescue
end
return named_item
end
end
rescue
end
end
if iid > 0 && ["weapon", "armor", "item"].include?(raw_kind)
item = _bootstrap_data_item(raw_kind, iid)
return nil if item.nil?
return item if _bootstrap_item_fits_slot?(actor, slot_ref, item)
return nil
end
mp_state_infra_resolve_equip_item_without_strict(actor, slot_ref, kind, item_id, item_name)
rescue
nil
end
end
end
end
end
if defined?(Story_Stats)
class Story_Stats
unless method_defined?(:mp_quest_cloud_set_without_sync)
alias mp_quest_cloud_set_without_sync []=
def []=(key, value)
existed = false
previous = nil
begin
data = instance_variable_get(:@data)
if data.is_a?(Hash)
existed = data.has_key?(key)
previous = data[key] if existed
end
rescue
existed = false
previous = nil
end
result = mp_quest_cloud_set_without_sync(key, value)
changed = !existed || previous != value
return result unless changed
return result unless defined?(MPQuestCloudState) && MPQuestCloudState.quest_key?(key)
reason = "cloud_manual_quest_story:#{key}"
begin
if defined?(MPImmediateLiveSync) && MPImmediateLiveSync.respond_to?(:trigger)
MPImmediateLiveSync.trigger(reason, false, false)
elsif defined?(MPStateInfra) && MPStateInfra.respond_to?(:note_local_change)
MPStateInfra.note_local_change(reason)
end
rescue
end
result
end
end
end
end
if defined?(MPImmediateLiveSync)
module MPImmediateLiveSync
class << self
unless method_defined?(:mp_state_infra_trigger_without_guard)
alias mp_state_infra_trigger_without_guard trigger
end
def trigger(reason=nil, with_playersync=true, with_position=false)
MPStateInfra.note_local_change(reason) if defined?(MPStateInfra)
return false if defined?(MPStateInfra) && !MPStateInfra.live_sync_allowed?(reason)
mp_state_infra_trigger_without_guard(reason, with_playersync, with_position)
rescue
false
end
end
end
end
if defined?(MP_ServerSyncSave)
module MP_ServerSyncSave
class << self
unless method_defined?(:mp_state_infra_request_selected_slot_save_without_guard)
alias mp_state_infra_request_selected_slot_save_without_guard request_selected_slot_save
end
def request_selected_slot_save(reason="server_sync")
if defined?(MPStateInfra) && !MPStateInfra.bootstrap_autosave_allowed?
MPStateInfra.log_line("server_slot_save_blocked", MPStateInfra.last_bootstrap_reason)
return false
end
mp_state_infra_request_selected_slot_save_without_guard(reason)
rescue
false
end
unless method_defined?(:mp_state_infra_safe_to_save_now_without_guard)
alias mp_state_infra_safe_to_save_now_without_guard safe_to_save_now?
end
def safe_to_save_now?
return false if defined?(MPStateInfra) && MPStateInfra.suppress_sync?
return false if defined?(MPStateInfra) && !MPStateInfra.bootstrap_autosave_allowed?
mp_state_infra_safe_to_save_now_without_guard
rescue
false
end
end
end
end
if defined?(DataManager)
module DataManager
class << self
unless method_defined?(:mp_state_infra_setup_new_game_without_identity)
alias mp_state_infra_setup_new_game_without_identity setup_new_game
end
def setup_new_game(*args, &block)
result = mp_state_infra_setup_new_game_without_identity(*args, &block)
MPStateInfra.ensure_character_uuid if defined?(MPStateInfra)
result
end
unless method_defined?(:mp_state_infra_extract_save_contents_without_identity)
alias mp_state_infra_extract_save_contents_without_identity extract_save_contents
end
def extract_save_contents(contents)
result = mp_state_infra_extract_save_contents_without_identity(contents)
MPStateInfra.ensure_character_uuid if defined?(MPStateInfra)
result
end
end
end
end