2629 lines
72 KiB
Ruby
2629 lines
72 KiB
Ruby
# 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
|
||
|