743 lines
25 KiB
Ruby
743 lines
25 KiB
Ruby
# encoding: UTF-8
|
|
#==============================================================================
|
|
# PvPCombatUXFix 1.1.0
|
|
# - suppresses vanilla low-stamina / overfatigue cutscenes when stamina was
|
|
# exhausted by another player in PvP;
|
|
# - highlights the current PvP aggressor red only on the victim's client.
|
|
#
|
|
# Client-only. Does not alter damage, stamina, capture/slavery, saves, chat,
|
|
# ClanEstate, or server state.
|
|
#==============================================================================
|
|
|
|
return unless defined?(WebSocket)
|
|
|
|
module WebSocket
|
|
MP_PVP_AGGRESSOR_HOLD_SEC = 8.0 unless const_defined?(:MP_PVP_AGGRESSOR_HOLD_SEC)
|
|
|
|
class << self
|
|
if method_defined?(:_mp_pvp_apply_skill_payload) && !method_defined?(:_mp_ux_old_apply_skill_payload)
|
|
alias_method :_mp_ux_old_apply_skill_payload, :_mp_pvp_apply_skill_payload
|
|
end
|
|
if method_defined?(:handle_being_attacked) && !method_defined?(:_mp_ux_old_handle_being_attacked)
|
|
alias_method :_mp_ux_old_handle_being_attacked, :handle_being_attacked
|
|
end
|
|
end
|
|
|
|
def self._mp_ux_now
|
|
Time.now.to_f
|
|
rescue
|
|
0.0
|
|
end
|
|
|
|
def self._mp_ux_local_actor
|
|
begin
|
|
return _mp_pvp_local_actor if respond_to?(:_mp_pvp_local_actor)
|
|
rescue
|
|
end
|
|
begin
|
|
return _mp_local_actor if respond_to?(:_mp_local_actor)
|
|
rescue
|
|
end
|
|
begin
|
|
return $game_player.actor if $game_player && $game_player.respond_to?(:actor)
|
|
rescue
|
|
end
|
|
begin
|
|
return $game_party.leader
|
|
rescue
|
|
end
|
|
nil
|
|
end
|
|
|
|
def self._mp_ux_actor_sta(actor=nil)
|
|
actor ||= _mp_ux_local_actor
|
|
return nil if actor.nil? || !actor.respond_to?(:sta)
|
|
actor.sta.to_f
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
# Called before an incoming PvP hit is applied. This makes the suppression
|
|
# active even if the original damage code performs a nested player refresh.
|
|
def self._mp_ux_begin_incoming(attacker_id)
|
|
@mp_ux_incoming_depth = @mp_ux_incoming_depth.to_i + 1
|
|
@mp_ux_incoming_attacker = attacker_id.to_i
|
|
rescue
|
|
end
|
|
|
|
def self._mp_ux_finish_incoming(attacker_id, before_sta=nil, after_sta=nil)
|
|
aid = attacker_id.to_i
|
|
|
|
# Mark attacker for victim-only red tint. Refresh on every received hit.
|
|
if aid > 0
|
|
@mp_ux_aggressors ||= {}
|
|
@mp_ux_aggressors[aid] = _mp_ux_now + MP_PVP_AGGRESSOR_HOLD_SEC.to_f
|
|
end
|
|
|
|
# If the incoming player hit leaves us with no stamina, remember that this
|
|
# exhaustion belongs to PvP. Keep the latch until stamina is positive again
|
|
# so the vanilla scene cannot pop a few seconds later after combat TTL ends.
|
|
cur = after_sta
|
|
cur = _mp_ux_actor_sta if cur.nil?
|
|
if !cur.nil? && cur.to_f <= 0.0
|
|
@mp_ux_pvp_exhausted = true
|
|
@mp_ux_pvp_exhausted_by = aid if aid > 0
|
|
end
|
|
rescue
|
|
ensure
|
|
@mp_ux_incoming_depth = [@mp_ux_incoming_depth.to_i - 1, 0].max
|
|
@mp_ux_incoming_attacker = nil if @mp_ux_incoming_depth.to_i <= 0
|
|
end
|
|
|
|
def self.mp_pvp_stamina_cutscene_suppressed?
|
|
# Suppress during the actual incoming damage call too.
|
|
return true if @mp_ux_incoming_depth.to_i > 0
|
|
|
|
actor = _mp_ux_local_actor
|
|
return false if actor.nil?
|
|
|
|
sta = _mp_ux_actor_sta(actor)
|
|
return false if sta.nil?
|
|
|
|
# Recovery clears the PvP exhaustion latch. A later normal exhaustion may
|
|
# therefore use the vanilla low-stamina event as usual.
|
|
if sta.to_f > 0.0
|
|
@mp_ux_pvp_exhausted = false
|
|
@mp_ux_pvp_exhausted_by = nil
|
|
return false
|
|
end
|
|
|
|
@mp_ux_pvp_exhausted ? true : false
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.mp_pvp_aggressor?(player_id)
|
|
pid = player_id.to_i
|
|
return false if pid <= 0
|
|
@mp_ux_aggressors ||= {}
|
|
until_t = @mp_ux_aggressors[pid]
|
|
return false if until_t.nil?
|
|
if until_t.to_f <= _mp_ux_now
|
|
@mp_ux_aggressors.delete(pid)
|
|
return false
|
|
end
|
|
true
|
|
rescue
|
|
false
|
|
end
|
|
|
|
# Extended PvP skill payload path (98_pvp_skill_sync.rb).
|
|
if respond_to?(:_mp_ux_old_apply_skill_payload)
|
|
def self._mp_pvp_apply_skill_payload(attacker_id, payload_hash)
|
|
return false if defined?(MPSafeZone) && MPSafeZone.active?
|
|
actor = _mp_ux_local_actor
|
|
before_sta = _mp_ux_actor_sta(actor)
|
|
_mp_ux_begin_incoming(attacker_id)
|
|
result = false
|
|
begin
|
|
result = _mp_ux_old_apply_skill_payload(attacker_id, payload_hash)
|
|
ensure
|
|
after_sta = _mp_ux_actor_sta(actor)
|
|
_mp_ux_finish_incoming(attacker_id, before_sta, after_sta)
|
|
end
|
|
result
|
|
end
|
|
end
|
|
|
|
# Legacy / basic attack path. 98_pvp_skill_sync also routes fallback hits here.
|
|
if respond_to?(:_mp_ux_old_handle_being_attacked)
|
|
def self.handle_being_attacked(attacker_id, damage, opts=nil)
|
|
return if defined?(MPSafeZone) && MPSafeZone.active?
|
|
actor = _mp_ux_local_actor
|
|
before_sta = _mp_ux_actor_sta(actor)
|
|
_mp_ux_begin_incoming(attacker_id)
|
|
result = nil
|
|
begin
|
|
begin
|
|
result = _mp_ux_old_handle_being_attacked(attacker_id, damage, opts)
|
|
rescue ArgumentError
|
|
result = _mp_ux_old_handle_being_attacked(attacker_id, damage)
|
|
end
|
|
ensure
|
|
after_sta = _mp_ux_actor_sta(actor)
|
|
_mp_ux_finish_incoming(attacker_id, before_sta, after_sta)
|
|
end
|
|
result
|
|
end
|
|
end
|
|
end
|
|
|
|
#------------------------------------------------------------------------------
|
|
# Vanilla stamina events
|
|
# check_MainStats_event contains BOTH:
|
|
# sta <= -100 -> OverEvent_Overfatigue.rb
|
|
# sta <= 0 -> low-stamina portrait/dialogue
|
|
# We only bypass it while health is still positive and exhaustion is PvP-owned.
|
|
# Health-death handling remains untouched.
|
|
#------------------------------------------------------------------------------
|
|
if defined?(Game_Interpreter) && Game_Interpreter.instance_methods.include?(:check_MainStats_event)
|
|
class Game_Interpreter
|
|
unless instance_methods.include?(:mp_pvp_ux_old_check_MainStats_event)
|
|
alias mp_pvp_ux_old_check_MainStats_event check_MainStats_event
|
|
end
|
|
|
|
def check_MainStats_event(parallel=false)
|
|
begin
|
|
if defined?(WebSocket) && WebSocket.respond_to?(:mp_pvp_stamina_cutscene_suppressed?) &&
|
|
WebSocket.mp_pvp_stamina_cutscene_suppressed? &&
|
|
defined?($game_player) && $game_player && $game_player.respond_to?(:actor) &&
|
|
$game_player.actor && $game_player.actor.respond_to?(:health) &&
|
|
$game_player.actor.respond_to?(:sta) &&
|
|
$game_player.actor.health.to_f > 0.0 && $game_player.actor.sta.to_f <= 0.0
|
|
return
|
|
end
|
|
rescue
|
|
end
|
|
mp_pvp_ux_old_check_MainStats_event(parallel)
|
|
end
|
|
end
|
|
end
|
|
|
|
#------------------------------------------------------------------------------
|
|
# Victim-only aggressor highlight.
|
|
# Remote players are Game_Event objects with @net_player_id. We tint only their
|
|
# character sprite, not the nickname/status UI. No packet is sent to server.
|
|
#------------------------------------------------------------------------------
|
|
if defined?(Sprite_Character)
|
|
class Sprite_Character
|
|
unless instance_methods.include?(:mp_pvp_ux_old_update)
|
|
alias mp_pvp_ux_old_update update
|
|
end
|
|
|
|
def update
|
|
mp_pvp_ux_old_update
|
|
mp_pvp_ux_update_aggressor_tint
|
|
end
|
|
|
|
def mp_pvp_ux_update_aggressor_tint
|
|
pid = 0
|
|
begin
|
|
if @character && @character.instance_variable_defined?(:@net_player_id)
|
|
pid = @character.instance_variable_get(:@net_player_id).to_i
|
|
end
|
|
rescue
|
|
pid = 0
|
|
end
|
|
|
|
active = false
|
|
begin
|
|
active = pid > 0 && defined?(WebSocket) && WebSocket.respond_to?(:mp_pvp_aggressor?) && WebSocket.mp_pvp_aggressor?(pid)
|
|
rescue
|
|
active = false
|
|
end
|
|
|
|
if active
|
|
unless @mp_pvp_ux_red_tint
|
|
begin
|
|
c = self.color
|
|
@mp_pvp_ux_saved_color = [c.red, c.green, c.blue, c.alpha]
|
|
rescue
|
|
@mp_pvp_ux_saved_color = [0, 0, 0, 0]
|
|
end
|
|
@mp_pvp_ux_red_tint = true
|
|
end
|
|
begin
|
|
self.color.set(255, 0, 0, 112)
|
|
rescue
|
|
self.color = Color.new(255, 0, 0, 112) rescue nil
|
|
end
|
|
elsif @mp_pvp_ux_red_tint
|
|
vals = @mp_pvp_ux_saved_color || [0, 0, 0, 0]
|
|
begin
|
|
self.color.set(vals[0], vals[1], vals[2], vals[3])
|
|
rescue
|
|
self.color = Color.new(vals[0], vals[1], vals[2], vals[3]) rescue nil
|
|
end
|
|
@mp_pvp_ux_red_tint = false
|
|
@mp_pvp_ux_saved_color = nil
|
|
end
|
|
rescue
|
|
end
|
|
end
|
|
end
|
|
|
|
puts "[PVP-UX] loaded 1.0.0; PvP stamina cutscenes suppressed, aggressor tint active" rescue nil
|
|
|
|
|
|
#==============================================================================
|
|
# PvPCombatUXFix 1.1.0 additions
|
|
# 1) STA <= -100 from PvP is NOT treated as Lona death while HEALTH > 0.
|
|
# This fixes the old "first exhausted hit works, further HP damage stops until
|
|
# map reload" bug caused by Game_Actor#lonaDeath? short-circuiting PvP hits.
|
|
# 2) Victim pushes a lightweight player-stat sync after every PvP hit.
|
|
# 3) Attacker sees the same flying HEALTH/STA numbers above the remote target.
|
|
# 4) Attacker keeps a local mirror of the remote target HEALTH/STA so advanced
|
|
# PvP skill calculations do not use a stale map-entry snapshot.
|
|
#==============================================================================
|
|
|
|
module WebSocket
|
|
def self.mp_pvp_local_exhaustion_alive?(actor=nil)
|
|
actor ||= _mp_ux_local_actor rescue nil
|
|
return false if actor.nil?
|
|
begin
|
|
local = _mp_ux_local_actor
|
|
return false unless actor.equal?(local)
|
|
rescue
|
|
return false
|
|
end
|
|
|
|
hp = actor.respond_to?(:health) ? actor.health.to_f : 0.0
|
|
sta = actor.respond_to?(:sta) ? actor.sta.to_f : 0.0
|
|
return false unless hp > 0.0 && sta <= -100.0
|
|
|
|
# During the incoming hit the latch may not have been set yet. Afterwards
|
|
# @mp_ux_pvp_exhausted keeps the exception alive until stamina recovers.
|
|
@mp_ux_incoming_depth.to_i > 0 || !!@mp_ux_pvp_exhausted
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self._mp_ux_sync_local_stats_after_hit
|
|
begin
|
|
send_playersync_full("pvp_damage", true) if respond_to?(:send_playersync_full)
|
|
rescue
|
|
end
|
|
end
|
|
|
|
def self._mp_ux_remote_actor(player_id)
|
|
pid = player_id.to_i
|
|
return nil if pid <= 0 || !@players || !@players[pid]
|
|
rp = @players[pid]
|
|
begin
|
|
return rp.actor if rp.respond_to?(:actor)
|
|
rescue
|
|
end
|
|
begin
|
|
return rp.instance_variable_get(:@net_actor)
|
|
rescue
|
|
end
|
|
nil
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def self._mp_ux_apply_remote_damage_mirror(target_id, hp_damage, sta_damage)
|
|
actor = _mp_ux_remote_actor(target_id)
|
|
return false if actor.nil?
|
|
hd = hp_damage.to_i
|
|
sd = sta_damage.to_i
|
|
begin
|
|
if hd > 0 && actor.respond_to?(:health) && actor.respond_to?(:health=)
|
|
cur = actor.health
|
|
actor.health = cur.to_f - hd.to_f unless cur.nil?
|
|
end
|
|
rescue
|
|
end
|
|
begin
|
|
if sd > 0 && actor.respond_to?(:sta) && actor.respond_to?(:sta=)
|
|
cur = actor.sta
|
|
actor.sta = cur.to_f - sd.to_f unless cur.nil?
|
|
end
|
|
rescue
|
|
end
|
|
true
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self._mp_ux_show_outgoing_popups(x, y, direction, hp_damage, sta_damage)
|
|
return unless defined?($game_damage_popups) && $game_damage_popups
|
|
hd = hp_damage.to_i
|
|
sd = sta_damage.to_i
|
|
dir = direction.to_i
|
|
dir = 2 unless [2,4,6,8].include?(dir)
|
|
begin
|
|
$game_damage_popups.add(hd, x.to_i, y.to_i, dir, MP_PVP_POPUP_HP_TYPE) if hd > 0
|
|
rescue
|
|
end
|
|
begin
|
|
$game_damage_popups.add(sd, x.to_i, y.to_i, dir, MP_PVP_POPUP_STA_TYPE) if sd > 0
|
|
rescue
|
|
end
|
|
end
|
|
|
|
class << self
|
|
# WebSocket.parse is installed with prepend at the end of this file. Using
|
|
# alias here can recurse if ClanEstate already prepended its parser during a
|
|
# mobile loading-frame Graphics.update.
|
|
if method_defined?(:send_deistvia) && !method_defined?(:mp_pvp_ux11_send_deistvia_without_outgoing_popup)
|
|
alias_method :mp_pvp_ux11_send_deistvia_without_outgoing_popup, :send_deistvia
|
|
end
|
|
end
|
|
|
|
# Extended PvP skills already know their exact hp/sta deltas in payload.
|
|
# The server excludes the sender from deistvia relay, so render/mirror here.
|
|
def self._mp_ux_payload_is_heal?(payload)
|
|
return false if payload.nil?
|
|
if payload.is_a?(Hash)
|
|
return true if payload["heal"].to_s == "1"
|
|
return true if payload["sup"].to_s == "1" && (
|
|
payload["skill_name"].to_s.include?("NunHeal") ||
|
|
payload["skill"].to_s.include?("NunHeal") ||
|
|
payload["hp"].to_i < 0 || payload["sta"].to_i < 0
|
|
)
|
|
return true if payload["skill_name"].to_s == "BasicNunHeal"
|
|
return false
|
|
end
|
|
s = payload.to_s
|
|
return true if s.include?("heal=1")
|
|
return true if s.include?("BasicNunHeal")
|
|
return true if s.include?("sup=1") && (s.include?("NunHeal") || s.include?("hp=-") || s.include?("sta=-"))
|
|
false
|
|
rescue
|
|
false
|
|
end
|
|
|
|
if respond_to?(:mp_pvp_ux11_send_deistvia_without_outgoing_popup)
|
|
def self.send_deistvia(action_id, phase, payload)
|
|
begin
|
|
if action_id.to_s == "pvp_skill_hit" && phase.to_s != "stop" && payload.is_a?(Hash)
|
|
target_id = (payload["target"] || payload["tgt"] || payload["target_id"]).to_i
|
|
if target_id > 0 && (!@my_id || target_id != @my_id.to_i)
|
|
hp_raw = (payload["hp"] || 0).to_i
|
|
sta_raw = (payload["sta"] || 0).to_i
|
|
tx = (payload["tx"] || 0).to_i
|
|
ty = (payload["ty"] || 0).to_i
|
|
dir = ($game_player.direction rescue 2)
|
|
if _mp_ux_payload_is_heal?(payload)
|
|
# Heal amounts may be positive (heal=1) or negative (stock deltas).
|
|
hh = hp_raw.abs
|
|
sh = sta_raw.abs
|
|
begin
|
|
if defined?($game_damage_popups) && $game_damage_popups
|
|
$game_damage_popups.add(hh, tx, ty, dir, (defined?(MP_PVP_POPUP_PLUS_HP_TYPE) ? MP_PVP_POPUP_PLUS_HP_TYPE : 10)) if hh > 0
|
|
$game_damage_popups.add(sh, tx, ty, dir, (defined?(MP_PVP_POPUP_PLUS_STA_TYPE) ? MP_PVP_POPUP_PLUS_STA_TYPE : 11)) if sh > 0
|
|
end
|
|
rescue
|
|
end
|
|
# Mirror heal onto local remote actor preview (add, don't subtract).
|
|
begin
|
|
actor = _mp_ux_remote_actor(target_id)
|
|
if actor
|
|
actor.health = actor.health.to_f + hh if hh > 0 && actor.respond_to?(:health=)
|
|
actor.sta = actor.sta.to_f + sh if sh > 0 && actor.respond_to?(:sta=)
|
|
end
|
|
rescue
|
|
end
|
|
else
|
|
_mp_ux_show_outgoing_popups(tx, ty, dir, hp_raw, sta_raw)
|
|
_mp_ux_apply_remote_damage_mirror(target_id, hp_raw, sta_raw)
|
|
end
|
|
end
|
|
end
|
|
rescue
|
|
end
|
|
mp_pvp_ux11_send_deistvia_without_outgoing_popup(action_id, phase, payload)
|
|
end
|
|
end
|
|
end
|
|
|
|
# PvP stamina exhaustion must not trip the stock death predicate. Without this,
|
|
# multiplayer/04_remote_players.rb returns before applying the next hit whenever
|
|
# STA <= -100, which is why HP starts decreasing again only after a map reload.
|
|
if defined?(Game_Actor)
|
|
class Game_Actor
|
|
if method_defined?(:lonaDeath?) && !method_defined?(:mp_pvp_ux11_lonaDeath_without_fix)
|
|
alias_method :mp_pvp_ux11_lonaDeath_without_fix, :lonaDeath?
|
|
def lonaDeath?
|
|
begin
|
|
if defined?(WebSocket) && WebSocket.respond_to?(:mp_pvp_local_exhaustion_alive?) &&
|
|
WebSocket.mp_pvp_local_exhaustion_alive?(self)
|
|
return false
|
|
end
|
|
rescue
|
|
end
|
|
mp_pvp_ux11_lonaDeath_without_fix
|
|
end
|
|
end
|
|
|
|
if method_defined?(:determine_death) && !method_defined?(:mp_pvp_ux11_determine_death_without_fix)
|
|
alias_method :mp_pvp_ux11_determine_death_without_fix, :determine_death
|
|
def determine_death
|
|
begin
|
|
if defined?(WebSocket) && WebSocket.respond_to?(:mp_pvp_local_exhaustion_alive?) &&
|
|
WebSocket.mp_pvp_local_exhaustion_alive?(self)
|
|
# If an older hit already put the actor in :death solely because of
|
|
# stamina, recover the action state. HEALTH death is never masked.
|
|
if respond_to?(:health) && health.to_f > 0.0
|
|
begin
|
|
set_action_state(:none, true) if respond_to?(:set_action_state) && respond_to?(:action_state) && action_state == :death
|
|
rescue
|
|
end
|
|
return
|
|
end
|
|
end
|
|
rescue
|
|
end
|
|
mp_pvp_ux11_determine_death_without_fix
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
# Add the lightweight stat broadcast to the already-installed incoming-hit
|
|
# finalizer without changing cloud-save behavior.
|
|
module WebSocket
|
|
class << self
|
|
if method_defined?(:_mp_ux_finish_incoming) && !method_defined?(:mp_pvp_ux11_finish_incoming_without_stat_sync)
|
|
alias_method :mp_pvp_ux11_finish_incoming_without_stat_sync, :_mp_ux_finish_incoming
|
|
end
|
|
end
|
|
|
|
if respond_to?(:mp_pvp_ux11_finish_incoming_without_stat_sync)
|
|
def self._mp_ux_finish_incoming(attacker_id, before_sta=nil, after_sta=nil)
|
|
result = mp_pvp_ux11_finish_incoming_without_stat_sync(attacker_id, before_sta, after_sta)
|
|
_mp_ux_sync_local_stats_after_hit
|
|
result
|
|
end
|
|
end
|
|
end
|
|
|
|
puts "[PVP-UX] loaded v1.1.0; PvP exhaustion stays alive, outgoing damage popups + stat sync active" rescue nil
|
|
|
|
#==============================================================================
|
|
# PvPCombatUXFix 1.3.0 additions
|
|
# - mark the aggressor directly from authoritative network traffic;
|
|
# - show a separate red aura BEHIND the aggressor on the victim's client;
|
|
# - do not recolor/tint the aggressor character itself.
|
|
#==============================================================================
|
|
|
|
module WebSocket
|
|
MP_PVP_AGGRESSOR_HOLD_SEC = 8.0 unless const_defined?(:MP_PVP_AGGRESSOR_HOLD_SEC)
|
|
|
|
def self.mp_pvp_mark_aggressor(player_id, seconds=nil)
|
|
pid = player_id.to_i
|
|
return false if pid <= 0
|
|
hold = seconds.nil? ? MP_PVP_AGGRESSOR_HOLD_SEC.to_f : seconds.to_f
|
|
hold = MP_PVP_AGGRESSOR_HOLD_SEC.to_f if hold <= 0.0
|
|
@mp_ux_aggressors ||= {}
|
|
@mp_ux_aggressors[pid] = _mp_ux_now + hold
|
|
puts "[PVP-UX] aggressor aura pid=#{pid} hold=#{hold}" rescue nil
|
|
true
|
|
rescue
|
|
false
|
|
end
|
|
|
|
class << self
|
|
if method_defined?(:handle_remote_deistvia) && !method_defined?(:mp_pvp_ux13_remote_deistvia_without_aggressor_mark)
|
|
alias_method :mp_pvp_ux13_remote_deistvia_without_aggressor_mark, :handle_remote_deistvia
|
|
end
|
|
end
|
|
|
|
if respond_to?(:mp_pvp_ux13_remote_deistvia_without_aggressor_mark)
|
|
def self.handle_remote_deistvia(player_id, action_id, phase, payload)
|
|
# Safe zone: block hostile PvP hits, but always allow support heals
|
|
# (BasicNunHeal / sup=1 / heal=1). The old blanket return prevented
|
|
# Исцеление души from ever applying on the receiver.
|
|
if action_id.to_s == "pvp_skill_hit" && defined?(MPSafeZone) && MPSafeZone.active?
|
|
allow_heal = _mp_ux_payload_is_heal?(payload)
|
|
return unless allow_heal
|
|
end
|
|
begin
|
|
if action_id.to_s == "pvp_skill_hit" && phase.to_s != "stop"
|
|
target_id = 0
|
|
if payload.is_a?(Hash)
|
|
target_id = (payload["target"] || payload["tgt"] || payload["target_id"]).to_i
|
|
elsif payload.is_a?(String)
|
|
begin
|
|
h = respond_to?(:_deistvia_unpack) ? _deistvia_unpack(payload.to_s) : {}
|
|
target_id = (h["target"] || h["tgt"] || h["target_id"]).to_i
|
|
rescue
|
|
target_id = 0
|
|
end
|
|
end
|
|
# Do not mark heal casters as aggressors.
|
|
unless _mp_ux_payload_is_heal?(payload)
|
|
if @my_id && target_id == @my_id.to_i && player_id.to_i != @my_id.to_i
|
|
mp_pvp_mark_aggressor(player_id.to_i)
|
|
end
|
|
end
|
|
end
|
|
rescue
|
|
end
|
|
mp_pvp_ux13_remote_deistvia_without_aggressor_mark(player_id, action_id, phase, payload)
|
|
end
|
|
end
|
|
end
|
|
|
|
# Runtime-generated pixel aura. A single cached bitmap is shared by all remote
|
|
# character sprites, so there is no per-frame bitmap allocation.
|
|
module MPPvPAggressorAura
|
|
WIDTH = 52
|
|
HEIGHT = 58
|
|
|
|
def self.bitmap
|
|
return @bitmap if @bitmap && !(@bitmap.disposed? rescue false)
|
|
bmp = Bitmap.new(WIDTH, HEIGHT)
|
|
cx = (WIDTH - 1) / 2.0
|
|
cy = (HEIGHT - 1) / 2.0
|
|
rx = WIDTH * 0.46
|
|
ry = HEIGHT * 0.46
|
|
|
|
y = 0
|
|
while y < HEIGHT
|
|
x = 0
|
|
while x < WIDTH
|
|
dx = (x - cx) / rx
|
|
dy = (y - cy) / ry
|
|
d = Math.sqrt(dx * dx + dy * dy)
|
|
alpha = 0
|
|
# A hollow halo: brightest around the character silhouette, fading both
|
|
# inward and outward. The character itself stays completely untinted.
|
|
if d >= 0.48 && d <= 1.08
|
|
ring = 1.0 - ((d - 0.76).abs / 0.32)
|
|
ring = 0.0 if ring < 0.0
|
|
alpha = (ring * 118.0).to_i
|
|
end
|
|
# Small ground glow behind the feet.
|
|
if y >= HEIGHT - 12
|
|
gx = (x - cx).abs / (WIDTH * 0.42)
|
|
gy = (y - (HEIGHT - 7)).abs / 7.0
|
|
gd = gx * gx + gy * gy
|
|
if gd <= 1.0
|
|
g_alpha = ((1.0 - gd) * 72.0).to_i
|
|
alpha = g_alpha if g_alpha > alpha
|
|
end
|
|
end
|
|
bmp.set_pixel(x, y, Color.new(255, 24, 24, alpha)) if alpha > 0
|
|
x += 1
|
|
end
|
|
y += 1
|
|
end
|
|
@bitmap = bmp
|
|
rescue
|
|
nil
|
|
end
|
|
end
|
|
|
|
if defined?(Sprite_Character)
|
|
class Sprite_Character
|
|
if method_defined?(:dispose) && !method_defined?(:mp_pvp_ux13_dispose_without_aura)
|
|
alias mp_pvp_ux13_dispose_without_aura dispose
|
|
def dispose
|
|
begin
|
|
if @mp_pvp_ux_aura_sprite
|
|
@mp_pvp_ux_aura_sprite.dispose unless @mp_pvp_ux_aura_sprite.disposed?
|
|
@mp_pvp_ux_aura_sprite = nil
|
|
end
|
|
rescue
|
|
end
|
|
mp_pvp_ux13_dispose_without_aura
|
|
end
|
|
end
|
|
|
|
def mp_pvp_ux_remote_player_id
|
|
return 0 unless @character
|
|
return 0 unless @character.instance_variable_defined?(:@net_player_id)
|
|
@character.instance_variable_get(:@net_player_id).to_i
|
|
rescue
|
|
0
|
|
end
|
|
|
|
def mp_pvp_ux_ensure_aura_sprite
|
|
return @mp_pvp_ux_aura_sprite if @mp_pvp_ux_aura_sprite && !(@mp_pvp_ux_aura_sprite.disposed? rescue true)
|
|
aura = Sprite.new(self.viewport)
|
|
aura.bitmap = MPPvPAggressorAura.bitmap
|
|
aura.ox = MPPvPAggressorAura::WIDTH / 2
|
|
aura.oy = MPPvPAggressorAura::HEIGHT - 2
|
|
aura.visible = false
|
|
aura.opacity = 0
|
|
@mp_pvp_ux_aura_sprite = aura
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
# Kept under the old method name because the base part of this patch calls
|
|
# it from Sprite_Character#update. It now manages ONLY the background aura.
|
|
def mp_pvp_ux_update_aggressor_tint
|
|
pid = mp_pvp_ux_remote_player_id
|
|
active = false
|
|
begin
|
|
active = pid > 0 && defined?(WebSocket) &&
|
|
WebSocket.respond_to?(:mp_pvp_aggressor?) &&
|
|
WebSocket.mp_pvp_aggressor?(pid)
|
|
rescue
|
|
active = false
|
|
end
|
|
|
|
aura = @mp_pvp_ux_aura_sprite
|
|
if active
|
|
aura = mp_pvp_ux_ensure_aura_sprite
|
|
return if aura.nil?
|
|
aura.x = self.x
|
|
aura.y = self.y + 2
|
|
aura.z = self.z.to_i - 1
|
|
aura.zoom_x = self.zoom_x rescue 1.0
|
|
aura.zoom_y = self.zoom_y rescue 1.0
|
|
aura.visible = self.visible
|
|
# Gentle pulse, not a full-character flash.
|
|
phase = ((Graphics.frame_count rescue 0).to_f / 8.0)
|
|
aura.opacity = 175 + (Math.sin(phase) * 28).to_i
|
|
elsif aura
|
|
aura.visible = false
|
|
aura.opacity = 0
|
|
end
|
|
rescue
|
|
begin
|
|
@mp_pvp_ux_aura_sprite.visible = false if @mp_pvp_ux_aura_sprite
|
|
rescue
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
#------------------------------------------------------------------------------
|
|
# Order-safe WebSocket parser layer for mobile/desktop.
|
|
#------------------------------------------------------------------------------
|
|
module MPPvPCombatUXWebSocketParsePatch
|
|
def parse(msg)
|
|
begin
|
|
line = msg.to_s
|
|
|
|
# Victim: remember who hit us so the aura can be shown locally.
|
|
if line =~ /\Aattack:(\d+):(\d+):/
|
|
attacker_id = $1.to_i
|
|
target_id = $2.to_i
|
|
if @my_id && target_id == @my_id.to_i && attacker_id != @my_id.to_i
|
|
mp_pvp_mark_aggressor(attacker_id) if respond_to?(:mp_pvp_mark_aggressor)
|
|
end
|
|
end
|
|
|
|
# Attacker: mirror accepted basic hit and show outgoing HP/STA numbers.
|
|
if line =~ /^attack:(\d+):(\d+):(\d+):(\d+):(\d+)/
|
|
attacker_id = $1.to_i
|
|
target_id = $2.to_i
|
|
tx = $3.to_i
|
|
ty = $4.to_i
|
|
raw = $5.to_i
|
|
if @my_id && attacker_id == @my_id.to_i && target_id != @my_id.to_i
|
|
raw = 1 if raw < 1
|
|
hp_dmg = (raw + 1) / 2
|
|
sta_dmg = raw * 2
|
|
dir = ($game_player.direction rescue 2)
|
|
_mp_ux_show_outgoing_popups(tx, ty, dir, hp_dmg, sta_dmg)
|
|
_mp_ux_apply_remote_damage_mirror(target_id, hp_dmg, sta_dmg)
|
|
end
|
|
end
|
|
rescue
|
|
end
|
|
super(msg)
|
|
end
|
|
end
|
|
|
|
begin
|
|
sc = WebSocket.singleton_class
|
|
sc.prepend(MPPvPCombatUXWebSocketParsePatch) unless sc.ancestors.include?(MPPvPCombatUXWebSocketParsePatch)
|
|
rescue => e
|
|
puts "[PVP-UX] parser prepend failed #{e.class}: #{e.message}" rescue nil
|
|
end
|
|
|
|
puts "[PVP-UX] loaded v1.3.0; aggressor shown with victim-local red background aura" rescue nil
|