# 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