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

502 lines
14 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
#==============================================================================
# 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