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

2121 lines
55 KiB
Ruby

# encoding: UTF-8
# OnlineServerSelect client UI 1.0.1 — stable server overview rendering.
begin
require "json" unless defined?(JSON)
rescue LoadError, ScriptError
end
begin
unless defined?(MPNativeSecureChannel)
secure_path = File.join(Dir.pwd.to_s, 'ModScripts', '001_MPNativeSecureChannel.rb')
load secure_path if File.file?(secure_path)
end
rescue Exception => e
puts "[SECURE] status loader failed: #{e.class}: #{e.message}" rescue nil
end
module ArenaFlagFile
FILE_PATH = File.expand_path("arena.json", __dir__)
class << self
def pvp_arena_entry?(entry)
return false unless entry.is_a?(Hash)
sid = entry["id"].to_s.downcase rescue ""
name = entry["name"].to_s.downcase rescue ""
return true if sid == "pvp_arena"
return true if sid.include?("arena") && sid.include?("pvp")
return true if name.include?("arena") && name.include?("pvp")
return true if name.include?("арена") && name.include?("pvp")
false
rescue
false
end
def write_value(value)
num = value.to_i > 0 ? 1 : 0
begin
$mp_arena_runtime_flag = num
rescue
end
payload = { "arena" => num }
raw = nil
begin
raw = JSON.pretty_generate(payload) if defined?(JSON)
rescue
raw = nil
end
raw = "{\n \"arena\": #{num}\n}\n" if raw.nil? || raw.to_s.empty?
begin
dir = File.dirname(FILE_PATH)
Dir.mkdir(dir) unless dir.nil? || dir.empty? || Dir.exist?(dir)
rescue
end
File.open(FILE_PATH, "wb") { |f| f.write(raw) }
true
rescue
false
end
def mark_connect(entry)
write_value(pvp_arena_entry?(entry) ? 1 : 0)
rescue
false
end
def mark_main_menu
write_value(0)
rescue
false
end
end
end
module PvPArenaSaveBackup
BACKUP_NAME = "Backup.rvdata2"
PVP_ARENA_MAP_ID = 90
class << self
def save01_path
return DataManager.make_filename(0) if defined?(DataManager) && DataManager.respond_to?(:make_filename)
File.join("UserData", "Save01.rvdata2")
rescue
File.join("UserData", "Save01.rvdata2")
end
def backup_path
base = save01_path.to_s
dir = File.dirname(base)
return File.join(dir, BACKUP_NAME) unless dir.nil? || dir.to_s.strip == ""
BACKUP_NAME
rescue
File.join("UserData", BACKUP_NAME)
end
def pvp_entry?(entry)
return false unless defined?(ArenaFlagFile) && ArenaFlagFile.respond_to?(:pvp_arena_entry?)
ArenaFlagFile.pvp_arena_entry?(entry)
rescue
false
end
def copy_file(src, dst)
return false if src.to_s.strip == "" || dst.to_s.strip == ""
return false unless File.exist?(src)
begin
dir = File.dirname(dst)
Dir.mkdir(dir) unless dir.nil? || dir.empty? || Dir.exist?(dir)
rescue
end
File.open(src, "rb") do |infile|
File.open(dst, "wb") do |outfile|
while (chunk = infile.read(16384))
outfile.write(chunk)
end
end
end
true
rescue
false
end
def backup_save01
copy_file(save01_path, backup_path)
rescue
false
end
def restore_save01_if_missing
save_path = save01_path
return false if File.exist?(save_path)
copy_file(backup_path, save_path)
rescue
false
end
def prepare_online_menu_entry
restore_save01_if_missing
rescue
false
end
def map_id_from_save(path)
return nil if path.to_s.strip == "" || !File.exist?(path)
File.open(path, "rb") do |file|
Marshal.load(file) rescue nil
contents = Marshal.load(file) rescue nil
return nil unless contents.is_a?(Hash)
map_obj = contents[:map] rescue nil
return nil if map_obj.nil?
begin
return map_obj.map_id.to_i if map_obj.respond_to?(:map_id)
rescue
end
begin
raw = map_obj.instance_variable_get(:@map_id)
return raw.to_i unless raw.nil?
rescue
end
end
nil
rescue
nil
end
def restore_save01_if_arena_position
save_path = save01_path
bak_path = backup_path
return false unless File.exist?(save_path)
return false unless File.exist?(bak_path)
map_id = map_id_from_save(save_path)
return false unless map_id.to_i == PVP_ARENA_MAP_ID
copy_file(bak_path, save_path)
rescue
false
end
def prepare_server_connect(entry)
if pvp_entry?(entry)
backup_save01
else
restore_save01_if_arena_position
end
rescue
false
end
end
end
module OnlineServerRegistry
FILE_PATH = "ModScripts/selver_list.json"
DEFAULT_SERVERS = [
{
"id" => "anarchy",
"name" => "Анархия",
"description" => "Основной сервер без ограничений.",
"host" => "lonarpg.online",
"port" => 25565,
"save_slot" => 1
},
{
"id" => "pvp_arena",
"name" => "PvP Арена",
"description" => "Арена для боев между игроками.",
"host" => "lonarpg.online",
"port" => 25566,
"save_slot" => 1
},
{
"id" => "peaceful",
"name" => "Мирный",
"description" => "Мирный сервер для спокойной игры.",
"host" => "lonarpg.online",
"port" => 25567,
"save_slot" => 20
},
{
"id" => "vip",
"name" => "Vip",
"description" => "Vip server.",
"host" => "lonarpg.online",
"port" => 25569,
"save_slot" => 1
},
{
"id" => "development",
"name" => "Разработка",
"description" => "Сервер разработки. Доступ только для OWNER.",
"host" => "lonarpg.online",
"port" => 50126,
"save_slot" => 1
}
]
class << self
def strip_utf8_bom(text)
raw = text.to_s
raw.sub(/\A\xEF\xBB\xBF/n, "")
rescue
text.to_s
end
def json_unescape(text)
out = text.to_s.dup
out.gsub!(/\\u([0-9a-fA-F]{4})/) do
begin
[$1.to_i(16)].pack("U")
rescue
""
end
end
out.gsub!(/\\(["\\\/bfnrt])/) do
case $1
when '"'
'"'
when "\\"
"\\"
when "/"
"/"
when "b"
"\b"
when "f"
"\f"
when "n"
"\n"
when "r"
"\r"
when "t"
"\t"
else
$1
end
end
out
rescue
text.to_s
end
def extract_json_string(text, key)
md = text.to_s.match(/"#{Regexp.escape(key)}"\s*:\s*"((?:\\.|[^"])*)"/m)
return nil unless md
json_unescape(md[1])
rescue
nil
end
def extract_json_int(text, key)
md = text.to_s.match(/"#{Regexp.escape(key)}"\s*:\s*(-?\d+)/m)
return nil unless md
md[1].to_i
rescue
nil
end
def manual_parse_servers(raw)
text = strip_utf8_bom(raw)
begin
text = text.dup.force_encoding("UTF-8")
rescue
end
body = text
begin
md = text.match(/"servers"\s*:\s*\[(.*)\]\s*\}\s*\z/m)
body = md[1].to_s if md
rescue
end
parsed = []
begin
body.scan(/\{(.*?)\}/m) do |match|
chunk = match[0].to_s
entry = {
"id" => extract_json_string(chunk, "id"),
"name" => extract_json_string(chunk, "name"),
"description" => extract_json_string(chunk, "description"),
"host" => extract_json_string(chunk, "host"),
"port" => extract_json_int(chunk, "port"),
"save_slot" => extract_json_int(chunk, "save_slot")
}
parsed << entry
end
rescue
end
normalize_servers(parsed)
rescue
[]
end
def parse_servers(raw)
text = strip_utf8_bom(raw)
begin
text = text.dup.force_encoding("UTF-8")
rescue
end
obj = nil
if defined?(JSON)
begin
obj = JSON.parse(text)
rescue
begin
obj = JSON.parse(text)
rescue
obj = nil
end
end
end
list =
if obj.is_a?(Hash)
obj["servers"] || obj[:servers]
else
obj
end
parsed = normalize_servers(list)
return parsed unless parsed.empty?
manual_parse_servers(text)
rescue
manual_parse_servers(raw)
end
def normalize_servers(list)
out = []
Array(list).each do |entry|
next unless entry.is_a?(Hash)
name = (entry["name"] || entry[:name]).to_s.strip
host = (entry["host"] || entry[:host]).to_s.strip
description = (entry["description"] || entry[:description]).to_s.strip
port = (entry["port"] || entry[:port]).to_i
save_slot = (entry["save_slot"] || entry[:save_slot]).to_i
next if name == "" || host == "" || port <= 0 || save_slot <= 0
out << {
"id" => (entry["id"] || entry[:id]).to_s,
"name" => name,
"description" => description,
"host" => host,
"port" => port,
"save_slot" => save_slot
}
end
out
rescue
[]
end
def load_servers
begin
if File.exist?(FILE_PATH)
raw = Ruby310Compat.read_text_file(FILE_PATH)
parsed = parse_servers(raw)
return parsed unless parsed.empty?
end
rescue
end
normalize_servers(DEFAULT_SERVERS)
end
def servers
@servers = load_servers if @servers.nil? || !@servers.is_a?(Array) || @servers.empty?
@servers
end
def reload!
old_id = nil
begin
old_id = @selected_server["id"].to_s if @selected_server.is_a?(Hash)
rescue
old_id = nil
end
@servers = nil
list = servers
picked = nil
if old_id && old_id != ""
begin
picked = list.find { |srv| srv.is_a?(Hash) && srv["id"].to_s == old_id }
rescue
picked = nil
end
end
@selected_server = picked.is_a?(Hash) ? picked.dup : nil
@selected_server = default_server if @selected_server.nil?
list
end
def default_server
list = servers
first = list.first if list.is_a?(Array)
first.is_a?(Hash) ? first.dup : nil
rescue
nil
end
def select_server(entry)
@selected_server = entry.is_a?(Hash) ? entry.dup : nil
rescue
@selected_server = nil
end
def selected_server
@selected_server = default_server if @selected_server.nil? || !@selected_server.is_a?(Hash)
@selected_server
end
def selected_name
srv = selected_server
return "Онлайн" unless srv.is_a?(Hash)
name = srv["name"].to_s.strip
name == "" ? "Онлайн" : name
rescue
"Онлайн"
end
def selected_host
srv = selected_server
fallback = default_server || {}
return fallback["host"].to_s unless srv.is_a?(Hash)
host = srv["host"].to_s.strip
host = fallback["host"].to_s.strip if host == ""
host == "" ? "lonarpg.online" : host
rescue
"lonarpg.online"
end
def selected_port
srv = selected_server
fallback = default_server || {}
fallback_port = fallback["port"].to_i
fallback_port = 6134 if fallback_port <= 0
return fallback_port unless srv.is_a?(Hash)
port = srv["port"].to_i
port > 0 ? port : fallback_port
rescue
6134
end
def selected_save_slot
srv = selected_server
return 1 unless srv.is_a?(Hash)
slot = srv["save_slot"].to_i
slot > 0 ? slot : 1
rescue
1
end
def selected_slot_index
idx = selected_save_slot.to_i - 1
idx < 0 ? 0 : idx
rescue
0
end
def vip_server_entry?(entry = nil)
srv = entry.is_a?(Hash) ? entry : selected_server
return false unless srv.is_a?(Hash)
sid = srv["id"].to_s.strip.downcase
name = srv["name"].to_s.strip.downcase
sid == "vip" || name == "vip"
rescue
false
end
def development_server_entry?(entry = nil)
srv = entry.is_a?(Hash) ? entry : selected_server
return false unless srv.is_a?(Hash)
sid = srv["id"].to_s.strip.downcase
name = srv["name"].to_s.strip.downcase
sid == "development" || name == "разработка"
rescue
false
end
def vip_code
@vip_code = "" if @vip_code.nil?
@vip_code.to_s
rescue
""
end
def set_vip_code(code)
safe = code.to_s.gsub(/[^0-9A-Za-z_\-]/, "")
safe = safe[0, 32]
@vip_code = safe
safe
rescue
@vip_code = ""
""
end
def clear_vip_code
@vip_code = ""
rescue
@vip_code = ""
end
end
end
module OnlineServerStatus
REFRESH_FRAMES = 300
HANG_FRAMES = 120
READ_TIMEOUT = 1.5
class << self
def reset
@records = {}
end
def records
@records ||= {}
end
def key(entry)
host = entry.is_a?(Hash) ? entry["host"].to_s : ""
port = entry.is_a?(Hash) ? entry["port"].to_i : 0
"#{host}:#{port}"
rescue
""
end
def record(entry)
k = key(entry)
records[k] ||= {
:state => :unknown,
:online_count => nil,
:checked_at => 0,
:started_at => 0,
:thread => nil,
:token => 0
}
end
def state(entry)
rec = record(entry)
now = Graphics.frame_count rescue 0
if rec[:state] == :checking && rec[:started_at].to_i > 0 && (now - rec[:started_at].to_i) > HANG_FRAMES
rec[:state] = :offline
rec[:checked_at] = now
end
rec[:state]
rescue
:unknown
end
def status_text(entry)
case state(entry)
when :online then "ВКЛЮЧЕН"
when :offline then "ВЫКЛЮЧЕН"
when :checking then "ПРОВЕРКА..."
else "НЕИЗВЕСТНО"
end
rescue
"НЕИЗВЕСТНО"
end
def status_color(entry)
case state(entry)
when :online then Color.new(90, 255, 120)
when :offline then Color.new(255, 90, 90)
when :checking then Color.new(255, 210, 110)
else Color.new(220, 220, 220)
end
rescue
Color.new(220, 220, 220)
end
def signature(entry)
rec = record(entry)
"#{rec[:state]}:#{rec[:checked_at]}:#{rec[:online_count]}"
rescue
"unknown:0"
end
def online_count(entry)
rec = record(entry)
value = rec[:online_count]
return nil if value.nil?
out = value.to_i
out < 0 ? nil : out
rescue
nil
end
def online_count_text(entry)
st = state(entry)
count = online_count(entry)
return count.to_i.to_s unless count.nil?
return "..." if st == :checking
"0"
rescue
"0"
end
def read_probe_payload(sock)
payload = ""
begin
deadline = (Time.now.to_f rescue 0.0) + READ_TIMEOUT.to_f
loop do
now = (Time.now.to_f rescue 0.0)
left = deadline - now
break if left <= 0.0
ready = IO.select([sock], nil, nil, left)
break unless ready && ready[0] && ready[0].include?(sock)
chunk = sock.recv(512).to_s
break if chunk.nil? || chunk.empty?
payload << chunk
extra = IO.select([sock], nil, nil, 0.02)
break unless extra && extra[0] && extra[0].include?(sock)
end
rescue
payload = ""
end
payload
end
def extract_online_count(payload)
text = payload.to_s
patterns = [
/online_count\s*[:=]\s*(-?\d+)/i,
/"online_count"\s*:\s*(-?\d+)/i,
/player_count\s*[:=]\s*(-?\d+)/i,
/"player_count"\s*:\s*(-?\d+)/i,
/players_online\s*[:=]\s*(-?\d+)/i,
/"players_online"\s*:\s*(-?\d+)/i,
/players\s*[:=]\s*(-?\d+)/i,
/"players"\s*:\s*(-?\d+)/i,
/online\s*[:=]\s*(-?\d+)/i,
/"online"\s*:\s*(-?\d+)/i
]
patterns.each do |rx|
md = text.match(rx)
next unless md
v = md[1].to_i
return nil if v < 0
return v
end
nil
rescue
nil
end
def touch(entry)
return unless entry.is_a?(Hash)
rec = record(entry)
now = Graphics.frame_count rescue 0
if rec[:thread] && rec[:thread].alive?
if rec[:state] != :checking
rec[:state] = :checking
rec[:started_at] = now
end
return
end
return if rec[:checked_at].to_i > 0 && (now - rec[:checked_at].to_i) < REFRESH_FRAMES
host = entry["host"].to_s
port = entry["port"].to_i
return if host == "" || port <= 0
token = rec[:token].to_i + 1
rec[:token] = token
rec[:state] = :checking
rec[:started_at] = now
rec[:thread] = Thread.new do
ok = false
online_count = nil
begin
raise LoadError, 'MPNativeSecureChannel is unavailable' unless defined?(MPNativeSecureChannel)
payload = MPNativeSecureChannel.status_probe(host, port, READ_TIMEOUT.to_f + 1.5)
ok = server_payload_valid?(payload)
online_count = extract_online_count(payload)
rescue Exception => e
puts "[SECURE] status probe failed #{host}:#{port}: #{e.class}: #{e.message}" rescue nil
ok = false
end
begin
current = records[key(entry)]
if current && current[:token].to_i == token
current[:state] = ok ? :online : :offline
current[:online_count] = ok ? (online_count.nil? ? 0 : online_count) : nil
current[:checked_at] = (Graphics.frame_count rescue 0)
current[:started_at] = 0
current[:thread] = nil
end
rescue
end
end
rescue
rec[:state] = :offline if rec
end
def server_payload_valid?(payload)
text = payload.to_s
return false if text.strip == ""
return true if text.include?("server_status:ok")
return true if text.include?("online_count:")
return true if text.include?("\"online_count\"")
return true if text.include?("\"player_count\"")
return true if text.include?("\"players_online\"")
return true if text.include?("welcome:")
return true if text.include?("version_need:")
return true if text.include?("cap:proto:")
return true if text.include?("version_ok")
return true if text.include?("version_bad:")
false
rescue
false
end
def touch_all(entries)
Array(entries).each { |entry| touch(entry) }
rescue
end
def dispose
begin
records.each_value do |rec|
thr = rec[:thread]
thr.kill if thr && thr.alive?
end
rescue
end
@records = {}
end
end
end
class Window_ServerSaveFile < Window_Base
attr_reader :selected
def initialize(height, index, entry)
tmpGW = Graphics.width
super(tmpGW / 20, index * height, tmpGW / 2 - tmpGW / 20, height)
@server_entry = entry
@file_index = index
@selected = false
@last_signature = nil
contents.font.size = System_Settings::FONT_SIZE::WINDOW_FILE_SAVE_SLOT
contents.font.outline = false
refresh
end
def server_name_font
return MPSafeFont.server_name if defined?(MPSafeFont) && MPSafeFont.respond_to?(:server_name)
return FONT_MOD::SAVE_SLOT if defined?(FONT_MOD) && FONT_MOD.const_defined?(:SAVE_SLOT)
"VL Gothic"
rescue
"VL Gothic"
end
def server_status_font
return MPSafeFont.server_status_name if defined?(MPSafeFont) && MPSafeFont.respond_to?(:server_status_name)
return FONT_MOD::FILE_TITLE if defined?(FONT_MOD) && FONT_MOD.const_defined?(:FILE_TITLE)
server_name_font
rescue
server_name_font
end
def server_meta_font
return MPSafeFont.server_meta_name if defined?(MPSafeFont) && MPSafeFont.respond_to?(:server_meta_name)
return FONT_MOD::STAT_INFO if defined?(FONT_MOD) && FONT_MOD.const_defined?(:STAT_INFO)
server_name_font
rescue
server_name_font
end
def selected=(selected)
@selected = selected
update_cursor
end
def update
super
sig = window_signature
return if sig == @last_signature
refresh
end
def update_cursor
if @selected
cursor_rect.set(0, 0, contents.width, contents.height)
else
cursor_rect.empty
end
end
def slot_index
idx = @server_entry["save_slot"].to_i - 1
idx < 0 ? 0 : idx
rescue
0
end
def load_header
DataManager.load_header(slot_index)
rescue
nil
end
def save_exists?
DataManager.saveFileExistsRGSS_slot?(slot_index + 1)
rescue
false
end
def window_signature
header = load_header
[
OnlineServerStatus.signature(@server_entry),
header ? header[:date].to_s : "",
header ? header[:playtime_s].to_s : "",
header ? header[:title].to_s : "",
save_exists?.to_s
].join("|")
rescue
"sig-error"
end
def refresh
@last_signature = window_signature
contents.clear
contents.font.outline = false
draw_server_name
draw_server_status
draw_slot_label
draw_save_title
draw_save_date
draw_playtime
rescue
end
def draw_server_name
contents.font.name = server_name_font
contents.font.size = System_Settings::FONT_SIZE::WINDOW_FILE_SAVE_SLOT
contents.font.color = normal_color
contents.draw_text(6, 0, contents.width - 12, line_height, @server_entry["name"].to_s, 0)
end
def draw_server_status
contents.font.name = server_status_font
contents.font.size = System_Settings::FONT_SIZE::WINDOW_FILE_PLAYTIME
contents.font.color = OnlineServerStatus.status_color(@server_entry)
contents.draw_text(-6, 0, contents.width - 8, line_height, OnlineServerStatus.status_text(@server_entry), 2)
rescue
contents.font.color = normal_color
end
def draw_slot_label
contents.font.name = server_meta_font
contents.font.size = System_Settings::FONT_SIZE::WINDOW_FILE_LVL
contents.font.color = normal_color
contents.draw_text(6, contents.height - line_height + 3, contents.width - 4, line_height, "Онлайн #{OnlineServerStatus.online_count_text(@server_entry)}", 0)
end
def draw_playtime
header = load_header
contents.font.name = server_meta_font
contents.font.size = System_Settings::FONT_SIZE::WINDOW_FILE_PLAYTIME
contents.font.color = normal_color
txt = "--:--:--"
begin
txt = header[:playtime_s].to_s if header && header[:playtime_s]
rescue
txt = "--:--:--"
end
contents.draw_text(-6, contents.height - line_height + 3, contents.width - 4, line_height, txt, 2)
end
def draw_save_date
header = load_header
contents.font.name = server_meta_font
contents.font.size = System_Settings::FONT_SIZE::WINDOW_FILE_DATE
contents.font.color = normal_color
txt = "Нет сохранения"
begin
txt = header[:date].to_s if header && header[:date]
rescue
txt = "Нет сохранения"
end
contents.draw_text(6, contents.height - line_height + 3, contents.width - 4, line_height, txt, 1)
end
def draw_save_title
header = load_header
contents.font.size = System_Settings::FONT_SIZE::WINDOW_FILE_TITLE
contents.font.color = normal_color
txt = @server_entry["description"].to_s
begin
if header && header[:title]
txt = $game_text[header[:title]]
end
rescue
end
txt = "" if txt.nil? || txt.to_s.strip == ""
# contents.draw_text(-6, 7, contents.width - 4, line_height, txt.to_s, 2)
end
end
class Window_ServerOverview < Window_Base
def initialize(x, y, width, height)
super
@server_index = 0
@last_signature = nil
@server_logo_warned = {}
normalize_visual_state
end
# The overview is informational and must never inherit a faded/closed state
# from another file/menu window. The frame and contents stay fully visible.
def normalize_visual_state
self.visible = true
self.openness = 255
self.opacity = 255
self.back_opacity = 255
self.contents_opacity = 255
self.color.set(0, 0, 0, 0) if self.respond_to?(:color) && self.color
self.tone.set(0, 0, 0, 0) if self.respond_to?(:tone) && self.tone
true
rescue
false
end
def server_name_font
return MPSafeFont.server_name if defined?(MPSafeFont) && MPSafeFont.respond_to?(:server_name)
return FONT_MOD::SAVE_SLOT if defined?(FONT_MOD) && FONT_MOD.const_defined?(:SAVE_SLOT)
"VL Gothic"
rescue
"VL Gothic"
end
def server_status_font
return MPSafeFont.server_status_name if defined?(MPSafeFont) && MPSafeFont.respond_to?(:server_status_name)
return FONT_MOD::FILE_TITLE if defined?(FONT_MOD) && FONT_MOD.const_defined?(:FILE_TITLE)
server_name_font
rescue
server_name_font
end
def server_description_font
return MPSafeFont.server_description_name if defined?(MPSafeFont) && MPSafeFont.respond_to?(:server_description_name)
return FONT_MOD::STAT_INFO if defined?(FONT_MOD) && FONT_MOD.const_defined?(:STAT_INFO)
server_name_font
rescue
server_name_font
end
def set_file_index(index)
set_server_index(index)
end
def set_server_index(index)
@server_index = index.to_i
refresh
rescue
end
def update
normalize_visual_state
super
sig = window_signature
return if sig == @last_signature
refresh
end
def current_entry
OnlineServerRegistry.servers[@server_index]
rescue
nil
end
def slot_index
entry = current_entry
return 0 unless entry.is_a?(Hash)
idx = entry["save_slot"].to_i - 1
idx < 0 ? 0 : idx
rescue
0
end
def load_header
DataManager.load_header(slot_index)
rescue
nil
end
def window_signature
entry = current_entry
header = load_header
[
OnlineServerStatus.signature(entry),
entry ? entry["name"].to_s : "",
entry ? entry["description"].to_s : "",
header ? header[:date].to_s : "",
header ? header[:playtime_s].to_s : ""
].join("|")
rescue
"overview-error"
end
def refresh
signature = window_signature
normalize_visual_state
contents.clear
entry = current_entry
unless entry.is_a?(Hash)
@last_signature = nil
return
end
draw_server_name(entry)
draw_server_status(entry)
draw_screenshot(entry)
draw_details(entry)
# Commit the signature only after the whole card was rendered. A transient
# bitmap error therefore cannot permanently suppress the next redraw.
@last_signature = signature
rescue => e
@last_signature = nil
puts "[SERVER SELECT] overview redraw failed: #{e.class}: #{e.message}" rescue nil
end
def draw_server_name(entry)
contents.font.outline = false
contents.font.name = server_name_font
contents.font.size = 24
contents.font.color = normal_color
contents.draw_text(0, 0, contents.width, 30, entry["name"].to_s, 1)
end
def draw_server_status(entry)
contents.font.name = server_status_font
contents.font.size = 18
contents.font.color = OnlineServerStatus.status_color(entry)
contents.draw_text(0, 26, contents.width, 24, OnlineServerStatus.status_text(entry), 1)
contents.font.color = normal_color
rescue
end
def draw_screenshot(entry)
sid = entry["id"].to_s.downcase rescue ""
name = entry["name"].to_s.downcase rescue ""
screen_shot_name =
if defined?(ArenaFlagFile) && ArenaFlagFile.respond_to?(:pvp_arena_entry?) && ArenaFlagFile.pvp_arena_entry?(entry)
"Graphics/Online/pvp_logo.png"
elsif sid == "development" || name == "разработка"
"Graphics/Online/razrab_logo.png"
elsif sid == "vip" || name == "vip"
"Graphics/Online/vip_logo.png"
elsif sid == "anarchy" || sid.include?("anarch") || name.include?("анарх")
"Graphics/Online/anarhy_logo.png"
elsif sid == "peaceful" || name.include?("РјРёСЂРЅ")
"Graphics/Online/world_logo.png"
else
case entry["save_slot"].to_i
when 10
"Graphics/Online/pvp_logo.png"
when 20
"Graphics/Online/world_logo.png"
when 1
"Graphics/Online/anarhy_logo.png"
else
DataManager.make_filename_screenshot(slot_index)
end
end
fallback = "Graphics/System/SaveNotFound.png"
screen_shot_name = fallback unless FileTest.exist?(screen_shot_name)
screen_shot = nil
begin
# Server logos are immutable package assets. Loading a private bitmap for
# the redraw avoids collisions with the mutable save-preview cache.
screen_shot = Bitmap.new(screen_shot_name)
raise "empty server logo #{screen_shot_name}" if screen_shot.disposed? || screen_shot.width <= 0 || screen_shot.height <= 0
img_x = (contents.width - screen_shot.width) / 2
img_y = 56
@mp_server_select_image_bottom = img_y + screen_shot.height
contents.blt(img_x, img_y, screen_shot, screen_shot.rect, 255)
true
rescue => e
draw_server_logo_placeholder(screen_shot_name)
unless @server_logo_warned[screen_shot_name]
@server_logo_warned[screen_shot_name] = true
puts "[SERVER SELECT] logo load failed #{screen_shot_name}: #{e.class}: #{e.message}" rescue nil
end
false
ensure
screen_shot.dispose if screen_shot && !screen_shot.disposed?
end
end
def draw_server_logo_placeholder(path)
img_y = 56
img_h = 160
margin = 12
contents.fill_rect(margin, img_y, contents.width - margin * 2, img_h, Color.new(12, 12, 18, 255))
contents.font.name = server_description_font
contents.font.size = 16
contents.font.outline = false
contents.font.color = normal_color
contents.draw_text(margin, img_y, contents.width - margin * 2, img_h, "Изображение сервера недоступно", 1)
@mp_server_select_image_bottom = img_y + img_h
rescue
@mp_server_select_image_bottom = 216
end
def draw_details(entry)
header = load_header
base_y = contents.height - 60
base_y = 280 if base_y < 280
contents.font.outline = false
contents.font.size = 18
contents.font.color = normal_color
playtime = "--:--:--"
date = "Нет сохранения"
begin
playtime = header[:playtime_s].to_s if header && header[:playtime_s]
date = header[:date].to_s if header && header[:date]
rescue
end
draw_pair(base_y + 0, "Время", playtime)
draw_pair(base_y + 24, "Дата", date)
rescue
end
def draw_pair(y, label, value)
contents.draw_text(12, y, 110, 24, "#{label}:", 0)
contents.draw_text(120, y, contents.width - 132, 24, value.to_s, 0)
end
end
class Window_VipCodeInput < Window_Base
MAX_CODE_LEN = 32
def initialize
w = (Graphics.width * 0.70).to_i
w = 420 if w < 420
h = fitting_height(4)
x = (Graphics.width - w) / 2
y = (Graphics.height - h) / 2
super(x, y, w, h)
self.z = 9999
@code = ""
begin
if defined?(OnlineServerRegistry) && OnlineServerRegistry.respond_to?(:vip_code)
@code = OnlineServerRegistry.vip_code.to_s
end
rescue
@code = ""
end
@code = @code.gsub(/[^0-9A-Za-z_\-]/, "")[0, MAX_CODE_LEN]
@ok_handler = nil
@cancel_handler = nil
@last_input_frame = -1
refresh
activate
end
def set_handler(sym, method_obj)
@ok_handler = method_obj if sym == :ok
@cancel_handler = method_obj if sym == :cancel
end
def update
super
return unless active
current_frame = Graphics.frame_count rescue nil
if !current_frame.nil?
return if @last_input_frame == current_frame
@last_input_frame = current_frame
end
handle_text_input
handle_keys
end
def handle_text_input
add = if defined?(NicknameInput) && NicknameInput.respond_to?(:single_press_chars)
NicknameInput.single_press_chars
else
typed_chars
end
if add != ""
changed = false
add.each_char do |ch|
c = ch.to_s
next unless c =~ /[0-9A-Za-z_\-]/
break if @code.length >= MAX_CODE_LEN
@code << c
changed = true
end
refresh if changed
end
if Input.repeat?(:BACK) || Input.repeat?(:DELETE)
if @code.length > 0
@code.chop!
refresh
end
end
rescue
end
def typed_chars
text = ""
begin
if defined?(MPTextInput) && MPTextInput.respond_to?(:native_available?) && MPTextInput.native_available?
text = MPTextInput.repeated_text.to_s
end
rescue
text = ""
end
if text.to_s == ""
begin
text = Input.UTF8String.to_s
rescue
text = ""
end
end
text = text.to_s.gsub(/[\r\n\t]/, "")
text = text.gsub("\0", "")
text
rescue
""
end
def confirm_pressed?
return true if Input.trigger?(:C)
return true if Input.trigger?(:RETURN)
return true if Input.trigger?(:ENTER)
false
rescue
false
end
def cancel_pressed?
return true if Input.trigger?(:B)
return true if Input.trigger?(:ESCAPE)
false
rescue
false
end
def handle_keys
if confirm_pressed?
safe = @code.to_s.gsub(/[^0-9A-Za-z_\-]/, "")[0, MAX_CODE_LEN]
if safe == ""
SndLib.sys_buzzer if defined?(SndLib)
else
SndLib.sys_ok if defined?(SndLib)
deactivate
@ok_handler.call(safe) if @ok_handler
end
return
end
if cancel_pressed?
SndLib.sys_cancel if defined?(SndLib)
deactivate
@cancel_handler.call if @cancel_handler
end
rescue
end
def refresh
contents.clear
contents.font.outline = false
contents.font.size = 18
contents.font.bold = false
draw_text(0, 0, contents_width, line_height, "Введите VIP-код:", 1)
cursor = ((Graphics.frame_count rescue 0) / 20) % 2 == 0 ? "|" : " "
draw_text(0, line_height, contents_width, line_height, @code.to_s + cursor, 1)
contents.font.size = 16
change_color(system_color)
draw_text(0, line_height * 2, contents_width, line_height, "Для входа нужен действующий код.", 1)
draw_text(0, line_height * 3, contents_width, line_height, "VIP-сервер может создать только VIP.", 1)
change_color(normal_color)
rescue
end
end
class Scene_OnlineServerSelect < Scene_File
def start
OnlineServerRegistry.reload!
OnlineServerStatus.reset
init_online_connect_state
super
end
def terminate
begin
@online_connect_thread.kill if @online_connect_thread && @online_connect_thread.alive?
rescue
end
begin
@overview_window.dispose if @overview_window
rescue
end
begin
@vip_code_window.dispose if @vip_code_window
rescue
end
OnlineServerStatus.dispose
super
end
def create_help_window
@help_window = Window_Help.new(1)
@help_window.opacity = 0
end
def create_savefile_windows
@savefile_windows = Array.new(item_max) do |i|
Window_ServerSaveFile.new(savefile_height, i, OnlineServerRegistry.servers[i])
end
@savefile_windows.each do |window|
window.x = 32
window.viewport = @savefile_viewport
end
end
def create_saveoverview_window
@overview_window = Window_ServerOverview.new(Graphics.width / 2, @savefile_viewport.rect.y, Graphics.width / 2 - 32, savefile_height * visible_max)
end
def item_max
[OnlineServerRegistry.servers.size, 1].max
end
def visible_max
[item_max, 3].min
end
def first_savefile_index
0
end
def init_online_connect_state
@online_connecting = false
@online_connect_result = nil
@online_connect_error = nil
@online_connect_thread = nil
@online_connect_started_at = nil
@vip_code_input_active = false
@vip_code_window = nil
@vip_code_entry = nil
@vip_handshake_wait = false
@vip_handshake_started_at = nil
@development_access_wait = false
@development_access_started_at = nil
end
def current_server_entry
OnlineServerRegistry.servers[@index]
rescue
nil
end
def update
super
OnlineServerStatus.touch_all(OnlineServerRegistry.servers)
begin
@overview_window.update if @overview_window
rescue
end
begin
@vip_code_window.update if @vip_code_window
rescue
end
process_online_connect_result
process_vip_handshake_state
process_development_access_state
end
def refresh_cursor(last_index, current_index)
super
begin
@overview_window.set_server_index(current_index) if @overview_window
rescue
end
end
def deactivate_save_windows
Array(@savefile_windows).each do |w|
begin
w.active = false if w.respond_to?(:active=)
rescue
end
end
rescue
end
def activate_save_windows
Array(@savefile_windows).each do |w|
begin
w.active = true if w.respond_to?(:active=)
rescue
end
end
rescue
end
def start_vip_code_input(entry)
return if @vip_code_input_active
@vip_code_input_active = true
@vip_code_entry = entry.is_a?(Hash) ? entry.dup : nil
deactivate_save_windows
begin
@vip_code_window.dispose if @vip_code_window
rescue
end
@vip_code_window = Window_VipCodeInput.new
@vip_code_window.set_handler(:ok, method(:on_vip_code_ok))
@vip_code_window.set_handler(:cancel, method(:on_vip_code_cancel))
rescue
@vip_code_input_active = false
@vip_code_entry = nil
activate_save_windows
end
def finish_vip_code_input
@vip_code_input_active = false
begin
@vip_code_window.dispose if @vip_code_window
rescue
end
@vip_code_window = nil
@vip_code_entry = nil
activate_save_windows
end
def on_vip_code_ok(code)
safe_code = code.to_s.gsub(/[^0-9A-Za-z_\-]/, "")[0, 32]
if safe_code == ""
notify_error("VIP code is empty.")
return
end
begin
OnlineServerRegistry.set_vip_code(safe_code) if OnlineServerRegistry.respond_to?(:set_vip_code)
rescue
end
entry = @vip_code_entry.is_a?(Hash) ? @vip_code_entry.dup : current_server_entry
finish_vip_code_input
start_server_connect(entry)
end
def on_vip_code_cancel
finish_vip_code_input
end
def start_server_connect(entry)
return unless entry.is_a?(Hash)
OnlineServerRegistry.select_server(entry)
begin
PvPArenaSaveBackup.prepare_server_connect(entry) if defined?(PvPArenaSaveBackup)
rescue
end
begin
ArenaFlagFile.mark_connect(entry)
rescue
end
begin
if defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.disconnect
end
rescue
end
host = OnlineServerRegistry.selected_host
port = OnlineServerRegistry.selected_port
name = OnlineServerRegistry.selected_name
notify_network("Подключение к серверу #{name}")
@online_connecting = true
@online_connect_result = nil
@online_connect_error = nil
@online_connect_started_at = Time.now.to_f rescue nil
@online_connect_thread = Thread.new do
begin
ok =
if defined?(WebSocket) && WebSocket.respond_to?(:connect)
WebSocket.connect(host, port)
else
false
end
@online_connect_result = ok ? :ok : :failed
rescue => e
@online_connect_error = e.message
@online_connect_result = :error
end
end
end
def on_savefile_ok
return if @online_connecting
return if @vip_handshake_wait
return if @development_access_wait
return if @vip_code_input_active
entry = current_server_entry
return unless entry.is_a?(Hash)
return SndLib.sys_buzzer unless OnlineServerStatus.state(entry) == :online
if OnlineServerRegistry.respond_to?(:vip_server_entry?) && OnlineServerRegistry.vip_server_entry?(entry)
start_vip_code_input(entry)
return
end
return start_server_connect(entry)
OnlineServerRegistry.select_server(entry)
begin
PvPArenaSaveBackup.prepare_server_connect(entry) if defined?(PvPArenaSaveBackup)
rescue
end
begin
ArenaFlagFile.mark_connect(entry)
rescue
end
begin
if defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.disconnect
end
rescue
end
host = OnlineServerRegistry.selected_host
port = OnlineServerRegistry.selected_port
name = OnlineServerRegistry.selected_name
notify_network("Подключение к серверу #{name}")
@online_connecting = true
@online_connect_result = nil
@online_connect_error = nil
@online_connect_started_at = Time.now.to_f rescue nil
@online_connect_thread = Thread.new do
begin
ok =
if defined?(WebSocket) && WebSocket.respond_to?(:connect)
WebSocket.connect(host, port)
else
false
end
@online_connect_result = ok ? :ok : :failed
rescue => e
@online_connect_error = e.message
@online_connect_result = :error
end
end
end
def on_savefile_cancel
return SndLib.sys_buzzer if @online_connecting || @vip_handshake_wait || @development_access_wait
if @vip_code_input_active
on_vip_code_cancel
return
end
SndLib.sys_cancel rescue nil
SceneManager.goto(Scene_MapTitle)
end
def process_online_connect_result
return unless @online_connecting
if @online_connect_result.nil?
begin
if @online_connect_started_at && (Time.now.to_f - @online_connect_started_at) > 10.0
@online_connect_thread.kill if @online_connect_thread && @online_connect_thread.alive?
@online_connect_result = :timeout
end
rescue
end
return
end
@online_connecting = false
if @online_connect_result == :ok
selected = nil
begin
selected = OnlineServerRegistry.selected_server if OnlineServerRegistry.respond_to?(:selected_server)
rescue
selected = nil
end
need_development_access = false
begin
if OnlineServerRegistry.respond_to?(:development_server_entry?) && OnlineServerRegistry.development_server_entry?(selected)
need_development_access = true
end
rescue
need_development_access = false
end
if need_development_access
@development_access_wait = true
@development_access_started_at = Time.now.to_f rescue nil
notify_network("Проверка статуса разработчика...")
@online_connect_result = nil
@online_connect_error = nil
@online_connect_thread = nil
@online_connect_started_at = nil
return
end
need_vip_handshake = false
begin
if OnlineServerRegistry.respond_to?(:vip_server_entry?) && OnlineServerRegistry.vip_server_entry?(selected)
need_vip_handshake = true
end
rescue
need_vip_handshake = false
end
if need_vip_handshake
@vip_handshake_wait = true
@vip_handshake_started_at = Time.now.to_f rescue nil
notify_network("VIP access check...")
@online_connect_result = nil
@online_connect_error = nil
@online_connect_thread = nil
@online_connect_started_at = nil
return
end
end
case @online_connect_result
when :ok
notify_success("Подключено к #{OnlineServerRegistry.selected_name}. Загрузка сохранения...")
SceneManager.goto(Scene_OnlineAutoLoad)
when :timeout
notify_error("Сервер #{OnlineServerRegistry.selected_name} не ответил вовремя.")
when :error
notify_error("Ошибка: #{@online_connect_error}")
else
notify_error("Сервер #{OnlineServerRegistry.selected_name} недоступен.")
end
@online_connect_result = nil
@online_connect_error = nil
@online_connect_thread = nil
@online_connect_started_at = nil
end
def process_development_access_state
return unless @development_access_wait
begin
if defined?(WebSocket) && WebSocket.respond_to?(:receive_packets) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.receive_packets
end
rescue
end
role_received = false
role_name = "PLAYER"
begin
if defined?(WebSocket) && WebSocket.respond_to?(:admin_role_received?)
role_received = WebSocket.admin_role_received?
end
if defined?(WebSocket) && WebSocket.respond_to?(:admin_role_name)
role_name = WebSocket.admin_role_name.to_s.upcase
end
rescue
role_received = false
role_name = "PLAYER"
end
if role_received
@development_access_wait = false
@development_access_started_at = nil
if role_name == "OWNER"
notify_success("Доступ разработчика подтверждён. Загрузка сохранения...")
SceneManager.goto(Scene_OnlineAutoLoad)
else
begin
if defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.disconnect
end
rescue
end
notify_error("Извините, вы не являетесь разработчиком!")
end
return
end
begin
if @development_access_started_at && (Time.now.to_f - @development_access_started_at) > 12.0
@development_access_wait = false
@development_access_started_at = nil
begin
if defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.disconnect
end
rescue
end
notify_error("Не удалось проверить статус разработчика.")
end
rescue
end
end
def process_vip_handshake_state
return unless @vip_handshake_wait
begin
if defined?(WebSocket) && WebSocket.respond_to?(:receive_packets) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.receive_packets
end
rescue
end
ready = false
failed = false
error_text = nil
begin
ready = WebSocket.vip_handshake_ready? if defined?(WebSocket) && WebSocket.respond_to?(:vip_handshake_ready?)
rescue
ready = false
end
begin
failed = WebSocket.vip_handshake_failed? if defined?(WebSocket) && WebSocket.respond_to?(:vip_handshake_failed?)
rescue
failed = false
end
begin
if defined?(WebSocket) && WebSocket.respond_to?(:vip_handshake_error_text)
error_text = WebSocket.vip_handshake_error_text.to_s
end
rescue
error_text = nil
end
if ready
@vip_handshake_wait = false
@vip_handshake_started_at = nil
notify_success("VIP access granted. Loading save...")
SceneManager.goto(Scene_OnlineAutoLoad)
return
end
if failed
@vip_handshake_wait = false
@vip_handshake_started_at = nil
begin
if defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.disconnect
end
rescue
end
if error_text.to_s.strip == ""
notify_error("VIP access denied.")
else
notify_error(error_text.to_s)
end
return
end
begin
if @vip_handshake_started_at && (Time.now.to_f - @vip_handshake_started_at) > 12.0
@vip_handshake_wait = false
@vip_handshake_started_at = nil
begin
if defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.disconnect
end
rescue
end
notify_error("VIP authorization timeout.")
end
rescue
end
end
end
class TitleMenu
unless method_defined?(:mp_server_select_old_handlerCmdOnline)
alias mp_server_select_old_handlerCmdOnline handlerCmdOnline
end
def handlerCmdOnline(value)
return if @onBegin == true
begin
PvPArenaSaveBackup.prepare_online_menu_entry if defined?(PvPArenaSaveBackup)
rescue
end
SceneManager.snapshot_for_background rescue nil
SndLib.openChest rescue nil
SceneManager.goto(Scene_OnlineServerSelect)
end
end
if defined?(Scene_Title)
class Scene_Title < Scene_Base
unless method_defined?(:mp_server_select_disconnect_before_title_start)
alias mp_server_select_disconnect_before_title_start start
end
def start
begin
MPPvPMainMenuSave.save_before_main_menu if defined?(MPPvPMainMenuSave)
rescue
end
begin
ArenaFlagFile.mark_main_menu
rescue
end
begin
if defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.disconnect
end
rescue
end
mp_server_select_disconnect_before_title_start
end
end
end
if defined?(Scene_MapTitle)
class Scene_MapTitle < Scene_Map
unless method_defined?(:mp_server_select_disconnect_before_maptitle_start)
alias mp_server_select_disconnect_before_maptitle_start start
end
def start
begin
MPPvPMainMenuSave.save_before_main_menu if defined?(MPPvPMainMenuSave)
rescue
end
begin
ArenaFlagFile.mark_main_menu
rescue
end
begin
if defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.disconnect
end
rescue
end
mp_server_select_disconnect_before_maptitle_start
end
end
end
class Window_ServerOverview
def draw_details(entry)
header = load_header
base_y = contents.height - 86
base_y = 252 if base_y < 252
contents.font.outline = false
contents.font.name = server_description_font
contents.font.size = 18
contents.font.color = normal_color
description = entry["description"].to_s.strip
description = "Без описания." if description == ""
playtime = "--:--:--"
date = "Нет сохранения"
begin
playtime = header[:playtime_s].to_s if header && header[:playtime_s]
date = header[:date].to_s if header && header[:date]
rescue
end
draw_pair(base_y + 0, "Описание", description)
draw_pair(base_y + 24, "Время", playtime)
draw_pair(base_y + 48, "Дата", date)
rescue
end
end
class Window_ServerOverview
def draw_details(entry)
base_y = (@mp_server_select_image_bottom || 236) + 8
max_y = contents.height - 28
base_y = max_y if base_y > max_y
base_y = 228 if base_y < 228
contents.font.outline = false
contents.font.size = 18
contents.font.color = normal_color
description = entry["description"].to_s.strip
description = "Без описания." if description == ""
contents.draw_text(12, base_y, contents.width - 24, 24, description, 1)
rescue
end
end
class Scene_OnlineAutoLoad < Scene_Base
BOOTSTRAP_WAIT_FRAMES = 240 unless const_defined?(:BOOTSTRAP_WAIT_FRAMES)
unless method_defined?(:mp_server_select_old_start)
alias mp_server_select_old_start start
end
def start
mp_server_select_old_start
begin
notify_network("Загрузка сохранения сервера #{OnlineServerRegistry.selected_name}...")
rescue
end
end
unless method_defined?(:mp_server_select_old_load_first_slot)
alias mp_server_select_old_load_first_slot load_first_slot
end
def update
super
return if @mp_server_select_autoload_done
@mp_server_select_bootstrap_wait ||= 0
@mp_server_select_bootstrap_wait += 1
bootstrap_ready = false
begin
bootstrap_ready = WebSocket.bootstrap_state_ready? if defined?(WebSocket) && WebSocket.respond_to?(:bootstrap_state_ready?)
rescue
bootstrap_ready = false
end
if @mp_server_select_bootstrap_wait == 1
begin
notify_network("Синхронизация данных игрока с сервера...")
rescue
end
end
return if !bootstrap_ready && @mp_server_select_bootstrap_wait < BOOTSTRAP_WAIT_FRAMES
unless load_first_slot
notify_error("Не удалось загрузить сохранение сервера")
WebSocket.disconnect rescue nil
@mp_server_select_autoload_done = true
SceneManager.goto(Scene_MapTitle)
return
end
bootstrap_state = nil
begin
bootstrap_state = WebSocket.consume_bootstrap_state if defined?(WebSocket) && WebSocket.respond_to?(:consume_bootstrap_state)
rescue
bootstrap_state = nil
end
bootstrap_applied = false
if bootstrap_state.is_a?(Hash)
begin
if defined?(WebSocket) && WebSocket.respond_to?(:apply_bootstrap_state)
bootstrap_applied = !!WebSocket.apply_bootstrap_state(bootstrap_state)
# Prevent try_finish_bootstrap from applying the same cloud load again.
# A second apply used to leave worn gear in place, then force_equip
# refresh released it into the bag and duplicated requirement items.
if bootstrap_applied
begin
WebSocket.instance_variable_set(:@bootstrap_applied, true)
rescue
end
end
end
rescue
bootstrap_applied = false
end
end
if bootstrap_applied
begin
if defined?(MP_ServerSyncSave) && MP_ServerSyncSave.respond_to?(:request_selected_slot_save)
in_arena_mode = defined?(MP_ArenaFlag) && MP_ArenaFlag.respond_to?(:arena_active?) && MP_ArenaFlag.arena_active?
MP_ServerSyncSave.request_selected_slot_save unless in_arena_mode
end
rescue
end
begin
map_interpreter = nil
if $game_map
begin
map_interpreter = $game_map.interpreter if $game_map.respond_to?(:interpreter)
rescue
map_interpreter = nil
end
if map_interpreter.nil?
begin
map_interpreter = $game_map.instance_variable_get(:@interpreter)
rescue
map_interpreter = nil
end
end
end
map_interpreter.clear if map_interpreter && map_interpreter.respond_to?(:clear)
rescue
end
begin
if $game_player
$game_player.instance_variable_set(:@move_route_forcing, false)
$game_player.instance_variable_set(:@wait_count, 0)
end
rescue
end
begin
$game_temp.clear_common_event if $game_temp && $game_temp.respond_to?(:clear_common_event)
rescue
end
end
begin
if bootstrap_applied
notify_success("Загрузка завершена. Данные игрока синхронизированы.")
else
notify_success("Игра загружена. Добро пожаловать в онлайн.")
end
rescue
end
$game_system.on_after_load rescue nil
$game_map.autoplay rescue nil
$game_player.refresh rescue nil
@mp_server_select_autoload_done = true
SceneManager.goto(Scene_Map)
end
def load_first_slot
slot_index = OnlineServerRegistry.selected_slot_index rescue nil
return mp_server_select_old_load_first_slot if slot_index.nil?
if DataManager.respond_to?(:load_game)
return true if DataManager.load_game(slot_index)
return false
end
if DataManager.respond_to?(:load_game_without_rescue)
begin
DataManager.load_game_without_rescue(slot_index)
return true
rescue
return false
end
end
false
end
end