# encoding: UTF-8 #============================================================================== # 22_ninja.rb — stealth visibility sync for remote players #------------------------------------------------------------------------------ # Что делает: # - НЕ меняет существующий сетевой протокол сервера и не требует правок server.py # - использует уже существующий relay deistvia:* как транспорт # - синхронизирует состояние скрытности локального игрока # - на каждом клиенте скрывает remote-player, если он в stealth и НЕ находится # в поле зрения локального игрока # - если скрытность спала — игрок снова виден всем # # База-игра (анализ Data.zip): # - stealth связан с move_sneak / player_sneak? (CTRL, движение :sneak) # - у skills есть флаг skill.stealth # - также встречаются stat["IntoShadow"] / stat["ShadowMaster"] # # ВАЖНО: # - файл не ломает существующий MP-мод: только alias/hook # - сервер не меняется; пересылка идёт через deistvia:ninja:* #============================================================================== return unless defined?(WebSocket) module WebSocket NINJA_SYNC_INTERVAL = 0.60 unless const_defined?(:NINJA_SYNC_INTERVAL) NINJA_REMOTE_TIMEOUT = 4.50 unless const_defined?(:NINJA_REMOTE_TIMEOUT) class << self begin alias_method :_ninja_old_update, :update unless method_defined?(:_ninja_old_update) rescue end begin alias_method :_ninja_old_handle_remote_deistvia, :handle_remote_deistvia unless method_defined?(:_ninja_old_handle_remote_deistvia) rescue end begin alias_method :_ninja_old_remove_remote_player, :remove_remote_player unless method_defined?(:_ninja_old_remove_remote_player) rescue end begin alias_method :_ninja_old_connect, :connect unless method_defined?(:_ninja_old_connect) rescue end begin alias_method :_ninja_old_disconnect, :disconnect unless method_defined?(:_ninja_old_disconnect) rescue end end @ninja_states ||= {} @ninja_local_last_active ||= nil @ninja_local_last_ghost ||= nil @ninja_local_last_sent_at ||= 0.0 @ninja_local_last_map_id ||= 0 def self._ninja_now begin Time.now.to_f rescue 0.0 end end def self._ninja_state_table @ninja_states ||= {} end def self._ninja_clear_state_cache @ninja_states = {} @ninja_local_last_active = nil @ninja_local_last_ghost = nil @ninja_local_last_sent_at = 0.0 begin @ninja_local_last_map_id = ($game_map ? $game_map.map_id.to_i : 0) rescue @ninja_local_last_map_id = 0 end end def self.connect(ip="lonarpg.online", port=6134) result = nil if self.respond_to?(:_ninja_old_connect) result = _ninja_old_connect(ip, port) end begin _ninja_clear_state_cache rescue end result end if self.respond_to?(:_ninja_old_connect) def self.disconnect begin _ninja_clear_state_cache rescue end if self.respond_to?(:_ninja_old_disconnect) _ninja_old_disconnect end end if self.respond_to?(:_ninja_old_disconnect) def self.remove_remote_player(id) begin if self.respond_to?(:_ninja_old_remove_remote_player) _ninja_old_remove_remote_player(id) end ensure begin _ninja_state_table.delete(id.to_i) rescue end end end if self.respond_to?(:_ninja_old_remove_remote_player) def self._ninja_local_actor actor = nil begin actor = $game_player.actor if $game_player && $game_player.respond_to?(:actor) rescue actor = nil end actor end def self._ninja_local_stealth? gp = nil begin gp = $game_player rescue gp = nil end return false if gp.nil? actor = _ninja_local_actor active = false begin active = true if gp.respond_to?(:player_sneak?) && gp.player_sneak? rescue end begin mv = gp.movement if gp.respond_to?(:movement) active = true if [:sneak, :sneak_overfatigue, :sneak_cuffed].include?(mv) rescue end begin if actor && actor.respond_to?(:skill) sk = actor.skill active = true if !sk.nil? && sk.respond_to?(:stealth) && sk.stealth end rescue end begin if actor && actor.respond_to?(:stat) st = actor.stat if st.is_a?(Hash) raw = nil raw = st["IntoShadow"] if st.has_key?("IntoShadow") raw = st[:IntoShadow] if raw.nil? && st.has_key?(:IntoShadow) active = true if !raw.nil? && raw.to_i == 1 raw2 = nil raw2 = st["ShadowMaster"] if st.has_key?("ShadowMaster") raw2 = st[:ShadowMaster] if raw2.nil? && st.has_key?(:ShadowMaster) active = true if !raw2.nil? && raw2.to_i == 1 end end rescue end # MODERATOR+ Ghost is a persistent visibility mode independent of crouching. begin active = true if respond_to?(:admin_ghost_active?) && admin_ghost_active? rescue end active end def self._ninja_send_packet(active, phase) # The ghost marker travels inside the existing ninja relay, so all # cooperating clients have the same toggle + heartbeat behaviour. ghost = (respond_to?(:admin_ghost_active?) && admin_ghost_active?) rescue false payload = { "active" => (active ? 1 : 0), "ghost" => (active && ghost ? 1 : 0) } begin if self.respond_to?(:send_deistvia) send_deistvia("ninja", phase.to_s, payload) return true end rescue end begin packed = "active=#{active ? 1 : 0},ghost=#{active && ghost ? 1 : 0}" send_line("deistvia:ninja:" + esc(phase.to_s) + ":" + esc(packed)) return true rescue end false end def self._ninja_tick_local return unless @connected # Worldsync controls world/NPC events, not the ordinary player relay. # Many servers do not enable it; Ghost must still be synchronized. return if @my_id.nil? begin return unless SceneManager.scene_is?(Scene_Map) rescue end now = _ninja_now current_map = 0 begin current_map = ($game_map ? $game_map.map_id.to_i : 0) rescue current_map = 0 end if @ninja_local_last_map_id.to_i != current_map.to_i @ninja_local_last_map_id = current_map.to_i @ninja_local_last_active = nil @ninja_local_last_ghost = nil @ninja_local_last_sent_at = 0.0 end ghost = (respond_to?(:admin_ghost_active?) && admin_ghost_active?) ? true : false active = _ninja_local_stealth? || ghost last_active = @ninja_local_last_active last_ghost = @ninja_local_last_ghost last_sent = (@ninja_local_last_sent_at.nil? ? 0.0 : @ninja_local_last_sent_at.to_f) must_send = false phase = "sync" if last_active.nil? || active != last_active || ghost != last_ghost must_send = true phase = active ? "start" : "stop" elsif active && (now - last_sent) >= NINJA_SYNC_INTERVAL must_send = true phase = "sync" end return unless must_send return unless _ninja_send_packet(active, phase) @ninja_local_last_active = active @ninja_local_last_ghost = ghost @ninja_local_last_sent_at = now end def self._ninja_unpack_active(phase, payload) active = (phase.to_s != "stop") begin h = nil if self.respond_to?(:_deistvia_unpack) h = _deistvia_unpack(payload.to_s) end if h.is_a?(Hash) raw = nil raw = h["active"] if h.has_key?("active") raw = h[:active] if raw.nil? && h.has_key?(:active) unless raw.nil? s = raw.to_s.strip.downcase return true if ["1", "true", "yes", "on"].include?(s) return false if ["0", "false", "no", "off"].include?(s) end end rescue end active end def self._ninja_unpack_ghost(payload) h = _deistvia_unpack(payload.to_s) if respond_to?(:_deistvia_unpack) return false unless h.is_a?(Hash) raw = h["ghost"] || h[:ghost] ["1", "true", "yes", "on"].include?(raw.to_s.strip.downcase) rescue false end def self._ninja_set_remote_state(player_id, active, ghost=false) pid = player_id.to_i return if pid <= 0 st = _ninja_state_table[pid] if st.nil? || !st.is_a?(Hash) st = {} _ninja_state_table[pid] = st end st[:active] = (active ? true : false) st[:ghost] = (active && ghost ? true : false) st[:updated_at] = _ninja_now end def self._ninja_remote_active?(player_id) st = nil begin st = _ninja_state_table[player_id.to_i] rescue st = nil end return false if st.nil? || !st.is_a?(Hash) return false unless st[:active] begin ts = st[:updated_at].to_f if ts > 0.0 && (_ninja_now - ts) > NINJA_REMOTE_TIMEOUT st[:active] = false st[:ghost] = false return false end rescue end true end def self.ninja_remote_active?(player_id) _ninja_remote_active?(player_id) end def self.handle_remote_deistvia(player_id, action_id, phase, payload) if action_id.to_s == "ninja" begin return if !player_id.nil? && !@my_id.nil? && player_id.to_i == @my_id.to_i rescue end begin active = _ninja_unpack_active(phase, payload) ghost = active && _ninja_unpack_ghost(payload) _ninja_set_remote_state(player_id, active, ghost) rescue end return end if self.respond_to?(:_ninja_old_handle_remote_deistvia) _ninja_old_handle_remote_deistvia(player_id, action_id, phase, payload) end end def self._ninja_sensor_visible?(observer, target) return true if observer.nil? || target.nil? begin if defined?(Sensors) && defined?(Sensors::Eyes) sensor = Sensors::Eyes mine = sensor.mine_number(observer, target, false) return false if mine.nil? return false if mine.to_f <= 0.0 visual_info = sensor.calc_sight_hp_and_dist(observer, target) return false if visual_info.nil? shp = visual_info[0].to_i return false if shp < 0 return true end rescue end begin ox = observer.x.to_i oy = observer.y.to_i tx = target.x.to_i ty = target.y.to_i dx = tx - ox dy = ty - oy return false if dx.abs > 6 || dy.abs > 6 dir = 2 begin dir = observer.direction.to_i if observer.respond_to?(:direction) rescue dir = 2 end case dir when 2 return false if dy < -1 when 8 return false if dy > 1 when 4 return false if dx > 1 when 6 return false if dx < -1 end true rescue true end end def self.ninja_hidden_for_local?(player_id, rp=nil) pid = player_id.to_i return false if pid <= 0 # Server-assigned OWNER can see stealth players on the same map. return false if respond_to?(:admin_see_hidden_enabled?) && admin_see_hidden_enabled? return false unless _ninja_remote_active?(pid) begin return false if !@my_id.nil? && pid == @my_id.to_i rescue end observer = nil begin observer = $game_player rescue observer = nil end # A ghost is invisible regardless of the observer's distance or angle. # OWNER's "See hidden" override above remains available for moderation. st = _ninja_state_table[pid] return true if st && st[:ghost] return false if observer.nil? char = rp begin char = @players[pid] if char.nil? && @players rescue char = nil end return false if char.nil? ! _ninja_sensor_visible?(observer, char) end def self.update _ninja_old_update if self.respond_to?(:_ninja_old_update) begin _ninja_tick_local rescue end end if self.respond_to?(:_ninja_old_update) end if defined?(Sprite_Character) class Sprite_Character < Sprite_Base unless method_defined?(:_ninja_old_update) alias _ninja_old_update update def update(*args) _ninja_old_update(*args) mp_ninja_apply_local_visibility end end def mp_ninja_apply_local_visibility return unless defined?(WebSocket) char = @character return if char.nil? pid = char.instance_variable_get(:@net_player_id) rescue nil return if pid.nil? hidden = WebSocket.ninja_hidden_for_local?(pid, char) if hidden self.visible = false @mp_ninja_forced_hidden = true # Hide the complete remote presentation, not just the character. [:@mp_nick_sprite, :@mp_nick_front_emoji_sprite, :@mp_nick_back_emoji_sprite, :@mp_presence_status_sprite, :@mp_chat_overhead_sprite].each do |ivar| sprite = instance_variable_get(ivar) rescue nil next if sprite.nil? || (sprite.respond_to?(:disposed?) && sprite.disposed?) sprite.visible = false end elsif @mp_ninja_forced_hidden # Only restore the sprites that this hook deliberately hid. # Nick emoji / status / chat sprites are managed by their own updates. self.visible = true if @mp_nick_sprite && !@mp_nick_sprite.disposed? @mp_nick_sprite.visible = true end @mp_ninja_forced_hidden = false end rescue => e puts "[GHOST] visibility render error: #{e.class}: #{e.message}" rescue nil end end end