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