Files
LonaRPG-Online-Games/ModScripts/multiplayer/22_ninja.rb
T

501 lines
14 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# 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