Files
LonaRPG-Online-Games/ModScripts/multiplayer/28_spawnpvp.rb
T
2026-10-29 21:59:06 +04:00

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