Files
LonaRPG-Online-Games/ModScripts/multiplayer/17_playersyncs.rb
T

1961 lines
55 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# encoding: UTF-8
#==============================================================================
# 17_playersyncs.rb — Player appearance/level/skills sync (LonaRPG / mkxp-z Ruby)
#------------------------------------------------------------------------------
# SAVE-SAFE ВАРИАНТ + ЛОГИРОВАНИЕ В syncg.txt
#
# Что делает:
# - НЕ трогает Z и другие кнопки.
# - При входе на карту шлёт plsync_full + plsync_req.
# - При изменении экипа/внешности/скиллов/уровня шлёт обновление.
# - Синхронизирует actor.stat для CHS-частей у удалённых игроков.
# - НЕ трогает @npc у Game_Event.
# - НЕ использует singleton methods на объектах событий (иначе ломается save).
# - Перед save временно убирает remote players из $game_map.events и возвращает назад.
# - Пишет лог в syncg.txt.
#
# Протокол (новый):
# client -> server:
# plsync_full:<actor_id>:<level>:<skills_csv>:<chs_type>:<charset_index>:<chs_name>:<chs_name_h>:<stat_pack>
# plsync_req
#
# server -> clients:
# plsync_full:<pid>:<actor_id>:<level>:<skills_csv>:<chs_type>:<charset_index>:<chs_name>:<chs_name_h>:<stat_pack>
# plsync_req:<pid>
#
# Старый формат (без chs_name/chs_name_h) тоже читается для совместимости.
#==============================================================================
return unless defined?(WebSocket)
module WebSocket
PLAYERSYNCS_DEBUG = false
PLAYERSYNCS_MIN_SEND_INTERVAL = 0.35
PLAYERSYNCS_CHECK_EVERY_FRAMES = 10
PLAYERSYNCS_REQ_COOLDOWN = 2.0
PLAYERSYNCS_RESP_COOLDOWN = 0.8
PLAYERSYNCS_LOG_ENABLED = false
PLAYERSYNCS_LOG_STDOUT = false
PLAYERSYNCS_LOG_FILE = "syncg.txt"
PLAYERSYNCS_LOG_MAX_TEXT = 1600
PLAYERSYNCS_TRACE_HOT_PATH = false
PLAYERSYNCS_FALLBACK_KEYS = %w[
body Race RaceRecord always persona pose
MainArm SecondArm MainLeg
equip_head equip_hair
equip_Top equip_Mid equip_Bot
equip_TopExtra equip_MidExtra equip_BotExtra
equip_Tampon
dirt dirt2 dirt3
sex_pos sex_position
]
#--------------------------------------------------------------------------
# Dummy actor for remote net players (dump-safe)
#--------------------------------------------------------------------------
class NetSyncActor
attr_accessor :record_HairColor
attr_accessor :action_state
attr_accessor :last_attacker
attr_accessor :last_hitted_target
attr_accessor :master
# Game_Event#set_dodge/update_dodge operate through event.actor. Remote
# players use NetSyncActor here, so it must expose the same transient combat
# flags as Battle_System. These are visual, per-remote-player values only;
# they never touch the local actor or authoritative damage state.
attr_accessor :dodged
attr_accessor :blocked
# Remote players are rendered as lightweight actors, but some stock
# skill effects still ask their actor for a combat target while the
# effect page is being initialized. Remote target selection is not
# authoritative on this client, so keep a compatible, nil-by-default
# slot instead of letting those visual effects crash the map.
attr_accessor :target
def initialize
@base_stat = {}
@render_stat = nil
@stat = {}
@statMap = @stat
@record_HairColor = 0
@action_state = :none
@last_attacker = nil
@last_hitted_target = nil
@master = nil
@target = nil
@dodged = false
@blocked = false
# Battle_System uses -1 while a hold is not running. Skill visuals
# compare these with launch_max, and nil breaks that comparison.
@holding_count = -1
@last_holding_count = -1
end
def stat
@stat = (@render_stat.is_a?(Hash) ? @render_stat : @base_stat)
@stat = {} unless @stat.is_a?(Hash)
@statMap = @stat
@stat
end
def base_stat
@base_stat = {} unless @base_stat.is_a?(Hash)
@base_stat
end
def stat=(value)
set_base_stat(value)
end
def set_base_stat(value)
@base_stat = value.is_a?(Hash) ? value.dup : {}
@render_stat = nil
stat
end
def apply_render_stat(value)
@render_stat = value.is_a?(Hash) ? value.dup : nil
stat
end
def clear_render_stat
@render_stat = nil
stat
end
def statMap
stat
end
def portrait_stat_value
stat
end
def report_portrait_stat(key, value)
h = stat.dup
h[key] = value
if @render_stat.is_a?(Hash)
@render_stat = h
else
@base_stat = h
end
stat
end
def _ps_stat_read(key_name)
h = stat
return nil unless h.is_a?(Hash)
begin
return h[key_name] if h.has_key?(key_name)
rescue
end
begin
sym = key_name.to_sym
return h[sym] if h.has_key?(sym)
rescue
end
begin
low = key_name.to_s.downcase
h.each do |k, v|
return v if k.to_s.downcase == low
end
rescue
end
nil
end
def _ps_stat_num(key_name)
value = _ps_stat_read(key_name)
return nil if value.nil?
return value if value.is_a?(Numeric)
s = value.to_s.strip
return nil if s == "" || s == "nil" || s == "NA"
begin
return s.to_f if s.include?(".")
return s.to_i
rescue
end
nil
end
def _ps_stat_write(key_name, value)
begin
b = base_stat.dup
b[key_name.to_s] = value
@base_stat = b
rescue
end
begin
if @render_stat.is_a?(Hash)
r = @render_stat.dup
r[key_name.to_s] = value
@render_stat = r
end
rescue
end
stat
value
end
def health
_ps_stat_num("health")
end
def sta
_ps_stat_num("sta")
end
def sat
_ps_stat_num("sat")
end
def health=(value)
_ps_stat_write("health", value)
end
def sta=(value)
_ps_stat_write("sta", value)
end
def sat=(value)
_ps_stat_write("sat", value)
end
# EffectDodge continues after set_dodge through
# actor.battle_stat.get_stat("move_speed"). NetSyncActor is intentionally
# lightweight, so expose a read-only compatible stat facade backed by the
# already replicated per-player stat hash.
def battle_stat
self
end
def get_stat(key_name, stat_type=nil)
value = _ps_stat_num(key_name.to_s)
return value unless value.nil?
return 3.0 if key_name.to_s == "move_speed"
return 14 if key_name.to_s == "dodge_frame"
0
rescue
0
end
def set_action_state(value, force=false)
@action_state = _ps_sync_norm_state(value)
end
def fraction
0
end
def friendly?(character)
false
end
def _ps_sync_norm_state(value)
return :none if value.nil?
s = value.to_s.strip
return :none if s == "" || s == "nil" || s == "none"
begin
s.to_sym
rescue
:none
end
end
# Remote skill visuals run the stock effect scripts (BasicAbomEatDed
# calls add_state, hold skills call cancel_holding, and so on). Those
# scripts are not authoritative on this client. Ignore unknown calls
# instead of raising. respond_to? stays false so sync code that checks
# for a real method still takes its dedicated path.
def method_missing(name, *args)
return nil if name.to_s.end_with?("=")
return false if name.to_s.end_with?("?")
nil
end
end
#--------------------------------------------------------------------------
# Logging helpers
#--------------------------------------------------------------------------
def self._ps_log_stamp
begin
t = Time.now
t.strftime("%Y-%m-%d %H:%M:%S") + "." + ("%03d" % (t.usec / 1000))
rescue
"time_error"
end
end
def self._ps_log_text(v, limit=nil)
limit = PLAYERSYNCS_LOG_MAX_TEXT if limit.nil?
s = ""
begin
s = v.is_a?(String) ? v : v.inspect
rescue
begin
s = v.to_s
rescue
s = "<unprintable>"
end
end
s = s.to_s
s = s.gsub(/\r|\n|\t/, " ")
s = s.gsub("\0", "")
if s.length > limit
s = s[0, limit] + "...(truncated " + s.length.to_s + " chars)"
end
s
end
def self.pslog(tag, msg=nil)
return unless PLAYERSYNCS_LOG_ENABLED
line = "[" + _ps_log_stamp + "] [PSYNC/" + _ps_log_text(tag, 64) + "] " + _ps_log_text(msg, PLAYERSYNCS_LOG_MAX_TEXT)
begin
puts line if PLAYERSYNCS_LOG_STDOUT
rescue
end
begin
File.open(PLAYERSYNCS_LOG_FILE, "ab") do |f|
f.write(line)
f.write("\r\n")
end
rescue
end
end
def self.pslog_error(tag, e=nil)
if e.nil?
pslog(tag, "ERROR unknown")
return
end
ek = nil
em = nil
begin
ek = e.class.to_s
rescue
ek = "UnknownError"
end
begin
em = e.message.to_s
rescue
begin
em = e.to_s
rescue
em = "unknown message"
end
end
pslog(tag, "ERROR " + ek.to_s + ": " + em.to_s)
end
#--------------------------------------------------------------------------
# Helpers
#--------------------------------------------------------------------------
def self._ps_now
begin
Time.now.to_f
rescue
0.0
end
end
def self._ps_actor
a = nil
begin
if $game_player && $game_player.respond_to?(:actor)
a = $game_player.actor
end
rescue
a = nil
end
if a.nil?
begin
a = $game_party.leader
rescue
a = nil
end
end
a
end
def self._ps_sanitize_field(s)
s = "" if s.nil?
s = s.to_s
s = s.gsub(":", ";")
s = s.gsub(/\r|\n|\t/, " ")
s = s.gsub("\0", "")
s.strip
end
def self._ps_pack_kv(h)
return "" unless h.is_a?(Hash)
out = []
h.each do |k, v|
kk = _ps_sanitize_field(k)
next if kk.nil? || kk == ""
vv = v
vv = "nil" if vv.nil?
vv = _ps_sanitize_field(vv)
vv = vv.gsub("|", "/")
out << (kk + "=" + vv)
end
out.join("|")
end
def self._ps_to_value(str)
s = (str.nil? ? "" : str.to_s)
return "nil" if s == "nil" || s == "NA"
if s =~ /^-?\d+$/
return s.to_i
end
s
end
def self._ps_unpack_kv(s)
h = {}
return h if s.nil? || s == ""
s.to_s.split("|").each do |pair|
next if pair.nil? || pair == ""
k, v = pair.split("=", 2)
next if k.nil? || k == ""
h[k] = _ps_to_value(v)
end
h
end
def self._ps_skills_csv(actor)
begin
list = actor.skills
return "" if list.nil?
arr = []
list.each do |sk|
begin
arr << sk.id.to_i
rescue
end
end
arr.join(",")
rescue
""
end
end
def self._ps_required_stat_keys(chs_type, charset_index=nil)
keys = []
begin
if $chs_data && chs_type && $chs_data[chs_type]
cd = $chs_data[chs_type]
if cd.respond_to?(:name_order)
no = cd.name_order
if no.is_a?(Hash)
no.each do |part_name, arr|
next if arr.nil?
begin
arr.each do |k|
next if k.nil?
keys << k.to_s
end
rescue
end
end
end
end
if cd.respond_to?(:parts)
begin
parts_src = nil
if !charset_index.nil? && cd.parts && cd.parts[charset_index.to_i].is_a?(Array)
parts_src = cd.parts[charset_index.to_i]
else
parts_src = cd.parts
end
if parts_src.is_a?(Array)
parts_src.each do |entry|
if entry.is_a?(Array)
entry.each do |part|
next if part.nil?
begin
pn = part.respond_to?(:part_name) ? part.part_name : nil
keys << pn.to_s unless pn.nil? || pn.to_s == ""
rescue
end
begin
dk = part.respond_to?(:dirtKey) ? part.dirtKey : nil
keys << dk.to_s unless dk.nil? || dk.to_s == ""
rescue
end
end
else
part = entry
next if part.nil?
begin
pn = part.respond_to?(:part_name) ? part.part_name : nil
keys << pn.to_s unless pn.nil? || pn.to_s == ""
rescue
end
begin
dk = part.respond_to?(:dirtKey) ? part.dirtKey : nil
keys << dk.to_s unless dk.nil? || dk.to_s == ""
rescue
end
end
end
end
rescue
end
end
end
rescue
keys = []
end
%w[body Race always persona pose MainArm SecondArm].each do |kk|
keys << kk unless keys.include?(kk)
end
keys << "sex_pos" unless keys.include?("sex_pos")
keys << "sex_position" unless keys.include?("sex_position")
keys = PLAYERSYNCS_FALLBACK_KEYS.dup if keys.empty?
out = []
keys.each do |k|
next if k.nil?
kk = k.to_s
next if kk == ""
out << kk unless out.include?(kk)
end
out
end
def self._ps_missing_default_for_key(k)
kk = (k.nil? ? "" : k.to_s)
low = kk.downcase
return 0 if low.include?("dirt")
return -1 if low == "sex_pos" || low == "sex_position"
"nil"
end
def self._ps_extract_stat_pack(actor, chs_type, charset_index=nil)
stat = nil
begin
if actor.respond_to?(:portrait_stat_value)
raw_stat = actor.portrait_stat_value rescue nil
stat = raw_stat if raw_stat.is_a?(Hash)
end
if stat.nil? && actor.respond_to?(:stat)
raw_stat = actor.stat rescue nil
stat = raw_stat if raw_stat.is_a?(Hash)
end
rescue
stat = nil
end
stat = {} if !stat.is_a?(Hash)
chs_cfg = nil
begin
if $game_player && $game_player.respond_to?(:statMap)
chs_cfg = $game_player.statMap
end
rescue
chs_cfg = nil
end
if !chs_cfg.is_a?(Hash)
begin
chs_cfg = $game_player.instance_variable_get(:@chs_configuration)
rescue
chs_cfg = nil
end
end
chs_cfg = {} if !chs_cfg.is_a?(Hash)
keys = _ps_required_stat_keys(chs_type, charset_index)
begin
keys = (keys + chs_cfg.keys.map { |kk| kk.to_s }).uniq if chs_cfg.is_a?(Hash)
keys = (keys + stat.keys.map { |kk| kk.to_s }).uniq if stat.is_a?(Hash)
rescue
end
h = {}
keys.each do |k|
begin
if chs_cfg.has_key?(k)
v = chs_cfg[k]
v = _ps_missing_default_for_key(k) if v.nil?
h[k] = v
elsif stat.has_key?(k)
v = stat[k]
v = _ps_missing_default_for_key(k) if v.nil?
h[k] = v
elsif stat.has_key?(k.to_sym)
v = stat[k.to_sym]
v = _ps_missing_default_for_key(k) if v.nil?
h[k] = v
else
h[k] = _ps_missing_default_for_key(k)
end
rescue
h[k] = _ps_missing_default_for_key(k)
end
end
%w[health sta sat].each do |stat_key|
begin
if actor.respond_to?(stat_key)
value = actor.send(stat_key)
h[stat_key] = value unless value.nil?
end
rescue
end
end
%w[combat_trait scoutcraft_trait wisdom_trait survival_trait constitution_trait].each do |stat_key|
begin
if actor.respond_to?(stat_key)
value = actor.send(stat_key)
h[stat_key] = value unless value.nil?
end
rescue
end
end
%w[IronWill WeakSoul Nymph Pessimist Prostitute Exhibitionism BloodLust WeaponryKnowledge HunterTraining ManaKnowledge ImproveThrowRock Omnivore IntoShadow NunKnowledge SemenGulper Succubus Cannibal SacredAegis TrapImprove Hitchhiker Masochist SaintFieldSupporter BloodyMess ShadowMaster Lilith].each do |trait_key|
begin
next unless actor.respond_to?(:state_stack)
h[trait_key] = actor.state_stack(trait_key).to_i > 0 ? 1 : 0
rescue
end
end
begin
hair_color = nil
if actor.respond_to?(:record_HairColor)
hair_color = actor.record_HairColor rescue nil
end
if hair_color.nil?
begin
hair_color = actor.instance_variable_get(:@record_HairColor)
rescue
hair_color = nil
end
end
h["HairColor"] = hair_color.nil? ? 0 : hair_color.to_i
rescue
h["HairColor"] = 0
end
# RaceRecord живёт в portrait (@prt_stat) и нужна BitmapChanger-палитрам.
# Явно кладём в пакет, даже если ключ не попал в chs_configuration.
begin
race_record = nil
if actor.respond_to?(:stat)
st = actor.stat rescue nil
race_record = st["RaceRecord"] if st.respond_to?(:[]) && !st["RaceRecord"].nil?
end
if race_record.nil? && actor.respond_to?(:portrait_stat_value)
prt = actor.portrait_stat_value rescue nil
race_record = prt["RaceRecord"] if prt.is_a?(Hash)
end
h["RaceRecord"] = race_record.to_s unless race_record.nil? || race_record.to_s == ""
rescue
end
begin
if actor.respond_to?(:race)
race_val = actor.race rescue nil
h["Race"] = race_val.to_s if !race_val.nil? && race_val.to_s != "" && !h.has_key?("Race")
end
rescue
end
begin
h["NetLightID"] = _ps_local_light_id.to_s
rescue
h["NetLightID"] = ""
end
packed = _ps_pack_kv(h)
pslog("_ps_extract_stat_pack", "chs_type=" + chs_type.to_s + " idx=" + charset_index.to_i.to_s + " keys=" + h.size.to_s + " packed_len=" + packed.length.to_s) if PLAYERSYNCS_TRACE_HOT_PATH
packed
end
def self._ps_local_light_id
return "" unless $game_player
return "" unless $game_player.respond_to?(:actor)
actor = $game_player.actor rescue nil
return "" if actor.nil?
return "lona_sight" if $game_map && $game_map.respond_to?(:isOverMap) && $game_map.isOverMap
no_light = false
begin
no_light = $game_player.no_light? if $game_player.respond_to?(:no_light?)
rescue
no_light = false
end
unless no_light
begin
lantern = $data_ItemName["ItemShLantern"] rescue nil
return "lantern_player" if lantern && actor.respond_to?(:equips) && actor.equips.include?(lantern)
rescue
end
begin
if actor.respond_to?(:ext_items)
has_small = actor.ext_items.any? do |item|
next false if item.nil?
next false if !$game_party || !$game_party.respond_to?(:item_number)
next false if $game_party.item_number(item) <= 0
item == "ItemShLantern"
end
return "lantern_player_sm" if has_small
end
rescue
end
end
"lona_sight"
rescue
""
end
def self._ps_apply_remote_light(rp, light_id)
return if rp.nil?
light_id = light_id.to_s
current_id = ""
begin
current_id = rp.instance_variable_get(:@ps_sync_light_id).to_s
rescue
current_id = ""
end
return if current_id == light_id
begin
if light_id == ""
rp.drop_light if rp.respond_to?(:drop_light)
else
rp.give_light(light_id) if rp.respond_to?(:give_light)
end
rp.instance_variable_set(:@ps_sync_light_id, light_id)
rescue
end
end
def self.refresh_remote_player_lights
return unless @players
@players.each_value do |rp|
next if rp.nil?
light_id = ""
begin
light_id = rp.instance_variable_get(:@ps_sync_light_id).to_s
rescue
light_id = ""
end
next if light_id == ""
begin
rp.give_light(light_id) if rp.respond_to?(:give_light)
rescue
end
end
rescue
end
def self._ps_signature(actor_id, level, skills_csv, chs_type, charset_index, chs_name, chs_name_h, stat_pack)
actor_id.to_s + "|" + level.to_s + "|" + skills_csv.to_s + "|" +
chs_type.to_s + "|" + charset_index.to_s + "|" +
chs_name.to_s + "|" + chs_name_h.to_s + "|" + stat_pack.to_s
end
#--------------------------------------------------------------------------
# Send
#--------------------------------------------------------------------------
def self.send_playersync_full(reason, force_send=false)
unless @connected
pslog("send_full/skip", "reason=" + reason.to_s + " not connected")
return
end
if @my_id.nil?
pslog("send_full/skip", "reason=" + reason.to_s + " my_id=nil")
return
end
actor = _ps_actor
if actor.nil?
pslog("send_full/skip", "reason=" + reason.to_s + " actor=nil")
return
end
actor_id = 0
level = 1
begin
actor_id = actor.id.to_i
rescue
actor_id = 0
end
begin
level = actor.level.to_i
rescue
level = 1
end
level = 1 if level < 1
skills_csv = _ps_skills_csv(actor)
chs_type = "Lona"
charset_index = 0
chs_name = ""
chs_name_h = ""
begin
chs_type = $game_player.chs_type.to_s
chs_type = "Lona" if chs_type.nil? || chs_type == ""
rescue
chs_type = "Lona"
end
begin
charset_index = $game_player.charset_index.to_i
rescue
charset_index = 0
end
begin
chs_name = $game_player.instance_variable_get(:@chs_name).to_s
rescue
chs_name = ""
end
begin
chs_name_h = $game_player.instance_variable_get(:@chs_name_h).to_s
rescue
chs_name_h = ""
end
stat_pack = _ps_extract_stat_pack(actor, chs_type, charset_index)
sig = _ps_signature(actor_id, level, skills_csv, chs_type, charset_index, chs_name, chs_name_h, stat_pack)
now = _ps_now
last_at = (@ps_last_sent_at.nil? ? 0.0 : @ps_last_sent_at)
if force_send
if (now - last_at) < 0.05
pslog("send_full/skip", "reason=" + reason.to_s + " force_cooldown")
return
end
else
if @ps_last_sent_sig == sig
pslog("send_full/skip", "reason=" + reason.to_s + " same_signature")
return
end
if (now - last_at) < PLAYERSYNCS_MIN_SEND_INTERVAL
pslog("send_full/skip", "reason=" + reason.to_s + " cooldown")
return
end
end
msg = "plsync_full:" + actor_id.to_s + ":" + level.to_s + ":" + skills_csv.to_s + ":" +
esc(chs_type) + ":" + charset_index.to_s + ":" +
esc(chs_name) + ":" + esc(chs_name_h) + ":" + esc(stat_pack)
send_line(msg)
@ps_last_sent_at = now
@ps_last_sent_sig = sig
pslog("send_full/sent", "reason=" + reason.to_s + " force=" + (!!force_send).to_s + " chs_type=" + chs_type.to_s + " idx=" + charset_index.to_i.to_s + " stat_len=" + stat_pack.length.to_s + " msg_len=" + msg.length.to_s)
if PLAYERSYNCS_DEBUG
begin
puts "[PSYNC] sent (" + reason.to_s + ") len=" + msg.length.to_s
rescue
end
end
end
def self.send_playersync_req
unless @connected
pslog("send_req/skip", "not connected")
return
end
if @my_id.nil?
pslog("send_req/skip", "my_id=nil")
return
end
now = _ps_now
last = (@ps_last_req_at.nil? ? 0.0 : @ps_last_req_at)
if (now - last) < PLAYERSYNCS_REQ_COOLDOWN
pslog("send_req/skip", "cooldown")
return
end
send_line("plsync_req")
@ps_last_req_at = now
pslog("send_req/sent", "my_id=" + @my_id.to_s)
end
#--------------------------------------------------------------------------
# Visual fix (NO singleton methods)
#--------------------------------------------------------------------------
def self._ps_force_netplayer_visual(rp)
# Male grab sex hides NetPlayer under proxy; do not fight that hide.
begin
pid = rp.instance_variable_get(:@net_player_id).to_i if rp
if pid.to_i > 0 && respond_to?(:mp_male_net_hidden?) && mp_male_net_hidden?(pid)
begin
rp.opacity = 0 if rp.respond_to?(:opacity=)
rp.transparent = true if rp.respond_to?(:transparent=)
rescue
end
return
end
rescue
end
begin
rp.transparent = false
rescue
begin
rp.instance_variable_set(:@transparent, false)
rescue
end
end
begin
rp.instance_variable_set(:@original_transparent, false)
rescue
end
begin
rp.opacity = 255
rescue
begin
rp.instance_variable_set(:@opacity, 255)
rescue
end
end
begin
rp.instance_variable_set(:@blend_type, 0)
rescue
end
end
#--------------------------------------------------------------------------
# Apply incoming sync
#--------------------------------------------------------------------------
def self.apply_playersync(pid, actor_id, level, skills_csv, chs_type, charset_index, chs_name, chs_name_h, stat_pack)
return if pid.nil?
pid = pid.to_i
return if pid <= 0
# Relayed appearance is remote-only. Never let an echoed packet mutate the
# local actor, even if a server/plugin accidentally includes the sender.
return if @my_id && pid == @my_id.to_i
pslog("apply/start", "pid=" + pid.to_s + " actor_id=" + actor_id.to_i.to_s + " level=" + level.to_i.to_s + " chs_type=" + chs_type.to_s + " idx=" + charset_index.to_i.to_s + " stat_len=" + stat_pack.to_s.length.to_s)
begin
create_remote_player(pid)
rescue
end
return unless @players && @players[pid]
rp = @players[pid]
@player_syncs ||= {}
@player_syncs[pid] = {
:actor_id => actor_id.to_i,
:level => level.to_i,
:skills => skills_csv.to_s
}
net_actor = nil
begin
net_actor = rp.instance_variable_get(:@net_actor)
rescue
net_actor = nil
end
if net_actor.nil? || !net_actor.respond_to?(:stat)
net_actor = NetSyncActor.new
begin
rp.instance_variable_set(:@net_actor, net_actor)
rescue
end
end
raw = _ps_unpack_kv(stat_pack.to_s)
remote_light_id = ""
begin
if raw.has_key?("NetLightID")
remote_light_id = raw.delete("NetLightID").to_s
elsif raw.has_key?(:NetLightID)
remote_light_id = raw.delete(:NetLightID).to_s
end
rescue
remote_light_id = ""
end
safe = {}
req_keys = _ps_required_stat_keys(chs_type, charset_index)
raw.each_key do |k|
kk = k.to_s
req_keys << kk unless req_keys.include?(kk)
end
req_keys.each do |k|
kk = k.to_s
v = raw.has_key?(kk) ? raw[kk] : _ps_missing_default_for_key(kk)
if kk.downcase.include?("dirt")
if v == "nil" || v == "NA" || v.nil?
safe[kk] = 0
else
begin
safe[kk] = v.to_i
rescue
safe[kk] = 0
end
end
elsif kk.downcase == "sex_pos" || kk.downcase == "sex_position"
if v == "nil" || v == "NA" || v.nil?
safe[kk] = -1
else
begin
safe[kk] = v.to_i
rescue
safe[kk] = -1
end
end
elsif kk == "HairColor"
if v == "nil" || v == "NA" || v.nil?
safe[kk] = 0
else
begin
safe[kk] = v.to_i
rescue
safe[kk] = 0
end
end
else
safe[kk] = v
end
end
begin
if net_actor.respond_to?(:set_base_stat)
net_actor.set_base_stat(safe)
else
net_actor.stat = safe
end
rescue
begin
net_actor.instance_variable_set(:@stat, safe)
rescue
end
end
begin
hair_color = safe.has_key?("HairColor") ? safe["HairColor"] : 0
if net_actor.respond_to?(:record_HairColor=)
net_actor.record_HairColor = hair_color.to_i
else
net_actor.instance_variable_set(:@record_HairColor, hair_color.to_i)
end
rescue
end
_ps_apply_remote_light(rp, remote_light_id)
_ps_force_netplayer_visual(rp)
begin
rp.instance_variable_set(:@chs_type, chs_type.to_s)
rescue
end
begin
rp.instance_variable_set(:@charset_index, charset_index.to_i)
rescue
end
begin
chs_def = ($chs_data && $chs_data[chs_type.to_s]) ? $chs_data[chs_type.to_s] : nil
real_char_index = 0
if chs_def && chs_def.respond_to?(:chs_default_index)
arr = chs_def.chs_default_index
if arr && !arr[charset_index.to_i].nil?
real_char_index = arr[charset_index.to_i].to_i
end
end
rp.instance_variable_set(:@character_index, real_char_index)
rp.instance_variable_set(:@ps_sync_character_index, real_char_index)
rescue
begin
rp.instance_variable_set(:@character_index, 0)
rescue
end
end
begin
rp.instance_variable_set(:@chs_configuration, safe.dup)
rescue
end
# Р’РђР–РќРћ:
# chs_name у CHS — это ключ кэша (Cache.chs_character), а НЕ имя файла.
# Если он пустой/одинаковый у нескольких remote players, они делят один и тот же bitmap.
# Отсюда эффект "все подтягивают одну внешность".
cache_key = "NetP" + pid.to_s
begin
rp.instance_variable_set(:@chs_name, cache_key)
rescue
end
begin
rp.instance_variable_set(:@chs_name_h, cache_key + "_H")
rescue
end
# Р’РђР–РќРћ:
# Sprite_Character#set_character_bitmap даже для CHS вычисляет размер кадра
# по sign из @character_name. У remote player из create_remote_player стоит
# !$_LonaSample.png, то есть '$'. Тогда CHS bitmap режется как $-charset (3x4),
# а не как CHS sheet (12x8), и src_rect уходит мимо — игрок выглядит прозрачным.
begin
rp.instance_variable_set(:@character_name, "")
rp.instance_variable_set(:@manual_character_name, "")
rescue
end
begin
rp.instance_variable_set(:@chs_need_update, true)
rescue
end
# Keep NetPlayer hidden under male-grab sex proxy; otherwise force visible.
begin
if respond_to?(:mp_male_net_hidden?) && mp_male_net_hidden?(pid)
begin
rp.opacity = 0 if rp.respond_to?(:opacity=)
rp.transparent = true if rp.respond_to?(:transparent=)
rescue
end
else
begin
rp.transparent = false
rescue
begin
rp.instance_variable_set(:@transparent, false)
rescue
end
end
begin
rp.instance_variable_set(:@original_transparent, false)
rescue
end
begin
rp.opacity = 255
rescue
begin
rp.instance_variable_set(:@opacity, 255)
rescue
end
end
end
rescue
end
pslog("apply/done", "pid=" + pid.to_s + " safe_keys=" + safe.size.to_s + " raw_keys=" + raw.size.to_s + " cache_key=" + cache_key.to_s)
end
#--------------------------------------------------------------------------
# Save-safe detach / restore remote players
#--------------------------------------------------------------------------
def self._ps_detach_remote_players_for_save
removed = []
return removed unless @players
return removed unless $game_map
return removed unless $game_map.respond_to?(:events)
begin
evs = $game_map.events
rescue
evs = nil
end
return removed if evs.nil?
@players.each do |id, ev|
next if ev.nil?
begin
evs.each do |event_id, event_obj|
if event_obj.equal?(ev)
removed << [event_id, event_obj]
evs.delete(event_id)
break
end
end
rescue
end
end
removed
end
def self._ps_restore_remote_players_after_save(removed)
return if removed.nil?
return unless $game_map
return unless $game_map.respond_to?(:events)
begin
evs = $game_map.events
rescue
evs = nil
end
return if evs.nil?
removed.each do |pair|
begin
event_id = pair[0]
ev = pair[1]
evs[event_id] = ev if ev
rescue
end
end
end
#--------------------------------------------------------------------------
# Hooks
#--------------------------------------------------------------------------
class << self
begin
alias_method :_ps_old_update, :update
rescue
end
end
def self.update(*args)
if self.respond_to?(:_ps_old_update)
begin
_ps_old_update(*args)
rescue
end
end
return unless @connected
if respond_to?(:gameplay_scene_active?)
return unless gameplay_scene_active?
else
return unless SceneManager.scene_is?(Scene_Map)
end
cur_map = 0
begin
cur_map = $game_map ? $game_map.map_id : 0
rescue
cur_map = 0
end
if @ps_last_map_id != cur_map
@ps_last_map_id = cur_map
@ps_last_sent_sig = nil
@ps_last_sent_at = 0.0
@ps_frame = 0
send_playersync_full("map_enter")
send_playersync_req
return
end
# Cheap dirty probe only; send_playersync_full computes the appearance
# signature and emits a packet exclusively when equipment/race/portrait
# data actually changed. This restores runtime delta replication without
# broadcasting character state every frame.
@ps_frame = @ps_frame.to_i + 1
return if @ps_frame < PLAYERSYNCS_CHECK_EVERY_FRAMES
@ps_frame = 0
send_playersync_full("appearance_dirty")
end
class << self
begin
alias_method :_ps_old_parse, :parse
rescue
end
end
def self.parse(msg)
if msg && msg.start_with?("plsync_req:")
pslog("parse/recv_req_pid", "raw=" + _ps_log_text(msg, 280))
begin
pid_s = msg.split(":", 2)[1]
pid = pid_s.to_i
if @connected && @my_id && pid > 0 && pid != @my_id
now = _ps_now
last = (@ps_last_resp_at.nil? ? 0.0 : @ps_last_resp_at)
if (now - last) > PLAYERSYNCS_RESP_COOLDOWN
send_playersync_full("respond_req", true)
@ps_last_resp_at = now
pslog("parse/respond_req_pid", "target_pid=" + pid.to_s + " my_id=" + @my_id.to_s)
else
pslog("parse/respond_req_pid/skip", "cooldown")
end
end
rescue
end
return
elsif msg == "plsync_req"
pslog("parse/recv_req", "raw=plsync_req")
begin
now = _ps_now
last = (@ps_last_resp_at.nil? ? 0.0 : @ps_last_resp_at)
if (now - last) > PLAYERSYNCS_RESP_COOLDOWN
send_playersync_full("respond_req(no_pid)", true)
@ps_last_resp_at = now
pslog("parse/respond_req", "broadcast style response sent")
else
pslog("parse/respond_req/skip", "cooldown")
end
rescue
end
return
elsif msg && msg.start_with?("plsync_full:")
pslog("parse/recv_full", "raw=" + _ps_log_text(msg, 420))
# Новый формат: 10 частей
parts10 = msg.split(":", 10)
if parts10.size >= 10
pid = parts10[1].to_i
actor_id = parts10[2].to_i
level = parts10[3].to_i
skills_csv = parts10[4].to_s
chs_type = unesc(parts10[5].to_s)
charset_index = parts10[6].to_i
chs_name = unesc(parts10[7].to_s)
chs_name_h = unesc(parts10[8].to_s)
stat_pack = unesc(parts10[9].to_s)
if @my_id && pid == @my_id
@player_syncs ||= {}
@player_syncs[pid] = { :actor_id => actor_id, :level => level, :skills => skills_csv }
pslog("parse/full_v2/self", "stored self snapshot pid=" + pid.to_s)
return
end
apply_playersync(pid, actor_id, level, skills_csv, chs_type, charset_index, chs_name, chs_name_h, stat_pack)
return
end
# Старый формат: 8 частей
parts8 = msg.split(":", 8)
if parts8.size >= 8
pid = parts8[1].to_i
actor_id = parts8[2].to_i
level = parts8[3].to_i
skills_csv = parts8[4].to_s
chs_type = unesc(parts8[5].to_s)
charset_index = parts8[6].to_i
stat_pack = unesc(parts8[7].to_s)
if @my_id && pid == @my_id
@player_syncs ||= {}
@player_syncs[pid] = { :actor_id => actor_id, :level => level, :skills => skills_csv }
pslog("parse/full_v1/self", "stored self snapshot pid=" + pid.to_s)
return
end
apply_playersync(pid, actor_id, level, skills_csv, chs_type, charset_index, "", "", stat_pack)
return
end
end
if self.respond_to?(:_ps_old_parse)
begin
_ps_old_parse(msg)
rescue
end
end
end
begin
pslog("boot", "playersync logger enabled -> " + PLAYERSYNCS_LOG_FILE)
rescue
end
end
#==============================================================================
# Save-safe class patches for Game_Event (NO singleton methods on instances)
#==============================================================================
class Game_Event
if !method_defined?(:_ps_sync_actor_original)
if method_defined?(:actor)
alias _ps_sync_actor_original actor
else
def _ps_sync_actor_original
nil
end
end
def actor
net_actor = nil
begin
net_actor = instance_variable_get(:@net_actor)
rescue
net_actor = nil
end
if WebSocket::PLAYERSYNCS_TRACE_HOT_PATH && !net_actor.nil?
WebSocket.pslog("Game_Event#actor", "return @net_actor")
end
return net_actor unless net_actor.nil?
_ps_sync_actor_original
end
end
# A replicated EffectDodge must remain visible. The stock method sets the
# transient actor flag; after it succeeds, attach the ordinary dodge CHS
# animation only to the addressed remote player event. The effect's own
# batch then performs its normal forward jump and sound.
if method_defined?(:set_dodge) && !method_defined?(:_ps_sync_set_dodge_original)
alias _ps_sync_set_dodge_original set_dodge
def set_dodge(frame=5)
result = _ps_sync_set_dodge_original(frame)
begin
net_actor = instance_variable_get(:@net_actor)
net_pid = instance_variable_get(:@net_player_id)
if !net_actor.nil? && !net_pid.nil? && respond_to?(:animation=) && respond_to?(:animation_dodge)
self.animation = self.animation_dodge
end
rescue
end
result
end
end
# Remote player events have no @npc, therefore vanilla update_npc returns
# before update_dodge. Tick the existing dodge timer explicitly so the
# transient flags are cleared after the visual finishes instead of staying
# true for the rest of the map session.
if method_defined?(:update) && !method_defined?(:_ps_sync_update_without_remote_dodge)
alias _ps_sync_update_without_remote_dodge update
def update(*args, &block)
result = _ps_sync_update_without_remote_dodge(*args, &block)
begin
net_actor = instance_variable_get(:@net_actor)
dodge_frames = instance_variable_get(:@dodge_frame).to_i
update_dodge if !net_actor.nil? && dodge_frames > 0
rescue
end
result
end
end
if !method_defined?(:_ps_sync_use_chs_original)
if method_defined?(:use_chs?)
alias _ps_sync_use_chs_original use_chs?
def use_chs?
begin
return true unless instance_variable_get(:@net_actor).nil?
rescue
end
_ps_sync_use_chs_original
end
else
def use_chs?
begin
return true unless instance_variable_get(:@net_actor).nil?
rescue
end
false
end
end
end
if !method_defined?(:_ps_sync_character_name_original)
alias _ps_sync_character_name_original character_name
def character_name
_ps_sync_character_name_original
end
end
if !method_defined?(:_ps_sync_character_index_original)
alias _ps_sync_character_index_original character_index
def character_index
begin
unless instance_variable_get(:@net_actor).nil?
cfg = instance_variable_get(:@chs_configuration)
sex_pos = -1
begin
if cfg.is_a?(Hash)
sex_pos = cfg.has_key?("sex_pos") ? cfg["sex_pos"] : cfg["sex_position"]
end
rescue
sex_pos = -1
end
return 0 if sex_pos.to_i != -1
mv = nil
begin
mv = instance_variable_get(:@net_movement)
rescue
mv = nil
end
begin
if defined?(WebSocket) && WebSocket.respond_to?(:mp_anim_movement_character_index)
midx = WebSocket.mp_anim_movement_character_index(mv, nil)
return midx.to_i unless midx.nil?
end
rescue
end
idx = instance_variable_get(:@ps_sync_character_index)
return idx.to_i unless idx.nil?
end
rescue
end
_ps_sync_character_index_original
end
end
if !method_defined?(:_ps_sync_sex_mode_original)
if method_defined?(:sex_mode?)
alias _ps_sync_sex_mode_original sex_mode?
def sex_mode?
begin
net_actor = instance_variable_get(:@net_actor)
unless net_actor.nil?
cfg = instance_variable_get(:@chs_configuration) rescue nil
if cfg.is_a?(Hash)
sex_pos = cfg.has_key?("sex_pos") ? cfg["sex_pos"] : cfg["sex_position"]
return sex_pos.to_i != -1
end
return false
end
rescue
end
_ps_sync_sex_mode_original
end
else
def sex_mode?
begin
net_actor = instance_variable_get(:@net_actor)
unless net_actor.nil?
cfg = instance_variable_get(:@chs_configuration) rescue nil
if cfg.is_a?(Hash)
sex_pos = cfg.has_key?("sex_pos") ? cfg["sex_pos"] : cfg["sex_position"]
return sex_pos.to_i != -1
end
return false
end
rescue
end
false
end
end
end
# BasicAbomEatDed and similar stock scripts call combat_jump_reverse on the
# caster. For anyone except the local player that method reads
# @summon_data[:user]. A remote player event has no summon data, so the
# call raises and takes down this client. The jump is not authoritative
# here; skip it and let the rest of the visual continue.
if method_defined?(:combat_jump_reverse) && !method_defined?(:_ps_sync_combat_jump_reverse_original)
alias _ps_sync_combat_jump_reverse_original combat_jump_reverse
def combat_jump_reverse(*args)
remote = false
begin
remote = !instance_variable_get(:@net_player_id).nil? || !instance_variable_get(:@net_actor).nil?
rescue
remote = false
end
if remote
data = nil
begin
data = @summon_data
rescue
data = nil
end
return unless data.respond_to?(:[]) && !data[:user].nil?
end
_ps_sync_combat_jump_reverse_original(*args)
end
end
end
#==============================================================================
# Safety patch for Lona dirt opacity (prevents nil opacity crash in CHS)
#==============================================================================
class Lona_Part
if method_defined?(:updateDirt) && !method_defined?(:_ps_sync_updateDirt_original)
alias _ps_sync_updateDirt_original updateDirt
def updateDirt(ref)
v = nil
begin
v = ref.stat[@dirtKey]
rescue
v = nil
end
v = 0 if v.nil?
begin
v = v.to_i unless v.is_a?(Numeric)
rescue
v = 0
end
v = 0 if v < 0
v = 255 if v > 255
@opacity = v
end
end
end
#==============================================================================
# Save-safe patch for DataManager
#==============================================================================
module DataManager
class << self
begin
alias_method :_ps_sync_save_game_original, :save_game unless method_defined?(:_ps_sync_save_game_original)
rescue
end
end
def self.save_game(index)
removed = []
WebSocket.pslog("save_game/start", "index=" + index.to_i.to_s)
begin
removed = WebSocket._ps_detach_remote_players_for_save
WebSocket.pslog("save_game/detached", "count=" + removed.size.to_s)
rescue => e
WebSocket.pslog_error("save_game/detach", e)
removed = []
end
begin
result = _ps_sync_save_game_original(index)
WebSocket.pslog("save_game/original_done", "result=" + result.to_s)
result
ensure
begin
WebSocket._ps_restore_remote_players_after_save(removed)
WebSocket.pslog("save_game/restored", "count=" + removed.size.to_s)
rescue => e
WebSocket.pslog_error("save_game/restore", e)
end
end
end
end
#==============================================================================
# HairColor + RaceRecord fix for remote players
#------------------------------------------------------------------------------
# Проблема:
# - CHS/BitmapChanger берёт цвет волос и RaceRecord у ЛОКАЛЬНОГО актёра
# ($game_player.actor.stat['RaceRecord']), а не у remote-event.
# - Из-за этого каждый клиент видит ВСЕХ remote players со своей расой/волосами.
#
# Фикс:
# - перед rebuild bitmap у Sprite_Character для remote-player временно
# подменяем локальные record_HairColor / RaceRecord / Race на значения
# именно этого remote-player (палитра BitmapChanger смотрит на condition);
# - после вызова оригинального set_character_bitmap сразу возвращаем назад.
#==============================================================================
module WebSocket
def self._ps_remote_cfg_value(char, *keys)
return nil if char.nil?
begin
cfg = char.instance_variable_get(:@chs_configuration)
if cfg.is_a?(Hash)
keys.each do |key|
return cfg[key] if cfg.has_key?(key)
sym = key.to_sym
return cfg[sym] if cfg.has_key?(sym)
end
end
rescue
end
# Male-grab Lona stand-in stores tint in the render Hash.
begin
render = char.instance_variable_get(:@mp_male_lona_render)
if render.is_a?(Hash)
keys.each do |key|
return render[key] if render.has_key?(key)
sym = key.to_sym
return render[sym] if render.has_key?(sym)
end
end
rescue
end
begin
net_actor = char.instance_variable_get(:@net_actor)
unless net_actor.nil?
st = nil
begin
st = net_actor.stat if net_actor.respond_to?(:stat)
rescue
st = nil
end
if st.is_a?(Hash)
keys.each do |key|
return st[key] if st.has_key?(key)
sym = key.to_sym
return st[sym] if st.has_key?(sym)
end
end
end
rescue
end
nil
end
def self._ps_remote_hair_color_for_character(char)
raw = _ps_remote_cfg_value(char, "HairColor")
return nil if raw.nil?
raw.to_i
rescue
nil
end
def self._ps_remote_race_record_for_character(char)
raw = _ps_remote_cfg_value(char, "RaceRecord")
return nil if raw.nil?
s = raw.to_s
return nil if s == "" || s == "nil" || s == "NA"
s
rescue
nil
end
def self._ps_remote_race_for_character(char)
raw = _ps_remote_cfg_value(char, "Race")
return nil if raw.nil?
s = raw.to_s
return nil if s == "" || s == "nil" || s == "NA"
s
rescue
nil
end
def self._ps_portrait_get(actor, key)
return nil if actor.nil?
begin
prt = actor.portrait_stat_value if actor.respond_to?(:portrait_stat_value)
return prt[key] if prt.is_a?(Hash) && prt.has_key?(key)
rescue
end
begin
prt = actor.instance_variable_get(:@prt_stat)
return prt[key] if prt.is_a?(Hash) && prt.has_key?(key)
rescue
end
nil
end
def self._ps_portrait_set(actor, key, value)
return if actor.nil?
# Пишем напрямую в @prt_stat — без report_portrait_stat, чтобы не
# дёргать UI-портрет локального игрока на каждый remote rebuild.
begin
prt = actor.instance_variable_get(:@prt_stat)
if prt.is_a?(Hash)
prt[key] = value
return
end
rescue
end
begin
actor.report_portrait_stat(key, value) if actor.respond_to?(:report_portrait_stat)
rescue
end
end
# Подмена локальных HairColor/RaceRecord/Race на значения remote-player
# на время сборки CHS-bitmap (палитры читают $game_player.actor).
def self._ps_with_local_appearance_override(temp_hair, temp_race_record, temp_race)
return yield unless block_given?
actor = nil
begin
actor = _ps_actor
rescue
actor = nil
end
return yield if actor.nil?
old_hair = nil
old_race_record = nil
old_race = nil
begin
old_hair = actor.instance_variable_get(:@record_HairColor)
rescue
old_hair = nil
end
begin
old_race_record = _ps_portrait_get(actor, "RaceRecord")
rescue
old_race_record = nil
end
begin
old_race = _ps_portrait_get(actor, "Race")
rescue
old_race = nil
end
begin
actor.instance_variable_set(:@record_HairColor, temp_hair.to_i) unless temp_hair.nil?
rescue
end
# Только portrait: BitmapChanger conditions читают actor.stat['RaceRecord'].
# Не трогаем actStat.race=, чтобы не дёргать live-sync / recalculate.
begin
_ps_portrait_set(actor, "RaceRecord", temp_race_record) unless temp_race_record.nil?
_ps_portrait_set(actor, "Race", temp_race) unless temp_race.nil?
rescue
end
begin
@ps_hair_override_active = true
@ps_hair_override = temp_hair.nil? ? nil : temp_hair.to_i
@ps_race_override_active = true
@ps_race_record_override = temp_race_record
@ps_race_override = temp_race
yield
ensure
begin
actor.instance_variable_set(:@record_HairColor, old_hair)
rescue
end
begin
_ps_portrait_set(actor, "RaceRecord", old_race_record) unless temp_race_record.nil?
_ps_portrait_set(actor, "Race", old_race) unless temp_race.nil?
rescue
end
@ps_hair_override = nil
@ps_hair_override_active = false
@ps_race_record_override = nil
@ps_race_override = nil
@ps_race_override_active = false
end
end
# Совместимость со старым именем.
def self._ps_with_local_hair_override(temp_color, &block)
_ps_with_local_appearance_override(temp_color, nil, nil, &block)
end
end
if defined?(Sprite_Character)
class Sprite_Character < Sprite_Base
if !method_defined?(:_ps_hair_sync_set_character_bitmap_original) && method_defined?(:set_character_bitmap)
alias _ps_hair_sync_set_character_bitmap_original set_character_bitmap
def set_character_bitmap(*args)
char = nil
begin
char = @character
rescue
char = nil
end
pid = nil
begin
pid = char.instance_variable_get(:@net_player_id) unless char.nil?
rescue
pid = nil
end
# Also male-grab receiver proxy (Lona stand-in): BitmapChanger still
# samples $game_player.actor RaceRecord/HairColor unless we override.
is_male_recv = false
begin
is_male_recv = true if char && (
char.instance_variable_get(:@mp_male_receiver_proxy) ||
char.instance_variable_get(:@mp_male_lona_render).is_a?(Hash)
)
rescue
is_male_recv = false
end
if (!pid.nil? || is_male_recv) && defined?(WebSocket)
hair_color = nil
race_record = nil
race_val = nil
begin
hair_color = WebSocket._ps_remote_hair_color_for_character(char)
rescue
hair_color = nil
end
begin
race_record = WebSocket._ps_remote_race_record_for_character(char)
rescue
race_record = nil
end
begin
race_val = WebSocket._ps_remote_race_for_character(char)
rescue
race_val = nil
end
if !hair_color.nil? || !race_record.nil? || !race_val.nil?
begin
return WebSocket._ps_with_local_appearance_override(hair_color, race_record, race_val) do
_ps_hair_sync_set_character_bitmap_original(*args)
end
rescue
end
end
end
_ps_hair_sync_set_character_bitmap_original(*args)
end
end
end
end
if defined?(Game_Actor)
class Game_Actor
if method_defined?(:record_HairColor) && !method_defined?(:_ps_hair_sync_record_HairColor_original)
alias _ps_hair_sync_record_HairColor_original record_HairColor
def record_HairColor(*args)
begin
if defined?(WebSocket) && WebSocket.instance_variable_get(:@ps_hair_override_active)
temp = WebSocket.instance_variable_get(:@ps_hair_override)
return temp.to_i unless temp.nil?
end
rescue
end
_ps_hair_sync_record_HairColor_original(*args)
end
end
end
end