425 lines
12 KiB
Ruby
425 lines
12 KiB
Ruby
# encoding: UTF-8
|
|
#==============================================================================
|
|
# Multiplayer safe zones
|
|
#------------------------------------------------------------------------------
|
|
# Combat is disabled for the local player on the listed maps. The server-side
|
|
# SafeZonePlugin enforces the same rule for network packets, while this client
|
|
# layer prevents local NPC damage, remote PvP damage and combat UI side effects.
|
|
#==============================================================================
|
|
|
|
module MPSafeZone
|
|
MAP_NAMES = {
|
|
15 => "Банк",
|
|
59 => "Горящий Бочонок",
|
|
76 => "Горящий Бочонок",
|
|
81 => "Пиратская Погибель",
|
|
92 => "Пиратская Погибель",
|
|
97 => "Твердыня Рока",
|
|
98 => "Твердыня Рока",
|
|
99 => "Твердыня Рока",
|
|
117 => "Таверна Рыбополиса",
|
|
154 => "Прибрежная Крепость"
|
|
}
|
|
|
|
ICON_FOLDER = "Graphics/Online/"
|
|
ICON_NAME = "sheat"
|
|
ICON_SIZE = 24
|
|
|
|
module_function
|
|
|
|
def map_id
|
|
return 0 unless defined?($game_map) && $game_map
|
|
$game_map.map_id.to_i
|
|
rescue
|
|
0
|
|
end
|
|
|
|
def active?
|
|
MAP_NAMES.has_key?(map_id)
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def map_name
|
|
MAP_NAMES[map_id].to_s
|
|
rescue
|
|
""
|
|
end
|
|
|
|
# Recognises both a Game_Player and the actor whose map_token is the player.
|
|
def local_attacker?(user)
|
|
return false if user.nil?
|
|
return true if defined?($game_player) && user.equal?($game_player)
|
|
token = user.map_token if user.respond_to?(:map_token)
|
|
defined?($game_player) && token.equal?($game_player)
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def npc_target?(target)
|
|
return false if remote_player_target?(target) || local_player_target?(target)
|
|
return true if defined?(Game_NonPlayerCharacter) && target.is_a?(Game_NonPlayerCharacter)
|
|
if defined?(Game_Event) && target.is_a?(Game_Event)
|
|
begin
|
|
return true if target.respond_to?(:npc?) && target.npc?
|
|
rescue
|
|
end
|
|
begin
|
|
actor = target.actor if target.respond_to?(:actor)
|
|
return true if defined?(Game_NonPlayerCharacter) && actor.is_a?(Game_NonPlayerCharacter)
|
|
rescue
|
|
end
|
|
end
|
|
token = target.map_token if target && target.respond_to?(:map_token)
|
|
return false if token.nil?
|
|
return false if remote_player_target?(token) || local_player_target?(token)
|
|
return true if token.respond_to?(:npc?) && token.npc?
|
|
defined?(Game_Event) && token.is_a?(Game_Event) &&
|
|
token.instance_variable_defined?(:@npc) && !token.instance_variable_get(:@npc).nil?
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def remote_player_target?(target)
|
|
return false if target.nil?
|
|
begin
|
|
return true if defined?(WebSocket::NetSyncActor) && target.is_a?(WebSocket::NetSyncActor)
|
|
rescue
|
|
end
|
|
begin
|
|
if target.instance_variable_defined?(:@net_player_id) &&
|
|
!target.instance_variable_get(:@net_player_id).nil?
|
|
return true
|
|
end
|
|
rescue
|
|
end
|
|
begin
|
|
token = target.map_token if target.respond_to?(:map_token)
|
|
if token && token.instance_variable_defined?(:@net_player_id) &&
|
|
!token.instance_variable_get(:@net_player_id).nil?
|
|
return true
|
|
end
|
|
rescue
|
|
end
|
|
false
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def local_player_target?(target)
|
|
return false if target.nil?
|
|
begin
|
|
return true if defined?($game_player) && target.equal?($game_player)
|
|
rescue
|
|
end
|
|
begin
|
|
actor = $game_player.actor if defined?($game_player) && $game_player && $game_player.respond_to?(:actor)
|
|
return true if !actor.nil? && target.equal?(actor)
|
|
rescue
|
|
end
|
|
begin
|
|
token = target.map_token if target.respond_to?(:map_token)
|
|
return true if defined?($game_player) && !token.nil? && token.equal?($game_player)
|
|
rescue
|
|
end
|
|
false
|
|
rescue
|
|
false
|
|
end
|
|
|
|
# Hostile PvP against players (local or remote). Support skills stay allowed.
|
|
def blocks_player_combat?(target, skill=nil)
|
|
active? && harmful_skill?(skill) &&
|
|
(local_player_target?(target) || remote_player_target?(target))
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def blocks_npc_hit?(target, user)
|
|
blocks_npc_damage?(target)
|
|
rescue
|
|
false
|
|
end
|
|
|
|
SUPPORT_SKILL_NAMES = %w[
|
|
BasicNunHeal
|
|
BasicBattleStandard HeavyBattleStandard
|
|
BasicProtectShield ControlProtectShield
|
|
].freeze
|
|
|
|
def support_skill?(skill)
|
|
return false if skill.nil?
|
|
begin
|
|
return true if skill.respond_to?(:is_support) && skill.is_support
|
|
rescue
|
|
end
|
|
begin
|
|
if defined?(WebSocket) && WebSocket.respond_to?(:_mp_pvp_skill_is_support?)
|
|
return true if WebSocket._mp_pvp_skill_is_support?(skill)
|
|
end
|
|
rescue
|
|
end
|
|
name = nil
|
|
begin
|
|
name = skill.name.to_s if skill.respond_to?(:name)
|
|
rescue
|
|
name = nil
|
|
end
|
|
if name.nil? || name.empty?
|
|
begin
|
|
name = skill.item_name.to_s if skill.respond_to?(:item_name)
|
|
rescue
|
|
name = nil
|
|
end
|
|
end
|
|
return true if SUPPORT_SKILL_NAMES.include?(name.to_s)
|
|
begin
|
|
return true if skill.respond_to?(:summon_hit) && skill.summon_hit.to_s == "EffectLifeBuffHit"
|
|
rescue
|
|
end
|
|
false
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def harmful_skill?(skill)
|
|
return true if skill.nil?
|
|
return false if support_skill?(skill)
|
|
true
|
|
end
|
|
|
|
# Training bags in NoerTavern2F (Горящий Бочонок 2): CommonSandBoxSetup /
|
|
# NeutralSandbagImmortal. Allow hits so practice dummies stay useful.
|
|
TRAINING_DUMMY_NPC_NAMES = %w[
|
|
NeutralSandbagImmortal
|
|
NeutralHp1Sandbag
|
|
SkillDummy
|
|
SkillDummyDestroyable
|
|
].freeze
|
|
|
|
def resolve_npc_actor(target)
|
|
return target if defined?(Game_NonPlayerCharacter) && target.is_a?(Game_NonPlayerCharacter)
|
|
begin
|
|
return target.npc if target.respond_to?(:npc) && target.npc
|
|
rescue
|
|
end
|
|
begin
|
|
actor = target.actor if target.respond_to?(:actor)
|
|
return actor if defined?(Game_NonPlayerCharacter) && actor.is_a?(Game_NonPlayerCharacter)
|
|
rescue
|
|
end
|
|
begin
|
|
token = target.map_token if target.respond_to?(:map_token)
|
|
if token
|
|
return token.npc if token.respond_to?(:npc) && token.npc
|
|
actor = token.actor if token.respond_to?(:actor)
|
|
return actor if defined?(Game_NonPlayerCharacter) && actor.is_a?(Game_NonPlayerCharacter)
|
|
end
|
|
rescue
|
|
end
|
|
nil
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def training_dummy?(target)
|
|
npc = resolve_npc_actor(target)
|
|
return false if npc.nil?
|
|
begin
|
|
name = npc.npc_name.to_s if npc.respond_to?(:npc_name)
|
|
name = npc.name.to_s if (name.nil? || name.empty?) && npc.respond_to?(:name)
|
|
n = name.to_s
|
|
return true if TRAINING_DUMMY_NPC_NAMES.include?(n)
|
|
return true if n.include?("Sandbag")
|
|
rescue
|
|
false
|
|
end
|
|
rescue
|
|
false
|
|
end
|
|
|
|
# Outgoing npc_hit:<event_id>:<delta> (or relayed 4-part form).
|
|
def npc_hit_training_dummy_message?(message)
|
|
parts = message.to_s.split(":")
|
|
return false if parts.length < 3
|
|
eid = parts.length >= 4 ? parts[2].to_i : parts[1].to_i
|
|
return false if eid <= 0
|
|
npc = nil
|
|
begin
|
|
if defined?(MP_WS_NPCSync) && MP_WS_NPCSync.respond_to?(:npc_from_event_id)
|
|
npc = MP_WS_NPCSync.npc_from_event_id(eid)
|
|
end
|
|
rescue
|
|
npc = nil
|
|
end
|
|
training_dummy?(npc)
|
|
rescue
|
|
false
|
|
end
|
|
|
|
# Safe-zone NPC protection is source-independent. Fire, traps, summons and
|
|
# periodic effects often replace the original player with an environmental
|
|
# actor, so checking only user == local player leaves a damage/aggro bypass.
|
|
def blocks_npc_damage?(target, skill=nil)
|
|
return false if training_dummy?(target)
|
|
active? && npc_target?(target) && harmful_skill?(skill)
|
|
rescue
|
|
false
|
|
end
|
|
|
|
# Support-хилы / summon аколита пропускаем в safe zone; вредный PvP — нет
|
|
def support_outgoing_deistvia?(message)
|
|
msg = message.to_s
|
|
return true if msg.start_with?("deistvia:pvp_support_summon:")
|
|
return false unless msg.start_with?("deistvia:pvp_skill_hit:")
|
|
return true if msg.include?("sup=1")
|
|
return true if msg.include?("heal=1")
|
|
return true if msg.include?("BasicNunHeal")
|
|
%w[
|
|
BasicNunHeal
|
|
BasicBattleStandard HeavyBattleStandard
|
|
BasicProtectShield ControlProtectShield
|
|
].any? { |n| msg.include?("skill_name=#{n}") || msg.include?("skill=#{n}") }
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def blocks_outgoing_packet?(message)
|
|
return false unless active?
|
|
msg = message.to_s
|
|
return true if msg.start_with?("attack:") || msg.start_with?("attack_try:")
|
|
if msg.start_with?("npc_hit:")
|
|
return false if npc_hit_training_dummy_message?(msg)
|
|
return true
|
|
end
|
|
return true if msg.start_with?("pwo_hit:")
|
|
return true if msg.start_with?("pwo_hit_try:")
|
|
return true if msg.start_with?("effect_area:npc_hit:")
|
|
if msg.start_with?("deistvia:pvp_skill_hit:")
|
|
return false if support_outgoing_deistvia?(msg)
|
|
return true
|
|
end
|
|
false
|
|
rescue
|
|
false
|
|
end
|
|
end
|
|
|
|
# Some projectile/effect batches redirect aggro directly and do not wait for
|
|
# take_skill_effect. Suppress that hostile reaction when their target is an NPC
|
|
# in a protected map; ordinary autonomous NPC AI is left untouched.
|
|
if defined?(Game_Event) && Game_Event.instance_methods.include?(:hit_effect_aggro_redirect)
|
|
class Game_Event
|
|
unless method_defined?(:mp_safe_zone_hit_effect_aggro_redirect)
|
|
alias mp_safe_zone_hit_effect_aggro_redirect hit_effect_aggro_redirect
|
|
def hit_effect_aggro_redirect(*args, &block)
|
|
begin
|
|
summon = instance_variable_get(:@summon_data)
|
|
target = summon[:target] if summon.is_a?(Hash)
|
|
skill = args.empty? ? nil : args[0]
|
|
if defined?(MPSafeZone)
|
|
return if MPSafeZone.blocks_npc_damage?(target, skill)
|
|
return if MPSafeZone.blocks_player_combat?(target, skill)
|
|
end
|
|
rescue
|
|
end
|
|
mp_safe_zone_hit_effect_aggro_redirect(*args, &block)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
module MPSafeZoneHUD
|
|
module_function
|
|
|
|
@viewport = nil
|
|
@sprite = nil
|
|
@bitmap = nil
|
|
|
|
def map_scene?
|
|
defined?(SceneManager) && defined?(Scene_Map) &&
|
|
SceneManager.respond_to?(:scene_is?) && SceneManager.scene_is?(Scene_Map)
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def ensure_hud
|
|
return true if @sprite && !@sprite.disposed?
|
|
dispose
|
|
source = Cache.load_bitmap(MPSafeZone::ICON_FOLDER, MPSafeZone::ICON_NAME)
|
|
return false if source.nil?
|
|
@bitmap = Bitmap.new(MPSafeZone::ICON_SIZE, MPSafeZone::ICON_SIZE)
|
|
@bitmap.stretch_blt(@bitmap.rect, source, source.rect)
|
|
@viewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
|
|
# Autosave HUD uses z=200_000 at the same screen position. The safe-zone
|
|
# marker is persistent while inside the map and must remain above it.
|
|
@viewport.z = 200_001
|
|
@sprite = Sprite.new(@viewport)
|
|
@sprite.bitmap = @bitmap
|
|
@sprite.z = 200_001
|
|
@sprite.ox = MPSafeZone::ICON_SIZE / 2
|
|
@sprite.x = Graphics.width / 2
|
|
@sprite.y = 6
|
|
@sprite.visible = false
|
|
true
|
|
rescue
|
|
dispose
|
|
false
|
|
end
|
|
|
|
def update
|
|
visible = map_scene? && MPSafeZone.active?
|
|
if visible
|
|
return unless ensure_hud
|
|
@sprite.x = Graphics.width / 2
|
|
@sprite.y = 6
|
|
@sprite.visible = true
|
|
elsif @sprite && !@sprite.disposed?
|
|
@sprite.visible = false
|
|
end
|
|
rescue
|
|
end
|
|
|
|
def dispose
|
|
begin
|
|
if @sprite && !@sprite.disposed?
|
|
@sprite.bitmap = nil rescue nil
|
|
@sprite.dispose
|
|
end
|
|
rescue
|
|
end
|
|
begin
|
|
@viewport.dispose if @viewport && !@viewport.disposed?
|
|
rescue
|
|
end
|
|
begin
|
|
@bitmap.dispose if @bitmap && !@bitmap.disposed?
|
|
rescue
|
|
end
|
|
@sprite = nil
|
|
@viewport = nil
|
|
@bitmap = nil
|
|
end
|
|
end
|
|
|
|
if defined?(Scene_Map)
|
|
class Scene_Map < Scene_Base
|
|
unless method_defined?(:mp_safe_zone_update_without_icon)
|
|
alias mp_safe_zone_update_without_icon update
|
|
def update(*args, &block)
|
|
result = mp_safe_zone_update_without_icon(*args, &block)
|
|
MPSafeZoneHUD.update
|
|
result
|
|
end
|
|
end
|
|
|
|
unless method_defined?(:mp_safe_zone_terminate_without_icon)
|
|
alias mp_safe_zone_terminate_without_icon terminate
|
|
def terminate(*args, &block)
|
|
MPSafeZoneHUD.dispose
|
|
mp_safe_zone_terminate_without_icon(*args, &block)
|
|
end
|
|
end
|
|
end
|
|
end
|