983 lines
28 KiB
Ruby
983 lines
28 KiB
Ruby
# encoding: UTF-8
|
|
|
|
module WebSocket
|
|
PVP_ARENA_NET_EVENT_ID_BASE = 900000
|
|
PVP_ARENA_SLOT_COUNT = 3
|
|
|
|
def self.pvp_arena_feature_enabled?
|
|
return false unless defined?(MP_ArenaFlag) && MP_ArenaFlag.respond_to?(:arena_active?)
|
|
!!MP_ArenaFlag.arena_active?
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.pvp_arena_remote_event_id(slot_id)
|
|
PVP_ARENA_NET_EVENT_ID_BASE + slot_id.to_i
|
|
rescue
|
|
900000 + slot_id.to_i
|
|
end
|
|
|
|
def self.pvp_force_spawn_log(tag, message)
|
|
return unless defined?(MPStateInfra) && MPStateInfra.respond_to?(:log_line)
|
|
MPStateInfra.log_line(tag, message)
|
|
rescue
|
|
end
|
|
|
|
def self.pvp_force_spawn_resolve_map_key(map_id)
|
|
return map_id unless defined?($data_mapinfos) && $data_mapinfos
|
|
return map_id if $data_mapinfos[map_id]
|
|
|
|
raw_text = map_id.to_s
|
|
numeric_id = raw_text.to_i
|
|
return map_id if numeric_id <= 0 && raw_text != "0"
|
|
|
|
found_key = nil
|
|
$data_mapinfos.each do |key, info|
|
|
next unless info && info.respond_to?(:id)
|
|
begin
|
|
if info.id.to_i == numeric_id
|
|
found_key = key
|
|
break
|
|
end
|
|
rescue
|
|
end
|
|
end
|
|
|
|
found_key || map_id
|
|
rescue
|
|
map_id
|
|
end
|
|
|
|
def self.pvp_force_spawn_map_key_valid?(map_key)
|
|
return false unless defined?($data_mapinfos) && $data_mapinfos
|
|
return true if $data_mapinfos[map_key]
|
|
false
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.pvp_force_spawn_numeric_map_id(map_key, fallback = nil)
|
|
begin
|
|
if defined?($data_mapinfos) && $data_mapinfos && $data_mapinfos[map_key] && $data_mapinfos[map_key].respond_to?(:id)
|
|
return $data_mapinfos[map_key].id.to_i
|
|
end
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
return fallback.to_i if fallback && fallback.to_i > 0
|
|
rescue
|
|
end
|
|
|
|
map_key.to_i
|
|
rescue
|
|
0
|
|
end
|
|
|
|
def self.pvp_force_spawn_recover_fade
|
|
begin
|
|
$game_player.instance_variable_set(:@transferring, false) if defined?($game_player) && $game_player
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
Graphics.fadein(15) if defined?(Graphics) && Graphics.respond_to?(:fadein)
|
|
rescue
|
|
end
|
|
rescue
|
|
end
|
|
|
|
def self.pvp_force_spawn_queue(map_id, x, y, dir = 2, fade = 0)
|
|
resolved_map_id = pvp_force_spawn_resolve_map_key(map_id)
|
|
valid_map = pvp_force_spawn_map_key_valid?(resolved_map_id)
|
|
pvp_force_spawn_log("pvp_force_spawn_resolve", "raw=#{map_id} resolved=#{resolved_map_id} ok=#{valid_map}")
|
|
|
|
@pvp_force_spawn_pending = {
|
|
map_id: resolved_map_id,
|
|
raw_map_id: map_id,
|
|
numeric_map_id: pvp_force_spawn_numeric_map_id(resolved_map_id, map_id),
|
|
x: x.to_i,
|
|
y: y.to_i,
|
|
dir: dir.to_i,
|
|
fade: fade.to_i,
|
|
}
|
|
rescue
|
|
@pvp_force_spawn_pending = nil
|
|
end
|
|
|
|
def self.pvp_force_spawn_pending?
|
|
!!(@pvp_force_spawn_pending && @pvp_force_spawn_pending.is_a?(Hash))
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.pvp_force_spawn_clear
|
|
@pvp_force_spawn_pending = nil
|
|
rescue
|
|
@pvp_force_spawn_pending = nil
|
|
end
|
|
|
|
def self.pvp_force_spawn_mark_same_map_reenter(map_id)
|
|
begin
|
|
@players.keys.each { |id| remove_remote_player(id) } if @players && respond_to?(:remove_remote_player)
|
|
@players.clear if @players.respond_to?(:clear)
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
cleanup_world_objects if respond_to?(:cleanup_world_objects)
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
@event_cache = {}
|
|
@event_ai_cache = {}
|
|
@event_target_cache = {}
|
|
@need_master_sync = true
|
|
@last_pos = ""
|
|
@last_sent_nick = nil
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
@ps_last_map_id = nil
|
|
@ps_last_sent_sig = nil
|
|
@ps_last_sent_at = 0.0
|
|
@ps_last_req_at = 0.0
|
|
@ps_last_resp_at = 0.0
|
|
@ps_frame = 0
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
if respond_to?(:connected?) && connected? && respond_to?(:send_line)
|
|
send_line("map_reenter:#{map_id.to_i}")
|
|
end
|
|
rescue
|
|
end
|
|
end
|
|
|
|
# Mirror change_map_story_stats_fix / prepare_home_transfer for force_spawn,
|
|
# which bypasses reserve_transfer and never arms ReRoll / clears RegionOuta.
|
|
def self.pvp_force_spawn_prep_tag_home(target_map_id)
|
|
kind = ""
|
|
begin
|
|
if defined?(NoerHomeEstate) && NoerHomeEstate.respond_to?(:home_target_kind)
|
|
kind = NoerHomeEstate.home_target_kind(target_map_id).to_s
|
|
end
|
|
rescue
|
|
kind = ""
|
|
end
|
|
token = target_map_id.to_s
|
|
is_home = (kind != "")
|
|
is_noer = token.include?("NoerHome")
|
|
return { "ok" => false, "kind" => kind } unless is_home || is_noer
|
|
|
|
begin
|
|
if defined?($story_stats) && $story_stats
|
|
$story_stats["RegionMap_RegionOuta"] = 0
|
|
$story_stats["RegionMap_RegionInsa"] = 0
|
|
$story_stats["RapeLoop"] = 0
|
|
$story_stats["Captured"] = 0
|
|
$story_stats["OnRegionMap"] = 0
|
|
$story_stats["OnRegionMapSpawnRace"] = 0
|
|
$story_stats["ReRollHalfEvents"] = 1
|
|
# Raper common-init: return delete unless GangBangSleepAtHome == 1
|
|
$story_stats["GangBangSleepAtHome"] = 0
|
|
end
|
|
rescue
|
|
end
|
|
begin
|
|
if is_home && defined?(NoerHomeEstate) && NoerHomeEstate.respond_to?(:prepare_home_transfer)
|
|
NoerHomeEstate.prepare_home_transfer(kind)
|
|
end
|
|
rescue
|
|
end
|
|
{ "ok" => true, "kind" => kind }
|
|
rescue
|
|
{ "ok" => false, "kind" => kind }
|
|
end
|
|
|
|
# Map053/etc queue AnimalRattus into @summoned_evs; Game_Map#setup never
|
|
# clears that queue, so update_for_fade spills vermin onto NoerHome.
|
|
def self.pvp_force_spawn_clear_pending_summons
|
|
begin
|
|
if $game_map && $game_map.instance_variable_defined?(:@summoned_evs)
|
|
q = $game_map.instance_variable_get(:@summoned_evs)
|
|
q.clear if q.is_a?(Array)
|
|
end
|
|
rescue
|
|
end
|
|
end
|
|
|
|
# Peaceful home login: wipe baked Rapers (if common-init missed) and any
|
|
# foreign vermin that leaked across maps.
|
|
def self.pvp_force_spawn_scrub_home_hostiles
|
|
return unless $game_map && $game_map.respond_to?(:events)
|
|
victims = []
|
|
$game_map.events.each_value do |ev|
|
|
next if ev.nil?
|
|
n = (ev.respond_to?(:name) ? ev.name.to_s : "")
|
|
next if n.empty?
|
|
next unless n =~ /Raper|Rattus|Roach|GiantMice|Catcher|RogueSpear|MobHumanRaper|WildAnimal/i
|
|
victims << ev
|
|
end
|
|
victims.each { |ev| pvp_arena_delete_event(ev) }
|
|
rescue
|
|
end
|
|
|
|
# Field reconnect: only remove FOREIGN leaked vermin (queue spill from Map053),
|
|
# not baked map wildlife that belongs on this field.
|
|
def self.pvp_force_spawn_scrub_leaked_vermin
|
|
return unless $game_map && $game_map.respond_to?(:events)
|
|
victims = []
|
|
$game_map.events.each_value do |ev|
|
|
next if ev.nil?
|
|
begin
|
|
next unless ev.respond_to?(:foreign_event) && ev.foreign_event
|
|
rescue
|
|
next
|
|
end
|
|
n = (ev.respond_to?(:name) ? ev.name.to_s : "")
|
|
next if n.empty?
|
|
next unless n =~ /Rattus|Roach|GiantMice|WildAnimal|FristQuestVer/i
|
|
victims << ev
|
|
end
|
|
victims.each { |ev| pvp_arena_delete_event(ev) }
|
|
rescue
|
|
end
|
|
|
|
def self.pvp_force_spawn_apply
|
|
data = @pvp_force_spawn_pending
|
|
return false unless data && data.is_a?(Hash)
|
|
return false unless defined?(SceneManager) && SceneManager.scene_is?(Scene_Map)
|
|
return false unless defined?($game_player) && $game_player
|
|
|
|
begin
|
|
clear_portal_wait if respond_to?(:clear_portal_wait)
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
fade_v = data[:fade].to_i
|
|
$game_temp.fade_type = fade_v if $game_temp && $game_temp.respond_to?(:fade_type=)
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
current_map_id = ($game_map ? $game_map.map_id.to_i : 0)
|
|
rescue
|
|
current_map_id = 0
|
|
end
|
|
|
|
raw_map_id = nil
|
|
target_map_id = nil
|
|
|
|
begin
|
|
raw_map_id = data[:raw_map_id] || data[:map_id]
|
|
target_map_id = pvp_force_spawn_resolve_map_key(data[:map_id])
|
|
unless pvp_force_spawn_map_key_valid?(target_map_id)
|
|
pvp_force_spawn_log("pvp_force_spawn_missing_map", "raw=#{raw_map_id} resolved=#{target_map_id}")
|
|
@pvp_force_spawn_pending = nil
|
|
return false
|
|
end
|
|
|
|
target_numeric_id = (data[:numeric_map_id].to_i rescue 0)
|
|
target_numeric_id = pvp_force_spawn_numeric_map_id(target_map_id, raw_map_id) if target_numeric_id <= 0
|
|
same_map_transfer = (current_map_id == target_numeric_id)
|
|
spawn_x = data[:x].to_i
|
|
spawn_y = data[:y].to_i
|
|
fade_used = data[:fade].to_i
|
|
|
|
# Second bootstrap queue: already at destination — skip reload (blink source).
|
|
if same_map_transfer && fade_used != 0 && fade_used != 1
|
|
begin
|
|
px = $game_player.x.to_i
|
|
py = $game_player.y.to_i
|
|
if px == spawn_x && py == spawn_y
|
|
@pvp_force_spawn_pending = nil
|
|
Graphics.brightness = 255 if defined?(Graphics) && Graphics.respond_to?(:brightness=)
|
|
if $game_map && $game_map.screen && $game_map.screen.respond_to?(:brightness=)
|
|
$game_map.screen.brightness = 255
|
|
end
|
|
return true
|
|
end
|
|
rescue
|
|
end
|
|
end
|
|
|
|
@pvp_force_spawn_pending = nil
|
|
|
|
prep = pvp_force_spawn_prep_tag_home(target_map_id)
|
|
home_ok = (prep.is_a?(Hash) && prep["ok"])
|
|
# Always drop pending summons before transfer. Map053 (etc.) queues
|
|
# WildGiantMice* into @summoned_evs; setup never clears it, so
|
|
# update_for_fade spills those vermin onto the destination field/home.
|
|
pvp_force_spawn_clear_pending_summons
|
|
if home_ok
|
|
begin
|
|
$game_map.force_setup = true if $game_map && $game_map.respond_to?(:force_setup=)
|
|
rescue
|
|
end
|
|
end
|
|
|
|
if same_map_transfer
|
|
begin
|
|
if home_ok && $game_map
|
|
# request_map_reload is a no-op in this build; force full setup so
|
|
# Raper common-init re-runs and foreign vermin are dropped.
|
|
$game_map.force_setup = true if $game_map.respond_to?(:force_setup=)
|
|
$game_map.setup(target_map_id)
|
|
elsif $game_player.respond_to?(:request_map_reload)
|
|
$game_player.request_map_reload
|
|
else
|
|
$game_player.instance_variable_set(:@needs_map_reload, true)
|
|
end
|
|
rescue
|
|
$game_player.instance_variable_set(:@needs_map_reload, true) rescue nil
|
|
end
|
|
end
|
|
|
|
$game_player.instance_variable_set(:@transferring, true)
|
|
$game_player.instance_variable_set(:@force_update, false)
|
|
$game_player.instance_variable_set(:@new_map_id, target_map_id)
|
|
$game_player.instance_variable_set(:@new_x, spawn_x)
|
|
$game_player.instance_variable_set(:@new_y, spawn_y)
|
|
$game_player.instance_variable_set(:@new_direction, data[:dir].to_i)
|
|
SceneManager.scene.perform_transfer if SceneManager.scene && SceneManager.scene.respond_to?(:perform_transfer)
|
|
|
|
# Tag/home maps use (1,1) as a service entry. Without AUTOBEGIN/fade delay
|
|
# the BIOS never snaps to StartPoint, which leaves RegionOuta/ReRoll in a
|
|
# bad state and can spawn Tar* mobs inside private homes.
|
|
begin
|
|
if spawn_x == 1 && spawn_y == 1 && $game_map && $game_map.respond_to?(:get_storypoint)
|
|
pt = $game_map.get_storypoint("StartPoint") rescue nil
|
|
if pt.is_a?(Array) && pt.length >= 2
|
|
$game_player.moveto(pt[0].to_i, pt[1].to_i) if $game_player.respond_to?(:moveto)
|
|
end
|
|
end
|
|
rescue
|
|
end
|
|
|
|
# Force-spawn skips reserve_transfer → BIOS may not call enter_static_tag_map.
|
|
begin
|
|
if defined?($story_stats) && $story_stats && $story_stats["ReRollHalfEvents"].to_i == 1
|
|
interp = ($game_map.interpreter rescue nil)
|
|
if interp && interp.respond_to?(:enter_static_tag_map, true)
|
|
interp.send(:enter_static_tag_map, nil, false)
|
|
end
|
|
end
|
|
rescue
|
|
end
|
|
|
|
# fade_type=2 skips Scene_Map fadeout/fadein. Restore brightness and give
|
|
# AUTORUN a few update_for_fade ticks without a visible fade.
|
|
begin
|
|
Graphics.brightness = 255 if defined?(Graphics) && Graphics.respond_to?(:brightness=)
|
|
if $game_map && $game_map.screen
|
|
$game_map.screen.clear_fade if $game_map.screen.respond_to?(:clear_fade)
|
|
$game_map.screen.brightness = 255 if $game_map.screen.respond_to?(:brightness=)
|
|
end
|
|
if fade_used != 0 && fade_used != 1
|
|
scene = SceneManager.scene
|
|
if scene && scene.respond_to?(:update_for_fade)
|
|
20.times { scene.update_for_fade }
|
|
end
|
|
end
|
|
rescue
|
|
end
|
|
|
|
# Belt: drop any queue refill during fade pump, then scrub leaked foreign
|
|
# quest/vermin mice that should never ride along on a reconnect transfer.
|
|
pvp_force_spawn_clear_pending_summons
|
|
if home_ok
|
|
pvp_force_spawn_scrub_home_hostiles
|
|
else
|
|
pvp_force_spawn_scrub_leaked_vermin
|
|
end
|
|
|
|
if same_map_transfer
|
|
begin
|
|
pvp_force_spawn_mark_same_map_reenter($game_map ? $game_map.map_id.to_i : target_numeric_id)
|
|
rescue
|
|
end
|
|
end
|
|
|
|
return true
|
|
rescue => e
|
|
pvp_force_spawn_log("pvp_force_spawn_error", "raw=#{raw_map_id} resolved=#{target_map_id} error=#{e.class}: #{e.message}")
|
|
@pvp_force_spawn_pending = nil
|
|
pvp_force_spawn_recover_fade
|
|
return false
|
|
end
|
|
end
|
|
|
|
def self.pvp_arena_active?
|
|
return false unless pvp_arena_feature_enabled?
|
|
return false unless $game_map && $game_map.map_id.to_i == 90
|
|
true
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.pvp_arena_slots
|
|
@pvp_arena_slots ||= {}
|
|
rescue
|
|
@pvp_arena_slots = {}
|
|
end
|
|
|
|
def self.pvp_arena_runtime_dirty?
|
|
return true if @pvp_arena_clear_pending
|
|
pending = @pvp_arena_pending
|
|
return true if pending && pending.is_a?(Hash) && !pending.empty?
|
|
slots = @pvp_arena_slots
|
|
return true if slots && slots.is_a?(Hash) && !slots.empty?
|
|
false
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.pvp_arena_spawn_queue(slot_id, npc_type, x, y)
|
|
@pvp_arena_pending ||= {}
|
|
@pvp_arena_pending[slot_id.to_i] = {
|
|
npc_type: npc_type.to_s,
|
|
x: x.to_i,
|
|
y: y.to_i
|
|
}
|
|
rescue
|
|
end
|
|
|
|
def self.pvp_arena_clear_all_queue
|
|
@pvp_arena_clear_pending = true
|
|
rescue
|
|
@pvp_arena_clear_pending = true
|
|
end
|
|
|
|
def self.pvp_arena_forget_slot(slot_id)
|
|
pvp_arena_slots.delete(slot_id.to_i)
|
|
rescue
|
|
end
|
|
|
|
def self.pvp_arena_delete_event(ev)
|
|
return unless ev
|
|
begin
|
|
ev.delete if ev.respond_to?(:delete) && (!ev.respond_to?(:deleted?) || !ev.deleted?)
|
|
rescue
|
|
end
|
|
begin
|
|
$game_map.delete_event_from_pos_hash(ev) if $game_map && $game_map.respond_to?(:delete_event_from_pos_hash)
|
|
rescue
|
|
end
|
|
begin
|
|
$game_map.events.delete(ev.id) if $game_map && $game_map.events && ev.respond_to?(:id)
|
|
rescue
|
|
end
|
|
end
|
|
|
|
def self.pvp_arena_local_event(slot_id)
|
|
info = pvp_arena_slots[slot_id.to_i]
|
|
return nil unless info && info.is_a?(Hash)
|
|
return nil unless info[:mode].to_s == "local"
|
|
event_id = info[:event_id].to_i
|
|
return nil if event_id <= 0
|
|
return nil unless $game_map && $game_map.events
|
|
ev = $game_map.events[event_id]
|
|
return nil if ev.nil?
|
|
ev
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def self.pvp_arena_event_dead?(ev)
|
|
return true if ev.nil?
|
|
dead = false
|
|
begin
|
|
dead ||= (ev.respond_to?(:deleted?) && ev.deleted?)
|
|
rescue
|
|
end
|
|
begin
|
|
dead ||= (ev.respond_to?(:erased?) && ev.erased?)
|
|
rescue
|
|
end
|
|
begin
|
|
dead ||= (ev.respond_to?(:npc?) && ev.npc? && ev.actor && ev.actor.action_state == :death)
|
|
rescue
|
|
end
|
|
dead
|
|
rescue
|
|
true
|
|
end
|
|
|
|
def self.pvp_arena_remote_placeholder(slot_id)
|
|
server_event_id = pvp_arena_remote_event_id(slot_id)
|
|
get_map_event(server_event_id)
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def self.pvp_arena_remove_placeholder(slot_id)
|
|
server_event_id = pvp_arena_remote_event_id(slot_id)
|
|
remove_remote_event(server_event_id) if respond_to?(:remove_remote_event)
|
|
rescue
|
|
end
|
|
|
|
def self.pvp_arena_clear_local
|
|
slots = pvp_arena_slots.dup rescue {}
|
|
slots.each do |slot_id, info|
|
|
next unless info.is_a?(Hash)
|
|
if info[:mode].to_s == "local"
|
|
event_id = info[:event_id].to_i rescue 0
|
|
if event_id > 0
|
|
ev = nil
|
|
begin
|
|
ev = $game_map.events[event_id] if $game_map && $game_map.events
|
|
rescue
|
|
ev = nil
|
|
end
|
|
pvp_arena_delete_event(ev) unless ev.nil?
|
|
end
|
|
end
|
|
pvp_arena_remove_placeholder(slot_id)
|
|
end
|
|
(1..PVP_ARENA_SLOT_COUNT).each { |slot_id| pvp_arena_remove_placeholder(slot_id) }
|
|
@pvp_arena_slots = {}
|
|
@pvp_arena_pending = {}
|
|
@pvp_arena_clear_pending = false
|
|
rescue
|
|
@pvp_arena_slots = {}
|
|
@pvp_arena_pending = {}
|
|
@pvp_arena_clear_pending = false
|
|
end
|
|
|
|
def self.pvp_arena_has_local_slots?
|
|
return false unless pvp_arena_slots && pvp_arena_slots.is_a?(Hash)
|
|
pvp_arena_slots.values.any? do |info|
|
|
next false unless info && info.is_a?(Hash)
|
|
info[:mode].to_s == "local"
|
|
end
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.pvp_arena_spawn_local(slot_id, npc_type, x, y)
|
|
return false unless pvp_arena_active?
|
|
return false unless map_master?
|
|
return false unless $game_map && $game_map.respond_to?(:ask_summon_event) && $game_map.respond_to?(:add_event_to_pos_hash)
|
|
|
|
pvp_arena_remove_placeholder(slot_id)
|
|
old_ev = pvp_arena_local_event(slot_id)
|
|
old_info = pvp_arena_slots[slot_id.to_i] rescue nil
|
|
if !old_ev.nil? && !pvp_arena_event_dead?(old_ev)
|
|
old_type = ""
|
|
begin
|
|
old_type = old_info[:npc_type].to_s if old_info.is_a?(Hash)
|
|
rescue
|
|
old_type = ""
|
|
end
|
|
if old_type == npc_type.to_s
|
|
begin
|
|
old_ev.instance_variable_set(:@mp_pvp_arena_managed, true)
|
|
old_ev.instance_variable_set(:@mp_pvp_arena_slot, slot_id.to_i)
|
|
old_ev.instance_variable_set(:@mp_pvp_arena_token, npc_type.to_s)
|
|
rescue
|
|
end
|
|
pvp_arena_slots[slot_id.to_i] = {
|
|
event_id: (old_ev.id.to_i rescue 0),
|
|
npc_type: npc_type.to_s,
|
|
x: (old_ev.x.to_i rescue x.to_i),
|
|
y: (old_ev.y.to_i rescue y.to_i),
|
|
reported: false,
|
|
mode: :local
|
|
}
|
|
return true
|
|
end
|
|
end
|
|
|
|
pvp_arena_delete_event(old_ev) unless old_ev.nil?
|
|
pvp_arena_forget_slot(slot_id)
|
|
|
|
ev = nil
|
|
used_token = npc_type.to_s
|
|
begin
|
|
candidates = [npc_type.to_s, "HumanWarrior", "GoblinBow", "UndeadCommoner"].uniq
|
|
candidates.each do |token|
|
|
next if token.to_s.empty?
|
|
begin
|
|
ev = $game_map.ask_summon_event(token.to_s, x.to_i, y.to_i, -1, {
|
|
"mp_pvp_arena" => true,
|
|
"mp_pvp_slot" => slot_id.to_i
|
|
})
|
|
rescue
|
|
ev = nil
|
|
end
|
|
next if ev.nil?
|
|
used_token = token.to_s
|
|
break
|
|
end
|
|
return false if ev.nil?
|
|
$game_map.add_event_to_pos_hash(ev)
|
|
rescue
|
|
return false
|
|
end
|
|
|
|
begin
|
|
ev.instance_variable_set(:@mp_pvp_arena_managed, true)
|
|
ev.instance_variable_set(:@mp_pvp_arena_slot, slot_id.to_i)
|
|
ev.instance_variable_set(:@mp_pvp_arena_token, used_token.to_s)
|
|
ev.instance_variable_set(:@mp_pvp_arena_reported, false)
|
|
ev.force_update = true if ev.respond_to?(:force_update=)
|
|
ev.refresh if ev.respond_to?(:refresh)
|
|
rescue
|
|
end
|
|
|
|
pvp_arena_slots[slot_id.to_i] = {
|
|
event_id: (ev.id.to_i rescue 0),
|
|
npc_type: used_token.to_s,
|
|
x: (ev.x.to_i rescue x.to_i),
|
|
y: (ev.y.to_i rescue y.to_i),
|
|
reported: false,
|
|
mode: :local
|
|
}
|
|
true
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.pvp_arena_spawn_placeholder(slot_id, npc_type, x, y)
|
|
return false unless pvp_arena_active?
|
|
server_event_id = pvp_arena_remote_event_id(slot_id)
|
|
|
|
begin
|
|
create_remote_event(server_event_id, 0, x.to_i, y.to_i, "PvpArena_#{slot_id}") if get_map_event(server_event_id).nil?
|
|
rescue
|
|
return false
|
|
end
|
|
|
|
ev = get_map_event(server_event_id)
|
|
return false if ev.nil?
|
|
|
|
begin
|
|
ev.instance_variable_set(:@net_npc_type, npc_type.to_s)
|
|
rescue
|
|
end
|
|
begin
|
|
apply_remote_npc_graphic(ev, npc_type.to_s) if respond_to?(:apply_remote_npc_graphic)
|
|
rescue
|
|
end
|
|
begin
|
|
page = ev.instance_variable_get(:@page) rescue nil
|
|
page.through = true if page && page.respond_to?(:through=)
|
|
ev.through = true if ev.respond_to?(:through=)
|
|
ev.instance_variable_set(:@through, true)
|
|
rescue
|
|
end
|
|
begin
|
|
move_remote_event(server_event_id, x.to_i, y.to_i, (ev.direction rescue 2), (ev.instance_variable_get(:@pattern) rescue 0)) if respond_to?(:move_remote_event)
|
|
rescue
|
|
end
|
|
|
|
pvp_arena_slots[slot_id.to_i] = {
|
|
event_id: server_event_id,
|
|
npc_type: npc_type.to_s,
|
|
x: x.to_i,
|
|
y: y.to_i,
|
|
reported: true,
|
|
mode: :remote
|
|
}
|
|
true
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.pvp_arena_reconcile_master_state
|
|
return false unless pvp_arena_active?
|
|
return false unless pvp_arena_slots && pvp_arena_slots.is_a?(Hash) && !pvp_arena_slots.empty?
|
|
|
|
changed = false
|
|
if map_master?
|
|
pvp_arena_slots.keys.sort.each do |slot_id|
|
|
info = pvp_arena_slots[slot_id]
|
|
next unless info && info.is_a?(Hash)
|
|
next if info[:mode].to_s == "local"
|
|
|
|
px = info[:x].to_i rescue 0
|
|
py = info[:y].to_i rescue 0
|
|
if (px <= 0 || py <= 0)
|
|
begin
|
|
ev = pvp_arena_remote_placeholder(slot_id)
|
|
px = ev.x.to_i if ev && px <= 0
|
|
py = ev.y.to_i if ev && py <= 0
|
|
rescue
|
|
end
|
|
end
|
|
next if px <= 0 || py <= 0
|
|
changed = true if pvp_arena_spawn_local(slot_id, info[:npc_type], px, py)
|
|
end
|
|
end
|
|
changed
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.pvp_arena_apply_pending
|
|
saved_pending = nil
|
|
begin
|
|
saved_pending = @pvp_arena_pending.dup if @pvp_arena_pending && @pvp_arena_pending.is_a?(Hash)
|
|
rescue
|
|
saved_pending = nil
|
|
end
|
|
if @pvp_arena_clear_pending
|
|
pvp_arena_clear_local
|
|
@pvp_arena_pending = saved_pending || {}
|
|
end
|
|
return false unless pvp_arena_active?
|
|
pending = @pvp_arena_pending
|
|
return false unless pending && pending.is_a?(Hash) && !pending.empty?
|
|
|
|
pending.keys.sort.each do |slot_id|
|
|
data = pending[slot_id]
|
|
next unless data && data.is_a?(Hash)
|
|
if map_master?
|
|
pvp_arena_spawn_local(slot_id, data[:npc_type], data[:x], data[:y])
|
|
else
|
|
old_ev = pvp_arena_local_event(slot_id)
|
|
pvp_arena_delete_event(old_ev) unless old_ev.nil?
|
|
pvp_arena_spawn_placeholder(slot_id, data[:npc_type], data[:x], data[:y])
|
|
end
|
|
end
|
|
@pvp_arena_pending = {}
|
|
true
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.pvp_arena_scan_deaths
|
|
unless pvp_arena_active?
|
|
pvp_arena_clear_local if pvp_arena_slots && !pvp_arena_slots.empty?
|
|
return
|
|
end
|
|
|
|
unless map_master?
|
|
pvp_arena_clear_local if pvp_arena_has_local_slots?
|
|
return
|
|
end
|
|
|
|
pvp_arena_slots.keys.each do |slot_id|
|
|
info = pvp_arena_slots[slot_id]
|
|
next unless info && info.is_a?(Hash)
|
|
ev = pvp_arena_local_event(slot_id)
|
|
|
|
if ev.nil?
|
|
next if info[:reported]
|
|
info[:reported] = true
|
|
send_line("pvp_arena_dead:#{slot_id}") if respond_to?(:send_line)
|
|
next
|
|
end
|
|
|
|
dead = pvp_arena_event_dead?(ev)
|
|
next unless dead
|
|
next if info[:reported]
|
|
|
|
info[:reported] = true
|
|
begin
|
|
send_line("pvp_arena_dead:#{slot_id}:#{ev.x.to_i}:#{ev.y.to_i}") if respond_to?(:send_line)
|
|
rescue
|
|
send_line("pvp_arena_dead:#{slot_id}") if respond_to?(:send_line)
|
|
end
|
|
end
|
|
rescue
|
|
end
|
|
|
|
class << self
|
|
unless method_defined?(:mp_pvp_spawn_parse__orig)
|
|
alias mp_pvp_spawn_parse__orig parse
|
|
def parse(msg)
|
|
if msg =~ /^pvp_force_spawn:(-?\d+):(-?\d+):(-?\d+):(-?\d+):(-?\d+)$/
|
|
pvp_force_spawn_queue($1, $2, $3, $4, $5)
|
|
return
|
|
end
|
|
if msg =~ /^pvp_arena_spawn:(\d+):([^:]+):(-?\d+):(-?\d+)$/
|
|
unless pvp_arena_feature_enabled?
|
|
pvp_arena_clear_local
|
|
return
|
|
end
|
|
pvp_arena_spawn_queue($1, $2, $3, $4)
|
|
return
|
|
end
|
|
if msg == "pvp_arena_clear_all"
|
|
if pvp_arena_feature_enabled?
|
|
pvp_arena_clear_all_queue
|
|
else
|
|
pvp_arena_clear_local
|
|
end
|
|
return
|
|
end
|
|
mp_pvp_spawn_parse__orig(msg)
|
|
end
|
|
end
|
|
|
|
if method_defined?(:disconnect) && !method_defined?(:mp_pvp_spawn_disconnect__orig)
|
|
alias mp_pvp_spawn_disconnect__orig disconnect
|
|
def disconnect(*args)
|
|
pvp_force_spawn_clear
|
|
pvp_arena_clear_local
|
|
mp_pvp_spawn_disconnect__orig(*args)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
module MPPvPMainMenuSave
|
|
SAVE_COOLDOWN = 0.75
|
|
|
|
module_function
|
|
|
|
def arena_active?
|
|
return false unless defined?(MP_ArenaFlag) && MP_ArenaFlag.respond_to?(:arena_active?)
|
|
!!MP_ArenaFlag.arena_active?
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def save_slot_index
|
|
if defined?(OnlineServerRegistry) && OnlineServerRegistry.respond_to?(:selected_slot_index)
|
|
idx = OnlineServerRegistry.selected_slot_index.to_i
|
|
return idx if idx >= 0
|
|
end
|
|
0
|
|
rescue
|
|
0
|
|
end
|
|
|
|
def can_save_now?
|
|
return false unless arena_active?
|
|
return false unless defined?(DataManager) && DataManager.respond_to?(:save_game)
|
|
return false unless defined?($game_player) && $game_player
|
|
return false unless defined?($game_party) && $game_party
|
|
true
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def read_save_contents(index)
|
|
return nil unless defined?(DataManager) && DataManager.respond_to?(:make_filename)
|
|
path = DataManager.make_filename(index.to_i) rescue nil
|
|
return nil if path.nil? || path.to_s.empty? || !File.exist?(path)
|
|
File.open(path, "rb") do |file|
|
|
Marshal.load(file) rescue nil
|
|
Marshal.load(file) rescue nil
|
|
end
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def begin_preserve(index)
|
|
@preserve_index = index.to_i
|
|
@preserve_old_contents = read_save_contents(@preserve_index)
|
|
rescue
|
|
@preserve_index = nil
|
|
@preserve_old_contents = nil
|
|
end
|
|
|
|
def finish_preserve
|
|
@preserve_index = nil
|
|
@preserve_old_contents = nil
|
|
rescue
|
|
@preserve_index = nil
|
|
@preserve_old_contents = nil
|
|
end
|
|
|
|
def patch_contents(contents)
|
|
return contents unless contents.is_a?(Hash)
|
|
old = @preserve_old_contents
|
|
return contents unless old.is_a?(Hash)
|
|
|
|
begin
|
|
contents[:map] = old[:map] if old.key?(:map)
|
|
contents[:player] = old[:player] if old.key?(:player)
|
|
rescue
|
|
end
|
|
|
|
contents
|
|
rescue
|
|
contents
|
|
end
|
|
|
|
def save_before_main_menu
|
|
return false unless can_save_now?
|
|
|
|
now = Time.now.to_f rescue 0.0
|
|
last = @last_menu_save_at.to_f rescue 0.0
|
|
return false if last > 0.0 && (now - last) < SAVE_COOLDOWN
|
|
|
|
index = save_slot_index
|
|
begin_preserve(index)
|
|
ok = !!DataManager.save_game(index)
|
|
@last_menu_save_at = now
|
|
ok
|
|
rescue
|
|
false
|
|
ensure
|
|
finish_preserve
|
|
end
|
|
end
|
|
|
|
module DataManager
|
|
class << self
|
|
unless method_defined?(:mp_pvp_main_menu_make_save_contents__orig)
|
|
alias mp_pvp_main_menu_make_save_contents__orig make_save_contents
|
|
end
|
|
|
|
def make_save_contents
|
|
contents = mp_pvp_main_menu_make_save_contents__orig
|
|
if defined?(MPPvPMainMenuSave)
|
|
contents = MPPvPMainMenuSave.patch_contents(contents)
|
|
end
|
|
contents
|
|
end
|
|
end
|
|
end
|
|
|
|
if defined?(Menu_System)
|
|
class Menu_System
|
|
unless method_defined?(:mp_pvp_main_menu_return_title__orig)
|
|
alias mp_pvp_main_menu_return_title__orig return_title_handler
|
|
end
|
|
|
|
def return_title_handler
|
|
begin
|
|
MPPvPMainMenuSave.save_before_main_menu if defined?(MPPvPMainMenuSave)
|
|
rescue
|
|
end
|
|
begin
|
|
$titleCreateActorReq = true
|
|
rescue
|
|
end
|
|
mp_pvp_main_menu_return_title__orig
|
|
end
|
|
end
|
|
end
|
|
|
|
class Scene_Map < Scene_Base
|
|
alias mp_pvp_spawn_update update
|
|
def update
|
|
begin
|
|
WebSocket.pvp_force_spawn_apply if defined?(WebSocket)
|
|
rescue
|
|
end
|
|
begin
|
|
if defined?(WebSocket)
|
|
if WebSocket.pvp_arena_feature_enabled?
|
|
WebSocket.pvp_arena_apply_pending
|
|
WebSocket.pvp_arena_reconcile_master_state
|
|
WebSocket.pvp_arena_scan_deaths
|
|
elsif WebSocket.pvp_arena_runtime_dirty?
|
|
WebSocket.pvp_arena_clear_local
|
|
end
|
|
end
|
|
rescue
|
|
end
|
|
mp_pvp_spawn_update
|
|
end
|
|
end
|