# 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:::::::: # plsync_req # # server -> clients: # plsync_full::::::::: # plsync_req: # # Старый формат (без 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 = "" 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