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

1962 lines
55 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.
# 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