# 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