1255 lines
39 KiB
Ruby
1255 lines
39 KiB
Ruby
# 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
|