# 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