Files
LonaRPG-Online-Games/ModScripts/multiplayer/21_sync.rb
T
2026-10-29 21:59:06 +04:00

2273 lines
67 KiB
Ruby
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
require 'zlib'
# Quest progress is spread across Story_Stats and does not have a single
# registry in the base game. Keep the predicate in one place so both the
# cloud serializer and Story_Stats change hook use exactly the same rules.
module MPQuestCloudState
QUEST_KEY_PREFIXES = [
"quprog", "rec", "guild", "unique", "hostage",
"ending_", "endunlock", "recordfirstmission",
"nfl_", "southfl_", "smcloudvillage_", "syb_"
] unless const_defined?(:QUEST_KEY_PREFIXES)
QUEST_EXACT_KEYS = [
"BackStreetArrearsInterest",
"BackStreetArrearsPrepayDateAMT",
"BackStreetArrearsPrincipal",
"BackStreetArrearsWhorePrincipal",
"Captured",
"CapturedStatic",
"Captured_PrisonMiningNeed",
"Captured_PrisonMiningPoint",
"CecilyCoinSupport",
"CoconaFoodSupport",
"DreamPTSD",
"Kidnapping",
"NoerHouseBought",
"LonaCraftHome_noer_shack",
"LonaCraftHome_noer_stonehouse",
"LonaCraftOnlineId",
"LonaCraftOnlineIds",
"LonaCraftChests",
"SlaveOwner"
] unless const_defined?(:QUEST_EXACT_KEYS)
def self.quest_key?(key)
text = key.to_s
return false if text == ""
down = text.downcase
return true if down.include?("quest") || down.include?("mission")
return true if QUEST_KEY_PREFIXES.any? { |prefix| down.start_with?(prefix) }
QUEST_EXACT_KEYS.include?(text)
rescue
false
end
end
# encoding: UTF-8
#==============================================================================
# 20_sync.rb
#------------------------------------------------------------------------------
# Отправляет на сервер в реальном времени слепок состояния игрока:
# - уровень
# - золото
# - HP / MaxHP
# - предметы, оружие, броня
# - экипировка по слотам
#
# Формат пакета:
# sync_state:<level>:<gold>:<hp>:<max_hp>:<items>:<weapons>:<armors>:<equips>
#==============================================================================
module WebSocket
LIVE_SYNC_INTERVAL = 0.50 unless const_defined?(:LIVE_SYNC_INTERVAL)
LIVE_SYNC_FORCE_INTERVAL = 5.00 unless const_defined?(:LIVE_SYNC_FORCE_INTERVAL)
LIVE_SYNC_PROBE_INTERVAL = 0.20 unless const_defined?(:LIVE_SYNC_PROBE_INTERVAL)
LIVE_SYNC_STATS_BLOB_LIMIT = 32768 unless const_defined?(:LIVE_SYNC_STATS_BLOB_LIMIT)
LIVE_SYNC_AUX_BLOB_LIMIT = 32768 unless const_defined?(:LIVE_SYNC_AUX_BLOB_LIMIT)
LIVE_SYNC_BANK_BLOB_LIMIT = 262144 unless const_defined?(:LIVE_SYNC_BANK_BLOB_LIMIT)
LIVE_SYNC_BODY_BLOB_LIMIT = 262144 unless const_defined?(:LIVE_SYNC_BODY_BLOB_LIMIT)
@live_sync_last_sig = nil
@live_sync_last_at = 0.0
@live_sync_last_force_at = 0.0
@live_sync_last_probe_at = 0.0
def self._live_sync_now
begin
Time.now.to_f
rescue
0.0
end
end
def self._live_sync_log(tag, message)
if defined?(MPStateInfra) && MPStateInfra.respond_to?(:log_line)
MPStateInfra.log_line(tag.to_s, message.to_s)
end
rescue
end
def self._live_sync_hotkey_summary
player = nil
begin
player = $game_player if defined?($game_player)
rescue
player = nil
end
return "player=nil" if player.nil?
names = %w[slot_skill_normal slot_skill_heavy slot_skill_control slot_hotkey_0 slot_hotkey_1 slot_hotkey_2 slot_hotkey_3 slot_hotkey_4 slot_hotkey_other slot_RosterCurrent slot_RosterArray]
out = []
names.each do |name|
begin
value = nil
if player.respond_to?(name)
value = player.send(name)
else
value = player.instance_variable_get(("@" + name).to_sym)
end
if name == "slot_RosterArray" && value.respond_to?(:length)
current = 0
begin
current = player.slot_RosterCurrent.to_i if player.respond_to?(:slot_RosterCurrent)
rescue
current = 0
end
row = nil
begin
row = value[current]
rescue
row = nil
end
value = "len=#{value.length},cur=#{current},row=#{row.inspect}"
end
out << "#{name}=#{value.inspect}"
rescue
end
end
out.join(" ")
rescue
"summary_error"
end
def self._live_sync_actor
actor = nil
begin
actor = $game_player.actor if $game_player && $game_player.respond_to?(:actor)
rescue
actor = nil
end
if actor.nil?
begin
actor = $game_party.leader if $game_party
rescue
actor = nil
end
end
actor
end
def self._live_sync_arena_mode?
begin
return arena_active_runtime? if respond_to?(:arena_active_runtime?)
rescue
end
begin
return !!MP_ArenaFlag.arena_active? if defined?(MP_ArenaFlag) && MP_ArenaFlag.respond_to?(:arena_active?)
rescue
end
begin
runtime = $mp_arena_runtime_flag
return runtime.to_i == 1 unless runtime.nil?
rescue
end
false
rescue
false
end
def self._live_sync_item_count(db_item)
return 0 if db_item.nil?
begin
return $game_party.item_number(db_item).to_i if $game_party && $game_party.respond_to?(:item_number)
rescue
end
0
end
def self._live_sync_collect_array(arr)
out = {}
return out if arr.nil?
begin
arr.each do |obj|
next if obj.nil?
item_id = 0
begin
item_id = obj.id.to_i
rescue
item_id = 0
end
next if item_id <= 0
qty = _live_sync_item_count(obj)
next if qty <= 0
out[item_id] = qty
end
rescue
end
out
end
def self._live_sync_collect_items
begin
return _live_sync_collect_array($game_party.items)
rescue
{}
end
end
def self._live_sync_coin3_item
begin
return $data_ItemName["ItemCoin3"] if defined?($data_ItemName) && $data_ItemName && $data_ItemName["ItemCoin3"]
rescue
end
begin
return $data_items[52] if defined?($data_items) && $data_items
rescue
end
nil
end
def self._live_sync_coin3_count
item = _live_sync_coin3_item
return 0 if item.nil? || !$game_party || !$game_party.respond_to?(:item_number)
$game_party.item_number(item).to_i
rescue
0
end
def self._live_sync_collect_weapons
begin
return _live_sync_collect_array($game_party.weapons)
rescue
{}
end
end
def self._live_sync_collect_armors
begin
return _live_sync_collect_array($game_party.armors)
rescue
{}
end
end
def self._live_sync_equip_kind(eq)
return "none" if eq.nil?
begin
return "weapon" if defined?(RPG::Weapon) && eq.is_a?(RPG::Weapon)
rescue
end
begin
return "armor" if defined?(RPG::Armor) && eq.is_a?(RPG::Armor)
rescue
end
begin
return "weapon" if eq.respond_to?(:is_weapon?) && eq.is_weapon?
rescue
end
begin
return "armor" if eq.respond_to?(:is_armor?) && eq.is_armor?
rescue
end
begin
return "weapon" if eq.respond_to?(:weapon?) && eq.weapon?
rescue
end
begin
return "armor" if eq.respond_to?(:armor?) && eq.armor?
rescue
end
begin
return "weapon" if eq.respond_to?(:wtype_id) && !eq.wtype_id.nil?
rescue
end
begin
return "armor" if eq.respond_to?(:atype_id) && !eq.atype_id.nil?
rescue
end
begin
if eq.respond_to?(:etype_id)
etype = eq.etype_id.to_i
return "weapon" if etype == 0
return "armor" if etype > 0
end
rescue
end
klass = ""
begin
klass = eq.class.to_s.downcase
rescue
klass = ""
end
return "weapon" if klass.include?("weapon")
return "armor" if klass.include?("armor")
"item"
rescue
"item"
end
def self._live_sync_equip_id(eq)
return 0 if eq.nil?
item_id = 0
begin
item_id = eq.id.to_i if eq.respond_to?(:id)
rescue
item_id = 0
end
if item_id <= 0
begin
if eq.respond_to?(:item_name)
raw = eq.item_name.to_s
item_id = raw.to_i
if item_id <= 0 && defined?($data_ItemName) && $data_ItemName
ref = $data_ItemName[raw]
item_id = ref.id.to_i if ref && ref.respond_to?(:id)
end
end
rescue
item_id = 0
end
end
if item_id <= 0
begin
if eq.respond_to?(:name) && defined?($data_ItemName) && $data_ItemName
ref = $data_ItemName[eq.name.to_s]
item_id = ref.id.to_i if ref && ref.respond_to?(:id)
end
rescue
end
end
item_id = 0 if item_id < 0
item_id
rescue
0
end
def self._live_sync_equip_name(eq)
return "" if eq.nil?
name = ""
begin
name = eq.item_name.to_s if eq.respond_to?(:item_name)
rescue
name = ""
end
if name.to_s.strip == ""
begin
name = eq.name.to_s if eq.respond_to?(:name)
rescue
name = ""
end
end
text = name.to_s.strip
text = text.gsub(",", ";")
text
rescue
""
end
def self._live_sync_storage_item_kind(item)
return "" if item.nil?
begin
return "item" if defined?(RPG::Item) && item.is_a?(RPG::Item)
rescue
end
begin
return "weapon" if defined?(RPG::Weapon) && item.is_a?(RPG::Weapon)
rescue
end
begin
return "armor" if defined?(RPG::Armor) && item.is_a?(RPG::Armor)
rescue
end
begin
return "weapon" if item.respond_to?(:is_weapon?) && item.is_weapon?
rescue
end
begin
return "armor" if item.respond_to?(:is_armor?) && item.is_armor?
rescue
end
begin
return "weapon" if item.respond_to?(:wtype_id) && !item.wtype_id.nil?
rescue
end
begin
return "armor" if item.respond_to?(:atype_id) && !item.atype_id.nil?
rescue
end
begin
raw_type = item.type.to_i if item.respond_to?(:type)
return "item" if raw_type == 0
return "weapon" if raw_type == 1
return "armor" if raw_type == 2
rescue
end
klass = ""
begin
klass = item.class.to_s.downcase
rescue
klass = ""
end
return "weapon" if klass.include?("weapon")
return "armor" if klass.include?("armor")
return "item" if klass.include?("item")
"item"
rescue
""
end
def self._live_sync_storage_item_id(item)
return 0 if item.nil?
begin
return item.id.to_i if item.respond_to?(:id) && item.id.to_i > 0
rescue
end
0
rescue
0
end
def self._live_sync_storage_item_name(item)
return "" if item.nil?
name = ""
begin
name = item.item_name.to_s if item.respond_to?(:item_name)
rescue
name = ""
end
if name.to_s.strip == ""
begin
name = item.name.to_s if item.respond_to?(:name)
rescue
name = ""
end
end
text = name.to_s.strip
text = text.gsub("\r", " ").gsub("\n", " ").gsub(":", ";").gsub("|", "/")
text
rescue
""
end
def self._live_sync_bank_storage_id
begin
return System_Settings::STORAGE_BANK.to_i if defined?(System_Settings) && System_Settings.const_defined?(:STORAGE_BANK)
rescue
end
65533
rescue
65533
end
def self._live_sync_collect_storage_box(box_id)
out = { "storage_id" => box_id.to_i, "entries" => [] }
return out unless defined?($game_boxes) && $game_boxes && $game_boxes.respond_to?(:box)
box = nil
begin
box = $game_boxes.box(box_id)
rescue
box = nil
end
return out unless box.is_a?(Hash)
box.each do |item, amount|
qty = 0
begin
qty = amount.to_i
rescue
qty = 0
end
next if qty <= 0 || item.nil?
kind = _live_sync_storage_item_kind(item)
item_id = _live_sync_storage_item_id(item)
name = _live_sync_storage_item_name(item)
next if kind.to_s == "" || (item_id <= 0 && name.to_s == "")
out["entries"] << {
"kind" => kind.to_s,
"id" => item_id.to_i,
"name" => name.to_s,
"amount" => qty.to_i
}
end
begin
out["entries"].sort_by! { |entry| [entry["kind"].to_s, entry["id"].to_i, entry["name"].to_s] }
rescue
end
out
rescue
{ "storage_id" => box_id.to_i, "entries" => [] }
end
def self._live_sync_collect_bank_storage
out = _live_sync_collect_storage_box(_live_sync_bank_storage_id)
begin
if defined?(LonaCraft::ChestCloud) && LonaCraft::ChestCloud.respond_to?(:collect_for_bank)
chests = LonaCraft::ChestCloud.collect_for_bank
out["lc_chests"] = chests if chests.is_a?(Array) && !chests.empty?
end
rescue
end
out
rescue
{ "storage_id" => _live_sync_bank_storage_id, "entries" => [] }
end
def self._live_sync_collect_equips(actor)
out = {}
return out if actor.nil?
equips = nil
begin
equips = actor.equips if actor.respond_to?(:equips)
rescue
equips = nil
end
return out if equips.nil?
begin
if equips.is_a?(Hash)
equips.each do |slot_key, eq|
slot = slot_key.to_s
next if slot == ""
kind = _live_sync_equip_kind(eq)
item_id = _live_sync_equip_id(eq)
item_name = _live_sync_equip_name(eq)
token = kind.to_s + "," + item_id.to_i.to_s
token += "," + item_name unless item_name.to_s.empty?
out[slot] = token
end
else
equips.each_with_index do |eq, idx|
kind = _live_sync_equip_kind(eq)
item_id = _live_sync_equip_id(eq)
item_name = _live_sync_equip_name(eq)
token = kind.to_s + "," + item_id.to_i.to_s
token += "," + item_name unless item_name.to_s.empty?
out[idx.to_i] = token
end
end
rescue
end
out
end
def self._live_sync_skills_csv(actor)
return "" if actor.nil?
skill_ids = []
begin
# actor.skills also contains temporary equipment/state grants.
# Only persist the actor's learned skills.
raw = actor.instance_variable_get(:@skills)
if raw.is_a?(Array)
raw.each do |sid|
begin
sid_i = sid.to_i
skill_ids << sid_i if sid_i > 0
rescue
end
end
end
rescue
end
skill_ids = skill_ids.uniq.sort
skill_ids.join(",")
rescue
""
end
def self._live_sync_sanitize_json_value(value)
return value if value.nil? || value.is_a?(Numeric) || value == true || value == false
if value.is_a?(String)
s = value.dup
begin
s.force_encoding("UTF-8")
rescue
end
return s
end
if value.is_a?(Symbol)
return value.to_s
end
if value.is_a?(Array)
return value.map { |vv| _live_sync_sanitize_json_value(vv) }
end
if value.is_a?(Hash)
out = {}
value.each do |kk, vv|
out[kk.to_s] = _live_sync_sanitize_json_value(vv)
end
return out
end
begin
return value.to_i if value.respond_to?(:to_i) && value.to_i.to_s == value.to_s
rescue
end
begin
return value.to_f if value.respond_to?(:to_f) && value.to_f.to_s == value.to_s
rescue
end
value.to_s
rescue
value.to_s
end
def self._live_sync_json_escape(value)
s = value.to_s
begin
s.force_encoding("UTF-8")
rescue
end
# Never use a replacement string for backslashes here. Ruby interprets
# backslashes in String#gsub replacements a second time, so the previous
# gsub("\\", "\\\\") could leave Lona control codes such as \} in the
# generated JSON. Jackson then rejects the whole cloud-save packet with
# "Unrecognized character escape '}'". A block returns the exact bytes.
s = s.gsub(/["\\\x00-\x1f]/) do |char|
case char
when '"' then '\\"'
when '\\' then '\\\\'
when "\b" then '\\b'
when "\f" then '\\f'
when "\n" then '\\n'
when "\r" then '\\r'
when "\t" then '\\t'
else "\\u%04x" % char.ord
end
end
"\"" + s + "\""
rescue
"\"\""
end
def self._live_sync_json_generate(value)
return "null" if value.nil?
return "true" if value == true
return "false" if value == false
if value.is_a?(Numeric)
text = value.to_s
return "0" if text =~ /nan|inf/i
return text
end
return _live_sync_json_escape(value.to_s) if value.is_a?(String) || value.is_a?(Symbol)
if value.is_a?(Array)
return "[" + value.map { |vv| _live_sync_json_generate(vv) }.join(",") + "]"
end
if value.is_a?(Hash)
keys = []
begin
keys = value.keys.sort_by { |k| k.to_s }
rescue
keys = value.keys
end
pairs = []
keys.each do |key|
pairs << (_live_sync_json_escape(key.to_s) + ":" + _live_sync_json_generate(value[key]))
end
return "{" + pairs.join(",") + "}"
end
_live_sync_json_escape(value.to_s)
rescue
"null"
end
def self._live_sync_collect_stats(actor)
out = {}
return out if actor.nil?
begin
act_stat = actor.instance_variable_get(:@actStat)
raw = act_stat.stat if act_stat && act_stat.respond_to?(:stat)
if raw.is_a?(Hash)
raw.each do |kk, vv|
key = kk.to_s
next if key.nil? || key == ""
if vv.is_a?(Array)
out[key] = _live_sync_sanitize_json_value(vv[0])
else
out[key] = _live_sync_sanitize_json_value(vv)
end
end
end
rescue
end
begin
act_stat = actor.instance_variable_get(:@actStat)
raw = act_stat.stat if act_stat && act_stat.respond_to?(:stat)
out["act_stat_full"] = _live_sync_sanitize_json_value(raw) if raw.is_a?(Hash)
rescue
end
begin
out["trait_point"] = actor.trait_point.to_i if actor.respond_to?(:trait_point)
rescue
end
begin
out["actor_class_id"] = actor.instance_variable_get(:@class_id).to_i
rescue
end
begin
out["actor_exp"] = _live_sync_sanitize_json_value(actor.instance_variable_get(:@exp))
rescue
end
begin
out["actor_skills"] = _live_sync_sanitize_json_value(actor.instance_variable_get(:@skills))
out["learned_skills_version"] = actor.instance_variable_get(:@mp_learned_skills_version).to_i
rescue
end
# Quest progress used to live only in the separately requested body blob.
# Keep an authoritative copy in the atomic stats row as well. Bootstrap
# applies this ledger last, after any legacy/stale body response.
begin
if defined?(MP_Save14) && MP_Save14.respond_to?(:collect_progression_ledger)
ledger = MP_Save14.collect_progression_ledger
out["progression_ledger"] = _live_sync_sanitize_json_value(ledger) if ledger.is_a?(Hash)
out["progression_ledger_version"] = 1
end
rescue
end
# Race and registered cosmetic values are portrait state in LonaRPG, not
# actStat values. Keep the registry generic so appearance mods can opt in.
begin
portrait = actor.respond_to?(:portrait_stat_value) ? actor.portrait_stat_value : actor.instance_variable_get(:@prt_stat)
identity = {}
if portrait.is_a?(Hash)
portrait.each do |raw_key, raw_value|
key = raw_key.to_s
persistent_mod_key = defined?(MPPortraitPersistence) && MPPortraitPersistence.key?(key)
next unless key.downcase.include?("race") || persistent_mod_key
identity[key] = _live_sync_sanitize_json_value(raw_value)
end
end
out["portrait_identity"] = identity unless identity.empty?
rescue
end
begin
out["hp"] = actor.hp.to_i if actor.respond_to?(:hp)
rescue
end
begin
out["max_hp"] = actor.mhp.to_i if actor.respond_to?(:mhp)
rescue
end
begin
out["level"] = actor.level.to_i if actor.respond_to?(:level)
rescue
end
begin
journal = _live_sync_collect_journal(actor)
out["player_journal"] = journal if journal.is_a?(Hash)
rescue
end
# Титул (простолюдинка / наёмница / верующая…) живёт в attr_accessor
# actor.record_lona_title и не попадает в actStat/portrait автоматически.
begin
if actor.respond_to?(:record_lona_title)
title = actor.record_lona_title
out["record_lona_title"] = title.to_s unless title.nil?
end
rescue
end
out
rescue
{}
end
def self._live_sync_collect_states(actor)
out = {}
return out if actor.nil?
begin
state_ids = []
if actor.respond_to?(:states)
actor.states.each do |st|
next if st.nil?
begin
sid = st.id.to_i
state_ids << sid if sid > 0
rescue
end
end
end
# @states intentionally contains duplicate IDs: each duplicate is one
# stack. Keep both the duplicate-preserving array and an explicit count
# map. The latter is unambiguous while the former remains compatible
# with readers that only understand `states`.
out["states"] = state_ids.sort
stacks = {}
state_ids.each { |sid| stacks[sid.to_s] = stacks.fetch(sid.to_s, 0).to_i + 1 }
out["state_stacks"] = stacks
out["state_stack_version"] = 1
rescue
end
begin
out["state_steps"] = _live_sync_sanitize_json_value(actor.instance_variable_get(:@state_steps))
rescue
end
begin
out["state_frames"] = _live_sync_sanitize_json_value(actor.instance_variable_get(:@state_frames))
rescue
end
begin
out["buffs"] = _live_sync_sanitize_json_value(actor.instance_variable_get(:@buffs))
rescue
end
begin
out["buff_turns"] = _live_sync_sanitize_json_value(actor.instance_variable_get(:@buff_turns))
rescue
end
out
rescue
{}
end
LIVE_SYNC_BODY_KEYWORDS = [
"sex", "rape", "fuck", "vag", "vagina", "anal", "anus", "ass",
"mouth", "oral", "kiss", "breast", "boob", "milk", "lact", "nippl",
"cum", "semen", "sperm", "preg", "birth", "baby", "uter", "ovul",
"menses", "menstru", "period", "arousal", "sensitivity", "virgin",
"hymen", "urinary", "urine", "defec", "slave", "morality", "karma",
"fame", "reputation", "relation", "favor", "affection"
] unless const_defined?(:LIVE_SYNC_BODY_KEYWORDS)
def self._live_sync_body_key?(key)
text = key.to_s.downcase
return false if text == ""
LIVE_SYNC_BODY_KEYWORDS.any? { |word| text.include?(word) }
rescue
false
end
def self._live_sync_body_safe_value(value, depth = 0)
return nil if depth.to_i > 4
return value if value.nil? || value.is_a?(Numeric) || value == true || value == false
if value.is_a?(String)
s = value.dup
begin
s.force_encoding("UTF-8")
rescue
end
return s[0, 4096]
end
return value.to_s if value.is_a?(Symbol)
if value.is_a?(Array)
out = []
value.first(256).each do |entry|
safe = _live_sync_body_safe_value(entry, depth.to_i + 1)
out << safe unless safe.nil?
end
return out
end
if value.is_a?(Hash)
out = {}
value.each do |raw_key, raw_value|
break if out.length >= 512
key = raw_key.to_s
next if key == ""
safe = _live_sync_body_safe_value(raw_value, depth.to_i + 1)
out[key] = safe unless safe.nil?
end
return out
end
nil
rescue
nil
end
def self._live_sync_collect_body_stats(actor)
out = {}
return out if actor.nil?
begin
act_stat = actor.instance_variable_get(:@actStat)
raw = act_stat.stat if act_stat && act_stat.respond_to?(:stat)
if raw.is_a?(Hash)
raw.each do |raw_key, raw_value|
key = raw_key.to_s
next unless _live_sync_body_key?(key)
safe = _live_sync_body_safe_value(raw_value)
out[key] = safe unless safe.nil?
end
end
rescue
end
out
rescue
{}
end
def self._live_sync_collect_story_body
out = {}
story = nil
begin
story = $story_stats if defined?($story_stats)
rescue
story = nil
end
return out if story.nil?
source = nil
begin
source = story.data if story.respond_to?(:data)
rescue
source = nil
end
source = story if !source.is_a?(Hash) && story.is_a?(Hash)
return out unless source && source.respond_to?(:each)
source.each do |raw_key, raw_value|
break if out.length >= 2048
key = raw_key.to_s
next unless _live_sync_body_key?(key) ||
(defined?(MPQuestCloudState) && MPQuestCloudState.quest_key?(key))
safe = _live_sync_body_safe_value(raw_value)
out[key] = safe unless safe.nil?
end
out
rescue
{}
end
def self._live_sync_collect_body_ivars(obj)
out = {}
return out if obj.nil?
vars = []
begin
vars = obj.instance_variables
rescue
vars = []
end
vars.each do |ivar|
key = ivar.to_s
next unless _live_sync_body_key?(key)
begin
safe = _live_sync_body_safe_value(obj.instance_variable_get(ivar))
out[key] = safe unless safe.nil?
rescue
end
end
out
rescue
{}
end
def self._live_sync_collect_body(actor)
out = { "schema" => 2 }
body_stats = _live_sync_collect_body_stats(actor)
story_stats = _live_sync_collect_story_body
actor_ivars = _live_sync_collect_body_ivars(actor)
player_ivars = _live_sync_collect_body_ivars($game_player)
out["body_stats"] = body_stats unless body_stats.empty?
out["story_stats"] = story_stats unless story_stats.empty?
out["actor_ivars"] = actor_ivars unless actor_ivars.empty?
out["player_ivars"] = player_ivars unless player_ivars.empty?
out
rescue
{ "schema" => 2 }
end
def self._live_sync_collect_player_meta(actor)
out = {}
begin
unless _live_sync_arena_mode?
begin
out["map_id"] = ($game_map ? $game_map.map_id.to_i : 0)
rescue
out["map_id"] = 0
end
begin
if $game_player
out["x"] = $game_player.x.to_i
out["y"] = $game_player.y.to_i
out["direction"] = $game_player.direction.to_i
end
rescue
end
end
if $game_player
%w[slot_skill_normal slot_skill_heavy slot_skill_control slot_hotkey_0 slot_hotkey_1 slot_hotkey_2 slot_hotkey_3 slot_hotkey_4 slot_hotkey_other slot_RosterCurrent slot_RosterArray].each do |name|
if $game_player.respond_to?(name)
begin
out[name] = _live_sync_sanitize_json_value($game_player.send(name))
rescue
end
else
begin
iv = $game_player.instance_variable_get(('@' + name).to_sym)
out[name] = _live_sync_sanitize_json_value(iv) unless iv.nil?
rescue
end
end
end
end
rescue
end
begin
exp = actor.instance_variable_get(:@exp) if actor
out["exp"] = _live_sync_sanitize_json_value(exp) if exp
rescue
end
# Quick-use slots ext-1..ext-5 (Menu_Equips) — имена предметов, не объекты.
begin
if actor && actor.respond_to?(:ext_items)
raw = actor.ext_items
if raw.is_a?(Array)
slots = Array.new(5)
5.times do |i|
v = raw[i]
next if v.nil?
s = v.to_s.strip
next if s.empty? || s == "nil"
slots[i] = s
end
out["ext_items"] = slots
end
end
rescue
end
out
rescue
{}
end
def self._live_sync_blob_from_object(obj, limit=nil, label=nil)
return "" if obj.nil?
json = ""
begin
json = JSON.generate(obj) if defined?(JSON) && JSON.respond_to?(:generate)
rescue
json = ""
end
if json.to_s.empty?
begin
json = obj.to_json
rescue
json = ""
end
end
if json.to_s.empty?
begin
json = _live_sync_json_generate(obj)
rescue
json = ""
end
end
_live_sync_log("live_sync_json_empty", "#{label || 'blob'} keys=#{obj.keys.join(',') rescue 'n/a'}") if json.to_s.empty?
return "" if json.to_s.empty?
packed = ""
begin
packed = Zlib::Deflate.deflate(json.to_s, Zlib::BEST_SPEED)
rescue
packed = json.to_s
end
hex = ""
begin
hex = packed.unpack('H*')[0].to_s
rescue
hex = ""
end
if limit && limit.to_i > 0 && hex.length > limit.to_i
_live_sync_log("live_sync_blob_oversize", "#{label || 'blob'} hex=#{hex.length} limit=#{limit.to_i}")
return ""
end
hex
rescue
""
end
def self._live_sync_pack_hash(h)
return "" unless h.is_a?(Hash)
keys = []
begin
keys = h.keys.sort
rescue
keys = h.keys
end
out = []
keys.each do |k|
next if k.nil?
key = k.to_s.gsub(":", ";").gsub("|", "/").gsub("=", "-")
val = h[k]
val = "0" if val.nil?
value = val.to_s.gsub(":", ";").gsub("|", "/").gsub("=", "-")
out << (key + "=" + value)
end
out.join("|")
end
# Full stats dump duplicates every attribute as a flat value and again inside
# act_stat_full, then adds the quest ledger. Past the wire limit the old
# code sent an empty blob, so login kept the level and snapped experience
# to that level's floor. Never drop experience or spent trait points.
LIVE_SYNC_TRAIT_KEYS = %w[
combat_trait scoutcraft_trait wisdom_trait survival_trait constitution_trait
] unless const_defined?(:LIVE_SYNC_TRAIT_KEYS)
# Body/need meters that must survive stats_core / stats_keepers truncation.
# Distinct from the Lactation state buff (actor.stat["Lactation"]).
LIVE_SYNC_BODY_METER_KEYS = %w[
arousal lactation_level urinary_level defecate_level
dirt mood sat sta health baby_health
pee_request poo_request itch_level
] unless const_defined?(:LIVE_SYNC_BODY_METER_KEYS)
LIVE_SYNC_REPRO_IVARS = %w[
@menses_schedule @status_log @prev_menses_schedule @prev_status_log
@prev_preg_rates @currentDay @preg_day @preg_race @preg_cycle @preg_level
@forcePreg @labor_date @preg_date @preg_rate @preg_rates @current_log_no
@cycle_start @baby_race @baby_birth_dialog @pain_value_preg @puke_value_preg
] unless const_defined?(:LIVE_SYNC_REPRO_IVARS)
LIVE_SYNC_INTIMATE_STATS = %w[preg vag_damage anal_damage] unless const_defined?(:LIVE_SYNC_INTIMATE_STATS)
def self._live_sync_collect_mails
system = defined?($game_system) ? $game_system : nil
mails = system ? system.instance_variable_get(:@mails) : nil
return [] unless mails.is_a?(Hash)
out = []
mails.each do |symbol, mail|
next if mail.nil?
date = mail.instance_variable_get(:@date) rescue nil
out << {
"symbol" => symbol.to_s,
"state" => (mail.instance_variable_get(:@state) || "unread").to_s,
"deleted" => !!mail.instance_variable_get(:@deleted),
"attachments_claimed" => !!mail.instance_variable_get(:@attachments_claimed),
"date" => (date.respond_to?(:to_i) ? date.to_i : 0)
}
end
out
rescue
[]
end
def self._live_sync_collect_reproduction(actor)
out = {}
return out if actor.nil?
LIVE_SYNC_REPRO_IVARS.each do |name|
value = actor.instance_variable_get(name.to_sym) rescue nil
next if value.nil?
out[name] = _live_sync_sanitize_json_value(value)
end
out
rescue
{}
end
def self._live_sync_collect_sex_records
story = defined?($story_stats) ? $story_stats : nil
data = story.respond_to?(:data) ? story.data : nil
return {} unless data.is_a?(Hash)
out = {}
data.each do |raw_key, raw_value|
key = raw_key.to_s
next if key.empty?
next unless key.start_with?("sex_record_") ||
key == "record_giveup_PeePoo" || key == "record_Rebirth" ||
key == "record_CoconaVag" || key == "record_CoconaOgrasm" || key == "record_CoconaPeeWith"
safe = _live_sync_sanitize_json_value(raw_value)
out[key] = safe unless safe.nil?
end
out
rescue
{}
end
def self._live_sync_collect_intimate_stats(actor)
out = {}
return out if actor.nil?
act_stat = actor.instance_variable_get(:@actStat) rescue nil
return out unless act_stat && act_stat.respond_to?(:get_stat)
LIVE_SYNC_INTIMATE_STATS.each do |key|
begin
out[key] = act_stat.get_stat(key)
rescue
end
end
begin
out["baby_health"] = act_stat.get_stat("baby_health")
out["baby_health_max"] = act_stat.get_stat("baby_health", 2)
out["displayBabyHealth"] = act_stat.get_stat("displayBabyHealth")
rescue
end
out
rescue
{}
end
def self._live_sync_collect_cums(actor)
return {} if actor.nil?
meters = actor.instance_variable_get(:@cumsMeters) rescue nil
vag = actor.instance_variable_get(:@vag_cums) rescue nil
out_meters = {}
if meters.is_a?(Hash)
meters.each do |key, amount|
name = key.to_s
next if name.empty?
out_meters[name] = amount.to_i
end
end
out_vag = []
if vag.is_a?(Array)
vag.each do |cum|
next if cum.nil?
out_vag << {
"part" => cum.respond_to?(:part) ? cum.part.to_s : "",
"race" => cum.respond_to?(:race) ? cum.race.to_s : "",
"amt" => cum.respond_to?(:amt) ? cum.amt.to_i : 0,
"sort" => cum.respond_to?(:sort) ? cum.sort.to_i : 0
}
end
end
display = actor.respond_to?(:getDisplayCumsAmt) ? actor.getDisplayCumsAmt : {}
{
"meters" => out_meters,
"vag" => out_vag,
"number" => (actor.instance_variable_get(:@cumsNumber) rescue 0).to_i,
"body" => display.is_a?(Hash) ? display["body"].to_i : 0,
"vag_amt" => display.is_a?(Hash) ? display["vag"].to_i : 0,
"anal" => display.is_a?(Hash) ? display["anal"].to_i : 0
}
rescue
{}
end
def self._live_sync_collect_journal(actor)
{
"mails" => _live_sync_collect_mails,
"reproduction" => _live_sync_collect_reproduction(actor),
"sex_records" => _live_sync_collect_sex_records,
"intimate_stats" => _live_sync_collect_intimate_stats(actor),
"cums" => _live_sync_collect_cums(actor)
}
rescue
{}
end
def self._live_sync_merge_body_meters(target, full)
return target unless target.is_a?(Hash) && full.is_a?(Hash)
LIVE_SYNC_BODY_METER_KEYS.each do |key|
target[key] = full[key] if full.has_key?(key)
end
raw_full = full["act_stat_full"]
if raw_full.is_a?(Hash)
merged = target["act_stat_full"].is_a?(Hash) ? target["act_stat_full"].dup : {}
LIVE_SYNC_BODY_METER_KEYS.each do |key|
merged[key] = raw_full[key] if raw_full.has_key?(key)
end
target["act_stat_full"] = merged unless merged.empty?
end
target
rescue
target
end
def self._live_sync_stats_core(full)
core = {}
return core unless full.is_a?(Hash)
# morality_lona is the permanent reputation counter. The menu value and
# morality_plus are rebuilt from states and equipment, so a temporary
# MoralityDown30 must not become the saved number.
# record_lona_title — постоянный титул персонажа (не пересобирается из состояний).
%w[trait_point actor_class_id actor_exp actor_skills learned_skills_version level portrait_identity player_journal morality_lona record_lona_title mp_trait_budget_fix_v1].each do |key|
core[key] = full[key] if full.has_key?(key)
end
LIVE_SYNC_TRAIT_KEYS.each do |key|
core[key] = full[key] if full.has_key?(key)
end
raw_full = full["act_stat_full"]
if raw_full.is_a?(Hash)
traits = {}
LIVE_SYNC_TRAIT_KEYS.each do |key|
traits[key] = raw_full[key] if raw_full.has_key?(key)
end
core["act_stat_full"] = traits unless traits.empty?
end
_live_sync_merge_body_meters(core, full)
end
# Last resort when the portrait palette and the flat stat table no longer
# fit. Experience, spent traits, notes, the cycle calendar and intimate
# history stay. Appearance remains in any earlier snapshot that still fit.
def self._live_sync_stats_keepers(full)
keepers = {}
return keepers unless full.is_a?(Hash)
%w[trait_point actor_class_id actor_exp actor_skills learned_skills_version level player_journal morality_lona record_lona_title mp_trait_budget_fix_v1].each do |key|
keepers[key] = full[key] if full.has_key?(key)
end
LIVE_SYNC_TRAIT_KEYS.each do |key|
keepers[key] = full[key] if full.has_key?(key)
end
_live_sync_merge_body_meters(keepers, full)
end
def self._live_sync_stats_blob(actor)
full = _live_sync_collect_stats(actor)
blob = _live_sync_blob_from_object(full, LIVE_SYNC_STATS_BLOB_LIMIT, "stats")
if blob.to_s.empty?
trimmed = {}
if full.is_a?(Hash)
full.each do |key, value|
name = key.to_s
next if name == "act_stat_full" || name == "progression_ledger" || name == "hp" || name == "max_hp"
trimmed[key] = value
end
end
blob = _live_sync_blob_from_object(trimmed, LIVE_SYNC_STATS_BLOB_LIMIT, "stats_trimmed")
end
if blob.to_s.empty?
core = _live_sync_stats_core(full)
blob = _live_sync_blob_from_object(core, LIVE_SYNC_STATS_BLOB_LIMIT, "stats_core")
_live_sync_log("live_sync_stats_core_only", "keys=#{core.keys.join(',')}") unless blob.to_s.empty?
end
if blob.to_s.empty?
keepers = _live_sync_stats_keepers(full)
blob = _live_sync_blob_from_object(keepers, LIVE_SYNC_STATS_BLOB_LIMIT, "stats_keepers")
_live_sync_log("live_sync_stats_keepers_only", "keys=#{keepers.keys.join(',')}") unless blob.to_s.empty?
end
blob.to_s
end
def self._live_sync_build_packet
actor = _live_sync_actor
return nil if actor.nil?
return nil if _live_sync_arena_mode?
level = 1
hp = 0
max_hp = 0
gold = 0
begin
level = actor.level.to_i if actor.respond_to?(:level)
rescue
level = 1
end
begin
hp = actor.hp.to_i if actor.respond_to?(:hp)
rescue
hp = 0
end
begin
max_hp = actor.mhp.to_i if actor.respond_to?(:mhp)
rescue
begin
max_hp = actor.maxhp.to_i if actor.respond_to?(:maxhp)
rescue
max_hp = hp
end
end
gold = _live_sync_coin3_count
items_blob = _live_sync_pack_hash(_live_sync_collect_items)
weapons_blob = _live_sync_pack_hash(_live_sync_collect_weapons)
armors_blob = _live_sync_pack_hash(_live_sync_collect_armors)
equips_blob = _live_sync_pack_hash(_live_sync_collect_equips(actor))
skills_csv = _live_sync_skills_csv(actor)
stats_blob = _live_sync_stats_blob(actor)
states_blob = _live_sync_blob_from_object(_live_sync_collect_states(actor), LIVE_SYNC_AUX_BLOB_LIMIT, "states")
player_meta = _live_sync_collect_player_meta(actor)
player_blob = _live_sync_blob_from_object(player_meta, LIVE_SYNC_AUX_BLOB_LIMIT, "player")
bank_payload = _live_sync_collect_bank_storage
bank_entries = bank_payload.is_a?(Hash) ? bank_payload["entries"] : nil
lc_chests = bank_payload.is_a?(Hash) ? bank_payload["lc_chests"] : nil
bank_has_data = (bank_entries.is_a?(Array) && !bank_entries.empty?) ||
(lc_chests.is_a?(Array) && !lc_chests.empty?)
bank_blob = bank_has_data ? _live_sync_blob_from_object(bank_payload, LIVE_SYNC_BANK_BLOB_LIMIT, "bank") : ""
stat_pack = ""
body_blob = _live_sync_blob_from_object(_live_sync_collect_body(actor), LIVE_SYNC_BODY_BLOB_LIMIT, "body")
if player_blob.to_s.empty?
now = _live_sync_now
last_warn = 0.0
begin
last_warn = @live_sync_last_player_blob_warning_at.to_f
rescue
last_warn = 0.0
end
if now <= 0.0 || (now - last_warn) > 3.0
@live_sync_last_player_blob_warning_at = now
keys = player_meta.is_a?(Hash) ? player_meta.keys.join(",") : "nil"
_live_sync_log("live_sync_player_blob_empty", "keys=#{keys} #{_live_sync_hotkey_summary}")
end
end
packet = "sync_state:#{level.to_i}:#{gold.to_i}:#{hp.to_i}:#{max_hp.to_i}:#{items_blob}:#{weapons_blob}:#{armors_blob}:#{equips_blob}:#{skills_csv}:#{stats_blob}:#{states_blob}:#{player_blob}:#{bank_blob}:#{stat_pack}:#{body_blob}"
[packet, packet]
end
def self.live_sync_position_now(reason=nil, force=false)
return false unless @connected
begin
return false if respond_to?(:bootstrap_sync_unlocked?) && !bootstrap_sync_unlocked?
rescue
end
begin
now_pos = mp_position_packet if respond_to?(:mp_position_packet)
now_pos = "#{$game_player.x}:#{$game_player.y}:#{$game_player.direction}" if now_pos.nil?
rescue
return false
end
return false if now_pos.nil? || now_pos.empty?
return false if !force && now_pos == @last_pos
send_line("pos:#{now_pos}")
@last_pos = now_pos
true
rescue
false
end
def self.live_sync_send_now(reason=nil, with_playersync=true, with_position=false)
return false unless @connected
begin
return false if respond_to?(:bootstrap_sync_unlocked?) && !bootstrap_sync_unlocked?
rescue
end
built = _live_sync_build_packet
return false if built.nil?
ok = false
begin
sent = send_line(built[0])
ok = !sent.nil? && sent.to_i >= 0
rescue
ok = false
end
if ok
now = _live_sync_now
@live_sync_last_sig = built[1]
@live_sync_last_at = now
@live_sync_last_force_at = now
@live_sync_last_probe_at = now
begin
MPImmediateLiveSync.clear_deferred_if_map_sync(reason) if defined?(MPImmediateLiveSync) && MPImmediateLiveSync.respond_to?(:clear_deferred_if_map_sync)
rescue
end
end
begin
live_sync_position_now(reason, false) if with_position
rescue
end
begin
if ok && with_playersync && respond_to?(:send_playersync_full)
send_playersync_full(reason || 'live_sync_send_now', true)
end
rescue
end
ok
rescue
false
end
def self.live_sync_tick(force=false)
return unless @connected
return if respond_to?(:bootstrap_sync_unlocked?) && !bootstrap_sync_unlocked?
if respond_to?(:gameplay_scene_active?)
return unless gameplay_scene_active?
else
return unless SceneManager.scene_is?(Scene_Map)
end
return unless force
now = _live_sync_now
last_probe = (@live_sync_last_probe_at.nil? ? 0.0 : @live_sync_last_probe_at)
if !force && (now - last_probe) < LIVE_SYNC_PROBE_INTERVAL
return
end
@live_sync_last_probe_at = now
built = _live_sync_build_packet
return if built.nil?
packet = built[0]
sig = built[1]
if !force && sig == @live_sync_last_sig
return if (now - @live_sync_last_force_at) < LIVE_SYNC_FORCE_INTERVAL
@live_sync_last_force_at = now
else
return if !force && (now - @live_sync_last_at) < LIVE_SYNC_INTERVAL
@live_sync_last_force_at = now if force
end
send_line(packet)
@live_sync_last_sig = sig
@live_sync_last_at = now
end
# Force one final sync packet regardless of current scene/tick throttles.
# Used before disconnect / return-to-title to avoid losing the latest loot.
def self.live_sync_flush_final(reason=nil)
return false unless @connected
built = _live_sync_build_packet
return false if built.nil?
packet = built[0]
sig = built[1]
res = send_line(packet)
ok = !res.nil? && res.to_i >= 0
if ok
now = _live_sync_now
@live_sync_last_sig = sig
@live_sync_last_at = now
@live_sync_last_force_at = now
@live_sync_last_probe_at = now
end
ok
rescue
false
end
end
module WebSocket
class << self
alias mp_live_sync_update update
def update
mp_live_sync_update
end
unless method_defined?(:mp_live_sync_disconnect)
alias mp_live_sync_disconnect disconnect
end
def disconnect(*args, &block)
begin
live_sync_flush_final("disconnect")
rescue
end
mp_live_sync_disconnect(*args, &block)
end
end
end
module MPImmediateLiveSync
INVENTORY_NOOP_FILTER_VERSION = "1.2" unless const_defined?(:INVENTORY_NOOP_FILTER_VERSION)
EVENT_FULL_SYNC_ENABLED = false unless const_defined?(:EVENT_FULL_SYNC_ENABLED)
DEFERRED_REASON_LIMIT = 24 unless const_defined?(:DEFERRED_REASON_LIMIT)
@deferred_full_sync = false
@deferred_reasons = []
def self.event_full_sync_allowed?(reason=nil)
return true if EVENT_FULL_SYNC_ENABLED
text = reason.to_s
text == "map_enter" ||
text == "setup_new_game" ||
text == "new_game" ||
text == "disconnect" ||
text.start_with?("cloud_map_enter") ||
text.start_with?("cloud_bootstrap") ||
text.start_with?("cloud_manual")
rescue
false
end
def self.defer(reason=nil)
@deferred_full_sync = true
@deferred_reasons ||= []
text = reason.to_s.strip
text = "event" if text == ""
@deferred_reasons << text unless @deferred_reasons.include?(text)
@deferred_reasons = @deferred_reasons.last(DEFERRED_REASON_LIMIT)
true
rescue
false
end
def self.deferred?
!!@deferred_full_sync
rescue
false
end
def self.clear_deferred
@deferred_full_sync = false
@deferred_reasons = []
true
rescue
false
end
def self.map_sync_reason?(reason=nil)
text = reason.to_s
text == "map_enter" ||
text.start_with?("map_enter") ||
text.start_with?("cloud_map_enter") ||
text.start_with?("cloud_bootstrap")
rescue
false
end
def self.clear_deferred_if_map_sync(reason=nil)
clear_deferred if map_sync_reason?(reason)
rescue
false
end
def self.player_actor
begin
return $game_player.actor if $game_player && $game_player.respond_to?(:actor)
rescue
end
nil
end
def self.player_actor?(actor)
pa = player_actor
!pa.nil? && !actor.nil? && pa.equal?(actor)
rescue
false
end
def self.player_act_stat?(stat_obj)
actor = player_actor
return false if actor.nil? || stat_obj.nil?
begin
act_stat = actor.instance_variable_get(:@actStat)
return !act_stat.nil? && act_stat.equal?(stat_obj)
rescue
false
end
end
def self.trigger(reason=nil, with_playersync=true, with_position=false)
return unless defined?(WebSocket)
return unless WebSocket.respond_to?(:live_sync_send_now)
unless event_full_sync_allowed?(reason)
position(reason, false) if with_position
return defer(reason)
end
ok = WebSocket.live_sync_send_now(reason, with_playersync, with_position)
clear_deferred_if_map_sync(reason) if ok
ok
rescue
end
def self.position(reason=nil, force=false)
return unless defined?(WebSocket)
return unless WebSocket.respond_to?(:live_sync_position_now)
WebSocket.live_sync_position_now(reason, force)
rescue
end
def self.hotkey_summary
return "player=nil" unless $game_player
names = %w[slot_skill_normal slot_skill_heavy slot_skill_control slot_hotkey_0 slot_hotkey_1 slot_hotkey_2 slot_hotkey_3 slot_hotkey_4 slot_hotkey_other]
out = []
begin
roster = $game_player.respond_to?(:slot_RosterArray) ? $game_player.slot_RosterArray : $game_player.instance_variable_get(:@slot_RosterArray)
cur = $game_player.respond_to?(:slot_RosterCurrent) ? $game_player.slot_RosterCurrent.to_i : $game_player.instance_variable_get(:@slot_RosterCurrent).to_i
row = roster[cur] rescue nil
out << "roster_len=#{roster.respond_to?(:length) ? roster.length : 0}"
out << "cur=#{cur}"
out << "row=#{row.inspect}"
rescue
end
names.each do |name|
begin
value = $game_player.respond_to?(name) ? $game_player.send(name) : $game_player.instance_variable_get(("@" + name).to_sym)
out << "#{name}=#{value.inspect}"
rescue
end
end
out.join(" ")
rescue
"hotkey_summary_error"
end
def self.trait_summary
actor = player_actor
return "actor=nil" if actor.nil?
out = []
begin
out << "tp=#{actor.respond_to?(:trait_point) ? actor.trait_point.inspect : actor.instance_variable_get(:@trait_point).inspect}"
rescue
end
%w[combat_trait scoutcraft_trait wisdom_trait survival_trait constitution_trait].each do |name|
begin
value = actor.respond_to?(name) ? actor.send(name) : nil
out << "#{name}=#{value.inspect}"
rescue
end
end
out.join(" ")
rescue
"trait_summary_error"
end
def self.hotkey(reason=nil)
return defer(reason || "cloud_hotkey") unless event_full_sync_allowed?(reason || "cloud_hotkey")
begin
MPStateInfra.log_line("cloud_hotkey_save", "#{reason} #{hotkey_summary}") if defined?(MPStateInfra)
rescue
end
cloud_reason = "cloud_hotkey"
if defined?(MPCloudOnlySave)
ok = MPCloudOnlySave.send_tracked_now(cloud_reason, true)
MPCloudOnlySave.request(cloud_reason, 1) unless ok
return ok || MPCloudOnlySave.pending?
end
trigger(reason || cloud_reason, true, true)
rescue
end
def self.progress(reason=nil)
return defer(reason || "cloud_actor_progress") unless event_full_sync_allowed?(reason || "cloud_actor_progress")
cloud_reason = "cloud_actor_progress"
begin
MPStateInfra.log_line("cloud_actor_progress", "#{reason} #{trait_summary}") if defined?(MPStateInfra)
rescue
end
if defined?(MPCloudOnlySave)
ok = MPCloudOnlySave.send_tracked_now(cloud_reason, true)
delay = (reason.to_s == "accept_traits" ? 1 : MPCloudOnlySave::MIN_DELAY_FR)
MPCloudOnlySave.request(cloud_reason, delay) unless ok
return ok || MPCloudOnlySave.pending?
end
trigger(reason || cloud_reason, true, true)
rescue
end
def self.overmap_position(reason=nil)
# IMPORTANT: this method is called from every player step/moveto.
# Only the world/overmap (map_id == 2) is allowed to dirty the durable
# overmap snapshot. The old order called defer("increase_steps") first,
# so Save14 treated every ordinary-map step as a full cloud-save event.
begin
return false unless defined?($game_map) && $game_map && $game_map.map_id.to_i == 2
rescue
return false
end
sync_reason = reason || "cloud_overmap_position"
return defer(sync_reason) unless event_full_sync_allowed?(sync_reason)
begin
MPStateInfra.log_line("cloud_overmap_position", reason.to_s) if defined?(MPStateInfra)
rescue
end
if defined?(MPCloudOnlySave)
return MPCloudOnlySave.request("cloud_overmap_position", MPCloudOnlySave::MIN_DELAY_FR)
end
trigger("cloud_overmap_position", true, true)
rescue
false
end
end
class Scene_ItemStorage
unless method_defined?(:mp_live_sync_bank_move_item)
alias mp_live_sync_bank_move_item move_item
def move_item(val=nil)
result = mp_live_sync_bank_move_item(val)
begin
bank_id = WebSocket._live_sync_bank_storage_id if defined?(WebSocket) && WebSocket.respond_to?(:_live_sync_bank_storage_id)
if !bank_id.nil? && @box_id.to_i == bank_id.to_i
WebSocket.bootstrap_remember_current_bank if defined?(WebSocket) && WebSocket.respond_to?(:bootstrap_remember_current_bank)
if defined?(MPCloudOnlySave)
ok = MPCloudOnlySave.send_tracked_now("cloud_bank_storage", true)
MPCloudOnlySave.request("cloud_bank_storage", 1) unless ok
elsif defined?(MPImmediateLiveSync)
MPImmediateLiveSync.trigger("bank_storage", true, false)
end
end
rescue
end
result
end
end
end
class Game_Party
# 21_sync must react to a REAL inventory/equipment mutation, not merely to a
# call of gain_item/lose_item. LonaRPG periodically runs actor.refresh;
# release_unequippable_items can reach trade_item_with_party(nil, nil), which
# in turn calls gain_item(nil, +/-1). Those calls are intentional no-ops and
# must not dirty cloud state.
unless method_defined?(:mp_live_sync_inventory_snapshot)
def mp_live_sync_normalize_inventory_item(item)
begin
if respond_to?(:normalize_party_item, true)
return send(:normalize_party_item, item)
end
rescue
end
item
rescue
nil
end
def mp_live_sync_same_inventory_item?(left, right)
return true if left.equal?(right)
return false if left.nil? || right.nil?
begin
return false unless left.class == right.class
return left.id.to_i == right.id.to_i if left.respond_to?(:id) && right.respond_to?(:id)
rescue
end
false
rescue
false
end
def mp_live_sync_equipped_item_count(item)
count = 0
begin
members.each do |actor|
next if actor.nil? || !actor.respond_to?(:equips)
actor.equips.each do |eq|
count += 1 if mp_live_sync_same_inventory_item?(eq, item)
end
end
rescue
end
count
rescue
0
end
def mp_live_sync_inventory_snapshot(item, include_equip=false)
object = mp_live_sync_normalize_inventory_item(item)
return nil if object.nil?
# Invalid objects/strings that the party cannot actually store are also
# no-ops. Checking the real container avoids false dirty events.
begin
if respond_to?(:item_container_for_object, true)
return nil if send(:item_container_for_object, object).nil?
end
rescue
end
count = 0
begin
count = item_number(object).to_i
rescue
count = 0
end
equipped = nil
equipped = mp_live_sync_equipped_item_count(object) if include_equip
klass = begin object.class.name.to_s rescue object.class.to_s end
id = begin object.id.to_i rescue 0 end
[klass, id, count, equipped]
rescue
nil
end
end
unless method_defined?(:mp_live_sync_gain_item)
alias mp_live_sync_gain_item gain_item
def gain_item(item, amount=1, include_equip=false)
# lose_item in the base game is implemented through gain_item(item,-n).
# Keep a small nesting guard so one real loss produces ONE event instead
# of both gain_item and lose_item events.
top_level = @mp_live_sync_inventory_hook_depth.to_i == 0
before = top_level ? mp_live_sync_inventory_snapshot(item, include_equip) : nil
@mp_live_sync_inventory_hook_depth = @mp_live_sync_inventory_hook_depth.to_i + 1
begin
result = mp_live_sync_gain_item(item, amount, include_equip)
ensure
@mp_live_sync_inventory_hook_depth = [@mp_live_sync_inventory_hook_depth.to_i - 1, 0].max
end
if top_level && !before.nil?
after = mp_live_sync_inventory_snapshot(item, include_equip)
if !after.nil? && before != after
MPImmediateLiveSync.trigger("gain_item", true, false)
end
end
result
end
end
unless method_defined?(:mp_live_sync_lose_item)
alias mp_live_sync_lose_item lose_item
def lose_item(item, amount=1, include_equip=false)
top_level = @mp_live_sync_inventory_hook_depth.to_i == 0
before = top_level ? mp_live_sync_inventory_snapshot(item, include_equip) : nil
@mp_live_sync_inventory_hook_depth = @mp_live_sync_inventory_hook_depth.to_i + 1
begin
result = mp_live_sync_lose_item(item, amount, include_equip)
ensure
@mp_live_sync_inventory_hook_depth = [@mp_live_sync_inventory_hook_depth.to_i - 1, 0].max
end
if top_level && !before.nil?
after = mp_live_sync_inventory_snapshot(item, include_equip)
if !after.nil? && before != after
MPImmediateLiveSync.trigger("lose_item", true, false)
end
end
result
end
end
unless method_defined?(:mp_live_sync_gain_gold)
alias mp_live_sync_gain_gold gain_gold
def gain_gold(amount)
result = mp_live_sync_gain_gold(amount)
MPImmediateLiveSync.trigger("gain_gold", true, false) if amount.to_i != 0
result
end
end
unless method_defined?(:mp_live_sync_set_gold)
alias mp_live_sync_set_gold set_gold
def set_gold(amount)
result = mp_live_sync_set_gold(amount)
MPImmediateLiveSync.trigger("set_gold", true, false)
result
end
end
end
class Game_Actor
unless method_defined?(:mp_live_sync_change_equip)
alias mp_live_sync_change_equip change_equip
def change_equip(slot_id, item)
result = mp_live_sync_change_equip(slot_id, item)
MPImmediateLiveSync.trigger("change_equip", true, false) if MPImmediateLiveSync.player_actor?(self)
result
end
end
unless method_defined?(:mp_live_sync_force_change_equip)
alias mp_live_sync_force_change_equip force_change_equip
def force_change_equip(slot_id, item)
result = mp_live_sync_force_change_equip(slot_id, item)
MPImmediateLiveSync.trigger("force_change_equip", true, false) if MPImmediateLiveSync.player_actor?(self)
result
end
end
unless method_defined?(:mp_live_sync_learn_skill)
alias mp_live_sync_learn_skill learn_skill
def learn_skill(skill_id)
result = mp_live_sync_learn_skill(skill_id)
if MPImmediateLiveSync.player_actor?(self)
MPImmediateLiveSync.trigger("learn_skill", true, false)
MPImmediateLiveSync.progress("learn_skill")
end
result
end
end
unless method_defined?(:mp_live_sync_forget_skill)
alias mp_live_sync_forget_skill forget_skill
def forget_skill(skill_id)
result = mp_live_sync_forget_skill(skill_id)
if MPImmediateLiveSync.player_actor?(self)
MPImmediateLiveSync.trigger("forget_skill", true, false)
MPImmediateLiveSync.progress("forget_skill")
end
result
end
end
unless method_defined?(:mp_live_sync_add_state)
alias mp_live_sync_add_state add_state
def add_state(state_id)
result = mp_live_sync_add_state(state_id)
if MPImmediateLiveSync.player_actor?(self)
MPImmediateLiveSync.trigger("add_state", true, false)
MPImmediateLiveSync.progress("add_state")
end
result
end
end
if method_defined?(:change_exp)
unless method_defined?(:mp_live_sync_change_exp)
alias mp_live_sync_change_exp change_exp
def change_exp(exp, show)
old_exp = nil
old_level = nil
begin
old_exp = self.exp if respond_to?(:exp)
old_level = @level
rescue
end
result = mp_live_sync_change_exp(exp, show)
begin
new_exp = (respond_to?(:exp) ? self.exp : old_exp)
if MPImmediateLiveSync.player_actor?(self) && (old_exp != new_exp || old_level != @level)
MPImmediateLiveSync.progress("change_exp")
end
rescue
end
result
end
end
end
unless method_defined?(:mp_live_sync_change_level)
alias mp_live_sync_change_level change_level
def change_level(level, show)
result = mp_live_sync_change_level(level, show)
if MPImmediateLiveSync.player_actor?(self)
MPImmediateLiveSync.trigger("change_level", true, false)
MPImmediateLiveSync.progress("change_level")
end
result
end
end
end
class Game_BattlerBase
unless method_defined?(:mp_live_sync_hp_set)
alias mp_live_sync_hp_set hp=
def hp=(hp)
old_hp = nil
begin
old_hp = self.hp if respond_to?(:hp)
rescue
old_hp = nil
end
result = self.mp_live_sync_hp_set(hp)
begin
new_hp = self.hp if respond_to?(:hp)
MPImmediateLiveSync.trigger("hp_set", true, false) if MPImmediateLiveSync.player_actor?(self) && old_hp != new_hp
rescue
end
result
end
end
end
class Game_Battler
unless method_defined?(:mp_live_sync_remove_state)
alias mp_live_sync_remove_state remove_state
def remove_state(state_id)
result = mp_live_sync_remove_state(state_id)
MPImmediateLiveSync.trigger("remove_state", true, false) if MPImmediateLiveSync.player_actor?(self)
result
end
end
end
class ActorStat
unless method_defined?(:mp_live_sync_set_stat)
alias mp_live_sync_set_stat set_stat
def set_stat(stat_name, value, type=CURRENT_STAT)
old_value = nil
begin
old_value = get_stat(stat_name, type)
rescue
old_value = nil
end
result = mp_live_sync_set_stat(stat_name, value, type)
begin
new_value = get_stat(stat_name, type)
if type == CURRENT_STAT && MPImmediateLiveSync.player_act_stat?(self) && old_value != new_value
# Health, stamina and similar meters tick on their own. A full cloud
# snapshot for each tick is what kept the diskette on screen.
unless defined?(MP_Save14) && MP_Save14.respond_to?(:volatile_actor_stat?) && MP_Save14.volatile_actor_stat?(stat_name)
MPImmediateLiveSync.trigger("set_stat:#{stat_name}", true, false)
MPImmediateLiveSync.progress("set_stat:#{stat_name}")
end
end
rescue
end
result
end
end
end
# The player writes stats through LonaActorStat#set_stat, which does not call
# ActorStat#set_stat. Only the permanent reputation counter schedules a save.
# morality and morality_plus move whenever a temporary mark or piece of gear
# is refreshed, and refresh rebuilds both from the stored counter.
if defined?(LonaActorStat)
class LonaActorStat
unless method_defined?(:mp_live_sync_lona_set_stat)
alias mp_live_sync_lona_set_stat set_stat
def set_stat(stat_name, value, type=CURRENT_STAT)
watch = type == CURRENT_STAT && stat_name.to_s == "morality_lona"
old_value = nil
begin
old_value = get_stat(stat_name, type) if watch
rescue
old_value = nil
end
result = mp_live_sync_lona_set_stat(stat_name, value, type)
begin
if watch && defined?(MPImmediateLiveSync) && MPImmediateLiveSync.player_act_stat?(self)
new_value = get_stat(stat_name, type)
if old_value != new_value
MPImmediateLiveSync.trigger("set_stat:morality_lona", true, false)
MPImmediateLiveSync.progress("set_stat:morality_lona") if MPImmediateLiveSync.respond_to?(:progress)
end
end
rescue
end
result
end
end
end
end
# Титул меняется через attr_accessor, а не через actStat — ловим запись,
# чтобы cloud save не откладывал смену до следующего полного синка.
if defined?(Game_Actor)
class Game_Actor
unless method_defined?(:mp_live_sync_record_lona_title_writer)
if method_defined?(:record_lona_title=)
alias mp_live_sync_record_lona_title_writer record_lona_title=
def record_lona_title=(value)
old_value = nil
begin
old_value = record_lona_title
rescue
old_value = nil
end
result = mp_live_sync_record_lona_title_writer(value)
begin
if defined?(MPImmediateLiveSync) && MPImmediateLiveSync.respond_to?(:player_actor?) && MPImmediateLiveSync.player_actor?(self)
if old_value.to_s != value.to_s
MPImmediateLiveSync.trigger("record_lona_title", true, false)
MPImmediateLiveSync.progress("record_lona_title") if MPImmediateLiveSync.respond_to?(:progress)
end
end
rescue
end
result
end
end
end
end
end
class Game_CharacterBase
unless method_defined?(:mp_live_sync_increase_steps)
alias mp_live_sync_increase_steps increase_steps
def increase_steps
result = mp_live_sync_increase_steps
begin
MPImmediateLiveSync.position("increase_steps", false) if self.equal?($game_player)
rescue
end
begin
MPImmediateLiveSync.overmap_position("increase_steps") if self.equal?($game_player)
rescue
end
result
end
end
unless method_defined?(:mp_live_sync_moveto)
alias mp_live_sync_moveto moveto
def moveto(x, y)
result = mp_live_sync_moveto(x, y)
begin
MPImmediateLiveSync.position("moveto", true) if self.equal?($game_player)
rescue
end
begin
MPImmediateLiveSync.overmap_position("moveto") if self.equal?($game_player)
rescue
end
result
end
end
end
class Game_Player
if method_defined?(:setup_SkillRoster)
unless method_defined?(:mp_live_sync_setup_skill_roster)
alias mp_live_sync_setup_skill_roster setup_SkillRoster
def setup_SkillRoster(*args, &block)
result = mp_live_sync_setup_skill_roster(*args, &block)
begin
MPImmediateLiveSync.hotkey("setup_SkillRoster")
rescue
end
result
end
end
end
if method_defined?(:update_GetNextSkillRoster)
unless method_defined?(:mp_live_sync_next_skill_roster)
alias mp_live_sync_next_skill_roster update_GetNextSkillRoster
def update_GetNextSkillRoster(*args, &block)
result = mp_live_sync_next_skill_roster(*args, &block)
begin
MPImmediateLiveSync.hotkey("update_GetNextSkillRoster")
rescue
end
result
end
end
end
if method_defined?(:update_GetPrevSkillRoster)
unless method_defined?(:mp_live_sync_prev_skill_roster)
alias mp_live_sync_prev_skill_roster update_GetPrevSkillRoster
def update_GetPrevSkillRoster(*args, &block)
result = mp_live_sync_prev_skill_roster(*args, &block)
begin
MPImmediateLiveSync.hotkey("update_GetPrevSkillRoster")
rescue
end
result
end
end
end
end
if defined?(Menu_Traits) && Menu_Traits.method_defined?(:accept_handler)
class Menu_Traits
unless method_defined?(:mp_live_sync_accept_traits_without_cloud)
alias mp_live_sync_accept_traits_without_cloud accept_handler
def accept_handler(*args, &block)
result = mp_live_sync_accept_traits_without_cloud(*args, &block)
begin
MPImmediateLiveSync.progress("accept_traits")
rescue
end
result
end
end
end
end
if defined?(Menu_System) && Menu_System.method_defined?(:hotkeyRoster_opt_handler)
class Menu_System
unless method_defined?(:mp_live_sync_hotkey_roster_opt_handler)
alias mp_live_sync_hotkey_roster_opt_handler hotkeyRoster_opt_handler
def hotkeyRoster_opt_handler(*args, &block)
before = nil
begin
before = Marshal.dump($game_player.slot_RosterArray) if $game_player && $game_player.respond_to?(:slot_RosterArray)
rescue
before = nil
end
result = mp_live_sync_hotkey_roster_opt_handler(*args, &block)
begin
after = Marshal.dump($game_player.slot_RosterArray) if $game_player && $game_player.respond_to?(:slot_RosterArray)
MPImmediateLiveSync.hotkey("hotkeyRoster_opt_handler") if before != after
rescue
end
result
end
end
end
end
module DataManager
class << self
unless method_defined?(:mp_live_sync_setup_new_game)
alias mp_live_sync_setup_new_game setup_new_game
end
def setup_new_game(*args)
result = mp_live_sync_setup_new_game(*args)
begin
if defined?(WebSocket) && WebSocket.respond_to?(:live_sync_send_now)
WebSocket.live_sync_send_now("setup_new_game", true, true)
end
rescue
end
result
end
end
end