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

2376 lines
72 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.
#==============================================================================
# Блокировать запуск 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