Release 0.0.1.8.8.7

This commit is contained in:
WorldBosse committed 2026-10-29 21:59:06 +04:00
1 parent 3c8a17aa78
commit c7beab414c
16283 files changed
+768761 -2

No files matched your search

+628
View File
@@ -0,0 +1,628 @@
# encoding: UTF-8
# Safe-zone pass-through for NPCs + Action hub (NPC + remote players).
# Loaded late via multiplayer.rb so MPSafeZone / WebSocket / Scene_Map exist.
# Replaces the early ModScripts/99z_safezone_pass.rb stub.
module MPSafeZonePass
TEXT_PLAYERS = "\u0418\u0433\u0440\u043E\u043A\u0438"
TEXT_LEAVE = "\u0423\u0439\u0442\u0438"
TEXT_TALK = "\u041F\u043E\u0433\u043E\u0432\u043E\u0440\u0438\u0442\u044C"
class << self
def active?
return false unless defined?(MPSafeZone) && MPSafeZone.respond_to?(:active?)
!!MPSafeZone.active?
rescue
false
end
def overmap?
return false unless defined?(MPOvermapStack) && MPOvermapStack.respond_to?(:overmap?)
!!MPOvermapStack.overmap?
rescue
false
end
def remote_players
return {} unless defined?(WebSocket)
players = WebSocket.instance_variable_get(:@players)
players.is_a?(Hash) ? players : {}
rescue
{}
end
def remote_player_event?(event)
return false if event.nil?
return false unless event.instance_variable_defined?(:@net_player_id)
event.instance_variable_get(:@net_player_id).to_i > 0
rescue
false
end
def world_object_event?(event)
return false if event.nil?
begin
return true if event.instance_variable_defined?(:@mp_remote_player_object_id) &&
event.instance_variable_get(:@mp_remote_player_object_id).to_i > 0
rescue
end
begin
return true if event.instance_variable_defined?(:@mp_remote_player_object_real) &&
event.instance_variable_get(:@mp_remote_player_object_real)
rescue
end
false
end
# Solid props / crates / traps — never walk-through (avoids getting stuck).
def solid_prop_event?(event)
return true if world_object_event?(event)
return false unless event.respond_to?(:npc?) && event.npc?
actor = nil
begin
actor = event.npc if event.respond_to?(:npc)
actor = event.actor if actor.nil? && event.respond_to?(:actor)
rescue
actor = nil
end
return false if actor.nil?
begin
return true if actor.respond_to?(:is_object) && actor.is_object
rescue
end
return true if defined?(GameTrap) && actor.is_a?(GameTrap)
return true if defined?(Game_DestroyableObject) && actor.is_a?(Game_DestroyableObject)
false
rescue
false
end
def npc_actor(event)
return nil if event.nil?
begin
return event.npc if event.respond_to?(:npc) && event.npc
rescue
end
begin
return event.actor if event.respond_to?(:actor)
rescue
end
nil
end
# alert_level 2 = combat aggro (!). Level 0/1 = idle / suspicious — pass-through.
def event_in_combat?(event)
return false if event.nil?
return false if remote_player_event?(event)
actor = npc_actor(event)
return false if actor.nil?
begin
return true if actor.respond_to?(:alert_level) && actor.alert_level.to_i >= 2
rescue
end
begin
state = actor.action_state if actor.respond_to?(:action_state)
return true if state == :skill
rescue
end
false
rescue
false
end
# Walk-through living NPCs ONLY while they are aggressive (alert 2 / skill).
# Calm NPCs stay solid. Remotes stay pass-through. Props stay solid always.
def soft_event?(event)
return false if event.nil?
return false if solid_prop_event?(event)
return true if remote_player_event?(event)
return false unless event.respond_to?(:npc?) && event.npc?
event_in_combat?(event)
rescue
false
end
def apply_soft_through(event)
return if event.nil?
return if overmap? && remote_player_event?(event)
if active? && soft_event?(event)
event.instance_variable_set(:@mp_sz_pass_forced_through, true)
event.instance_variable_set(:@manual_through, true)
event.instance_variable_set(:@through, true)
event.through = true if event.respond_to?(:through=)
elsif event.instance_variable_get(:@mp_sz_pass_forced_through)
# Clear leftover through on props that were soft under the old rules.
event.instance_variable_set(:@mp_sz_pass_forced_through, nil)
event.instance_variable_set(:@manual_through, nil)
page = event.instance_variable_get(:@page) rescue nil
page_through = page ? !!page.through : false
event.instance_variable_set(:@through, page_through)
event.through = page_through if event.respond_to?(:through=)
end
rescue
end
def refresh_soft_through
return unless $game_map && $game_map.events
$game_map.events.each_value { |event| apply_soft_through(event) }
remote_players.each_value { |event| apply_soft_through(event) }
rescue
end
def front_xy
return [0, 0] unless $game_player && $game_map
x = $game_map.round_x_with_direction($game_player.x, $game_player.direction)
y = $game_map.round_y_with_direction($game_player.y, $game_player.direction)
[x.to_i, y.to_i]
rescue
[0, 0]
end
def target_tiles
return [] unless $game_player
tiles = [[$game_player.x.to_i, $game_player.y.to_i]]
fx, fy = front_xy
tiles << [fx, fy] unless tiles.include?([fx, fy])
tiles
rescue
[]
end
def npc_label(event)
return TEXT_TALK if event.nil?
name = nil
begin
if event.respond_to?(:npc) && event.npc
npc = event.npc
name = npc.name if npc.respond_to?(:name)
name = npc.npc_name if (name.nil? || name.to_s.empty?) && npc.respond_to?(:npc_name)
end
rescue
name = nil
end
if (name.nil? || name.to_s.strip.empty?) && event.respond_to?(:event) && event.event
name = event.event.name rescue nil
end
text = name.to_s.strip
return "#{TEXT_TALK}: #{text}" unless text.empty?
TEXT_TALK
rescue
TEXT_TALK
end
# Stairs / doors / MapBlockBox / Transfer Player — never open the hub;
# let vanilla Action run so the exit wins. Talk to players by facing them.
def transfer_like_event?(event)
return false if event.nil?
name = ""
begin
name = event.event.name.to_s if event.respond_to?(:event) && event.event
rescue
name = ""
end
n = name.downcase
return true if n.include?("mapblock")
return true if n.include?("blockbox")
return true if n.include?("transfer")
return true if n =~ /\Ahh\d/i
begin
page = event.instance_variable_get(:@page)
list = page.list if page && page.respond_to?(:list)
if list.is_a?(Array)
return true if list.any? { |cmd| cmd && cmd.code.to_i == 201 }
end
rescue
end
false
rescue
false
end
def talkable_npcs_at(x, y)
list = []
return list unless $game_map && $game_player
$game_map.events_xy(x.to_i, y.to_i).each do |event|
next if remote_player_event?(event)
next if transfer_like_event?(event)
next if solid_prop_event?(event)
# Hub only for real NPCs — exits/doors are not "talk" targets.
next unless event.respond_to?(:npc?) && event.npc?
next unless event.respond_to?(:normal_priority?) && event.normal_priority?
next unless event.respond_to?(:trigger_in?) && event.trigger_in?([0, 1, 2])
begin
next unless $game_player.checkNpcAbleTrigger(event)
rescue
next
end
list << event
end
list
rescue
[]
end
def players_at(x, y)
ids = []
remote_players.each do |player_id, event|
next if event.nil?
next unless event.x.to_i == x.to_i && event.y.to_i == y.to_i
pid = player_id.to_i
ids << pid if pid > 0
end
ids.uniq.sort
rescue
[]
end
def gather_candidates
npcs = []
players = []
target_tiles.each do |x, y|
talkable_npcs_at(x, y).each do |ev|
npcs << ev unless npcs.any? { |other| other.equal?(ev) }
end
players.concat(players_at(x, y))
end
players = players.uniq.sort
return nil if npcs.empty? || players.empty?
{ :npcs => npcs, :players => players }
rescue
nil
end
def player_label(player_id)
if defined?(MPOvermapStack) && MPOvermapStack.respond_to?(:player_label)
return MPOvermapStack.player_label(player_id)
end
nick = nil
begin
nick = WebSocket.nickname_for(player_id) if defined?(WebSocket) && WebSocket.respond_to?(:nickname_for)
rescue
nick = nil
end
text = nick.to_s.strip
return text unless text.empty?
"ID #{player_id.to_i}"
rescue
"ID #{player_id.to_i}"
end
def menu_open?
scene = SceneManager.scene rescue nil
return false unless scene && scene.respond_to?(:mp_sz_pass_menu_active?)
scene.mp_sz_pass_menu_active?
rescue
false
end
def should_open_hub?
return false unless active?
return false if overmap?
return false if menu_open?
return false if defined?(MPOvermapStack) && MPOvermapStack.respond_to?(:menu_open?) && MPOvermapStack.menu_open?
return false if defined?(WebSocket) && WebSocket.respond_to?(:player_menu_open?) && WebSocket.player_menu_open?
return false if $game_map && $game_map.interpreter && $game_map.interpreter.running?
return false if $game_message && ($game_message.busy? || $game_message.visible)
return false if defined?(WebSocket) && WebSocket.respond_to?(:trade_active?) && WebSocket.trade_active?
return false if defined?(MPCompanionSync) && MPCompanionSync.respond_to?(:ui_active?) && MPCompanionSync.ui_active?
!gather_candidates.nil?
rescue
false
end
def open_hub
return unless should_open_hub?
scene = SceneManager.scene rescue nil
return unless scene && scene.respond_to?(:mp_sz_pass_request)
scene.mp_sz_pass_request(:hub)
begin
SndLib.sys_ok if defined?(SndLib) && SndLib.respond_to?(:sys_ok)
rescue
end
rescue
end
def start_npc(event_id)
return unless $game_map
ev = $game_map.events[event_id.to_i]
return if ev.nil?
ev.start if ev.respond_to?(:start)
rescue
end
end
end
#------------------------------------------------------------------------------
# Collision filters
#------------------------------------------------------------------------------
class Game_CharacterBase
unless method_defined?(:mp_sz37_collide_with_events)
alias mp_sz37_collide_with_events collide_with_events?
end
def collide_with_events?(x, y)
unless MPSafeZonePass.active?
return mp_sz37_collide_with_events(x, y)
end
$game_map.events_xy_nt(x, y).any? do |event|
next false if MPSafeZonePass.soft_event?(event)
event.normal_priority? || (is_a?(Game_Event) && !(respond_to?(:npc?) && npc?))
end
end
end
class Game_Event < Game_Character
unless method_defined?(:mp_sz37_collide_with_player)
alias mp_sz37_collide_with_player collide_with_player_characters?
end
unless method_defined?(:mp_sz37_event_refresh)
alias mp_sz37_event_refresh refresh
end
def collide_with_player_characters?(x, y)
return false if MPSafeZonePass.active?
mp_sz37_collide_with_player(x, y)
end
# find_proper_page clears @manual_through every refresh — restore immediately.
def refresh(*args)
result = mp_sz37_event_refresh(*args)
MPSafeZonePass.apply_soft_through(self) if MPSafeZonePass.active?
result
end
end
#------------------------------------------------------------------------------
# Player movement + Action hub
#------------------------------------------------------------------------------
class Game_Player < Game_Character
unless method_defined?(:mp_sz37_check_action_event)
alias mp_sz37_check_action_event check_action_event
end
unless method_defined?(:mp_sz37_player_passable)
alias mp_sz37_player_passable passable?
end
def check_action_event(*args)
if MPSafeZonePass.should_open_hub?
MPSafeZonePass.open_hub
return true
end
mp_sz37_check_action_event(*args)
end
def passable?(x, y, d)
unless MPSafeZonePass.active?
return mp_sz37_player_passable(x, y, d)
end
x2 = $game_map.round_x_with_direction(x, d)
y2 = $game_map.round_y_with_direction(y, d)
return false unless $game_map.valid?(x2, y2)
return true if debug_through?
return false unless map_passable?(x, y, d)
# Never enter impassable map tiles (furniture / counters) — that is what
# caused getting stuck inside "soft" objects.
return false unless map_passable?(x2, y2, reverse_dir(d))
# Living NPCs / remotes do not block; props and other solids still do.
!$game_map.events_xy_nt(x2, y2).any? do |event|
next false if MPSafeZonePass.soft_event?(event)
event.normal_priority? || false
end
end
end
module WebSocket
class << self
unless method_defined?(:mp_sz37_player_menu_open?)
alias_method :mp_sz37_player_menu_open?, :player_menu_open?
end
end
def self.player_menu_open?
return true if MPSafeZonePass.menu_open?
mp_sz37_player_menu_open?
rescue
false
end
end
class Scene_Map < Scene_Base
unless method_defined?(:mp_sz37_scene_update)
alias mp_sz37_scene_update update
end
unless method_defined?(:mp_sz37_scene_start)
alias mp_sz37_scene_start start
end
unless method_defined?(:mp_sz37_scene_terminate)
alias mp_sz37_scene_terminate terminate
end
unless method_defined?(:mp_sz37_call_menu)
alias mp_sz37_call_menu update_call_menu
end
def update(*args, &block)
MPSafeZonePass.refresh_soft_through
mp_sz37_scene_update(*args, &block)
mp_sz_pass_finish_frame
end
def start(*args, &block)
mp_sz37_scene_start(*args, &block)
mp_sz_pass_dispose
MPSafeZonePass.refresh_soft_through
end
def terminate(*args, &block)
mp_sz_pass_dispose
mp_sz37_scene_terminate(*args, &block)
end
def update_call_menu(*args, &block)
return if mp_sz_pass_menu_active?
mp_sz37_call_menu(*args, &block)
end
def mp_sz_pass_menu_active?
window = @mp_sz_pass_window
return false if window.nil?
return false if window.respond_to?(:disposed?) && window.disposed?
true
rescue
false
end
def mp_sz_pass_request(kind)
return if mp_sz_pass_menu_active?
@mp_sz_pass_pending = kind
end
def mp_sz_pass_finish_frame
mp_sz_pass_maintain if @mp_sz_pass_pending.nil?
mp_sz_pass_apply_pending
rescue
end
def mp_sz_pass_maintain
return unless mp_sz_pass_menu_active?
if !MPSafeZonePass.active? || MPSafeZonePass.overmap? || MPSafeZonePass.gather_candidates.nil?
@mp_sz_pass_pending = :close
return
end
return unless @mp_sz_pass_mode == :list
cand = MPSafeZonePass.gather_candidates
ids = cand ? cand[:players] : []
@mp_sz_pass_pending = :players if ids != @mp_sz_pass_ids
rescue
end
def mp_sz_pass_apply_pending
pending = @mp_sz_pass_pending
return if pending.nil?
@mp_sz_pass_pending = nil
if pending == :close
mp_sz_pass_dispose
elsif pending == :hub
mp_sz_pass_show_hub
elsif pending == :players
mp_sz_pass_show_players
elsif pending.is_a?(Array) && pending[0] == :npc
event_id = pending[1].to_i
mp_sz_pass_dispose
MPSafeZonePass.start_npc(event_id)
elsif pending.is_a?(Array) && pending[0] == :pick
player_id = pending[1].to_i
mp_sz_pass_dispose
if player_id > 0 && defined?(WebSocket) && WebSocket.respond_to?(:open_player_menu)
WebSocket.open_player_menu(player_id)
end
end
rescue
mp_sz_pass_dispose
end
def mp_sz_pass_show_hub
return unless defined?(Window_MPPlayerMenu)
cand = MPSafeZonePass.gather_candidates
if cand.nil?
mp_sz_pass_dispose
return
end
mp_sz_pass_dispose
actions = []
cand[:npcs].each do |event|
actions << [MPSafeZonePass.npc_label(event), :npc, event.id]
end
if cand[:players].size == 1
pid = cand[:players][0]
actions << [MPSafeZonePass.player_label(pid), :pick, pid]
else
actions << [MPSafeZonePass::TEXT_PLAYERS, :players]
end
actions << [MPSafeZonePass::TEXT_LEAVE, :leave]
window = Window_MPPlayerMenu.new
window.set_actions(actions)
window.set_handler(:npc, method(:mp_sz_pass_on_npc))
window.set_handler(:players, method(:mp_sz_pass_on_players))
window.set_handler(:pick, method(:mp_sz_pass_on_pick))
window.set_handler(:leave, method(:mp_sz_pass_on_leave))
window.set_handler(:cancel, method(:mp_sz_pass_on_leave))
window.activate
@mp_sz_pass_window = window
@mp_sz_pass_mode = :hub
@mp_sz_pass_ids = cand[:players]
rescue
mp_sz_pass_dispose
end
def mp_sz_pass_show_players
return unless defined?(Window_MPPlayerMenu)
cand = MPSafeZonePass.gather_candidates
ids = cand ? cand[:players] : []
if ids.empty?
mp_sz_pass_dispose
return
end
mp_sz_pass_dispose
actions = []
ids.each do |player_id|
actions << [MPSafeZonePass.player_label(player_id), :pick, player_id]
end
window = Window_MPPlayerMenu.new
window.set_actions(actions)
window.set_handler(:pick, method(:mp_sz_pass_on_pick))
window.set_handler(:cancel, method(:mp_sz_pass_on_back))
window.activate
@mp_sz_pass_window = window
@mp_sz_pass_mode = :list
@mp_sz_pass_ids = ids
rescue
mp_sz_pass_dispose
end
def mp_sz_pass_on_npc
window = @mp_sz_pass_window
ext = nil
begin
ext = window.current_ext if window && window.respond_to?(:current_ext)
rescue
ext = nil
end
@mp_sz_pass_pending = [:npc, ext.to_i]
end
def mp_sz_pass_on_players
@mp_sz_pass_pending = :players
end
def mp_sz_pass_on_leave
@mp_sz_pass_pending = :close
end
def mp_sz_pass_on_back
@mp_sz_pass_pending = :hub
end
def mp_sz_pass_on_pick
window = @mp_sz_pass_window
ext = nil
begin
ext = window.current_ext if window && window.respond_to?(:current_ext)
rescue
ext = nil
end
@mp_sz_pass_pending = [:pick, ext.to_i]
end
def mp_sz_pass_dispose
window = @mp_sz_pass_window
@mp_sz_pass_window = nil
@mp_sz_pass_mode = nil
@mp_sz_pass_ids = nil
begin
window.dispose if window && (!window.respond_to?(:disposed?) || !window.disposed?)
rescue
end
end
end