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