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

2629 lines
72 KiB
Ruby
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 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