Files
LonaRPG-Online-Games/ModScripts/multiplayer/98_pvp_skill_sync.rb
T

2628 lines
72 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# encoding: UTF-8
return unless defined?(WebSocket)
module WebSocket
MP_PVP_COMBAT_HOLD_SEC = 8.0
MP_PVP_SKILL_SEND_GAP_FRAMES = 6
MP_PVP_POPUP_HP_TYPE = 1
MP_PVP_POPUP_STA_TYPE = 2
# PlusHealth / PlusSta в DamagePopup (см. ArpgSkill#set_popup_type)
MP_PVP_POPUP_PLUS_HP_TYPE = 10
MP_PVP_POPUP_PLUS_STA_TYPE = 11
# Support-умения аколита / реликвий Святого — явная синхронизация в MP
MP_PVP_SUPPORT_HEAL_SKILLS = %w[BasicNunHeal].freeze
MP_PVP_SUPPORT_BANNER_SKILLS = %w[BasicBattleStandard HeavyBattleStandard].freeze
MP_PVP_SUPPORT_SHIELD_SKILLS = %w[BasicProtectShield ControlProtectShield].freeze
# PvP репутация (как нападение на мирного NPC): временная метка + постоянный штраф за убийство.
# Арена и самооборона без штрафа.
MP_PVP_REP_AGGRO_HOLD_SEC = 8.0 unless const_defined?(:MP_PVP_REP_AGGRO_HOLD_SEC)
MP_PVP_REP_KILL_AMOUNT = -10 unless const_defined?(:MP_PVP_REP_KILL_AMOUNT)
MP_PVP_REP_KILL_COOLDOWN_SEC = 30.0 unless const_defined?(:MP_PVP_REP_KILL_COOLDOWN_SEC)
MP_PVP_REP_ASSAULT_STATE = "MoralityDown30".freeze unless const_defined?(:MP_PVP_REP_ASSAULT_STATE)
class << self
if method_defined?(:handle_remote_deistvia) && !method_defined?(:_mp_pvp_old_handle_remote_deistvia)
alias_method :_mp_pvp_old_handle_remote_deistvia, :handle_remote_deistvia
end
if method_defined?(:handle_being_attacked) && !method_defined?(:_mp_pvp_old_handle_being_attacked)
alias_method :_mp_pvp_old_handle_being_attacked, :handle_being_attacked
end
if method_defined?(:send_line) && !method_defined?(:_mp_pvp_old_send_line)
alias_method :_mp_pvp_old_send_line, :send_line
end
end
def self._mp_pvp_now
begin
Time.now.to_f
rescue
0.0
end
end
def self._mp_pvp_mark_local_combat(sec=MP_PVP_COMBAT_HOLD_SEC)
ttl = _mp_pvp_now + sec.to_f
@mp_pvp_local_combat_until = 0.0 if @mp_pvp_local_combat_until.nil?
@mp_pvp_local_combat_until = ttl if ttl > @mp_pvp_local_combat_until.to_f
rescue
end
def self.mp_pvp_local_combat?
return false unless @connected
@mp_pvp_local_combat_until.to_f > _mp_pvp_now
rescue
false
end
# --- PvP reputation (assault mark + kill) ---------------------------------
def self._mp_pvp_rep_arena?
return true if respond_to?(:arena_active_runtime?) && arena_active_runtime?
begin
return true if defined?(MP_ArenaFlag) && MP_ArenaFlag.respond_to?(:arena_active?) && MP_ArenaFlag.arena_active?
rescue
end
false
rescue
false
end
def self._mp_pvp_rep_mark_aggressor(attacker_id, sec=MP_PVP_REP_AGGRO_HOLD_SEC)
pid = attacker_id.to_i
return if pid <= 0
return if @my_id && pid == @my_id.to_i
@mp_pvp_rep_aggressors ||= {}
ttl = _mp_pvp_now + sec.to_f
prev = @mp_pvp_rep_aggressors[pid].to_f
@mp_pvp_rep_aggressors[pid] = ttl if ttl > prev
rescue
end
def self._mp_pvp_rep_self_defense_vs?(target_id)
pid = target_id.to_i
return false if pid <= 0
@mp_pvp_rep_aggressors ||= {}
until_t = @mp_pvp_rep_aggressors[pid].to_f
return false if until_t <= _mp_pvp_now
true
rescue
false
end
def self._mp_pvp_rep_should_penalize?(target_id)
return false if _mp_pvp_rep_arena?
return false if defined?(MPSafeZone) && MPSafeZone.active?
return false if _mp_pvp_rep_self_defense_vs?(target_id)
true
rescue
false
end
def self._mp_pvp_rep_local_dead?(actor=nil)
actor = _mp_pvp_local_actor if actor.nil?
return false if actor.nil?
begin
return true if actor.respond_to?(:lonaDeath?) && actor.lonaDeath?
rescue
end
begin
health = actor.respond_to?(:health) ? actor.health.to_f : nil
sta = actor.respond_to?(:sta) ? actor.sta.to_f : nil
return true if !health.nil? && health <= 0.0
return true if !sta.nil? && sta <= -100.0
rescue
end
false
rescue
false
end
def self._mp_pvp_rep_apply_assault!(target_id)
return false unless _mp_pvp_rep_should_penalize?(target_id)
actor = _mp_pvp_local_actor
return false if actor.nil? || !actor.respond_to?(:add_state)
begin
actor.add_state(MP_PVP_REP_ASSAULT_STATE)
rescue
return false
end
begin
actor.recalculate_stats if actor.respond_to?(:recalculate_stats)
rescue
end
true
rescue
false
end
def self._mp_pvp_rep_kill_cooldown_ok?(victim_id)
vid = victim_id.to_i
return false if vid <= 0
@mp_pvp_rep_kill_applied ||= {}
now = _mp_pvp_now
return false if @mp_pvp_rep_kill_applied[vid].to_f > now
@mp_pvp_rep_kill_applied[vid] = now + MP_PVP_REP_KILL_COOLDOWN_SEC.to_f
true
rescue
false
end
def self._mp_pvp_rep_apply_kill!(victim_id)
return false unless _mp_pvp_rep_should_penalize?(victim_id)
return false unless _mp_pvp_rep_kill_cooldown_ok?(victim_id)
amount = MP_PVP_REP_KILL_AMOUNT.to_i
amount = -1 if amount == 0
begin
if $game_map && $game_map.respond_to?(:interpreter) &&
$game_map.interpreter && $game_map.interpreter.respond_to?(:optain_morality)
$game_map.interpreter.optain_morality(amount)
return true
end
rescue
end
actor = _mp_pvp_local_actor
return false if actor.nil? || !actor.respond_to?(:morality_lona=)
begin
actor.morality_lona = actor.morality_lona.to_i + amount
rescue
return false
end
begin
actor.recalculate_stats if actor.respond_to?(:recalculate_stats)
rescue
end
begin
if $game_map && $game_map.respond_to?(:popup)
sym = amount > 0 ? "+" : ""
spd = amount > 0 ? 1 : -1
label = ($game_text && $game_text["menu:equip/mori"]) || "REP"
$game_map.popup(0, "#{label}#{sym}#{amount}", 0, spd)
end
rescue
end
true
rescue
false
end
def self._mp_pvp_rep_on_outgoing_hostile_hit(target_id)
tid = target_id.to_i
return if tid <= 0
return if @my_id && tid == @my_id.to_i
_mp_pvp_rep_apply_assault!(tid)
rescue
end
def self._mp_pvp_rep_report_kill_credit(killer_id)
kid = killer_id.to_i
return if kid <= 0
return if @my_id && kid == @my_id.to_i
return if _mp_pvp_rep_arena?
return if defined?(MPSafeZone) && MPSafeZone.active?
now = _mp_pvp_now
@mp_pvp_rep_kill_report_until = 0.0 if @mp_pvp_rep_kill_report_until.nil?
return if @mp_pvp_rep_kill_report_until.to_f > now
@mp_pvp_rep_kill_report_until = now + MP_PVP_REP_KILL_COOLDOWN_SEC.to_f
payload = { "killer" => kid }
begin
if respond_to?(:send_deistvia)
send_deistvia("pvp_kill_credit", "hit", payload)
else
packed = respond_to?(:_deistvia_pack) ? _deistvia_pack(payload) : "killer=#{kid}"
send_line("deistvia:" + esc("pvp_kill_credit") + ":" + esc("hit") + ":" + esc(packed))
end
rescue
end
rescue
end
def self._mp_pvp_rep_after_incoming_damage(attacker_id, was_dead)
aid = attacker_id.to_i
return if aid <= 0
_mp_pvp_rep_mark_aggressor(aid)
return if was_dead
return unless _mp_pvp_rep_local_dead?
_mp_pvp_rep_report_kill_credit(aid)
rescue
end
def self._mp_pvp_local_actor
if self.respond_to?(:_pvp_get_actor)
begin
actor = _pvp_get_actor
return actor unless actor.nil?
rescue
end
end
begin
return _mp_local_actor if self.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_pvp_target_id_from_char(ch)
return 0 if ch.nil?
begin
if ch.instance_variable_defined?(:@net_player_id)
pid = ch.instance_variable_get(:@net_player_id).to_i
return pid if pid > 0
end
rescue
end
0
end
def self._mp_pvp_front_tile_target
tx = nil
ty = nil
begin
if self.respond_to?(:_pvp_front_tile)
fx, fy, _fd = _pvp_front_tile
tx = fx.to_i
ty = fy.to_i
end
rescue
tx = nil
ty = nil
end
if tx.nil? || ty.nil?
begin
tx = $game_player.x.to_i
ty = $game_player.y.to_i
case $game_player.direction.to_i
when 2 then ty += 1
when 4 then tx -= 1
when 6 then tx += 1
when 8 then ty -= 1
end
rescue
tx = 0
ty = 0
end
end
pid = nil
begin
pid = _pvp_find_player_at(tx, ty) if self.respond_to?(:_pvp_find_player_at)
rescue
pid = nil
end
if pid.nil? && @players
begin
@players.each do |id, pl|
next if pl.nil?
next unless pl.respond_to?(:x) && pl.respond_to?(:y)
if pl.x.to_i == tx.to_i && pl.y.to_i == ty.to_i
pid = id.to_i
break
end
end
rescue
pid = nil
end
end
return nil if pid.nil? || pid.to_i <= 0
[pid.to_i, tx.to_i, ty.to_i]
end
def self._mp_pvp_basic_normal_skill?(skill)
return false if skill.nil?
begin
if defined?($data_arpgskills) && $data_arpgskills
return true if $data_arpgskills["BasicNormal"] == skill
end
rescue
end
begin
return true if skill.respond_to?(:name) && skill.name.to_s == "BasicNormal"
rescue
end
false
end
def self._mp_pvp_skill_is_support?(skill)
return false if skill.nil?
begin
return true if skill.respond_to?(:is_support) && skill.is_support
rescue
end
# Name / summon fallbacks: some hold-release paths lose is_support, and the
# safe-zone early-out must still allow Исцеление души / banners / shields.
return true if _mp_pvp_support_heal_skill?(skill)
return true if _mp_pvp_support_banner_skill?(skill)
return true if _mp_pvp_support_shield_skill?(skill)
false
end
def self._mp_pvp_support_heal_skill?(skill)
n = _mp_pvp_skill_name(skill)
return true if MP_PVP_SUPPORT_HEAL_SKILLS.include?(n)
begin
return true if skill.respond_to?(:summon_hit) && skill.summon_hit.to_s == "EffectLifeBuffHit"
rescue
end
false
end
def self._mp_pvp_support_banner_skill?(skill)
n = _mp_pvp_skill_name(skill)
return true if MP_PVP_SUPPORT_BANNER_SKILLS.include?(n)
begin
su = skill.summon_user.to_s if skill.respond_to?(:summon_user)
return true if !su.nil? && !su.empty? && su.include?("BattleStandard")
rescue
end
false
end
def self._mp_pvp_support_shield_skill?(skill)
n = _mp_pvp_skill_name(skill)
return true if MP_PVP_SUPPORT_SHIELD_SKILLS.include?(n)
begin
sh = skill.summon_hit.to_s if skill.respond_to?(:summon_hit)
return true if !sh.nil? && !sh.empty? && (sh.include?("SaintShield") || sh.include?("ProtectShield"))
rescue
end
false
end
def self._mp_pvp_payload_support?(payload_hash)
return false if payload_hash.nil? || !payload_hash.is_a?(Hash)
return true if payload_hash["sup"].to_s == "1"
return true if payload_hash["heal"].to_s == "1"
sn = payload_hash["skill_name"].to_s
sn = payload_hash["skill"].to_s if sn.empty?
return false if sn.empty?
return true if MP_PVP_SUPPORT_HEAL_SKILLS.include?(sn)
return true if sn.include?("NunHeal")
return true if MP_PVP_SUPPORT_BANNER_SKILLS.include?(sn)
return true if MP_PVP_SUPPORT_SHIELD_SKILLS.include?(sn)
false
end
# Зеркало efx_skill_BasicNunHeal: ChannelSpdBuff по constitution кастера
def self._mp_pvp_channel_spd_buff_state(attacker_actor)
con = 0
begin
if attacker_actor && attacker_actor.respond_to?(:battle_stat) && attacker_actor.battle_stat
con = attacker_actor.battle_stat.get_stat("constitution").to_i
end
rescue
con = 0
end
if con >= 50
"ChannelSpdBuff10"
elsif con >= 35
"ChannelSpdBuff8"
elsif con >= 10
"ChannelSpdBuff6"
else
"ChannelSpdBuff4"
end
rescue
"ChannelSpdBuff4"
end
# Прокси кастера для remote summon (знамя/щит).
# У NetPlayer нет @npc, а сток-эффекты зовут user.npc.friendly? — краш.
class MpSupportSummonProxy
attr_reader :summon_data
def initialize(real_user)
@real = real_user
@summon_data = { :user => real_user }
@actor = nil
begin
@actor = real_user.actor if real_user && real_user.respond_to?(:actor)
rescue
@actor = nil
end
if @actor.nil? && real_user
begin
@actor = real_user.instance_variable_get(:@net_actor)
rescue
@actor = nil
end
end
if @actor.nil?
@actor = MpSupportSummonStubActor.new
end
end
def actor
@actor
end
# Сток-эффекты (EffectAoeChannelSpdBuff и т.п.) используют .npc, не .actor
def npc
@actor
end
def npc?
!@actor.nil?
end
def direction
begin
return @real.direction.to_i if @real && @real.respond_to?(:direction)
rescue
end
2
end
def x
begin
return @real.x if @real && @real.respond_to?(:x)
rescue
end
0
end
def y
begin
return @real.y if @real && @real.respond_to?(:y)
rescue
end
0
end
def method_missing(name, *args, &block)
return nil if @real.nil?
@real.send(name, *args, &block)
rescue
nil
end
def respond_to_missing?(name, include_private=false)
return false if @real.nil?
@real.respond_to?(name, include_private)
rescue
false
end
end
# Минимальный stub, если @net_actor ещё не приехал
class MpSupportSummonStubActor
def friendly?(_character=nil)
false
end
def fraction
0
end
def battle_stat
self
end
def get_stat(_key_name, _stat_type=nil)
0
end
def action_state
:none
end
def method_missing(name, *args)
return false if name.to_s.end_with?("?")
return nil if name.to_s.end_with?("=")
nil
end
def respond_to_missing?(_name, _include_private=false)
true
end
end
def self._mp_pvp_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_pvp_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_pvp_char_actor(ch)
return nil if ch.nil?
begin
return ch.actor if ch.respond_to?(:actor)
rescue
end
nil
rescue
nil
end
def self._mp_pvp_stat_number(actor, key)
return 0 if actor.nil? || key.nil?
k = key.to_s
begin
return actor.send(k).to_f if actor.respond_to?(k)
rescue
end
begin
h = actor.stat if actor.respond_to?(:stat)
if h.is_a?(Hash)
return h[k].to_f if h.has_key?(k) && !h[k].nil?
sym = k.to_sym
return h[sym].to_f if h.has_key?(sym) && !h[sym].nil?
end
rescue
end
begin
h = actor.portrait_stat_value if actor.respond_to?(:portrait_stat_value)
if h.is_a?(Hash)
return h[k].to_f if h.has_key?(k) && !h[k].nil?
sym = k.to_sym
return h[sym].to_f if h.has_key?(sym) && !h[sym].nil?
end
rescue
end
0
rescue
0
end
def self._mp_pvp_current_stat(actor, attr, attr_type=nil)
return 0 if actor.nil? || attr.nil?
begin
if actor.respond_to?(:battle_stat) && actor.battle_stat
return actor.battle_stat.get_stat(attr, attr_type).to_f
end
rescue
end
_mp_pvp_stat_number(actor, attr)
rescue
0
end
def self._mp_pvp_calc_adjust(value, effect)
v = value.to_f
begin
case effect.type
when "+"
v += effect.adjust.to_f
when "-"
v -= effect.adjust.to_f
when "*"
v *= effect.adjust.to_f
when "/"
adj = effect.adjust.to_f
v /= adj unless adj == 0.0
end
rescue
end
v
rescue
value.to_f
end
def self._mp_pvp_affected_attr(actor, effect)
return 0 if effect.nil?
begin
return actor.get_affected_attr(effect).to_f if actor && actor.respond_to?(:get_affected_attr)
rescue
end
base = _mp_pvp_current_stat(actor, effect.attr, effect.attr_type)
_mp_pvp_calc_adjust(base, effect)
rescue
0
end
def self._mp_pvp_damage_delta_for_effect(target_actor, eff, result)
return ["", 0] if eff.nil? || eff.damage.nil?
attr = eff.damage.attr.to_s
cur = _mp_pvp_current_stat(target_actor, eff.damage.attr, eff.damage.attr_type)
nxt = cur
amount = result.to_f
begin
case eff.damage.type
when "+"
nxt = cur + amount
when "-"
nxt = cur - amount
when "*"
nxt = cur * amount
when "/"
nxt = amount == 0.0 ? cur : cur / amount
end
rescue
nxt = cur
end
[attr, (cur - nxt).round]
rescue
["", 0]
end
def self._mp_pvp_decrease_damage_result(skill, result, hit_index)
out = result.to_i
begin
return out unless skill && skill.respond_to?(:hit_DecreaseDamage) && skill.hit_DecreaseDamage
idx = hit_index.to_i
return out if idx < 2
out = [out / idx, 1].max.to_i
rescue
end
out
rescue
result.to_i
end
def self._mp_pvp_backstab?(skill, attacker_token, target_token)
return false if skill.nil? || attacker_token.nil? || target_token.nil?
return false unless skill.respond_to?(:back_stab) && skill.back_stab
begin
return false unless attacker_token.respond_to?(:near_the_target?) && attacker_token.near_the_target?(target_token, 2)
return false unless attacker_token.respond_to?(:direction) && target_token.respond_to?(:direction)
return attacker_token.direction.to_i == target_token.direction.to_i
rescue
end
false
rescue
false
end
def self._mp_pvp_skill_result_payload(skill, target_char=nil, attacker_actor=nil, attacker_token=nil, force_hit=false, hit_index=1)
attacker_actor = _mp_pvp_local_actor if attacker_actor.nil?
attacker_token = $game_player if attacker_token.nil?
target_actor = _mp_pvp_char_actor(target_char)
hp_delta = 0
sta_delta = 0
raw_total = 0
return { "hp" => 0, "sta" => 0, "dmg" => 1 } if skill.nil?
effects = nil
begin
effects = skill.effect
rescue
effects = nil
end
effects = [] unless effects && effects.respond_to?(:each)
effects.each do |eff|
begin
if target_actor && target_actor.respond_to?(:race)
race = target_actor.race
next if eff.race_only && !eff.race_only.include?(race)
next if eff.race_skip && eff.race_skip.include?(race)
end
rescue
end
skill_effect = _mp_pvp_affected_attr(attacker_actor, eff.base)
receive_eff = _mp_pvp_affected_attr(target_actor, eff.compare)
mine_value = 1.0
ratio = 1.0
unless force_hit
begin
if skill.respond_to?(:hit_detection) && skill.hit_detection && attacker_token && target_char
mv = skill.hit_detection.mine_number(attacker_token, target_char, false)
mine_value = mv.nil? ? 1.0 : mv.to_f
sight_hp = skill.hit_detection.sight_hp.to_f
sight_hp = 1.0 if sight_hp <= 0.0
line = 1.0
begin
line = 1.0 - ($game_map.terrain_tag(target_char.x, target_char.y).to_f * 0.25)
line = 0.0 if line < 0.0
line = 1.0 if skill.respond_to?(:is_support) && skill.is_support && line > 0.0
rescue
line = 1.0
end
ratio = (10.0 * line) / sight_hp
end
rescue
mine_value = 1.0
ratio = 1.0
end
end
result = ((skill_effect - receive_eff) * ratio * mine_value).to_i
result = 1 if result < 1
begin
result = (result * skill.back_stab.to_f).to_i if _mp_pvp_backstab?(skill, attacker_token, target_char)
rescue
end
result = _mp_pvp_decrease_damage_result(skill, result, hit_index)
attr, delta = _mp_pvp_damage_delta_for_effect(target_actor, eff, result)
raw_total += delta.abs
case attr
when "health"
hp_delta += delta
when "sta"
sta_delta += delta
end
end
fallback = raw_total.to_i
fallback = 1 if fallback < 1
{ "hp" => hp_delta.to_i, "sta" => sta_delta.to_i, "dmg" => fallback }
rescue
{ "hp" => 0, "sta" => 0, "dmg" => 1 }
end
def self._mp_pvp_roll_states(skill)
out = []
begin
arr = skill.add_state if skill && skill.respond_to?(:add_state)
return out unless arr && arr.respond_to?(:each)
arr.each do |state|
next if state.nil?
chance = 0
begin
chance = state.chance.to_i
rescue
chance = 0
end
next if rand(100) > chance
begin
states = state.states
out << states.sample.to_s if states && states.respond_to?(:sample)
rescue
end
end
rescue
end
out.compact.reject { |x| x.nil? || x.empty? }
rescue
[]
end
def self._mp_pvp_skill_damage(skill)
payload = _mp_pvp_skill_result_payload(skill, nil, _mp_pvp_local_actor, $game_player, true)
dmg = payload["dmg"].to_i
dmg = 1 if dmg < 1
dmg
end
def self._mp_pvp_skill_sender_ready?
return false unless @connected
return false unless @worldsync
return false if @my_id.nil?
true
end
def self._mp_pvp_append_player_target(out, seen, pid, tx, ty, ch=nil)
id = pid.to_i
return if id <= 0 || seen[id]
begin
ch = @players[id] if ch.nil? && @players
rescue
ch = nil
end
out << [id, tx.to_i, ty.to_i, ch]
seen[id] = true
rescue
end
# Safe-zone through lets players overlap; heal must still find them on the
# front tile, the caster tile, or the four adjacent cells.
def self._mp_pvp_collect_nearby_player_targets(user_bs)
out = []
seen = {}
return out if user_bs.nil? || @players.nil? || @players.empty?
ux = 0
uy = 0
begin
token = user_bs.respond_to?(:map_token) ? user_bs.map_token : $game_player
ux = token.x.to_i
uy = token.y.to_i
rescue
return out
end
spots = [[ux, uy]]
begin
ft = _mp_pvp_front_tile_target
spots << [ft[1].to_i, ft[2].to_i] unless ft.nil?
rescue
end
spots.concat([[ux, uy + 1], [ux, uy - 1], [ux - 1, uy], [ux + 1, uy]])
@players.each do |pid, pl|
next if pl.nil?
begin
px = pl.x.to_i
py = pl.y.to_i
rescue
next
end
next unless spots.any? { |s| s[0] == px && s[1] == py }
_mp_pvp_append_player_target(out, seen, pid, px, py, pl)
end
out
rescue
[]
end
# Stock Sensors#scan only walks $game_map.all_characters (NPCs + local player).
# NetPlayers are never in that list, so SnipeMissile / Missile / Piercing etc.
# never see other players. Probe @players with the same hit_detection.
def self._mp_pvp_player_in_facing_range?(skill, token, pl)
return false if skill.nil? || token.nil? || pl.nil?
range = 1
begin
range = skill.range.to_i
rescue
range = 1
end
range = 1 if range < 1
# Holding snipes (LongBowControl) use launch_max as effective aim length
begin
if skill.respond_to?(:launch_max) && skill.launch_max.to_i > range
range = skill.range.to_i
range = 8 if range < 1
end
rescue
end
dx = 0
dy = 0
begin
dx = pl.x.to_i - token.x.to_i
dy = pl.y.to_i - token.y.to_i
rescue
return false
end
dist = dx.abs + dy.abs
return false if dist < 1 || dist > range
dir = 2
begin
dir = token.direction.to_i
rescue
dir = 2
end
# Narrow forward cone (matches SnipeMissile / Missile column)
case dir
when 2 then dy > 0 && dx.abs <= 1
when 4 then dx < 0 && dy.abs <= 1
when 6 then dx > 0 && dy.abs <= 1
when 8 then dy < 0 && dx.abs <= 1
else
false
end
rescue
false
end
def self._mp_pvp_collect_players_via_hit_detection(skill, user_bs)
out = []
seen = {}
return out if skill.nil? || user_bs.nil?
return out unless @players.is_a?(Hash) && !@players.empty?
token = nil
begin
token = user_bs.map_token if user_bs.respond_to?(:map_token)
rescue
token = nil
end
token = $game_player if token.nil?
hd = nil
begin
hd = skill.hit_detection if skill.respond_to?(:hit_detection)
rescue
hd = nil
end
@players.each do |pid, pl|
next if pl.nil?
pid_i = pid.to_i
next if pid_i <= 0 || seen[pid_i]
hit = false
begin
if hd
sig = hd.get_signal(token, pl)
hit = !(sig.nil? || sig == 0)
end
rescue
hit = false
end
unless hit
begin
hit = _mp_pvp_player_in_facing_range?(skill, token, pl)
rescue
hit = false
end
end
next unless hit
tx = 0
ty = 0
begin
tx = pl.x.to_i
ty = pl.y.to_i
rescue
next
end
_mp_pvp_append_player_target(out, seen, pid_i, tx, ty, pl)
end
out
rescue
[]
end
def self._mp_pvp_collect_skill_targets(skill, user_bs)
out = []
seen = {}
return out if skill.nil?
return out if user_bs.nil?
# Support heals: prefer positional player lookup first. Remote players are
# not always sensor-visible (no @npc), and safe-zone through can overlap.
if _mp_pvp_support_heal_skill?(skill)
begin
ft = _mp_pvp_front_tile_target
unless ft.nil?
_mp_pvp_append_player_target(out, seen, ft[0], ft[1], ft[2])
end
rescue
end
if out.empty?
_mp_pvp_collect_nearby_player_targets(user_bs).each do |row|
_mp_pvp_append_player_target(out, seen, row[0], row[1], row[2], row[3])
end
end
return out unless out.empty?
end
begin
if skill.respond_to?(:hit_detection) && skill.hit_detection && user_bs.respond_to?(:map_token)
targets = skill.hit_detection.scan(user_bs.map_token)
if targets && targets.respond_to?(:each)
targets.each do |entry|
ch = entry.is_a?(Array) ? entry[0] : entry
pid = _mp_pvp_target_id_from_char(ch)
next if pid <= 0 || seen[pid]
tx = 0
ty = 0
begin
tx = ch.x.to_i unless ch.nil?
rescue
tx = 0
end
begin
ty = ch.y.to_i unless ch.nil?
rescue
ty = 0
end
_mp_pvp_append_player_target(out, seen, pid, tx, ty, ch)
end
end
end
rescue
end
# Always merge NetPlayers via hit_detection / facing range (scan misses them).
begin
_mp_pvp_collect_players_via_hit_detection(skill, user_bs).each do |row|
_mp_pvp_append_player_target(out, seen, row[0], row[1], row[2], row[3])
end
rescue
end
if out.empty?
begin
if skill.respond_to?(:is_projectile?) && skill.is_projectile? && user_bs.respond_to?(:map_token) && user_bs.map_token
fake = user_bs.map_token.get_fake_target
pid = _mp_pvp_target_id_from_char(fake)
if pid > 0 && !seen[pid]
tx = 0
ty = 0
begin
tx = fake.x.to_i unless fake.nil?
rescue
tx = 0
end
begin
ty = fake.y.to_i unless fake.nil?
rescue
ty = 0
end
_mp_pvp_append_player_target(out, seen, pid, tx, ty, fake)
end
end
rescue
end
end
if out.empty?
begin
ft = _mp_pvp_front_tile_target
unless ft.nil?
_mp_pvp_append_player_target(out, seen, ft[0], ft[1], ft[2])
end
rescue
end
end
out
end
def self._mp_pvp_send_skill_hit(skill, target_id, tx, ty, target_char=nil, user_bs=nil, force_hit=false, hit_index=1)
return unless _mp_pvp_skill_sender_ready?
return if skill.nil?
skill_name = _mp_pvp_skill_name(skill)
skill_id = 0
begin
skill_id = skill.id.to_i
rescue
skill_id = 0
end
return if (skill_name.nil? || skill_name.empty?) && skill_id <= 0
tid = target_id.to_i
return if tid <= 0
frame = 0
begin
frame = Graphics.frame_count.to_i
rescue
frame = 0
end
@mp_pvp_skill_send_guard ||= {}
key = (skill_name.nil? || skill_name.empty? ? skill_id.to_s : skill_name.to_s) + ":" + tid.to_s
last = @mp_pvp_skill_send_guard[key]
if !last.nil? && (frame - last.to_i) < MP_PVP_SKILL_SEND_GAP_FRAMES
return
end
@mp_pvp_skill_send_guard[key] = frame
attacker_actor = nil
attacker_token = nil
begin
attacker_actor = user_bs.nil? ? _mp_pvp_local_actor : user_bs
attacker_token = user_bs && user_bs.respond_to?(:map_token) ? user_bs.map_token : $game_player
rescue
attacker_actor = _mp_pvp_local_actor
attacker_token = $game_player
end
# Support heals use the damage pipeline with "+" adjustors; force_hit keeps
# the payload stable when the remote token is not sensor-perfect.
is_sup = _mp_pvp_skill_is_support?(skill)
is_heal = is_sup && _mp_pvp_support_heal_skill?(skill)
force_hit = true if is_heal
real = _mp_pvp_skill_result_payload(skill, target_char, attacker_actor, attacker_token, force_hit, hit_index)
states = _mp_pvp_roll_states(skill)
# Доп. бафф скорости канала с Исцеления души
if is_heal
buff = _mp_pvp_channel_spd_buff_state(attacker_actor)
states << buff if !buff.nil? && !buff.empty? && !states.include?(buff)
end
hp_i = real["hp"].to_i
sta_i = real["sta"].to_i
# Receiver does health -= hp. Heal packets must carry negative deltas.
# Positive values here would damage the target before any "heal" UI runs.
if is_heal
hp_i = -hp_i.abs if hp_i > 0
sta_i = -sta_i.abs if sta_i > 0
end
# Пустой support-хит не шлём (иначе fallback dmg=1 на приёме)
if is_sup && hp_i == 0 && sta_i == 0 && states.empty?
return
end
payload = {
"target" => tid,
"skill" => skill_id,
"skill_name" => skill_name.to_s,
"dmg" => real["dmg"].to_i,
"hp" => hp_i,
"sta" => sta_i,
"tx" => tx.to_i,
"ty" => ty.to_i
}
payload["sup"] = 1 if is_sup
payload["states"] = states.join(";") unless states.empty?
_mp_pvp_mark_local_combat unless is_sup
begin
if self.respond_to?(:send_deistvia)
send_deistvia("pvp_skill_hit", "hit", 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("pvp_skill_hit") + ":" + esc("hit") + ":" + esc(packed))
end
rescue
end
# Hostile PvP hit → temporary reputation mark (NPC-style MoralityDown30).
begin
if !is_sup && !is_heal && (hp_i > 0 || sta_i > 0)
_mp_pvp_rep_on_outgoing_hostile_hit(tid)
end
rescue
end
end
# Оберег святых / ControlProtectShield — summon_hit на клиенте цели
def self._mp_pvp_send_support_summon(user_bs, skill)
return unless _mp_pvp_skill_sender_ready?
return if skill.nil?
ft = nil
begin
ft = _mp_pvp_front_tile_target
rescue
ft = nil
end
return if ft.nil?
tid = ft[0].to_i
return if tid <= 0
begin
return if @my_id && tid == @my_id.to_i
rescue
end
summon = ""
begin
summon = skill.summon_hit.to_s if skill.respond_to?(:summon_hit)
rescue
summon = ""
end
# Реликвия ControlProtectShield: если summon_hit не прогрузился — как у Basic
if (summon.nil? || summon.empty?) && _mp_pvp_support_shield_skill?(skill)
summon = "ProjPlayerSaintShield"
end
return if summon.nil? || summon.empty?
skill_name = _mp_pvp_skill_name(skill)
payload = {
"target" => tid,
"skill" => skill_name.to_s,
"summon" => summon.to_s,
"tx" => ft[1].to_i,
"ty" => ft[2].to_i,
"sup" => 1
}
begin
if self.respond_to?(:send_deistvia)
send_deistvia("pvp_support_summon", "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("pvp_support_summon") + ":" + esc("play") + ":" + esc(packed))
end
rescue
end
end
def self._mp_pvp_apply_support_summon(caster_id, payload_hash)
return false if payload_hash.nil?
begin
return false unless defined?(SceneManager) && SceneManager.scene_is?(Scene_Map)
rescue
return false
end
return false if $game_map.nil? || !$game_map.respond_to?(:summon_skill)
summon = payload_hash["summon"].to_s
return false if summon.empty?
skill_name = payload_hash["skill"].to_s
skill_name = payload_hash["skill_name"].to_s if skill_name.empty?
skill = _mp_pvp_arpg_skill(skill_name)
actor = _mp_pvp_local_actor
begin
return false if actor && actor.respond_to?(:with_ShieldEV?) && actor.with_ShieldEV?
rescue
end
caster = nil
begin
caster = @players[caster_id.to_i] if @players
rescue
caster = nil
end
return false if caster.nil?
proxy = MpSupportSummonProxy.new(caster)
data = { :user => proxy, :target => $game_player, :skill => skill }
begin
$game_map.summon_skill(summon, data)
rescue
return false
end
true
rescue
false
end
def self._mp_pvp_send_hits_from_skill_result(user_bs, skill)
return unless _mp_pvp_skill_sender_ready?
return if skill.nil?
return if _mp_pvp_basic_normal_skill?(skill)
support = _mp_pvp_skill_is_support?(skill)
sz = (defined?(MPSafeZone) && MPSafeZone.active?)
if sz && !support
return
end
# Щит: отдельный attach-пакет на front-tile игрока
if support && _mp_pvp_support_shield_skill?(skill)
_mp_pvp_send_support_summon(user_bs, skill)
return
end
# Знамя: только visual через arpg_skill_cast (90_hooks)
if support && _mp_pvp_support_banner_skill?(skill)
return
end
begin
return if skill.respond_to?(:blocking?) && skill.blocking?
rescue
end
# Снаряды по-прежнему не через pvp_skill_hit; support-heal не projectile
begin
return if !support && skill.respond_to?(:is_projectile?) && skill.is_projectile?
rescue
end
# Support без heal-эффектов не шлём как hit
if support && !_mp_pvp_support_heal_skill?(skill)
return
end
# Cast skills with empty effect[] (BasicThrow / LongBowHeavy / MusketHeavy /
# LongBowNormal) deal damage only when the summoned missile lands. Do not
# send a fake 1-dmg cast hit; projectile impact path handles NetPlayers.
begin
if !support && !_mp_pvp_support_heal_skill?(skill) &&
respond_to?(:_mp_pvp_skill_has_damage_effect?) &&
!_mp_pvp_skill_has_damage_effect?(skill)
return
end
rescue
end
targets = _mp_pvp_collect_skill_targets(skill, user_bs)
if targets.nil? || targets.empty?
return
end
targets.each_with_index do |row, idx|
next if row.nil? || row.length < 3
if _mp_pvp_support_heal_skill?(skill)
# HP/STA heal must use pvp_skill_hit (negative deltas). EffectLifeBuffHit
# only applies ChannelSpdBuff/wounds — it does not restore health.
_mp_pvp_send_heal_hit(skill, row[0], row[1], row[2], row[3], user_bs, idx.to_i + 1)
else
# force_hit: NetPlayers are not in stock sensor lists; mine_number/line
# checks are unreliable against @net_actor tokens.
_mp_pvp_send_skill_hit(skill, row[0], row[1], row[2], row[3], user_bs, true, idx.to_i + 1)
end
end
end
# Positive heal amounts only. Receiver always ADDS these — never subtracts.
def self._mp_pvp_send_heal_hit(skill, target_id, tx, ty, target_char=nil, user_bs=nil, hit_index=1)
return unless _mp_pvp_skill_sender_ready?
return if skill.nil?
tid = target_id.to_i
return if tid <= 0
skill_name = _mp_pvp_skill_name(skill)
skill_name = "BasicNunHeal" if skill_name.nil? || skill_name.empty?
frame = 0
begin
frame = Graphics.frame_count.to_i
rescue
frame = 0
end
@mp_pvp_skill_send_guard ||= {}
key = "heal:" + skill_name.to_s + ":" + tid.to_s
last = @mp_pvp_skill_send_guard[key]
if !last.nil? && (frame - last.to_i) < MP_PVP_SKILL_SEND_GAP_FRAMES
return
end
@mp_pvp_skill_send_guard[key] = frame
attacker_actor = nil
attacker_token = nil
begin
attacker_actor = user_bs.nil? ? _mp_pvp_local_actor : user_bs
attacker_token = user_bs && user_bs.respond_to?(:map_token) ? user_bs.map_token : $game_player
rescue
attacker_actor = _mp_pvp_local_actor
attacker_token = $game_player
end
real = _mp_pvp_skill_result_payload(skill, target_char, attacker_actor, attacker_token, true, hit_index)
# Payload deltas for "+" heals are negative (health -= delta). Convert to
# positive restore amounts for the dedicated heal channel.
hp_heal = real["hp"].to_i.abs
sta_heal = real["sta"].to_i.abs
if hp_heal <= 0 && sta_heal <= 0
begin
con = _mp_pvp_stat_number(attacker_actor, "constitution").to_f
con = 10.0 if con <= 0.0
sta_heal = [(con * 0.7) - (-10.0), 1.0].max.round
hp_heal = [(con * 0.5), 1.0].max.round
rescue
hp_heal = 1
sta_heal = 1
end
end
states = _mp_pvp_roll_states(skill)
buff = _mp_pvp_channel_spd_buff_state(attacker_actor)
states << buff if !buff.nil? && !buff.empty? && !states.include?(buff)
# Stock receivers do: health -= hp. Negative hp/sta => heal.
# heal=1 / sup=1 also mark the packet for UX safe-zone allow-lists.
payload = {
"target" => tid,
"skill" => 0,
"skill_name" => skill_name.to_s,
"dmg" => 0,
"hp" => -hp_heal.to_i.abs,
"sta" => -sta_heal.to_i.abs,
"tx" => tx.to_i,
"ty" => ty.to_i,
"sup" => 1,
"heal" => 1
}
payload["states"] = states.join(";") unless states.empty?
begin
if self.respond_to?(:send_deistvia)
send_deistvia("pvp_skill_hit", "hit", 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("pvp_skill_hit") + ":" + esc("hit") + ":" + esc(packed))
end
rescue
end
end
def self._mp_pvp_apply_heal_payload(attacker_id, payload_hash)
actor = _mp_pvp_local_actor
return false if actor.nil?
begin
race = actor.race.to_s if actor.respond_to?(:race)
sn = payload_hash["skill_name"].to_s
sn = payload_hash["skill"].to_s if sn.empty?
if race == "Undead" && (sn.empty? || sn == "BasicNunHeal" || MP_PVP_SUPPORT_HEAL_SKILLS.include?(sn))
return true
end
rescue
end
hp_heal = payload_hash.has_key?("hp") ? payload_hash["hp"].to_i.abs : 0
sta_heal = payload_hash.has_key?("sta") ? payload_hash["sta"].to_i.abs : 0
return false if hp_heal <= 0 && sta_heal <= 0 && payload_hash["states"].to_s.empty?
old_health = nil
old_sta = nil
begin
old_health = actor.health.to_f if actor.respond_to?(:health)
rescue
end
begin
old_sta = actor.sta.to_f if actor.respond_to?(:sta)
rescue
end
begin
if hp_heal > 0 && actor.respond_to?(:health) && actor.respond_to?(:health=)
actor.health = actor.health.to_f + hp_heal.to_f
end
rescue
end
begin
if sta_heal > 0 && actor.respond_to?(:sta) && actor.respond_to?(:sta=)
actor.sta = actor.sta.to_f + sta_heal.to_f
end
rescue
end
_mp_pvp_apply_state_names(actor, payload_hash["states"])
begin
if actor.respond_to?(:actor_ForceUpdate)
actor.actor_ForceUpdate
else
actor.update_state_frames if actor.respond_to?(:update_state_frames)
$game_player.update rescue nil
end
rescue
end
shown_hp = hp_heal
shown_sta = sta_heal
begin
shown_hp = (actor.health.to_f - old_health.to_f).round if old_health && actor.respond_to?(:health)
rescue
end
begin
shown_sta = (actor.sta.to_f - old_sta.to_f).round if old_sta && actor.respond_to?(:sta)
rescue
end
shown_hp = 0 if shown_hp < 0
shown_sta = 0 if shown_sta < 0
_mp_pvp_show_heal_popups(attacker_id.to_i, shown_hp, shown_sta)
true
rescue
false
end
def self._mp_pvp_send_object_skill_hit(ev, target_id, target_char=nil)
return false unless _mp_pvp_skill_sender_ready?
return false if ev.nil?
return false if defined?(MPSafeZone) && MPSafeZone.active?
skill = nil
begin
skill = player_object_combat_skill(ev) if respond_to?(:player_object_combat_skill)
rescue
skill = nil
end
if skill.nil?
begin
summon = ev.summon_data if ev.respond_to?(:summon_data)
if summon.is_a?(Hash)
skill = summon[:skill]
skill = summon["skill"] if skill.nil?
end
rescue
skill = nil
end
end
return false if skill.nil?
tx = 0
ty = 0
begin
tx = target_char.x.to_i if target_char && target_char.respond_to?(:x)
ty = target_char.y.to_i if target_char && target_char.respond_to?(:y)
rescue
begin
tx = ev.x.to_i
rescue
tx = 0
end
begin
ty = ev.y.to_i
rescue
ty = 0
end
end
_mp_pvp_send_skill_hit(skill, target_id.to_i, tx, ty, target_char, _mp_pvp_local_actor, true)
true
rescue
false
end
def self._mp_pvp_popup_direction(attacker_id)
dir = 2
begin
if @players && @players[attacker_id.to_i] && @players[attacker_id.to_i].respond_to?(:direction)
dir = @players[attacker_id.to_i].direction.to_i
end
rescue
dir = 2
end
dir = 2 unless [2, 4, 6, 8].include?(dir)
dir
end
def self._mp_pvp_show_damage_popups(attacker_id, health_dmg, sta_dmg)
return unless defined?($game_damage_popups)
return if $game_damage_popups.nil?
x = 0
y = 0
begin
x = $game_player.x.to_i
rescue
x = 0
end
begin
y = $game_player.y.to_i
rescue
y = 0
end
dir = _mp_pvp_popup_direction(attacker_id)
hd = health_dmg.to_i
sd = sta_dmg.to_i
hd = 0 if hd < 0
sd = 0 if sd < 0
begin
$game_damage_popups.add(hd, x, y, dir, MP_PVP_POPUP_HP_TYPE) if hd > 0
rescue
end
begin
$game_damage_popups.add(sd, x, y, dir, MP_PVP_POPUP_STA_TYPE) if sd > 0
rescue
end
end
def self._mp_pvp_show_heal_popups(attacker_id, health_heal, sta_heal)
return unless defined?($game_damage_popups)
return if $game_damage_popups.nil?
x = 0
y = 0
begin
x = $game_player.x.to_i
rescue
x = 0
end
begin
y = $game_player.y.to_i
rescue
y = 0
end
dir = _mp_pvp_popup_direction(attacker_id)
hh = health_heal.to_i.abs
sh = sta_heal.to_i.abs
begin
$game_damage_popups.add(hh, x, y, dir, MP_PVP_POPUP_PLUS_HP_TYPE) if hh > 0
rescue
end
begin
$game_damage_popups.add(sh, x, y, dir, MP_PVP_POPUP_PLUS_STA_TYPE) if sh > 0
rescue
end
end
def self._mp_pvp_extract_delta(old_val, new_val)
return nil if old_val.nil? || new_val.nil?
d = old_val.to_f - new_val.to_f
d = d.round
d = 0 if d < 0
d
rescue
nil
end
def self._mp_pvp_apply_state_names(actor, states_text)
return if actor.nil?
txt = states_text.to_s
return if txt.empty?
txt.split(";").each do |state_name|
next if state_name.nil? || state_name.empty?
begin
actor.add_state(state_name) if actor.respond_to?(:add_state)
rescue
end
begin
actor.apply_stun_effect(state_name) if actor.respond_to?(:apply_stun_effect)
rescue
end
end
rescue
end
def self._mp_pvp_apply_skill_payload(attacker_id, payload_hash)
support = _mp_pvp_payload_support?(payload_hash)
return false if defined?(MPSafeZone) && MPSafeZone.active? && !support
actor = _mp_pvp_local_actor
return false if actor.nil?
# Undead не получает Исцеление души (race_skip в JSON)
if support
begin
race = actor.race.to_s if actor.respond_to?(:race)
sn = payload_hash["skill_name"].to_s
sn = payload_hash["skill"].to_s if sn.empty?
if race == "Undead" && (sn == "BasicNunHeal" || _mp_pvp_support_heal_skill?(_mp_pvp_arpg_skill(sn)))
return true
end
rescue
end
end
hp_delta = nil
sta_delta = nil
begin
hp_delta = payload_hash["hp"].to_i if payload_hash.has_key?("hp")
rescue
hp_delta = nil
end
begin
sta_delta = payload_hash["sta"].to_i if payload_hash.has_key?("sta")
rescue
sta_delta = nil
end
if hp_delta.nil? && sta_delta.nil?
skill_name = payload_hash["skill_name"].to_s
skill_name = payload_hash["skill"].to_s if skill_name.empty?
skill = _mp_pvp_arpg_skill(skill_name)
if skill
attacker_char = nil
begin
attacker_char = @players[attacker_id.to_i] if @players
rescue
attacker_char = nil
end
attacker_actor = _mp_pvp_char_actor(attacker_char)
real = _mp_pvp_skill_result_payload(skill, $game_player, attacker_actor, attacker_char, false)
hp_delta = real["hp"].to_i
sta_delta = real["sta"].to_i
end
end
hp_delta = 0 if hp_delta.nil?
sta_delta = 0 if sta_delta.nil?
if hp_delta == 0 && sta_delta == 0 && payload_hash["states"].to_s.empty?
return false
end
heal_skill = false
sn = ""
begin
sn = payload_hash["skill_name"].to_s
sn = payload_hash["skill"].to_s if sn.empty?
heal_skill = MP_PVP_SUPPORT_HEAL_SKILLS.include?(sn)
heal_skill = true if sn.include?("NunHeal") || sn.include?("LifeBuff")
rescue
heal_skill = support
end
# Legacy pvp_skill_hit heal path: always ADD abs amounts (never subtract).
if heal_skill
return _mp_pvp_apply_heal_payload(attacker_id, {
"hp" => hp_delta.to_i.abs,
"sta" => sta_delta.to_i.abs,
"states" => payload_hash["states"],
"skill_name" => sn
})
end
# Support heal must never damage: apply uses health -= delta, so heal = negative.
if support
hp_delta = -hp_delta.to_i.abs if hp_delta.to_i > 0
sta_delta = -sta_delta.to_i.abs if sta_delta.to_i > 0
end
is_heal = support || hp_delta.to_i < 0 || sta_delta.to_i < 0
old_health = nil
old_sta = nil
was_dead = false
begin
old_health = actor.health.to_f if actor.respond_to?(:health)
rescue
old_health = nil
end
begin
old_sta = actor.sta.to_f if actor.respond_to?(:sta)
rescue
old_sta = nil
end
begin
was_dead = _mp_pvp_rep_local_dead?(actor)
rescue
was_dead = false
end
begin
actor.health = actor.health.to_f - hp_delta.to_f if hp_delta != 0 && actor.respond_to?(:health) && actor.respond_to?(:health=)
rescue
end
begin
actor.sta = actor.sta.to_f - sta_delta.to_f if sta_delta != 0 && actor.respond_to?(:sta) && actor.respond_to?(:sta=)
rescue
end
_mp_pvp_apply_state_names(actor, payload_hash["states"])
begin
actor.hit_effect_mood_fix([hp_delta.to_i, 1].max) if !is_heal && hp_delta.to_i > 0 && actor.respond_to?(:hit_effect_mood_fix)
rescue
end
begin
if actor.respond_to?(:actor_ForceUpdate)
actor.actor_ForceUpdate
else
actor.update_state_frames if actor.respond_to?(:update_state_frames)
$game_player.update rescue nil
end
rescue
end
begin
actor.determine_death if !is_heal && actor.respond_to?(:determine_death)
rescue
end
unless is_heal
begin
$game_map.screen.start_shake(5, 5, 10)
$game_player.animation_id = 12
rescue
end
end
if is_heal
heal_hp = 0
heal_sta = 0
if old_health && actor.respond_to?(:health)
begin
heal_hp = (actor.health.to_f - old_health.to_f).round
rescue
heal_hp = (-hp_delta.to_i)
end
else
heal_hp = (-hp_delta.to_i)
end
if old_sta && actor.respond_to?(:sta)
begin
heal_sta = (actor.sta.to_f - old_sta.to_f).round
rescue
heal_sta = (-sta_delta.to_i)
end
else
heal_sta = (-sta_delta.to_i)
end
heal_hp = 0 if heal_hp < 0
heal_sta = 0 if heal_sta < 0
_mp_pvp_show_heal_popups(attacker_id.to_i, heal_hp, heal_sta)
else
health_dmg = hp_delta.to_i
sta_dmg = sta_delta.to_i
if old_health && actor.respond_to?(:health)
begin
health_dmg = _mp_pvp_extract_delta(old_health, actor.health.to_f).to_i
rescue
health_dmg = hp_delta.to_i
end
end
if old_sta && actor.respond_to?(:sta)
begin
sta_dmg = _mp_pvp_extract_delta(old_sta, actor.sta.to_f).to_i
rescue
sta_dmg = sta_delta.to_i
end
end
_mp_pvp_show_damage_popups(attacker_id.to_i, health_dmg, sta_dmg)
_mp_pvp_mark_local_combat
_mp_pvp_rep_after_incoming_damage(attacker_id.to_i, was_dead)
end
true
rescue
false
end
def self.handle_being_attacked(attacker_id, damage, opts=nil)
if defined?(MPSafeZone) && MPSafeZone.active?
return
end
actor = nil
old_health = nil
old_sta = nil
was_dead = false
begin
actor = _mp_pvp_local_actor
old_health = actor.health.to_f if actor && actor.respond_to?(:health)
old_sta = actor.sta.to_f if actor && actor.respond_to?(:sta)
was_dead = _mp_pvp_rep_local_dead?(actor)
rescue
actor = nil
old_health = nil
old_sta = nil
was_dead = false
end
if self.respond_to?(:_mp_pvp_old_handle_being_attacked)
_mp_pvp_old_handle_being_attacked(attacker_id, damage)
else
return
end
begin
actor = _mp_pvp_local_actor if actor.nil?
rescue
actor = nil
end
new_health = nil
new_sta = nil
begin
new_health = actor.health.to_f if actor && actor.respond_to?(:health)
new_sta = actor.sta.to_f if actor && actor.respond_to?(:sta)
rescue
new_health = nil
new_sta = nil
end
health_dmg = _mp_pvp_extract_delta(old_health, new_health)
sta_dmg = _mp_pvp_extract_delta(old_sta, new_sta)
if (health_dmg.nil? || health_dmg <= 0) && (sta_dmg.nil? || sta_dmg <= 0)
raw = damage.to_i
raw = 1 if raw < 1
health_dmg = (raw + 1) / 2
sta_dmg = raw * 2
end
_mp_pvp_show_damage_popups(attacker_id, health_dmg.to_i, sta_dmg.to_i)
_mp_pvp_mark_local_combat
_mp_pvp_rep_after_incoming_damage(attacker_id.to_i, was_dead)
end
def self.handle_remote_deistvia(player_id, action_id, phase, payload)
if action_id.to_s == "pvp_kill_credit"
return if phase.to_s == "stop"
payload_hash = {}
begin
payload_hash = _deistvia_unpack(payload.to_s)
rescue
payload_hash = {}
end
killer_id = (payload_hash["killer"] || payload_hash["killer_id"] || payload_hash["atk"]).to_i
return if @my_id.nil?
return if killer_id <= 0
return if killer_id != @my_id.to_i
# Victim (player_id) credits us as killer → permanent reputation loss.
begin
_mp_pvp_rep_apply_kill!(player_id.to_i)
rescue
end
return
end
if action_id.to_s == "pvp_support_summon"
return if phase.to_s == "stop"
payload_hash = {}
begin
payload_hash = _deistvia_unpack(payload.to_s)
rescue
payload_hash = {}
end
target_id = (payload_hash["target"] || payload_hash["tgt"] || payload_hash["target_id"]).to_i
return if @my_id.nil?
return if target_id <= 0
return if target_id != @my_id.to_i
begin
_mp_pvp_apply_support_summon(player_id.to_i, payload_hash)
rescue
end
return
end
if action_id.to_s == "pvp_skill_hit"
return if phase.to_s == "stop"
payload_hash = {}
begin
payload_hash = _deistvia_unpack(payload.to_s)
rescue
payload_hash = {}
end
support = _mp_pvp_payload_support?(payload_hash)
sn = ""
begin
sn = payload_hash["skill_name"].to_s
sn = payload_hash["skill"].to_s if sn.empty?
rescue
sn = ""
end
heal_packet = payload_hash["heal"].to_s == "1" ||
MP_PVP_SUPPORT_HEAL_SKILLS.include?(sn) ||
sn.to_s.include?("NunHeal")
target_id = (payload_hash["target"] || payload_hash["tgt"] || payload_hash["target_id"]).to_i
# Heal packets are allowed in safe zones; hostile skill hits are not.
if defined?(MPSafeZone) && MPSafeZone.active? && !support && !heal_packet
return
end
return if @my_id.nil?
return if target_id <= 0
return if target_id != @my_id.to_i
skill_id = (payload_hash["skill"] || payload_hash["skill_id"]).to_i
# Explicit heal channel: always ADD, never damage fallback.
if heal_packet
begin
_mp_pvp_apply_heal_payload(player_id.to_i, payload_hash)
rescue
end
return
end
begin
if payload_hash.has_key?("hp") || payload_hash.has_key?("sta") ||
payload_hash.has_key?("states") || payload_hash.has_key?("skill_name")
return if _mp_pvp_apply_skill_payload(player_id.to_i, payload_hash)
return if support
end
rescue
return if support
end
return if support
dmg = (payload_hash["dmg"] || payload_hash["damage"]).to_i
dmg = 1 if dmg < 1
begin
handle_being_attacked(player_id.to_i, dmg, { :skill_id => skill_id, :source => :pvp_skill })
rescue ArgumentError
handle_being_attacked(player_id.to_i, dmg)
end
return
end
if self.respond_to?(:_mp_pvp_old_handle_remote_deistvia)
_mp_pvp_old_handle_remote_deistvia(player_id, action_id, phase, payload)
end
end
def self.send_line(message)
begin
msg = message.to_s
return false if defined?(MPSafeZone) && MPSafeZone.blocks_outgoing_packet?(msg)
if msg.start_with?("attack:") || msg.start_with?("attack_try:")
_mp_pvp_mark_local_combat
end
rescue
end
if self.respond_to?(:_mp_pvp_old_send_line)
_mp_pvp_old_send_line(message)
end
end
end
if defined?(Battle_System) && Battle_System.instance_methods.include?(:process_skill_result)
module Battle_System
unless instance_methods.include?(:mp_pvp_skill_sync_process_skill_result)
alias mp_pvp_skill_sync_process_skill_result process_skill_result
def process_skill_result(skill)
result = mp_pvp_skill_sync_process_skill_result(skill)
begin
return result unless defined?(WebSocket)
local_actor = nil
begin
local_actor = $game_player.actor
rescue
local_actor = nil
end
return result unless self == local_actor
WebSocket._mp_pvp_send_hits_from_skill_result(self, skill)
rescue
end
result
end
end
end
end
# Remote players have @net_actor but no @npc, so stock sensors skip them
# (!is_actor?). Expose them as actors for heal/hit detection; npc reader falls
# back to net_actor so ignore_dead?/is_object checks do not crash.
# Identity is @net_player_id (always set on create); @net_actor may arrive later.
if defined?(Game_Event)
class Game_Event
unless method_defined?(:mp_pvp_net_player?)
def mp_pvp_net_player?
begin
pid = instance_variable_get(:@net_player_id)
return false if pid.nil?
pid.to_i > 0
rescue
false
end
end
end
unless method_defined?(:mp_pvp_net_actor_ready?)
def mp_pvp_net_actor_ready?
begin
return false unless mp_pvp_net_player?
!instance_variable_get(:@net_actor).nil?
rescue
false
end
end
end
unless method_defined?(:mp_pvp_is_actor_original)
if method_defined?(:is_actor?)
alias mp_pvp_is_actor_original is_actor?
else
def mp_pvp_is_actor_original
false
end
end
def is_actor?
# Sensors call .npc on actors; only expose when net_actor exists.
return true if mp_pvp_net_actor_ready?
mp_pvp_is_actor_original
end
end
unless method_defined?(:mp_pvp_npc_reader_original)
if method_defined?(:npc)
alias mp_pvp_npc_reader_original npc
else
def mp_pvp_npc_reader_original
instance_variable_get(:@npc) rescue nil
end
end
def npc
n = nil
begin
n = mp_pvp_npc_reader_original
rescue
n = nil
end
return n unless n.nil?
begin
return instance_variable_get(:@net_actor) if mp_pvp_net_player?
rescue
end
nil
end
end
end
end
if defined?(Game_Map) && Game_Map.instance_methods.include?(:nearTheThreaten?)
class Game_Map
unless method_defined?(:mp_pvp_skill_sync_nearTheThreaten_original)
alias mp_pvp_skill_sync_nearTheThreaten_original nearTheThreaten?
def nearTheThreaten?(tmpTar, tmpRange=8)
begin
if tmpTar == $game_player && defined?(WebSocket) && WebSocket.respond_to?(:mp_pvp_local_combat?) && WebSocket.mp_pvp_local_combat?
return true
end
rescue
end
mp_pvp_skill_sync_nearTheThreaten_original(tmpTar, tmpRange)
end
end
end
end
# OWNER mega strength: 1,000,000 HEALTH damage for a successful strike.
# Applies only for the locally controlled attacker with a role issued by the
# online server. Never buffs remote players or support/healing effects.
if defined?(Battle_System) && Battle_System.instance_methods.include?(:take_damage) &&
Battle_System.instance_methods.include?(:get_affected_damage)
module Battle_System
unless instance_methods.include?(:mp_owner_mega_strength_take_damage)
alias mp_owner_mega_strength_take_damage take_damage
alias mp_owner_mega_strength_damage get_affected_damage
def take_damage(user, skill, *args)
previous = @mp_owner_mega_context
@mp_owner_mega_context = false
begin
owner = defined?(WebSocket) && WebSocket.respond_to?(:admin_mega_strength_enabled?) &&
WebSocket.admin_mega_strength_enabled?
player_actor = nil
begin
player_actor = $game_player.actor if defined?($game_player) && $game_player
rescue
end
is_attack = !(skill.respond_to?(:is_support) && skill.is_support)
@mp_owner_mega_context = owner && player_actor && user.equal?(player_actor) &&
!self.equal?(player_actor) && is_attack
mp_owner_mega_strength_take_damage(user, skill, *args)
ensure
@mp_owner_mega_context = previous
end
end
def get_affected_damage(eff, current_val, damage)
if @mp_owner_mega_context && eff && eff.respond_to?(:damage) && eff.damage &&
eff.damage.respond_to?(:attr) && eff.damage.attr.to_s == "health" &&
eff.damage.respond_to?(:type) && eff.damage.type.to_s == "-"
damage = 1_000_000
end
mp_owner_mega_strength_damage(eff, current_val, damage)
end
end
end
end
# PvP uses a separate hit payload instead of Battle_System#take_damage.
# WARNING: the server must validate OWNER status and mega-strength allowance
# BEFORE forwarding a boosted payload; do not trust an attacker's hp field.
if defined?(WebSocket) && WebSocket.respond_to?(:_mp_pvp_skill_result_payload)
module WebSocket
class << self
unless method_defined?(:mp_owner_mega_strength_pvp_payload)
alias mp_owner_mega_strength_pvp_payload _mp_pvp_skill_result_payload
end
end
def self._mp_pvp_skill_result_payload(skill, target_char=nil, attacker_actor=nil, attacker_token=nil, force_hit=false, hit_index=1)
payload = mp_owner_mega_strength_pvp_payload(skill, target_char, attacker_actor, attacker_token, force_hit, hit_index)
return payload unless admin_mega_strength_enabled?
return payload unless payload.is_a?(Hash) && payload["hp"].to_i > 0
return payload if skill.respond_to?(:is_support) && skill.is_support
return payload if respond_to?(:_mp_pvp_support_heal_skill?) && _mp_pvp_support_heal_skill?(skill)
# Ensure the attacker really is the local Owner, not a remote actor.
local_actor = _mp_pvp_local_actor
return payload unless attacker_actor && attacker_actor.equal?(local_actor)
payload["hp"] = 1_000_000
payload["dmg"] = 1_000_000
payload
end
end
end
#------------------------------------------------------------------------------
# Projectile PvP (bow / musket / thrown): stock Game_PorjectileCharacter#select_npc
# skips remote players (!npc? — they only have @net_actor). Melee already sends
# pvp_skill_hit at cast, but projectiles early-return from that path; damage must
# be sent when the missile actually lands on a NetPlayer tile.
#
# Gaps closed vs earlier patch:
# - find NetPlayer by @net_player_id (do not require @net_actor yet)
# - every-frame tile check (sensor_freq can skip the co-occupied tile)
# - send pvp_skill_hit BEFORE set_killer_skill (launch can abort / crash)
# - never use empty support cast skills (BasicThrow / MusketHeavy) as impact
#------------------------------------------------------------------------------
module WebSocket
def self._mp_pvp_projectile_owner_is_local?(ev)
return false if ev.nil?
user = nil
begin
sd = ev.summon_data if ev.respond_to?(:summon_data)
user = sd[:user] if sd.is_a?(Hash)
rescue
user = nil
end
return false if user.nil?
begin
return true if user == $game_player
rescue
end
begin
return true if user.respond_to?(:actor) && user.actor &&
_mp_pvp_local_actor && user.actor.equal?(_mp_pvp_local_actor)
rescue
end
false
rescue
false
end
def self._mp_pvp_skill_has_damage_effect?(skill)
return false if skill.nil?
begin
return false if skill.respond_to?(:is_support) && skill.is_support
rescue
end
effects = nil
begin
effects = skill.effect
rescue
effects = nil
end
return false unless effects && effects.respond_to?(:each)
effects.each do |eff|
begin
return true if eff && eff.respond_to?(:damage) && eff.damage
rescue
end
end
false
rescue
false
end
def self._mp_pvp_projectile_skill_from_name(name)
key = name.to_s
return nil if key.empty?
sk = _mp_pvp_arpg_skill(key)
return sk if _mp_pvp_skill_has_damage_effect?(sk)
nil
rescue
nil
end
def self._mp_pvp_projectile_impact_skill(projectile_npc, ev)
candidates = []
begin
sk = projectile_npc.skill if projectile_npc && projectile_npc.respond_to?(:skill)
candidates << sk unless sk.nil?
rescue
end
if projectile_npc && projectile_npc.respond_to?(:skills_killer)
begin
list = projectile_npc.skills_killer
if list && list.respond_to?(:each)
list.each do |sk|
next if sk.nil?
candidates << sk
end
end
rescue
end
end
if projectile_npc && projectile_npc.respond_to?(:skills_killer_list)
begin
list = projectile_npc.skills_killer_list
if list && list.respond_to?(:each)
list.each do |name|
sk = _mp_pvp_projectile_skill_from_name(name)
candidates << sk unless sk.nil?
end
end
rescue
end
end
begin
npc_name = nil
npc_name = projectile_npc.npc_name if projectile_npc && projectile_npc.respond_to?(:npc_name)
npc_name = projectile_npc.name if npc_name.to_s.empty? && projectile_npc && projectile_npc.respond_to?(:name)
sk = _mp_pvp_projectile_skill_from_name(npc_name)
candidates << sk unless sk.nil?
rescue
end
begin
ev_name = ev.name.to_s if ev && ev.respond_to?(:name)
if !ev_name.nil? && !ev_name.empty?
sk = _mp_pvp_projectile_skill_from_name(ev_name)
candidates << sk unless sk.nil?
# Common summon aliases → impact skills
low = ev_name.downcase
if low.include?("rock") || low.include?("throw") || low.include?("stone")
sk = _mp_pvp_projectile_skill_from_name("MissileThrowingRock")
candidates << sk unless sk.nil?
elsif low.include?("arrow") || low.include?("bow") || low.include?("bolt")
sk = _mp_pvp_projectile_skill_from_name("MissileTypical")
candidates << sk unless sk.nil?
elsif low.include?("musket") || low.include?("gun") || low.include?("bullet")
sk = _mp_pvp_projectile_skill_from_name("MissileTypical")
sk2 = _mp_pvp_projectile_skill_from_name("MissileThrowingRock")
candidates << sk unless sk.nil?
candidates << sk2 unless sk2.nil?
end
end
rescue
end
if ev && ev.respond_to?(:summon_data)
begin
sd = ev.summon_data
if sd.is_a?(Hash)
cast = sd[:skill]
cast = sd["skill"] if cast.nil?
candidates << cast unless cast.nil?
end
rescue
end
end
candidates.each do |sk|
return sk if _mp_pvp_skill_has_damage_effect?(sk)
end
# Last resort: known impact skills (never empty cast like BasicThrow)
%w[MissileTypical MissileThrowingRock].each do |name|
sk = _mp_pvp_projectile_skill_from_name(name)
return sk unless sk.nil?
end
nil
rescue
nil
end
# NetPlayer on tile (x,y). Does not require @net_actor — only @net_player_id.
def self._mp_pvp_projectile_find_player_at(x, y, missile_ev=nil)
return nil unless @players.is_a?(Hash) && !@players.empty?
tx = x.to_i
ty = y.to_i
user = nil
begin
sd = missile_ev.summon_data if missile_ev && missile_ev.respond_to?(:summon_data)
user = sd[:user] if sd.is_a?(Hash)
rescue
user = nil
end
@players.each_value do |ev|
next if ev.nil?
begin
next unless ev.x.to_i == tx && ev.y.to_i == ty
rescue
next
end
next if user && ev == user
begin
pid = ev.instance_variable_get(:@net_player_id).to_i
next if pid <= 0
rescue
next
end
begin
next if user && user.respond_to?(:actor) && user.actor &&
user.actor.respond_to?(:friendly?) && user.actor.friendly?(ev)
rescue
end
actor = nil
begin
actor = ev.instance_variable_get(:@net_actor)
actor = ev.actor if actor.nil? && ev.respond_to?(:actor)
rescue
actor = nil
end
unless actor.nil?
begin
next if actor.respond_to?(:immune_damage) && actor.immune_damage
rescue
end
begin
next if actor.respond_to?(:ignore_projectile) && actor.ignore_projectile
rescue
end
begin
next if actor.respond_to?(:action_state) && actor.action_state == :death
rescue
end
end
return ev
end
nil
rescue
nil
end
# Call when a local player's projectile collides with a remote player event.
def self._mp_pvp_try_projectile_player_hit(ev, target_char, projectile_npc=nil)
return false unless _mp_pvp_skill_sender_ready?
return false if ev.nil? || target_char.nil?
return false if defined?(MPSafeZone) && MPSafeZone.active?
return false unless _mp_pvp_projectile_owner_is_local?(ev)
# One network hit per missile event
begin
if ev.instance_variable_get(:@mp_pvp_projectile_hit_sent)
return false
end
rescue
end
tid = _mp_pvp_target_id_from_char(target_char)
return false if tid <= 0
skill = _mp_pvp_projectile_impact_skill(projectile_npc, ev)
return false if skill.nil?
return false unless _mp_pvp_skill_has_damage_effect?(skill)
tx = 0
ty = 0
begin
tx = target_char.x.to_i
ty = target_char.y.to_i
rescue
begin
tx = ev.x.to_i
ty = ev.y.to_i
rescue
tx = 0
ty = 0
end
end
begin
ev.instance_variable_set(:@mp_pvp_projectile_hit_sent, true)
rescue
end
_mp_pvp_send_skill_hit(skill, tid, tx, ty, target_char, _mp_pvp_local_actor, true)
true
rescue
false
end
end
if defined?(Game_PorjectileCharacter)
class Game_PorjectileCharacter
unless method_defined?(:mp_pvp_select_npc_original)
alias mp_pvp_select_npc_original select_npc
def select_npc
tmp = mp_pvp_select_npc_original
return tmp unless tmp.nil?
# Stock loop requires ev.npc? — NetPlayers are never npc?.
begin
return nil unless defined?(WebSocket) &&
WebSocket.respond_to?(:_mp_pvp_projectile_find_player_at)
WebSocket._mp_pvp_projectile_find_player_at(@event.x, @event.y, @event)
rescue
nil
end
end
end
unless method_defined?(:mp_pvp_projectile_update_missile)
alias mp_pvp_projectile_update_missile update_missile
# sensor_freq can skip the single frame a fast missile shares a tile with
# a NetPlayer. Check every frame for local-owner projectiles.
def update_missile
begin
if defined?(WebSocket) &&
WebSocket.respond_to?(:_mp_pvp_projectile_owner_is_local?) &&
WebSocket._mp_pvp_projectile_owner_is_local?(@event) &&
WebSocket.respond_to?(:_mp_pvp_projectile_find_player_at)
hit_ev = WebSocket._mp_pvp_projectile_find_player_at(@event.x, @event.y, @event)
if hit_ev
begin
@event.opacity = 0
@event.syncToTargetXY(hit_ev)
rescue
end
begin
WebSocket._mp_pvp_try_projectile_player_hit(@event, hit_ev, self)
rescue
end
begin
set_killer_skill(0)
rescue
end
missile_auto_ded
return
end
end
rescue
end
mp_pvp_projectile_update_missile
end
end
unless method_defined?(:mp_pvp_projectile_scan_target)
alias mp_pvp_projectile_scan_target scan_target
# Same as stock scan_target, plus pvp_skill_hit when the tile target is a
# remote player (stock path never networked projectile impact damage).
def scan_target
@strand_count += 1 if !@event.move_succeed
miles = cur_mileage
targetedNPC = select_npc
hit = targetedNPC != nil || (!@event.move_succeed && effective?) ||
@strand_count >= 3 || self.move_speed < @stall_boundary || miles >= @range
return unless hit
if targetedNPC != nil
begin
@event.opacity = 0
@event.syncToTargetXY(targetedNPC)
rescue
end
end
# Network damage first — set_killer_skill may abort (friendly fire /
# cost) or raise against NetPlayer tokens.
begin
if targetedNPC && defined?(WebSocket) &&
WebSocket.respond_to?(:_mp_pvp_try_projectile_player_hit) &&
WebSocket.respond_to?(:_mp_pvp_target_id_from_char) &&
WebSocket._mp_pvp_target_id_from_char(targetedNPC) > 0
WebSocket._mp_pvp_try_projectile_player_hit(@event, targetedNPC, self)
end
rescue
end
begin
set_killer_skill(0)
rescue
end
missile_auto_ded
end
end
end
end