Files
LonaRPG-Online-Games/ModScripts/multiplayer/90_hooks.rb
T

2375 lines
72 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
#==============================================================================
# Блокировать запуск nap-режима vanilla overmap при подключении (существующий)
#==============================================================================
module GIM_OVC
alias mp__check_overmap_event__orig check_overmap_event
def check_overmap_event(parallel=false)
return if defined?(WebSocket) && WebSocket.connected?
mp__check_overmap_event__orig(parallel)
end
end
class Sprite_Character < Sprite_Base
def mp_create_net_nickname(text)
font_size = 16
font_name = MPSafeFont.nick_name
temp = Bitmap.new(1, 1)
temp.font.name = font_name
temp.font.size = font_size
temp.font.bold = false
temp.font.outline = false
temp.font.shadow = true
w = temp.text_size(text).width + 8
h = temp.text_size(text).height
temp.dispose
@mp_nick_sprite = Sprite.new(self.viewport)
@mp_nick_sprite.bitmap = Bitmap.new(w, h)
@mp_nick_sprite.bitmap.font.name = font_name
@mp_nick_sprite.bitmap.font.size = font_size
@mp_nick_sprite.bitmap.font.bold = false
@mp_nick_sprite.bitmap.font.outline = false
@mp_nick_sprite.bitmap.font.shadow = true
@mp_nick_sprite.ox = w / 2
@mp_nick_sprite.oy = h
@mp_nick_sprite.bitmap.draw_text(0, 0, w, h, text, 1)
end
end
module MPNotify
def self.redraw
return unless @sprite && @sprite.bitmap
b = @sprite.bitmap
b.clear
w = b.width
visible = (@items || []).last(MAX_LINES).reverse
visible.each_with_index do |it, idx|
text = ""
if it[:type] == :map_join
pid = it[:pid].to_i
nick = it[:nick].to_s
if nick.strip == ""
begin
nick = WebSocket.nickname_for(pid) if defined?(WebSocket)
rescue
nick = ""
end
if nick.to_s.strip == ""
begin
if defined?(WebSocket) && WebSocket.respond_to?(:my_id) && WebSocket.respond_to?(:local_nickname) && pid == WebSocket.my_id.to_i
nick = WebSocket.local_nickname
end
rescue
nick = ""
end
end
nick = nick.to_s
it[:nick] = nick if nick.strip != ""
end
nick = nick.to_s
next if MPNotify.respond_to?(:placeholder_nick?) && MPNotify.placeholder_nick?(nick)
text = "#{nick} зашол на карту"
else
text = it[:text].to_s
end
text = text.gsub("\t", " ").gsub("\0", "")
text = text[0, 140]
b.font.name = MPSafeFont.notify_name
b.font.size = 20
b.font.bold = false
b.font.outline = false
b.font.shadow = true
b.font.name = (defined?(MPSafeFont) ? MPSafeFont.notify_name : "VL Gothic")
b.font.name = (defined?(MPSafeFont) ? MPSafeFont.notify_name : "VL Gothic")
begin
b.font.color = (it[:color] || Color.new(255, 255, 255))
rescue
b.font.color = Color.new(255, 255, 255)
end
b.font.name = (defined?(MPSafeFont) ? MPSafeFont.notify_name : "VL Gothic")
b.draw_text(0, idx * LINE_H, w, LINE_H, text, 2)
end
@dirty = false
rescue
@dirty = false
end
end
module MPSafeFont
def self.unwrap_name(value)
value = value[0] if value.is_a?(Array)
value = value.to_s
return nil if value.strip == ""
value
rescue
nil
end
def self.rus2_font(*const_names)
return nil unless rus2_active?
const_names.each do |const_name|
next unless defined?(FONT_MOD) && FONT_MOD.const_defined?(const_name)
value = unwrap_name(FONT_MOD.const_get(const_name))
return value if value
end
nil
rescue
nil
end
def self.rus2_active?
begin
lng = (defined?(FONT_MOD) && FONT_MOD.const_defined?(:LNG)) ? FONT_MOD::LNG.to_s : nil
ini = (defined?(FONT_MOD) && FONT_MOD.const_defined?(:INI)) ? FONT_MOD::INI.to_s : nil
current = (defined?(DataManager) && DataManager.respond_to?(:get_lang_constant)) ? DataManager.get_lang_constant.to_s : nil
return false if lng.to_s.strip == ""
return true if ini == lng
return true if current == lng
rescue
end
false
end
def self.name
begin
if rus2_active?
return rus2_font(:MENU_M, :DIALOG, :CHOICE) || unwrap_name(FM_ST::MW_FNT)
end
rescue
end
begin
if defined?(System_Settings) && System_Settings.const_defined?(:MESSAGE_WINDOW_FONT_NAME)
return unwrap_name(System_Settings::MESSAGE_WINDOW_FONT_NAME)
end
rescue
end
begin
return unwrap_name(Font.default_name) if defined?(Font) && Font.respond_to?(:default_name)
rescue
end
"VL Gothic"
end
def self.chat_name
rus2_font(:DIALOG, :MENU_M, :CHOICE) || name
end
def self.nick_name
rus2_font(:NPCSTAT, :TITLE_MENU, :CHOICE) || name
end
def self.notify_name
rus2_font(:MENU_M, :DIALOG, :STAT_INFO) || name
end
def self.tab_header_name
rus2_font(:TITLE_MENU, :SAVE_SLOT, :CHOICE) || nick_name
end
def self.tab_name
rus2_font(:NPCSTAT, :TITLE_MENU, :CHOICE) || nick_name
end
def self.tab_sub_name
rus2_font(:FILE_TITLE, :STAT_INFO, :MENU_M) || name
end
def self.server_name
rus2_font(:SAVE_SLOT, :TITLE_MENU, :CHOICE) || nick_name
end
def self.server_status_name
rus2_font(:FILE_TITLE, :STAT_INFO, :CHOICE) || name
end
def self.server_meta_name
rus2_font(:STAT_INFO, :FILE_TITLE, :MENU_M) || name
end
def self.server_description_name
rus2_font(:STAT_INFO, :MENU_M, :DIALOG) || name
end
def self.skill_menu_name
rus2_font(:MENU_M, :MENU_L, :DIALOG) || name
end
def self.skill_menu_info_name
rus2_font(:MENU_L, :MENU_M, :DIALOG) || skill_menu_name
end
end
#==============================================================================
# Расширение Scene_Map (спрайты для сетевых объектов)
#==============================================================================
class Scene_Map < Scene_Base
alias ws_start start
def start(*args, &block)
ws_start(*args, &block)
if WebSocket.connected?
WebSocket.instance_variable_get(:@players).each do |id, player|
add_net_sprite(player) unless player.transparent
end
if WebSocket.worldsync?
drops = WebSocket.instance_variable_get(:@map_drops)
drops.each { |_, ev| add_net_sprite(ev) if ev }
evs = WebSocket.instance_variable_get(:@remote_events)
evs.each { |_, ev| add_net_sprite(ev) if ev }
end
end
end
def add_net_sprite(char)
return unless @spriteset
vp = @spriteset.instance_variable_get(:@viewport1)
array = @spriteset.instance_variable_get(:@character_sprites)
unless array.any? { |s| s.character == char }
array.push(Sprite_Character.new(vp, char))
end
end
def spriteset
@spriteset
end
end
#==============================================================================
# Запрос обновления Scene_Base (F8 подключить / F9 отключить / обновить WS)
#==============================================================================
class Scene_Base
alias ws_update update
def update
ws_update
if Input.trigger?(:F8) && !WebSocket.connected?
host = "lonarpg.online"
port = 6134
begin
if defined?(OnlineServerRegistry)
host = OnlineServerRegistry.selected_host
port = OnlineServerRegistry.selected_port
end
rescue
end
WebSocket.connect(host, port)
end
if Input.trigger?(:F9) && WebSocket.connected?
WebSocket.disconnect
msgbox "Отключено от сервера"
end
if WebSocket.connected?
WebSocket.update
end
end
end
#==============================================================================
# Отключить локальное передвижение NPC для не-главного персонажа (БЕЗ ТЕГОВ)
# - НЕ блокировать полное обновление (сохраняет триггеры / события dialog в безопасности)
#==============================================================================
class Game_Event < Game_Character
if method_defined?(:update_self_movement)
alias mp_net_update_self_movement update_self_movement
def update_self_movement
begin
if defined?(WebSocket) && WebSocket.connected? && WebSocket.worldsync? && WebSocket.npc_event?(self)
return unless WebSocket.npc_should_update_locally?(self)
end
rescue
end
mp_net_update_self_movement
end
end
end
#==============================================================================
# Таблички с никами для удаленных игроков
#==============================================================================
class Sprite_Character < Sprite_Base
alias mp_netnick_update update
def update
mp_netnick_update
mp_update_net_nickname
end
def mp_update_net_nickname
pid = nil
begin
if @character && @character.instance_variable_defined?(:@net_player_id)
pid = @character.instance_variable_get(:@net_player_id)
end
rescue
pid = nil
end
if pid.nil?
mp_dispose_net_nickname
return
end
nick = nil
begin
nick = WebSocket.nickname_for(pid) if defined?(WebSocket)
rescue
nick = nil
end
if nick.nil? || nick.to_s.strip == ""
mp_dispose_net_nickname
return
end
nick = nick.to_s
if @mp_nick_text != nick
mp_dispose_net_nickname
mp_create_net_nickname(nick)
@mp_nick_text = nick
end
return if @mp_nick_sprite.nil?
@mp_nick_sprite.x = self.x
@mp_nick_sprite.y = self.y - height - 1
@mp_nick_sprite.z = self.z + 1
@mp_nick_sprite.visible = self.visible
end
def mp_create_net_nickname(text)
font_size = 16 #18 # Print (хз)
font_name = MPSafeFont.name #Font.default_name # Print (хз)
temp = Bitmap.new(1, 1)
temp.font.name = font_name #+ # Print (чужие ники)
temp.font.size = font_size #+ # Print ()
temp.font.bold = false #+ # Print ()
temp.font.outline = false #+ # Print ()
temp.font.shadow = true #+ # Print ()
w = temp.text_size(text).width + 8
h = temp.text_size(text).height
temp.dispose
@mp_nick_sprite = Sprite.new(self.viewport)
@mp_nick_sprite.bitmap = Bitmap.new(w, h)
@mp_nick_sprite.bitmap.font.name = font_name # # Print (хз)
@mp_nick_sprite.bitmap.font.size = font_size # # Print ()
@mp_nick_sprite.bitmap.font.bold = false # # Print ()
@mp_nick_sprite.bitmap.font.outline = false #true # Print ()
@mp_nick_sprite.bitmap.font.shadow = true #true # Print ()
@mp_nick_sprite.ox = w / 2
@mp_nick_sprite.oy = h
@mp_nick_sprite.bitmap.draw_text(0, 0, w, h, text, 1)
end
def mp_dispose_net_nickname
if @mp_nick_sprite
@mp_nick_sprite.bitmap.dispose if @mp_nick_sprite.bitmap
@mp_nick_sprite.dispose
@mp_nick_sprite = nil
@mp_nick_text = nil
end
end
alias mp_netnick_dispose dispose
def dispose
mp_dispose_net_nickname
mp_netnick_dispose
end
end
#==============================================================================
# СИНХРОНИЗАЦИЯ ПОРТАЛОВ (порталы случайных карт)
#------------------------------------------------------------------------------
# Фикс: некоторые порталы выбирают случайную карту локально.
# В мультиплеере это даёт рассинхрон: игроки уходят в разные карты.
# Решение: сервер хранит выбранную карту для КАЖДОГО портала
# (ключ: source_map_id + event_id портала) и раздаёт всем одинаковый destination.
#
# Протокол:
# client -> server: portal_req:<src_map>:<event_id>:<dst_map>:<x>:<y>:<dir>:<fade>
# server -> map: portal_set:<src_map>:<event_id>:<dst_map>:<x>:<y>:<dir>:<fade>
# server -> map: portal_clear:<src_map>:<event_id>
#==============================================================================
module WebSocket
@portal_routes ||= {}
@portal_waiting ||= false
@portal_wait_key ||= nil
@portal_wait_frames ||= 0
def self.portal_key(src_map, event_id)
"#{src_map.to_i}:#{event_id.to_i}"
end
def self.clear_portal_wait
@portal_waiting = false
@portal_wait_key = nil
@portal_wait_frames = 0
end
# После disconnect/reconnect кэш portal_set может указывать на чужой этаж
# tag-map (OrkindCave) и кидать игрока в пустоту.
def self.clear_portal_routes(reason = nil)
@portal_routes = {}
clear_portal_wait
true
rescue
false
end
# Tag/sub этажи входят через (1,1), а AUTOBEGIN потом snap'ает на StartPoint
# / TagSubTrans. Финальные координаты из portal_set для таких входов вредны.
def self.portal_tag_entry_coords?(x, y)
x.to_i == 1 && y.to_i == 1
end
def self.portal_normalize_route(dst_map, x, y, dir, fade, prefer_tag_entry = false)
nx = x.to_i
ny = y.to_i
if prefer_tag_entry || portal_tag_entry_coords?(nx, ny)
nx = 1
ny = 1
end
[dst_map.to_i, nx, ny, dir.to_i, fade.to_i]
end
def self.portal_mark_tag_entry_pending
return unless defined?($story_stats) && $story_stats && $story_stats.respond_to?(:[]=)
# Гарантируем, что enter_static_tag_map сделает snap даже после reconnect.
$story_stats["ReRollHalfEvents"] = 1 if $story_stats["ReRollHalfEvents"].to_i != 1
rescue
end
def self.portal_set_from_server(src_map, event_id, dst_map, x, y, dir, fade)
# Same-map lock с сервера игнорируем — локальные координаты этажа важнее.
if src_map.to_i > 0 && src_map.to_i == dst_map.to_i
clear_portal_wait if @portal_waiting && @portal_wait_key == portal_key(src_map, event_id)
return
end
# Не принимаем portal_set на NoerHome tag-map: to_i("NoerHome") == 0.
begin
if defined?(NoerHomeEstate) && NoerHomeEstate.respond_to?(:home_target_kind)
kind = NoerHomeEstate.home_target_kind(dst_map).to_s
unless kind.empty?
clear_portal_wait if @portal_waiting && @portal_wait_key == portal_key(src_map, event_id)
return
end
end
rescue
end
key = portal_key(src_map, event_id)
# Для tag-entry всегда храним (1,1): snap сделает AUTOBEGIN.
route = portal_normalize_route(dst_map, x, y, dir, fade, portal_tag_entry_coords?(x, y))
@portal_routes[key] = route
if @portal_waiting && @portal_wait_key == key
portal_apply_transfer(route[0], route[1], route[2], route[3], route[4])
clear_portal_wait
end
end
def self.portal_clear_from_server(src_map, event_id)
key = portal_key(src_map, event_id)
@portal_routes.delete(key)
clear_portal_wait if @portal_wait_key == key
end
def self.portal_apply_transfer(dst_map, x, y, dir, fade)
return unless $game_player
begin
nx = x.to_i
ny = y.to_i
if portal_tag_entry_coords?(nx, ny)
portal_mark_tag_entry_pending
end
$game_player.instance_variable_set(:@new_map_id, dst_map.to_i)
$game_player.instance_variable_set(:@new_x, nx)
$game_player.instance_variable_set(:@new_y, ny)
$game_player.instance_variable_set(:@new_direction, dir.to_i)
rescue
end
begin
$game_temp.fade_type = fade.to_i if $game_temp && $game_temp.respond_to?(:fade_type=)
rescue
end
end
def self.portal_on_reserve_transfer(src_map, event_id, dst_map, x, y, dir, fade)
return unless @connected
return if src_map.to_i <= 0 || event_id.to_i <= 0
# Личный/клановый NoerHome — string tag-map ("NoerHome"/"NoerHomeOut").
# portal_set/apply делают dst_map.to_i => 0 и вешают переход (freeze/black).
begin
if defined?(NoerHomeEstate) && NoerHomeEstate.respond_to?(:home_target_kind)
kind = NoerHomeEstate.home_target_kind(dst_map).to_s
unless kind.empty?
clear_portal_wait
return
end
end
rescue
end
# Same-map переходы (этажи OrkindCave3/AbomHive3) не синхронизируем:
# portal_set с чужими/(1,1) координатами после релога кидает в пустоту.
if src_map.to_i == dst_map.to_i
clear_portal_wait
return
end
key = portal_key(src_map, event_id)
tag_entry = portal_tag_entry_coords?(x, y)
route = @portal_routes[key]
# Если уже знаем карту для этого портала — сразу подменяем.
# Для tag-entry берём map_id с сервера, но координаты оставляем (1,1).
if route && route.is_a?(Array) && route.size >= 5
apply_map = route[0]
# Не подменяем same-map маршрутом с сервера.
if apply_map.to_i == src_map.to_i
clear_portal_wait
return
end
apply_x = tag_entry ? 1 : route[1]
apply_y = tag_entry ? 1 : route[2]
apply_dir = route[3]
apply_fade = route[4]
portal_apply_transfer(apply_map, apply_x, apply_y, apply_dir, apply_fade)
clear_portal_wait
return
end
# Иначе — спрашиваем сервер и блокируем переход на пару секунд,
# чтобы дождаться portal_set.
@portal_waiting = true
@portal_wait_key = key
@portal_wait_frames = 300 # ~5 сек при 60 FPS
portal_mark_tag_entry_pending if tag_entry
send_line("portal_req:#{src_map.to_i}:#{event_id.to_i}:#{dst_map.to_i}:#{x.to_i}:#{y.to_i}:#{dir.to_i}:#{fade.to_i}")
end
def self.portal_block_transfer?
return false unless @portal_waiting
# Если трансфер уже сброшен игрой — не блокируем.
begin
unless $game_player && $game_player.transfer?
clear_portal_wait
return false
end
rescue
end
@portal_wait_frames -= 1 if @portal_wait_frames && @portal_wait_frames > 0
if @portal_wait_frames <= 0
# таймаут: пусть идёт локальный переход (чтобы не зависнуть навсегда)
clear_portal_wait
return false
end
true
end
end
# Запоминаем event_id, который вызвал Transfer Player
class Game_Temp
attr_accessor :mp_last_transfer_event_id
end
class Game_Interpreter
alias mp_portal_command_201 command_201
def command_201
begin
$game_temp.mp_last_transfer_event_id = @event_id
rescue
end
mp_portal_command_201
end
alias mp_portal_command_355 command_355
def command_355
begin
$game_temp.mp_last_transfer_event_id = @event_id
rescue
end
mp_portal_command_355
end
end
class Game_Player < Game_Character
alias mp_portal_reserve_transfer reserve_transfer
def reserve_transfer(map_id, x, y, dir = 2, fade = 0)
# Legacy cloud snapshots may have LastOverMapX/Y but no OverMapID. Repair
# the destination before the stock transfer reaches Game_Map#setup(0).
begin
if map_id.to_i <= 0 && defined?(WebSocket) && WebSocket.respond_to?(:ensure_overmap_story_location)
last_x = $story_stats["LastOverMapX"].to_i rescue nil
last_y = $story_stats["LastOverMapY"].to_i rescue nil
if !last_x.nil? && !last_y.nil? && x.to_i == last_x && y.to_i == last_y
repaired_map_id = WebSocket.ensure_overmap_story_location($game_map ? $game_map.map_id : nil)
map_id = repaired_map_id if repaired_map_id.to_i > 0
end
end
rescue
end
# вызов оригинала (в некоторых проектах есть параметр reserve_transfer без параметра fade)
begin
mp_portal_reserve_transfer(map_id, x, y, dir, fade)
rescue ArgumentError
mp_portal_reserve_transfer(map_id, x, y, dir)
end
begin
if defined?(WebSocket) && WebSocket.connected? && SceneManager.scene_is?(Scene_Map)
src_map = ($game_map ? $game_map.map_id : 0)
src_x = ($game_player ? $game_player.x : 0)
src_y = ($game_player ? $game_player.y : 0)
src_dir = ($game_player ? $game_player.direction : 2)
eid = 0
begin
eid = $game_temp.mp_last_transfer_event_id.to_i if $game_temp && $game_temp.respond_to?(:mp_last_transfer_event_id)
rescue
eid = 0
end
# fallback: interpreter event_id (for script-based transfers)
if eid <= 0
begin
if $game_map && $game_map.respond_to?(:interpreter) && $game_map.interpreter
eid = $game_map.interpreter.instance_variable_get(:@event_id).to_i rescue 0
end
rescue
eid = 0
end
end
# Если все еще неизвестно (обычное событие / прямой вызов), извлеките стабильный псевдоидентификатор из исходного фрагмента.
if eid <= 0
# ПРИМЕЧАНИЕ: направление НЕ ДОЛЖНО быть частью ключа, иначе 2 игрока, заходя в одну и ту же точку
# с разных сторон, получат разные portal_key и улетят в разные карты.
eid = 1000000 + (src_x.to_i << 12) + src_y.to_i
end
begin
$game_temp.mp_last_transfer_event_id = 0 if $game_temp && $game_temp.respond_to?(:mp_last_transfer_event_id=)
rescue
end
if src_map > 0
WebSocket.portal_on_reserve_transfer(src_map, eid, map_id, x, y, dir, fade)
end
end
rescue
end
end
alias mp_portal_perform_transfer perform_transfer
def perform_transfer
begin
if defined?(WebSocket) && WebSocket.connected? && WebSocket.portal_block_transfer?
return
end
rescue
end
old_map = 0
begin
old_map = ($game_map ? $game_map.map_id.to_i : 0)
rescue
old_map = 0
end
mp_portal_perform_transfer
# Same-map телепорт на служебные (1,1) после portal/reconnect → пустота.
# AUTOBEGIN при этом не перезапускается, поэтому snap здесь.
begin
next_map = ($game_map ? $game_map.map_id.to_i : 0)
if old_map > 0 && next_map == old_map && x.to_i == 1 && y.to_i == 1
pt = nil
begin
pt = $game_map.get_storypoint("StartPoint") if $game_map.respond_to?(:get_storypoint)
rescue
pt = nil
end
if pt && pt.is_a?(Array) && pt.length >= 2
moveto(pt[0].to_i, pt[1].to_i) if respond_to?(:moveto)
end
# Не гасим ReRollHalfEvents здесь: на Map018/144 от этого
# сундуки остаются открытыми/пустыми, а Tar* не получают RegionOuta.shift.
# Пустой RegionOuta=[] → 0, чтобы при ReRoll==1 список RandCV собрался заново.
begin
if defined?($story_stats) && $story_stats
outa = $story_stats["RegionMap_RegionOuta"]
$story_stats["RegionMap_RegionOuta"] = 0 if outa.is_a?(Array) && outa.empty?
end
rescue
end
end
rescue
end
end
end
#==============================================================================
# MP: Авторитетная смерть NPC + защита от локального "килла" у не-мастера
#==============================================================================
begin
# --- флаги для безопасной симуляции ---
$mp_ws_simulating_npc_hit = false
$mp_ws_processing_death = false
module MP_WS_NPCSync
module_function
def ws_ready?
return false unless defined?(WebSocket)
return false unless WebSocket.respond_to?(:connected?) && WebSocket.connected?
return false unless WebSocket.respond_to?(:worldsync?) && WebSocket.worldsync?
true
rescue
false
end
def map_master?
ws_ready? && WebSocket.respond_to?(:map_master?) && WebSocket.map_master?
rescue
false
end
def npc_owned_by_me?(event_id)
return false unless ws_ready?
return false unless WebSocket.respond_to?(:npc_owned_by_me?)
WebSocket.npc_owned_by_me?(event_id)
rescue
false
end
def network_event_id(ev)
return 0 if ev.nil?
sid = ev.instance_variable_get(:@net_server_event_id) rescue nil
return sid.to_i if sid && sid.to_i > 0
eid = ev.respond_to?(:id) ? ev.id.to_i : 0
if defined?(WebSocket) && WebSocket.respond_to?(:normalize_npc_event_id)
return WebSocket.normalize_npc_event_id(eid)
end
eid
rescue
0
end
def npc_owned_by_me_from_npc(npc)
return false if npc.nil?
ev = nil
begin
ev = npc.map_token if npc.respond_to?(:map_token)
rescue
ev = nil
end
event_id = 0
begin
event_id = ev.id.to_i if ev && ev.respond_to?(:id)
rescue
event_id = 0
end
return map_master? if event_id <= 0
npc_owned_by_me?(event_id)
rescue
false
end
def npc_event?(ev)
return false unless ws_ready?
return false unless ev.is_a?(Game_Event)
return false unless WebSocket.respond_to?(:npc_event?)
WebSocket.npc_event?(ev)
rescue
false
end
def npc_from_event_id(event_id)
ev = nil
if defined?(WebSocket) && WebSocket.respond_to?(:get_map_event)
ev = WebSocket.get_map_event(event_id.to_i)
end
ev = ($game_map && $game_map.events) ? $game_map.events[event_id] : nil if ev.nil?
return nil unless ev && ev.respond_to?(:npc?) && ev.npc?
# В ваниле Lona у Game_Event @npc без явного accessor'а:
npc = nil
npc = ev.npc rescue nil
npc = ev.instance_variable_get(:@npc) rescue nil if npc.nil?
npc
rescue
nil
end
# NPC owner applies delta and sends authoritative hp/state.
def apply_remote_hit(attacker_id, event_id, delta)
if defined?(MPSafeZone) && MPSafeZone.active?
probe = npc_from_event_id(event_id)
return unless probe && MPSafeZone.training_dummy?(probe)
end
return unless npc_owned_by_me?(event_id)
npc = npc_from_event_id(event_id)
return unless npc
old_hp = (npc.respond_to?(:health) ? npc.health.to_i : 0) rescue 0
new_hp = old_hp + delta.to_i
new_hp = 0 if new_hp < 0
# кап к max, если есть
max_hp = 0
max_hp = npc.max_health.to_i rescue 0 if npc.respond_to?(:max_health)
max_hp = npc.maxhp.to_i rescue 0 if max_hp <= 0 && npc.respond_to?(:maxhp)
new_hp = max_hp if max_hp > 0 && new_hp > max_hp
# apply authoritative value on owner client
npc.health = new_hp rescue nil if npc.respond_to?(:health=)
# send hp update (server relays to map)
begin
WebSocket.send_line("event_state:#{event_id}:hp:#{new_hp}")
rescue
end
# death transition is also authoritative on owner
if new_hp <= 0 && old_hp > 0
begin
npc.process_death if npc.respond_to?(:process_death)
rescue
end
begin
WebSocket.send_line("event_state:#{event_id}:state:death")
rescue
end
begin
WebSocket.send_line("event_state:#{event_id}:dead:1")
rescue
end
end
end
end
#--------------------------------------------------------------------------
# 1) НЕ-МАСТЕР: запрет реальных последствий смерти во время "dry-run"
#--------------------------------------------------------------------------
if defined?(Game_NonPlayerCharacter) && Game_NonPlayerCharacter.instance_methods.include?(:process_death)
class Game_NonPlayerCharacter
alias mp_ws_orig_process_death process_death
def process_death(*args)
# если мы не мастер и сейчас "симулируем" урон ради delta — ничего не делаем
if $mp_ws_simulating_npc_hit
return
end
mp_ws_orig_process_death(*args)
end
end
end
#--------------------------------------------------------------------------
# 2) Non-owners: if synced hp reaches 0, apply local death visuals/effects.
#--------------------------------------------------------------------------
if defined?(Game_NonPlayerCharacter) && Game_NonPlayerCharacter.instance_methods.include?(:health=)
class Game_NonPlayerCharacter
alias mp_ws_orig_health_set health=
def health=(v)
old_hp = (self.respond_to?(:health) ? self.health.to_i : 0) rescue 0
# Final invariant for safe maps: no source (fire DoT, trap, summon,
# script or network owner) may reduce an NPC's HP. Training dummies
# are exempt so practice bags in taverns still take hits.
begin
if defined?(MPSafeZone) && MPSafeZone.active? && v.to_f < old_hp.to_f
dummy = MPSafeZone.respond_to?(:training_dummy?) && MPSafeZone.training_dummy?(self)
return old_hp unless dummy
end
rescue
end
mp_ws_orig_health_set(v)
return if $mp_ws_simulating_npc_hit
return unless MP_WS_NPCSync.ws_ready?
return if MP_WS_NPCSync.npc_owned_by_me_from_npc(self)
new_hp = (self.respond_to?(:health) ? self.health.to_i : v.to_i) rescue v.to_i
if new_hp <= 0 && old_hp > 0 && !$mp_ws_processing_death
$mp_ws_processing_death = true
$mp_ws_remote_death_visual = true
begin
self.process_death if self.respond_to?(:process_death)
ensure
$mp_ws_remote_death_visual = false
$mp_ws_processing_death = false
end
end
end
end
end
# Stop hostile effects before Battle_System creates summon_hit/burning DoT.
# This prevents not only HP loss but also the visible ignition and aggro
# reaction that used to happen before the server rejected event_state.
if defined?(Battle_System) && Battle_System.instance_methods.include?(:skill_result_check_ignore_tgt)
module Battle_System
unless instance_methods.include?(:mp_safe_zone_skill_result_check_ignore_tgt)
alias mp_safe_zone_skill_result_check_ignore_tgt skill_result_check_ignore_tgt
def skill_result_check_ignore_tgt(character, skill)
if defined?(MPSafeZone) && MPSafeZone.active?
return true if MPSafeZone.blocks_npc_damage?(character, skill)
# Remotes: never run the local damage pipeline in a safe zone.
# Исцеление души heals via the dedicated pvp_heal network packet;
# local summon_hit popups look like damage and must not play here.
return true if MPSafeZone.remote_player_target?(character)
return true if MPSafeZone.blocks_player_combat?(character, skill)
end
mp_safe_zone_skill_result_check_ignore_tgt(character, skill)
end
end
end
end
#--------------------------------------------------------------------------
# 3) Hook Battle_System.take_skill_effect:
# - non-owner: computes delta, sends npc_hit, rolls HP back
# - owner: sends authoritative hp/state
#--------------------------------------------------------------------------
if defined?(Battle_System) && Battle_System.instance_methods.include?(:take_skill_effect)
module Battle_System
unless instance_methods.include?(:mp_ws_take_skill_effect)
alias mp_ws_take_skill_effect take_skill_effect
def take_skill_effect(user, skill, can_sap=false, force_hit=false)
# Safe-zone combat is rejected before vanilla effects run. This is
# deliberately outside worldsync/ownership checks so local/static NPCs
# are protected as well as network-owned NPCs.
if defined?(MPSafeZone) && MPSafeZone.blocks_npc_damage?(self, skill)
return
end
# Lantern DoT / synced summons call take_skill_effect on the local
# player directly and bypass skill_result_check_ignore_tgt.
if defined?(MPSafeZone) && MPSafeZone.blocks_player_combat?(self, skill)
return
end
if MP_WS_NPCSync.ws_ready?
mt = (self.map_token rescue nil)
if mt && MP_WS_NPCSync.npc_event?(mt)
net_event_id = MP_WS_NPCSync.network_event_id(mt)
shared_npc = true
begin
if defined?(WebSocket) && WebSocket.respond_to?(:static_map_event_id?) && WebSocket.static_map_event_id?(net_event_id)
tagged = WebSocket.respond_to?(:explicit_net_event?) && WebSocket.explicit_net_event?(mt)
matched = WebSocket.respond_to?(:static_npc_sync_compatible?) && WebSocket.static_npc_sync_compatible?(net_event_id, mt)
shared_npc = tagged || matched
end
rescue
shared_npc = false
end
# перенаправляем только когда атакует локальный игрок
if shared_npc && user && user.respond_to?(:map_token) && (user.map_token == $game_player rescue false)
old_hp = (self.respond_to?(:health) ? self.health.to_i : nil) rescue nil
old_state = (self.respond_to?(:action_state) ? self.action_state : nil) rescue nil
if !MP_WS_NPCSync.npc_owned_by_me?(net_event_id)
# -------- NON-OWNER --------
begin
$mp_ws_simulating_npc_hit = true
mp_ws_take_skill_effect(user, skill, can_sap, force_hit)
ensure
$mp_ws_simulating_npc_hit = false
end
new_hp = (self.respond_to?(:health) ? self.health.to_i : nil) rescue nil
if !old_hp.nil? && !new_hp.nil?
delta = new_hp - old_hp
begin
WebSocket.send_line("npc_hit:#{net_event_id}:#{delta}") if delta != 0
rescue
end
# откат локального HP/смерти
self.health = old_hp rescue nil
begin
if self.respond_to?(:action_state) && self.action_state == :death && old_state != :death
self.action_state = (old_state.nil? ? :none : old_state) rescue nil
end
rescue
end
end
return
else
# -------- OWNER --------
mp_ws_take_skill_effect(user, skill, can_sap, force_hit)
new_hp = (self.respond_to?(:health) ? self.health.to_i : nil) rescue nil
if !old_hp.nil? && !new_hp.nil? && new_hp != old_hp
begin
WebSocket.send_line("event_state:#{net_event_id}:hp:#{new_hp}")
rescue
end
if new_hp <= 0 && old_hp > 0
begin
WebSocket.send_line("event_state:#{net_event_id}:state:death")
rescue
end
begin
WebSocket.send_line("event_state:#{net_event_id}:dead:1")
rescue
end
end
end
return
end
end
end
end
mp_ws_take_skill_effect(user, skill, can_sap, force_hit)
end
end
end
end
# Game_Actor overrides take_skill_effect, so the Battle_System hook above does
# not run for the local player. Mirror the safe-zone player gate here so
# hostile DoTs (Lantern) are blocked while support heals still apply.
if defined?(Game_Actor) && Game_Actor.instance_methods.include?(:take_skill_effect)
class Game_Actor
unless method_defined?(:mp_safe_zone_actor_take_skill_effect)
alias mp_safe_zone_actor_take_skill_effect take_skill_effect
def take_skill_effect(user, skill, can_sap=true, force_hit=false)
if defined?(MPSafeZone) && MPSafeZone.blocks_player_combat?(self, skill)
return
end
mp_safe_zone_actor_take_skill_effect(user, skill, can_sap, force_hit)
end
end
end
end
#--------------------------------------------------------------------------
# 4) Drop guard:
# - remote visual deaths never create real drops
# - owner creates the vanilla death drop only once per local event object
#--------------------------------------------------------------------------
if defined?(Game_Event) && Game_Event.instance_methods.include?(:setup_drop_item)
class Game_Event
alias mp_ws_orig_setup_drop_item setup_drop_item
def setup_drop_item(*args)
return if $mp_ws_remote_death_visual
begin
if defined?(MP_WS_NPCSync) && MP_WS_NPCSync.ws_ready? && MP_WS_NPCSync.npc_event?(self)
return unless MP_WS_NPCSync.npc_owned_by_me?(self.id)
return if instance_variable_get(:@mp_ws_death_drop_done)
instance_variable_set(:@mp_ws_death_drop_done, true)
end
rescue
end
mp_ws_orig_setup_drop_item(*args)
end
end
end
#--------------------------------------------------------------------------
# 4) OWNER: process npc_hit (server -> current npc owner)
# Пытаемся подцепиться к самым частым методам парсинга строк.
#--------------------------------------------------------------------------
if defined?(WebSocket)
handler = proc do |line|
return false unless line.is_a?(String)
return false unless line.start_with?("npc_hit:")
parts = line.split(":")
# server->owner: npc_hit:<attacker_id>:<event_id>:<delta>
if parts.length >= 4
attacker_id = parts[1].to_i
event_id = parts[2].to_i
delta = parts[3].to_i
# (на всякий) старый формат: npc_hit:<event_id>:<delta>
elsif parts.length >= 3
attacker_id = 0
event_id = parts[1].to_i
delta = parts[2].to_i
else
return false
end
return false unless MP_WS_NPCSync.npc_owned_by_me?(event_id)
MP_WS_NPCSync.apply_remote_hit(attacker_id, event_id, delta)
true
end
sc = WebSocket.singleton_class
[:handle_line, :parse_line, :on_line, :dispatch, :process_line].each do |m|
next unless WebSocket.respond_to?(m)
next if sc.method_defined?(:"mp_ws_orig_#{m}")
sc.class_eval do
alias_method :"mp_ws_orig_#{m}", m
define_method(m) do |*args|
line = args.find { |a| a.is_a?(String) }
begin
handled = handler.call(line)
return if handled
rescue
end
send(:"mp_ws_orig_#{m}", *args)
end
end
end
end
rescue
end
#==============================================================================
# Уведомления в правом углу (чат / регистрация / выход)
# - Чат: "НИК: сообщение" (белый)
# - Регистрация: "НИК заул" (зеленый)
# - Выход: "НИК выул" (красный)
# - Автоматическое скрытие через 5 секунд
#==============================================================================
module MPNotify
DURATION_SEC = 5
MAX_LINES = 1
MARGIN = 8
LINE_H = 22
@items = []
@dirty = true
def self.mark_dirty
@dirty = true
end
def self._on_map_scene?
return false unless defined?(SceneManager) && defined?(Scene_Map)
begin
return SceneManager.scene_is?(Scene_Map)
rescue
return false
end
end
def self._now_frame
Graphics.frame_count
end
def self._frames(sec)
(sec.to_f * Graphics.frame_rate).to_i
end
def self.ensure
return unless _on_map_scene?
return if @sprite && !@sprite.disposed?
@items ||= []
@dirty = true
w = [420, Graphics.width - (MARGIN * 2)].min
h = LINE_H * MAX_LINES
@viewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
@viewport.z = 99_999
@sprite = Sprite.new(@viewport)
@sprite.bitmap = Bitmap.new(w, h)
@sprite.x = Graphics.width - w - MARGIN
@sprite.y = MARGIN
@sprite.z = 99_999
b = @sprite.bitmap
b.font.size = 18
b.font.outline = true
b.font.bold = true
rescue
dispose
end
def self.dispose
begin
if @sprite && !@sprite.disposed?
begin
@sprite.bitmap.dispose if @sprite.bitmap && !@sprite.bitmap.disposed?
rescue
end
@sprite.dispose
end
rescue
end
begin
@viewport.dispose if @viewport && !@viewport.disposed?
rescue
end
@sprite = nil
@viewport = nil
end
def self._push(item)
@items ||= []
item[:expires_at] ||= (_now_frame + _frames(DURATION_SEC))
@items << item
# keep some extra, just in case spam
@items = @items.last(50)
@dirty = true
ensure
end
def self.placeholder_nick?(nick)
s = nick.to_s.strip
return true if s == ""
return true if s =~ /\Aplayer\s*#?\s*\d+\z/i
false
rescue
true
end
def self.push_chat(nick, text, ts_ms=nil)
n = nick.to_s
n = "Player" if n.strip == ""
t = text.to_s
t = t.gsub(/\r\n?/, " ").gsub("\n", " ")
t = t.gsub("\0", "")
t = t.strip
t = t[0, 200]
return if t.empty?
time_text = ""
begin
time_text = WebSocket.chat_time_text(ts_ms) if defined?(WebSocket) && WebSocket.respond_to?(:chat_time_text)
rescue
time_text = ""
end
prefix = time_text.to_s.empty? ? "" : "#{time_text} "
_push({
:type => :chat,
:text => "#{prefix}#{n}: #{t}",
:color => Color.new(255, 255, 255)
})
end
def self.push_server_join(nick)
n = nick.to_s
n = "Player" if n.strip == ""
return if placeholder_nick?(n)
_push({
:type => :server_join,
:text => "#{n} зашёл на сервер",
:color => Color.new(0, 255, 0)
})
end
def self.push_map_join(pid)
_push({
:type => :map_join,
:pid => pid.to_i,
:color => Color.new(0, 160, 255)
})
end
def self.push_server_quit(nick)
n = nick.to_s
n = "Player" if n.strip == ""
return if placeholder_nick?(n)
_push({
:type => :server_quit,
:text => "#{n} вышел с сервера",
:color => Color.new(255, 0, 0)
})
end
def self.push_map_quit(nick)
n = nick.to_s
n = "Player" if n.strip == ""
return if placeholder_nick?(n)
_push({
:type => :map_quit,
:text => "#{n} вышел с карты",
:color => Color.new(255, 165, 0)
})
end
def self.push_quit_text(text)
_push({
:type => :quit,
:text => text.to_s,
:color => Color.new(255, 0, 0)
})
end
def self.update
return unless @sprite && !@sprite.disposed?
@items ||= []
now = _now_frame
before = @items.size
@items.reject! { |it| it[:expires_at].to_i <= now }
@dirty = true if @items.size != before
redraw if @dirty
rescue
end
def self.redraw
return unless @sprite && @sprite.bitmap
b = @sprite.bitmap
b.clear
w = b.width
# show newest first
visible = (@items || []).last(MAX_LINES).reverse
visible.each_with_index do |it, idx|
text = ""
if it[:type] == :map_join
pid = it[:pid].to_i
# Cache nickname once it becomes known, so it doesn't revert to PlayerX
nick = it[:nick].to_s
if nick.strip == ""
begin
nick = WebSocket.nickname_for(pid) if defined?(WebSocket)
rescue
nick = ""
end
if nick.to_s.strip == ""
begin
if defined?(WebSocket) && WebSocket.respond_to?(:my_id) && WebSocket.respond_to?(:local_nickname) && pid == WebSocket.my_id.to_i
nick = WebSocket.local_nickname
end
rescue
nick = ""
end
end
nick = nick.to_s
if nick.strip != ""
it[:nick] = nick
end
end
nick = nick.to_s
next if MPNotify.respond_to?(:placeholder_nick?) && MPNotify.placeholder_nick?(nick)
text = "#{nick} зашёл на карту"
else
text = it[:text].to_s
end
text = text.gsub("\t", " ").gsub("\0", "")
text = text[0, 140]
b.font.name = "Digital Pixel" # Print (Общий чат)
b.font.size = 20 # Print ()
b.font.bold = false # Print ()
b.font.outline = false # Print ()
b.font.shadow = true # Print ()
begin
b.font.color = (it[:color] || Color.new(255, 255, 255))
rescue
b.font.color = Color.new(255, 255, 255)
end
b.draw_text(0, idx * LINE_H, w, LINE_H, text, 2)
end
@dirty = false
rescue
@dirty = false
end
end
#=============================================================================
# Перехват Scene_Map (создание/обновление/ удаление спрайта уведомления)
#=============================================================================
class Scene_Map < Scene_Base
unless method_defined?(:mp_notify__orig_start)
alias mp_notify__orig_start start
end
def start(*args, &block)
mp_notify__orig_start(*args, &block)
MPNotify.ensure if defined?(MPNotify)
end
unless method_defined?(:mp_notify__orig_update)
alias mp_notify__orig_update update
end
def update
mp_notify__orig_update
MPNotify.update if defined?(MPNotify)
end
unless method_defined?(:mp_notify__orig_terminate)
alias mp_notify__orig_terminate terminate
end
def terminate
MPNotify.dispose if defined?(MPNotify)
mp_notify__orig_terminate
end
end
#=============================================================================
# WebSocket.parse hook (неинвазивный): отображение уведомлений на основе пакетов
#=============================================================================
module WebSocket
class << self
unless method_defined?(:mp_parse_without_notify)
alias mp_parse_without_notify parse
end
end
def self.parse(msg)
# IMPORTANT: if nickname packet, let core update mapping first, then refresh HUD
if msg.start_with?("nick:")
mp_parse_without_notify(msg)
begin
MPNotify.mark_dirty if defined?(MPNotify)
rescue
end
return
end
begin
# chat (server -> chat_msg:...)
if msg.start_with?("chat_msg:")
parts = msg.split(":", 6)
if parts.size >= 6
ts_ms = parts[2].to_i
nick = (unesc(parts[4].to_s) rescue parts[4].to_s)
text = parts[5].to_s
MPNotify.push_chat(nick, text, ts_ms) if defined?(MPNotify)
end
# server connect / disconnect (from server console)
elsif msg =~ /^srv_join:(\d+):(.*)/
# no HUD notify: server-level presence includes players in menu/lobby
elsif msg =~ /^srv_quit:(\d+):(.*)/
# no HUD notify: server-level presence includes players in menu/lobby
# join / quit on map
elsif msg =~ /^join:(\d+)/
MPNotify.push_map_join($1.to_i) if defined?(MPNotify)
elsif msg =~ /^quit:(\d+)/
pid = $1.to_i
nick = nil
begin
nick = nickname_for(pid)
rescue
nick = nil
end
nick = nick.to_s
# IMPORTANT: capture nick BEFORE core code deletes it
if defined?(MPNotify) && MPNotify.respond_to?(:placeholder_nick?) && !MPNotify.placeholder_nick?(nick)
MPNotify.push_map_quit(nick)
end
end
rescue
end
mp_parse_without_notify(msg)
end
end
#==============================================================================
# MPNotify: скрывать мини-чат/уведомления справа сверху,
# когда открыт основной чат (на T)
#==============================================================================
module MPNotify
# сюда можно вручную добавить имя ivar'а твоего основного чата,
# если авто-поиск не найдёт:
CHAT_WINDOW_HINTS = [
:@chat_window,
:@ws_chat_window,
:@main_chat_window,
:@window_chat,
:@chat_input_window,
:@chatlog_window,
:@chat_box,
:@chatui
]
def self.mp_any_window_open?(obj)
return false if obj.nil?
if obj.is_a?(Array)
obj.any? { |w| mp_window_open?(w) }
else
mp_window_open?(obj)
end
rescue
false
end
def self.mp_window_open?(w)
return false if w.nil?
# если объект вообще не "видимый" - считаем закрытым
vis = (w.respond_to?(:visible) ? (w.visible rescue true) : true)
return false unless vis
# активное окно (обычно ввод/фокус)
return true if w.respond_to?(:active) && (w.active rescue false)
# если есть open?/openness как у RGSS окон
return true if w.respond_to?(:open?) && (w.open? rescue false)
return true if w.respond_to?(:openness) && ((w.openness.to_i rescue 0) > 0)
false
rescue
false
end
def self.mp_main_chat_open?
return false unless _on_map_scene?
sc = SceneManager.scene
return false unless sc
# 1) сначала проверяем явные подсказки
CHAT_WINDOW_HINTS.each do |iv|
begin
next unless sc.instance_variable_defined?(iv)
obj = sc.instance_variable_get(iv)
return true if mp_any_window_open?(obj)
rescue
end
end
# 2) fallback: ищем любые ivar'ы содержащие "chat"
sc.instance_variables.each do |iv|
next unless iv.to_s.downcase.include?("chat")
begin
obj = sc.instance_variable_get(iv)
return true if mp_any_window_open?(obj)
rescue
end
end
false
rescue
false
end
class << self
unless method_defined?(:mp_hide_minichat__orig_update)
alias mp_hide_minichat__orig_update update
end
end
def self.update
begin
if @sprite && !@sprite.disposed?
@sprite.visible = !mp_main_chat_open?
end
rescue
end
mp_hide_minichat__orig_update
end
class << self
unless method_defined?(:mp_hide_minichat__orig_ensure)
alias mp_hide_minichat__orig_ensure ensure
end
end
def self.ensure
mp_hide_minichat__orig_ensure
begin
if @sprite && !@sprite.disposed?
@sprite.visible = !mp_main_chat_open?
end
rescue
end
end
end
#==============================================================================
# Skill cast visual sync (player -> server -> all clients)
# - отправляет skill_cast при реальном запуске навыка локальным игроком
# - принимает и старый relay-формат (без caster_id), и новый (с caster_id)
# - не дублирует локальный визуал на отправителе, если сервер шлёт caster_id
#==============================================================================
# ProjBattleStandard / EffectAoeChannelSpdBuff кладут Struct::FakeTarget в
# summon_data и зовут .npc/.actor — без stub крашит remote-клиент.
if defined?(Struct::FakeTarget) && !Struct::FakeTarget.method_defined?(:mp_faketraget_npc_stub?)
class Struct::FakeTarget
def mp_faketraget_npc_stub?
true
end
def npc
@_mp_fake_npc ||= begin
stub = Object.new
def stub.friendly?(_c=nil); false; end
def stub.fraction; 0; end
def stub.action_state; :none; end
def stub.battle_stat; self; end
def stub.get_stat(_k, _t=nil); 0; end
def stub.target; nil; end
def stub.target=(_v); nil; end
def stub.method_missing(name, *_a)
return false if name.to_s.end_with?("?")
nil
end
def stub.respond_to_missing?(_n, _i=false); true; end
stub
end
end
def actor
npc
end
def npc?
true
end
def moving?
false
end
def direction
2
end
def summon_data
@_mp_fake_summon_data ||= {}
end
end
end
if defined?(WebSocket)
module WebSocket
class << self
alias_method :_mp_skillvis_old_parse, :parse unless method_defined?(:_mp_skillvis_old_parse)
alias_method :_mp_skillvis_old_show_skill_cast, :show_skill_cast unless method_defined?(:_mp_skillvis_old_show_skill_cast)
if method_defined?(:handle_remote_deistvia) && !method_defined?(:_mp_skillvis_old_handle_remote_deistvia)
alias_method :_mp_skillvis_old_handle_remote_deistvia, :handle_remote_deistvia
end
end
def self.parse(msg)
if msg.is_a?(String)
begin
# fallback: server просто релеит клиентский пакет без caster_id
if msg =~ /^skill_cast:(\d+):(\d+):(\d+):(-?\d+)$/
return unless @worldsync
skill_id = $1.to_i
tx = $2.to_i
ty = $3.to_i
target_id = $4.to_i
_mp_skillvis_old_show_skill_cast(skill_id, 0, tx, ty, target_id)
return
end
rescue
end
end
_mp_skillvis_old_parse(msg)
end
def self.show_skill_cast(skill_id, caster_id, tx, ty, target_id)
begin
if !@my_id.nil? && caster_id.to_i > 0 && caster_id.to_i == @my_id.to_i
return
end
rescue
end
_mp_skillvis_old_show_skill_cast(skill_id, caster_id, tx, ty, target_id)
end
def self._mp_skillvis_ready?
return false unless connected?
return false unless worldsync?
return false if @my_id.nil?
true
end
def self._mp_skillvis_skill_name(skill)
return "" if skill.nil?
name = ""
begin
name = skill.name.to_s if skill.respond_to?(:name)
rescue
name = ""
end
if name.nil? || name.empty?
begin
name = skill.item_name.to_s if skill.respond_to?(:item_name)
rescue
name = ""
end
end
name.to_s
rescue
""
end
def self._mp_skillvis_arpg_skill(name)
key = name.to_s
return nil if key.empty?
begin
return $data_arpgskills[key] if defined?($data_arpgskills) && $data_arpgskills && $data_arpgskills[key]
rescue
end
nil
rescue
nil
end
def self._mp_skillvis_target_id_from_char(ch)
return 0 if ch.nil?
begin
return @my_id.to_i if ch == $game_player && !@my_id.nil?
rescue
end
begin
if ch.instance_variable_defined?(:@net_player_id)
pid = ch.instance_variable_get(:@net_player_id)
return pid.to_i if !pid.nil? && pid.to_i > 0
end
rescue
end
begin
if ch.is_a?(Game_Event)
eid = ch.id.to_i
return -eid if eid > 0
end
rescue
end
0
end
def self._mp_skillvis_xy_from_target(target)
ch = target
ch = target[0] if target.is_a?(Array)
x = nil
y = nil
begin
x = ch.x.to_i unless ch.nil?
rescue
x = nil
end
begin
y = ch.y.to_i unless ch.nil?
rescue
y = nil
end
begin
x = $game_player.x.to_i if x.nil? && $game_player
rescue
x = 0
end
begin
y = $game_player.y.to_i if y.nil? && $game_player
rescue
y = 0
end
x = 0 if x.nil?
y = 0 if y.nil?
[x, y]
end
def self._mp_skillvis_char_from_target_id(target_id)
tid = target_id.to_i
begin
return $game_player if !@my_id.nil? && tid == @my_id.to_i
rescue
end
begin
return @players[tid] if tid > 0 && @players && @players[tid]
rescue
end
begin
return $game_map.events[-tid] if tid < 0 && $game_map && $game_map.events && $game_map.events[-tid]
rescue
end
nil
rescue
nil
end
# Remote NetPlayer: @npc == nil, а EffectAoeChannelSpdBuff зовёт user.npc.friendly?
def self._mp_skillvis_safe_summon_user(caster)
return caster if caster.nil?
begin
if defined?(WebSocket::MpSupportSummonProxy)
return WebSocket::MpSupportSummonProxy.new(caster)
end
rescue
end
actor = nil
begin
actor = caster.actor if caster.respond_to?(:actor)
rescue
actor = nil
end
if actor.nil?
begin
actor = caster.instance_variable_get(:@net_actor)
rescue
actor = nil
end
end
if actor.nil?
actor = Object.new
def actor.friendly?(_c=nil); false; end
def actor.fraction; 0; end
end
proxy = Object.new
proxy.instance_variable_set(:@real, caster)
proxy.instance_variable_set(:@actor, actor)
proxy.instance_variable_set(:@summon_data, { :user => caster })
def proxy.summon_data; @summon_data; end
def proxy.actor; @actor; end
def proxy.npc; @actor; end
def proxy.npc?; !@actor.nil?; end
def proxy.x; @real.x rescue 0; end
def proxy.y; @real.y rescue 0; end
def proxy.direction; (@real.direction.to_i rescue 2); end
def proxy.method_missing(name, *args, &block)
@real.send(name, *args, &block)
rescue
nil
end
proxy
rescue
caster
end
# FakeTarget / голые координаты нельзя класть в :target — сток зовёт target.npc
def self._mp_skillvis_summon_target_ok?(ch)
return false if ch.nil?
begin
return false if defined?(Struct::FakeTarget) && ch.is_a?(Struct::FakeTarget)
rescue
end
begin
return true if ch.respond_to?(:npc)
rescue
end
begin
return true if ch.respond_to?(:actor) && !ch.actor.nil?
rescue
end
false
rescue
false
end
def self._mp_skillvis_local_only_summon?(skill)
return false if skill.nil?
name = ""
begin
name = skill.summon_user.to_s if skill.respond_to?(:summon_user)
rescue
name = ""
end
return true if name == "EffectBasicNeeds"
return true if !name.empty? && name.start_with?("EffectMC")
# Знамя правосудия / HeavyBattleStandard — shared summon у всех на карте
skill_name = ""
begin
skill_name = skill.name.to_s if skill.respond_to?(:name)
rescue
skill_name = ""
end
if skill_name == "BasicBattleStandard" || skill_name == "HeavyBattleStandard"
return false
end
if !name.empty? && name.include?("BattleStandard")
return false
end
support = false
begin
support = !!skill.is_support if skill.respond_to?(:is_support)
rescue
support = false
end
return false unless support
detection = nil
begin
detection = skill.hit_detection if skill.respond_to?(:hit_detection)
rescue
detection = nil
end
return true if defined?(Sensors) && detection == Sensors::NoRangeMap
return true if detection.to_s =~ /NoRangeMap\z/
false
rescue
false
end
def self._mp_skillvis_show_arpg_cast(player_id, payload_hash)
return if @my_id && player_id.to_i == @my_id.to_i
return unless SceneManager.scene_is?(Scene_Map)
skill_name = payload_hash["skill"].to_s
skill_name = payload_hash["skill_name"].to_s if skill_name.empty?
skill = _mp_skillvis_arpg_skill(skill_name)
return if skill.nil?
caster = nil
begin
caster = @players[player_id.to_i] if @players
rescue
caster = nil
end
return if caster.nil?
target = nil
begin
target = _mp_skillvis_char_from_target_id(payload_hash["target"].to_i)
rescue
target = nil
end
begin
caster.set_animation(skill.chs_animation) if skill.chs_animation && caster.respond_to?(:set_animation)
rescue
end
begin
if skill.summon_user && !_mp_skillvis_local_only_summon?(skill) && $game_map
# Safe zone: do not replicate hostile summons (Lantern fire / DoT).
# Support summons (heal, shield, banner) still play.
begin
if defined?(MPSafeZone) && MPSafeZone.active? &&
!(skill.respond_to?(:is_support) && skill.is_support)
return
end
rescue
end
summon_user = _mp_skillvis_safe_summon_user(caster)
# Только реальный персонаж; FakeTarget из дочерних summon патчится выше
summon_target = summon_user
if _mp_skillvis_summon_target_ok?(target)
begin
summon_target = _mp_skillvis_safe_summon_user(target)
rescue
summon_target = summon_user
end
end
data = { :user => summon_user, :target => summon_target, :skill => skill }
sx = nil
sy = nil
begin
sx = caster.x.to_i
sy = caster.y.to_i
rescue
sx = nil
sy = nil
end
# Явные координаты кастера: summon_skill(nil,nil) ставит на локального игрока
if !sx.nil? && !sy.nil? && $game_map.respond_to?(:reserve_summon_event)
$game_map.reserve_summon_event(skill.summon_user, sx, sy, -1, data)
elsif $game_map.respond_to?(:summon_skill)
$game_map.summon_skill(skill.summon_user, data)
end
end
rescue
end
rescue
end
def self.handle_remote_deistvia(player_id, action_id, phase, payload)
if action_id.to_s == "arpg_skill_cast"
begin
return if phase.to_s == "stop"
h = self.respond_to?(:_deistvia_unpack) ? _deistvia_unpack(payload.to_s) : {}
_mp_skillvis_show_arpg_cast(player_id.to_i, h)
rescue
end
return
end
if self.respond_to?(:_mp_skillvis_old_handle_remote_deistvia)
_mp_skillvis_old_handle_remote_deistvia(player_id, action_id, phase, payload)
end
end
def self.send_skill_cast_visual(skill, target=nil)
return unless _mp_skillvis_ready?
return if skill.nil?
ch = target
ch = target[0] if target.is_a?(Array)
tx, ty = _mp_skillvis_xy_from_target(target)
target_id = _mp_skillvis_target_id_from_char(ch)
skill_name = _mp_skillvis_skill_name(skill)
if !skill_name.nil? && !skill_name.empty? && _mp_skillvis_arpg_skill(skill_name)
begin
payload = {
"skill" => skill_name,
"tx" => tx.to_i,
"ty" => ty.to_i,
"target" => target_id.to_i
}
if self.respond_to?(:send_deistvia)
send_deistvia("arpg_skill_cast", "play", payload)
else
packed = self.respond_to?(:_deistvia_pack) ? _deistvia_pack(payload) : payload.map { |k, v| k.to_s + "=" + v.to_s }.join(",")
send_line("deistvia:" + esc("arpg_skill_cast") + ":" + esc("play") + ":" + esc(packed))
end
rescue
end
end
skill_id = 0
begin
skill_id = skill.id.to_i
rescue
skill_id = 0
end
return if skill_id <= 0
begin
send_line("skill_cast:#{skill_id}:#{tx}:#{ty}:#{target_id}")
rescue
end
end
end
if defined?(Battle_System) && Battle_System.instance_methods.include?(:process_skill_result)
module Battle_System
unless instance_methods.include?(:mp_ws_process_skill_result_vissync)
alias mp_ws_process_skill_result_vissync process_skill_result
def process_skill_result(skill)
had_launched = false
begin
had_launched = !!@current_skill_launched
rescue
had_launched = false
end
result = mp_ws_process_skill_result_vissync(skill)
begin
launched_now = !!@current_skill_launched
return result if had_launched
return result unless launched_now
return result if skill.nil?
return result unless defined?(WebSocket) && WebSocket._mp_skillvis_ready?
return result unless (self == $game_player.actor rescue false)
sent_any = false
# Знамя (NoRangeMap / projectile support): всегда шлём cast с позиции кастера
banner = false
begin
sn = skill.name.to_s if skill.respond_to?(:name)
banner = (sn == "BasicBattleStandard" || sn == "HeavyBattleStandard")
if !banner && skill.respond_to?(:summon_user)
su = skill.summon_user.to_s
banner = !su.empty? && su.include?("BattleStandard")
end
rescue
banner = false
end
if banner
WebSocket.send_skill_cast_visual(skill, $game_player)
sent_any = true
elsif skill.respond_to?(:is_projectile?) && skill.is_projectile?
tgt = nil
begin
if skill.respond_to?(:is_support) && skill.is_support
tgt = target
else
tgt = map_token.get_fake_target
end
rescue
tgt = nil
end
if tgt
WebSocket.send_skill_cast_visual(skill, tgt)
sent_any = true
end
else
begin
targets = skill.hit_detection.scan(map_token)
if targets && !targets.empty?
targets.each do |tgt|
next if tgt.nil?
WebSocket.send_skill_cast_visual(skill, tgt)
sent_any = true
end
end
rescue
end
end
WebSocket.send_skill_cast_visual(skill, $game_player) unless sent_any
rescue
end
result
end
end
end
end
end
#==============================================================================
# Skill charset animation sync (for skills that use set_animation / chs_animation)
# - needed for utility/pose skills like stealth, arson, etc.
# - mirrors local player's skill charset animation to remote players
#==============================================================================
if defined?(WebSocket)
module WebSocket
class << self
alias_method :_mp_skillchs_old_parse, :parse unless method_defined?(:_mp_skillchs_old_parse)
end
def self.parse(msg)
if msg.is_a?(String)
begin
if msg =~ /^skill_chs:([^:]*):(\d+)$/
return unless @worldsync
anim_name = unesc($1.to_s)
caster_id = $2.to_i
begin
if !@my_id.nil? && caster_id > 0 && caster_id == @my_id.to_i
return
end
rescue
end
begin
if @players && @players[caster_id]
pl = @players[caster_id]
if pl && anim_name && anim_name != "" && anim_name != "animation_nil"
pl.set_animation(anim_name) if pl.respond_to?(:set_animation)
end
end
rescue
end
return
end
rescue
end
end
_mp_skillchs_old_parse(msg)
end
def self.send_skill_charset_visual(animation_name)
return unless _mp_skillvis_ready?
anim_raw = animation_name.to_s
return if anim_raw == "" || anim_raw == "animation_nil"
now = 0
begin
now = Graphics.frame_count.to_i
rescue
now = 0
end
@mp_skillchs_last_sent ||= {}
last = @mp_skillchs_last_sent[anim_raw]
return if !last.nil? && (now - last.to_i) < 6
@mp_skillchs_last_sent[anim_raw] = now
begin
send_line("skill_chs:#{esc(anim_raw)}:#{@my_id.to_i}")
rescue
end
end
end
if defined?(Game_Player) && Game_Player.instance_methods.include?(:set_animation)
class Game_Player
unless instance_methods.include?(:_mp_skillchs_old_set_animation)
alias _mp_skillchs_old_set_animation set_animation
def set_animation(animation_name)
result = _mp_skillchs_old_set_animation(animation_name)
begin
if defined?(WebSocket) && WebSocket._mp_skillvis_ready?
anim_ok = !animation_name.nil? && animation_name.to_s != "" && animation_name.to_s != "animation_nil"
if anim_ok
act = nil
begin
act = self.actor if respond_to?(:actor)
rescue
act = nil
end
is_skill_anim = false
begin
is_skill_anim = (act && act.respond_to?(:action_state) && act.action_state == :skill)
rescue
is_skill_anim = false
end
begin
is_skill_anim ||= (!!act.skill) if act && act.respond_to?(:skill)
rescue
end
WebSocket.send_skill_charset_visual(animation_name) if is_skill_anim
end
end
rescue
end
result
end
end
end
end
end
class Sprite_Character < Sprite_Base
def mp_create_net_nickname(text)
font_size = 16
font_name = MPSafeFont.nick_name
temp = Bitmap.new(1, 1)
temp.font.name = font_name
temp.font.size = font_size
temp.font.bold = false
temp.font.outline = false
temp.font.shadow = true
w = temp.text_size(text).width + 8
h = temp.text_size(text).height
temp.dispose
@mp_nick_sprite = Sprite.new(self.viewport)
@mp_nick_sprite.bitmap = Bitmap.new(w, h)
@mp_nick_sprite.bitmap.font.name = font_name
@mp_nick_sprite.bitmap.font.size = font_size
@mp_nick_sprite.bitmap.font.bold = false
@mp_nick_sprite.bitmap.font.outline = false
@mp_nick_sprite.bitmap.font.shadow = true
@mp_nick_sprite.ox = w / 2
@mp_nick_sprite.oy = h
@mp_nick_sprite.bitmap.draw_text(0, 0, w, h, text, 1)
end
end
module MPNotify
def self.redraw
return unless @sprite && @sprite.bitmap
b = @sprite.bitmap
b.clear
w = b.width
visible = (@items || []).last(MAX_LINES).reverse
visible.each_with_index do |it, idx|
text = ""
if it[:type] == :map_join
pid = it[:pid].to_i
nick = it[:nick].to_s
if nick.strip == ""
begin
nick = WebSocket.nickname_for(pid) if defined?(WebSocket)
rescue
nick = ""
end
if nick.to_s.strip == ""
begin
if defined?(WebSocket) && WebSocket.respond_to?(:my_id) && WebSocket.respond_to?(:local_nickname) && pid == WebSocket.my_id.to_i
nick = WebSocket.local_nickname
end
rescue
nick = ""
end
end
nick = nick.to_s
it[:nick] = nick if nick.strip != ""
end
nick = nick.to_s
next if MPNotify.respond_to?(:placeholder_nick?) && MPNotify.placeholder_nick?(nick)
text = "#{nick} зашёл на карту"
else
text = it[:text].to_s
end
text = text.gsub("\t", " ").gsub("\0", "")
text = text[0, 140]
b.font.name = MPSafeFont.notify_name
b.font.size = 20
b.font.bold = false
b.font.outline = false
b.font.shadow = true
begin
b.font.color = (it[:color] || Color.new(255, 255, 255))
rescue
b.font.color = Color.new(255, 255, 255)
end
b.draw_text(0, idx * LINE_H, w, LINE_H, text, 2)
end
@dirty = false
rescue
@dirty = false
end
end