mrleo1nidandClaude Opus 5
5d50b609f6
Полторы сотни параметров сплошным списком читать невозможно. Теперь они разбиты на разделы — «Основное», «PVP и урон», «Убежища», «Античит» и так далее, — свёрнутые по умолчанию, кроме первого. Поиск раскрывает разделы с совпадениями и прячет остальные, а раскрытые разделы не схлопываются при возврате на вкладку. Категории составлены по настоящим конфигам Build 41 и 42: все 144 ключа .ini и 270 параметров песочницы раскладываются без остатка. Нумерованные и однотипные ключи (AntiCheatProtectionType1..24, *Loot, Animal*, Firearm*) подхватываются по префиксу, а незнакомые попадают в «Прочее» — в новых версиях игры ключи добавляют, и терять их со страницы нельзя. Описания параметров панель больше не выдумывает, а берёт из самого конфига: игра пишет их комментариями на языке сервера. Полный текст — во всплывающей подсказке, начало — под полем; поиск ищет и по описанию, так что параметр можно найти по-русски. Заодно исправлено сохранение файлов с виндовыми переводами строк: панель переписывала их в LF, и правка одного параметра меняла каждую строку файла. Проверено на реальном SandboxVars.lua: правка одного значения меняет ровно одну строку, размер файла не меняется. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1939 lines
78 KiB
JavaScript
1939 lines
78 KiB
JavaScript
"use strict";
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Обращения к API
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// Заголовок обязателен для всех изменяющих запросов: сервер использует его как
|
||
// защиту от CSRF вместо отдельных токенов.
|
||
const CSRF_HEADER = "X-PZM-Request";
|
||
|
||
async function api(method, path, body) {
|
||
const options = {
|
||
method,
|
||
headers: { [CSRF_HEADER]: "1" },
|
||
credentials: "same-origin",
|
||
};
|
||
if (body !== undefined) {
|
||
options.headers["Content-Type"] = "application/json";
|
||
options.body = JSON.stringify(body);
|
||
}
|
||
|
||
const response = await fetch(path, options);
|
||
if (response.status === 401) {
|
||
showAuth(false);
|
||
throw new Error("Сессия истекла, войдите заново");
|
||
}
|
||
|
||
const text = await response.text();
|
||
const data = text ? JSON.parse(text) : {};
|
||
if (!response.ok) {
|
||
throw new Error(data.error || `Ошибка ${response.status}`);
|
||
}
|
||
return data;
|
||
}
|
||
|
||
const get = (path) => api("GET", path);
|
||
const post = (path, body) => api("POST", path, body);
|
||
const put = (path, body) => api("PUT", path, body);
|
||
const del = (path) => api("DELETE", path);
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Мелкие утилиты
|
||
// ---------------------------------------------------------------------------
|
||
|
||
const $ = (selector) => document.querySelector(selector);
|
||
const $$ = (selector) => Array.from(document.querySelectorAll(selector));
|
||
|
||
function toast(message, kind = "") {
|
||
const el = document.createElement("div");
|
||
el.className = `toast ${kind}`;
|
||
el.textContent = message;
|
||
$("#toasts").appendChild(el);
|
||
setTimeout(() => el.remove(), kind === "err" ? 7000 : 4000);
|
||
}
|
||
|
||
const ok = (message) => toast(message, "ok");
|
||
const fail = (error) => toast(error.message || String(error), "err");
|
||
|
||
function formatBytes(bytes) {
|
||
if (!bytes) return "—";
|
||
const units = ["Б", "КБ", "МБ", "ГБ", "ТБ"];
|
||
let value = bytes;
|
||
let unit = 0;
|
||
while (value >= 1024 && unit < units.length - 1) {
|
||
value /= 1024;
|
||
unit++;
|
||
}
|
||
return `${value.toFixed(value < 10 && unit > 0 ? 1 : 0)} ${units[unit]}`;
|
||
}
|
||
|
||
function formatUptime(seconds) {
|
||
if (!seconds) return "";
|
||
const days = Math.floor(seconds / 86400);
|
||
const hours = Math.floor((seconds % 86400) / 3600);
|
||
const minutes = Math.floor((seconds % 3600) / 60);
|
||
const parts = [];
|
||
if (days) parts.push(`${days} д`);
|
||
if (hours) parts.push(`${hours} ч`);
|
||
parts.push(`${minutes} мин`);
|
||
return "Работает: " + parts.join(" ");
|
||
}
|
||
|
||
function formatDate(unixSeconds) {
|
||
return new Date(unixSeconds * 1000).toLocaleString("ru-RU");
|
||
}
|
||
|
||
// Экранирование не нужно там, где мы пишем в textContent, но пригодится для
|
||
// заголовков модов, которые приходят из Steam.
|
||
function escapeHTML(value) {
|
||
const div = document.createElement("div");
|
||
div.textContent = value ?? "";
|
||
return div.innerHTML;
|
||
}
|
||
|
||
const STATE_LABELS = {
|
||
stopped: "Остановлен",
|
||
restarting: "Ждёт перезапуска",
|
||
starting: "Запускается",
|
||
running: "Работает",
|
||
stopping: "Останавливается",
|
||
};
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Вход и первичная настройка
|
||
// ---------------------------------------------------------------------------
|
||
|
||
let setupMode = false;
|
||
|
||
function showAuth(needSetup) {
|
||
setupMode = needSetup;
|
||
$("#app").classList.add("hidden");
|
||
$("#auth-screen").classList.remove("hidden");
|
||
$("#token-field").hidden = !needSetup;
|
||
$("#auth-subtitle").textContent = needSetup
|
||
? "Создайте учётную запись администратора"
|
||
: "Управление сервером Project Zomboid";
|
||
$("#auth-submit").textContent = needSetup ? "Создать администратора" : "Войти";
|
||
$("#auth-form").querySelector("[name=password]").autocomplete = needSetup
|
||
? "new-password"
|
||
: "current-password";
|
||
stopPolling();
|
||
}
|
||
|
||
function showApp(login) {
|
||
$("#auth-screen").classList.add("hidden");
|
||
$("#app").classList.remove("hidden");
|
||
$("#current-user").textContent = login;
|
||
loadProfiles().catch(fail);
|
||
startPolling();
|
||
openConsoleStream();
|
||
loadTab(currentTab);
|
||
}
|
||
|
||
$("#auth-form").addEventListener("submit", async (event) => {
|
||
event.preventDefault();
|
||
const form = new FormData(event.target);
|
||
const payload = {
|
||
login: form.get("login").trim(),
|
||
password: form.get("password"),
|
||
};
|
||
if (setupMode) payload.token = (form.get("token") || "").trim();
|
||
|
||
const errorBox = $("#auth-error");
|
||
errorBox.hidden = true;
|
||
try {
|
||
const result = await post(setupMode ? "/api/setup" : "/api/login", payload);
|
||
event.target.reset();
|
||
showApp(result.login);
|
||
} catch (error) {
|
||
errorBox.textContent = error.message;
|
||
errorBox.hidden = false;
|
||
}
|
||
});
|
||
|
||
$("#btn-logout").addEventListener("click", async () => {
|
||
try {
|
||
await post("/api/logout");
|
||
} catch (error) {
|
||
/* даже при ошибке уводим на экран входа */
|
||
}
|
||
closeConsoleStream();
|
||
showAuth(false);
|
||
});
|
||
|
||
async function checkSession() {
|
||
const session = await get("/api/session");
|
||
if (session.authenticated) {
|
||
showApp(session.login);
|
||
} else {
|
||
showAuth(session.setup_needed);
|
||
}
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Вкладки
|
||
// ---------------------------------------------------------------------------
|
||
|
||
let currentTab = "overview";
|
||
|
||
$("#tabs").addEventListener("click", (event) => {
|
||
const tab = event.target.closest(".tab");
|
||
if (!tab) return;
|
||
currentTab = tab.dataset.tab;
|
||
$$(".tab").forEach((t) => t.classList.toggle("active", t === tab));
|
||
$$(".panel").forEach((p) => p.classList.toggle("active", p.dataset.panel === currentTab));
|
||
loadTab(currentTab);
|
||
});
|
||
|
||
// loadTab подгружает данные вкладки при переходе на неё: конфиги и списки
|
||
// модов меняются редко, держать их в опросе статуса незачем.
|
||
function loadTab(name) {
|
||
const loaders = {
|
||
profiles: loadProfiles,
|
||
config: loadServerConfig,
|
||
sandbox: loadSandbox,
|
||
mods: loadMods,
|
||
backups: loadBackups,
|
||
settings: loadSettings,
|
||
};
|
||
if (loaders[name]) loaders[name]().catch(fail);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Статус и управление сервером
|
||
// ---------------------------------------------------------------------------
|
||
|
||
let pollTimer = null;
|
||
let lastTaskName = "";
|
||
|
||
function startPolling() {
|
||
stopPolling();
|
||
refreshStatus();
|
||
pollTimer = setInterval(refreshStatus, 2000);
|
||
}
|
||
|
||
function stopPolling() {
|
||
if (pollTimer) clearInterval(pollTimer);
|
||
pollTimer = null;
|
||
}
|
||
|
||
async function refreshStatus() {
|
||
let data;
|
||
try {
|
||
data = await get("/api/status");
|
||
} catch (error) {
|
||
$("#status-text").textContent = "Нет связи с менеджером";
|
||
$("#status-dot").className = "dot";
|
||
return;
|
||
}
|
||
renderStatus(data.server);
|
||
renderTask(data.task);
|
||
}
|
||
|
||
// hostStats нужен карточкам профилей: там подсказываем, сколько памяти можно
|
||
// отдать JVM, чтобы не выбирать объём вслепую.
|
||
let hostStats = {};
|
||
|
||
function renderStatus(status) {
|
||
hostStats = status.host || {};
|
||
let label = STATE_LABELS[status.state] || status.state;
|
||
// Пока идёт обратный отсчёт, показываем, сколько осталось: иначе непонятно,
|
||
// происходит ли вообще что-нибудь.
|
||
if (status.state === "restarting" && status.restart_in_sec > 0) {
|
||
label = `Перезапуск через ${status.restart_in_sec} с`;
|
||
}
|
||
$("#status-text").textContent = label;
|
||
$("#status-dot").className = `dot ${status.state}`;
|
||
|
||
$("#ov-state").textContent = label;
|
||
$("#ov-profile").textContent = status.profile_title ? `Профиль: ${status.profile_title}` : "";
|
||
$("#ov-uptime").textContent = formatUptime(status.uptime_sec);
|
||
$("#ov-pid").textContent = status.pid ? `PID ${status.pid}` : "";
|
||
$("#ov-lastexit").textContent =
|
||
status.state === "stopped" && status.last_exit ? `Последнее завершение: ${status.last_exit}` : "";
|
||
|
||
const players = status.players || [];
|
||
$("#ov-players-count").textContent = players.length;
|
||
$("#ov-players").innerHTML = players.map((name) => `<li>${escapeHTML(name)}</li>`).join("");
|
||
|
||
$("#ov-cpu").textContent = status.proc.cpu_percent ? `${status.proc.cpu_percent.toFixed(0)} %` : "—";
|
||
$("#ov-rss").textContent = formatBytes(status.proc.rss_bytes);
|
||
$("#ov-threads").textContent = status.proc.threads || "—";
|
||
|
||
const host = status.host || {};
|
||
$("#ov-mem").textContent = host.mem_total_bytes
|
||
? `${formatBytes(host.mem_available_bytes)} из ${formatBytes(host.mem_total_bytes)}`
|
||
: "—";
|
||
$("#ov-load").textContent = host.cpu_count
|
||
? `${(host.load1 || 0).toFixed(2)} на ${host.cpu_count} ядер`
|
||
: (host.load1 || 0).toFixed(2);
|
||
$("#ov-disk").textContent = host.disk_total_bytes
|
||
? `${formatBytes(host.disk_free_bytes)} из ${formatBytes(host.disk_total_bytes)}`
|
||
: "—";
|
||
|
||
// Кнопка называет то, что произойдёт: на чистой машине это установка, на
|
||
// готовой — обновление.
|
||
$("#install-state").textContent = status.installed
|
||
? "Серверные файлы установлены."
|
||
: "Серверные файлы не найдены — сервер ещё не установлен.";
|
||
$("#btn-install").textContent = status.installed
|
||
? "Обновить сервер через SteamCMD"
|
||
: "Установить сервер через SteamCMD";
|
||
$("#install-hint").textContent = status.installed
|
||
? "Сервер должен быть остановлен. Обновление занимает несколько минут — прогресс виден во вкладке «Консоль»."
|
||
: "Займёт несколько минут и около 3 ГБ на диске — прогресс виден во вкладке «Консоль».";
|
||
|
||
const running = status.state !== "stopped";
|
||
const waitingRestart = status.state === "restarting";
|
||
|
||
// В ожидании автоподъёма обе кнопки осмысленны: «Запустить» поднимает
|
||
// сервер сразу, «Остановить» отменяет перезапуск.
|
||
$("#btn-start").disabled = (running && !waitingRestart) || !status.installed;
|
||
$("#btn-stop").disabled = !running;
|
||
$("#btn-stop").textContent = waitingRestart ? "Отменить перезапуск" : "Остановить";
|
||
$("#btn-restart").disabled = !status.installed;
|
||
$("#btn-install").disabled = running;
|
||
|
||
// Консоль есть только у живого процесса: у остановленного сервера нет stdin,
|
||
// и команда всё равно вернулась бы ошибкой.
|
||
const consoleInput = $("#console-command");
|
||
const consoleButton = $("#console-form").querySelector("button[type=submit]");
|
||
// Процесс есть только в этих двух состояниях; в ожидании перезапуска писать
|
||
// некуда, хотя формально сервер и не «остановлен».
|
||
const consoleReady = status.state === "running" || status.state === "starting";
|
||
consoleInput.disabled = !consoleReady;
|
||
consoleButton.disabled = !consoleReady;
|
||
consoleInput.placeholder = consoleReady
|
||
? "Команда сервера, например: players, save, quit"
|
||
: "Сервер остановлен — консоль принимает команды только на работающем";
|
||
|
||
// Профили делят игровые порты и файл запуска, поэтому переключать их можно
|
||
// только на остановленном сервере.
|
||
const picker = $("#profile-select");
|
||
picker.disabled = running && !waitingRestart;
|
||
picker.title = running
|
||
? "Остановите сервер, чтобы переключить профиль"
|
||
: "Профиль сервера: свой мир, конфиг и моды";
|
||
// Активный профиль мог смениться в другой вкладке браузера.
|
||
if (!running && status.profile && picker.value !== status.profile) {
|
||
picker.value = status.profile;
|
||
}
|
||
}
|
||
|
||
function renderTask(task) {
|
||
const banner = $("#task-banner");
|
||
banner.hidden = !task || !task.running;
|
||
if (task && task.running) {
|
||
$("#task-name").textContent = task.name;
|
||
lastTaskName = task.name;
|
||
} else if (task && task.name && task.name === lastTaskName) {
|
||
// Сообщаем об исходе один раз — на следующем опросе имя уже совпадать не будет.
|
||
lastTaskName = "";
|
||
if (task.error) {
|
||
toast(`${task.name}: ${task.error}`, "err");
|
||
} else {
|
||
ok(`${task.name} — готово`);
|
||
loadTab(currentTab);
|
||
}
|
||
}
|
||
}
|
||
|
||
async function serverAction(path, confirmText) {
|
||
if (confirmText && !confirm(confirmText)) return;
|
||
try {
|
||
await post(path);
|
||
refreshStatus();
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
}
|
||
|
||
$("#btn-start").addEventListener("click", () => serverAction("/api/server/start"));
|
||
$("#btn-stop").addEventListener("click", () => {
|
||
// Отмена перезапуска ничего не рушит, спрашивать незачем.
|
||
const waiting = $("#btn-stop").textContent === "Отменить перезапуск";
|
||
serverAction("/api/server/stop", waiting ? "" : "Остановить игровой сервер? Игроки будут отключены.");
|
||
});
|
||
$("#btn-restart").addEventListener("click", () =>
|
||
serverAction("/api/server/restart", "Перезапустить сервер? Игроки будут отключены."));
|
||
|
||
$("#btn-install").addEventListener("click", async () => {
|
||
// Тот же вопрос, что и на кнопке: «установить» и «обновить» — разные вещи
|
||
// по ощущениям, хотя команда SteamCMD одна.
|
||
const installed = $("#install-state").textContent.startsWith("Серверные файлы установлены");
|
||
const action = installed ? "Обновить серверные файлы" : "Установить сервер";
|
||
if (!confirm(`${action} через SteamCMD?`)) return;
|
||
try {
|
||
await post("/api/install");
|
||
ok("Задача запущена — следите за вкладкой «Консоль»");
|
||
refreshStatus();
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
$("#btn-task-cancel").addEventListener("click", async () => {
|
||
try {
|
||
await post("/api/task/cancel");
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Консоль
|
||
// ---------------------------------------------------------------------------
|
||
|
||
let eventSource = null;
|
||
let lastSeq = 0;
|
||
const MAX_CONSOLE_LINES = 3000;
|
||
|
||
function openConsoleStream() {
|
||
closeConsoleStream();
|
||
eventSource = new EventSource(`/api/logs/stream?since=${lastSeq}`);
|
||
eventSource.onmessage = (event) => appendConsoleLine(JSON.parse(event.data));
|
||
eventSource.onerror = () => {
|
||
// Браузер переподключается сам; сообщать об этом каждый раз не нужно.
|
||
};
|
||
}
|
||
|
||
function closeConsoleStream() {
|
||
if (eventSource) eventSource.close();
|
||
eventSource = null;
|
||
}
|
||
|
||
function appendConsoleLine(line) {
|
||
if (line.seq <= lastSeq) return;
|
||
lastSeq = line.seq;
|
||
|
||
const output = $("#console-output");
|
||
const filter = $("#console-filter").value.trim().toLowerCase();
|
||
|
||
const el = document.createElement("div");
|
||
el.className = `line-${line.stream}`;
|
||
el.textContent = line.text;
|
||
el.dataset.text = line.text.toLowerCase();
|
||
if (filter && !el.dataset.text.includes(filter)) el.hidden = true;
|
||
output.appendChild(el);
|
||
|
||
while (output.childElementCount > MAX_CONSOLE_LINES) {
|
||
output.removeChild(output.firstElementChild);
|
||
}
|
||
if ($("#console-autoscroll").checked) {
|
||
output.scrollTop = output.scrollHeight;
|
||
}
|
||
}
|
||
|
||
$("#console-filter").addEventListener("input", (event) => {
|
||
const filter = event.target.value.trim().toLowerCase();
|
||
Array.from($("#console-output").children).forEach((line) => {
|
||
line.hidden = filter && !line.dataset.text.includes(filter);
|
||
});
|
||
});
|
||
|
||
$("#btn-console-clear").addEventListener("click", () => {
|
||
// Чистим только экран: история остаётся в буфере менеджера.
|
||
$("#console-output").innerHTML = "";
|
||
});
|
||
|
||
// История отправленных команд: та же логика, что и в обычном терминале.
|
||
const commandHistory = [];
|
||
let historyIndex = 0;
|
||
|
||
$("#console-form").addEventListener("submit", async (event) => {
|
||
event.preventDefault();
|
||
const input = $("#console-command");
|
||
const command = input.value.trim();
|
||
if (!command) return;
|
||
try {
|
||
await post("/api/console", { command });
|
||
if (commandHistory[commandHistory.length - 1] !== command) commandHistory.push(command);
|
||
historyIndex = commandHistory.length;
|
||
input.value = "";
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
$("#console-command").addEventListener("keydown", (event) => {
|
||
if (event.key === "Enter") {
|
||
// Отправляем явно: полагаться на неявную отправку формы по Enter не стоит,
|
||
// она зависит от браузера.
|
||
event.preventDefault();
|
||
$("#console-form").requestSubmit();
|
||
return;
|
||
}
|
||
if (event.key !== "ArrowUp" && event.key !== "ArrowDown") return;
|
||
|
||
event.preventDefault();
|
||
historyIndex += event.key === "ArrowUp" ? -1 : 1;
|
||
historyIndex = Math.max(0, Math.min(historyIndex, commandHistory.length));
|
||
event.target.value = commandHistory[historyIndex] ?? "";
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Конфиг сервера
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// Подсказки к самым востребованным параметрам: остальные показываются как есть.
|
||
const CONFIG_HINTS = {
|
||
PublicName: "Название сервера в списке серверов",
|
||
PublicDescription: "Описание сервера",
|
||
Public: "Показывать сервер в публичном списке (true/false)",
|
||
Password: "Пароль для входа на сервер (пусто — без пароля)",
|
||
MaxPlayers: "Максимум игроков",
|
||
DefaultPort: "Игровой порт (UDP), по умолчанию 16261",
|
||
UDPPort: "Второй игровой порт, по умолчанию 16262",
|
||
PVP: "Разрешить бой между игроками",
|
||
PauseEmpty: "Ставить мир на паузу, когда никого нет онлайн",
|
||
GlobalChat: "Общий чат для всего сервера",
|
||
Open: "Пускать игроков без записи в белом списке",
|
||
ServerWelcomeMessage: "Приветственное сообщение",
|
||
SaveWorldEveryMinutes: "Как часто сохранять мир, минут",
|
||
BackupsOnStart: "Делать бэкап силами самой игры при старте",
|
||
RCONPort: "Порт RCON",
|
||
RCONPassword: "Пароль RCON",
|
||
AdminSafehouse: "Разрешить админам входить в чужие убежища",
|
||
SafetySystem: "Система защиты от PVP-урона",
|
||
DisplayUserName: "Показывать ники над персонажами",
|
||
SpawnPoint: "Точка появления новых игроков (x,y,z)",
|
||
Mods: "Список модов — редактируется во вкладке «Моды»",
|
||
WorkshopItems: "Моды мастерской — редактируется во вкладке «Моды»",
|
||
Map: "Карты — редактируется во вкладке «Моды»",
|
||
};
|
||
|
||
const BOOLEAN_VALUES = new Set(["true", "false"]);
|
||
|
||
// Категории параметров servertest.ini. Порядок важен: в нём и рисуются
|
||
// разделы, а всё, чего здесь нет, попадает в «Прочее» — конфиг PZ меняется от
|
||
// версии к версии, и новые ключи не должны пропадать со страницы.
|
||
const CONFIG_GROUPS = [
|
||
{
|
||
title: "Основное",
|
||
keys: ["PublicName", "PublicDescription", "Public", "Open", "MaxPlayers",
|
||
"ServerWelcomeMessage", "ResetID", "ServerPlayerID", "Seed",
|
||
"server_browser_announced_ip", "PublicServerIP", "ServerBrowserAnnouncedIP"],
|
||
},
|
||
{
|
||
title: "Доступ и учётные записи",
|
||
keys: ["Password", "MaxAccountsPerUser", "DenyLoginOnOverloadedServer",
|
||
"AutoCreateUserInWhiteList", "DropOffWhiteListAfterDeath", "LoginQueueEnabled",
|
||
"LoginQueueConnectTimeout", "AllowCoop", "AllowNonAsciiUsername",
|
||
"SteamScoreboard", "SteamVAC", "DoLuaChecksum"],
|
||
},
|
||
{
|
||
title: "Сеть и порты",
|
||
keys: ["DefaultPort", "UDPPort", "RCONPort", "RCONPassword", "PingLimit", "UPnP",
|
||
"MaxPacketsPerSecond", "ClientCommandFilter", "MultiplayerStatisticsPeriod"],
|
||
},
|
||
{
|
||
title: "PVP и урон",
|
||
keys: ["PVP", "PVPLogToolChat", "PVPLogToolFile", "SafetySystem", "ShowSafety",
|
||
"SafetyToggleTimer", "SafetyCooldownTimer", "SafetyDisconnectDelay",
|
||
"PVPMeleeDamageModifier", "PVPFirearmDamageModifier", "PVPMeleeWhileHitReaction",
|
||
"KnockedDownAllowed", "SneakModeHideFromOtherPlayers", "PlayerBumpPlayer",
|
||
"UsePhysicsHitReaction", "CarEngineAttractionModifier"],
|
||
},
|
||
{
|
||
title: "Мир и правила",
|
||
keys: ["Map", "SpawnPoint", "SpawnItems", "SaveWorldEveryMinutes", "PauseEmpty",
|
||
"NoFire", "AllowDestructionBySledgehammer", "SledgehammerOnlyInSafehouse",
|
||
"PlayerRespawnWithSelf", "PlayerRespawnWithOther", "FastForwardMultiplier",
|
||
"RemovePlayerCorpsesOnCorpseRemoval", "TrashDeleteAll", "BloodSplatLifespanDays",
|
||
"ItemNumbersLimitPerContainer", "SafehousePreventsLootRespawn",
|
||
"ConstructionPreventsLootRespawn", "HoursForLootRespawn", "MaxItemsForLootRespawn",
|
||
"SwitchZombiesOwnershipEachUpdate", "UltraSpeedDoesnotAffectToAnimals",
|
||
"SleepAllowed", "SleepNeeded", "SpeedLimit"],
|
||
},
|
||
{
|
||
title: "Бэкапы самой игры",
|
||
keys: ["BackupsCount", "BackupsOnStart", "BackupsOnVersionChange", "BackupsPeriod"],
|
||
},
|
||
{
|
||
title: "Моды",
|
||
keys: ["Mods", "WorkshopItems"],
|
||
},
|
||
{
|
||
title: "Чат и голос",
|
||
keys: ["GlobalChat", "ChatStreams", "VoiceEnable", "VoiceMinDistance", "VoiceMaxDistance",
|
||
"Voice3D", "ChatMessageCharacterLimit", "ChatMessageSlowModeTime", "AnnounceDeath",
|
||
"AnnounceAnimalDeath", "MinutesPerPage", "BanKickGlobalSound"],
|
||
},
|
||
{
|
||
title: "Фильтр брани",
|
||
keys: ["BadWordListFile", "GoodWordListFile", "BadWordPolicy", "BadWordReplacement"],
|
||
},
|
||
{
|
||
title: "Видимость игроков",
|
||
keys: ["DisplayUserName", "ShowFirstAndLastName", "UsernameDisguises",
|
||
"HideDisguisedUserName", "MouseOverToSeeDisplayName", "HidePlayersBehindYou",
|
||
"MapRemotePlayerVisibility", "ShowCoordinates", "DisableScoreboard",
|
||
"HideAdminsInPlayerList"],
|
||
},
|
||
{
|
||
title: "Убежища",
|
||
keys: ["PlayerSafehouse", "AdminSafehouse", "SafehouseAllowTrepass", "SafehouseAllowFire",
|
||
"SafehouseAllowLoot", "SafehouseAllowRespawn", "SafehouseDaySurvivedToClaim",
|
||
"SafeHouseRemovalTime", "SafehouseAllowNonResidential", "SafehouseDisableDisguises",
|
||
"MaxSafezoneSize", "DisableSafehouseWhenOwnerConnected",
|
||
"DisableSafehouseWhenPlayerConnected"],
|
||
},
|
||
{
|
||
title: "Фракции и войны",
|
||
keys: ["Faction", "FactionDaySurvivedToCreate", "FactionPlayersRequiredForTag",
|
||
"War", "WarStartDelay", "WarDuration", "WarSafehouseHitPoints"],
|
||
},
|
||
{
|
||
title: "Рации",
|
||
keys: ["DisableRadioStaff", "DisableRadioAdmin", "DisableRadioGM", "DisableRadioOverseer",
|
||
"DisableRadioModerator", "DisableRadioInvisible"],
|
||
},
|
||
{
|
||
title: "Discord",
|
||
keys: ["DiscordEnable", "DiscordToken", "DiscordChannel", "DiscordChannelID",
|
||
"DiscordChatChannel", "DiscordLogChannel", "DiscordCommandChannel", "WebhookAddress"],
|
||
},
|
||
{
|
||
title: "Античит и журналы",
|
||
keys: ["AntiCheatSafety", "AntiCheatSpeed", "AntiCheatNoClip", "AntiCheatHit",
|
||
"AntiCheatPacketException", "AntiCheatPermission", "AntiCheatXP", "AntiCheatSafeHouse",
|
||
"AntiCheatPlayer", "AntiCheatChecksum", "KickFastPlayers", "ClientActionLogs", "PerkLogs"],
|
||
// Нумерованных проверок два десятка, перечислять их поимённо бессмысленно.
|
||
prefixes: ["AntiCheatProtectionType"],
|
||
},
|
||
{
|
||
title: "Транспорт",
|
||
keys: ["DisableVehicleTowing", "DisableTrailerTowing", "DisableBurntTowing"],
|
||
},
|
||
];
|
||
|
||
// Категории верхнеуровневых параметров песочницы. Вложенные (ZombieLore.Speed
|
||
// и подобные) группируются сами — по имени таблицы, в которой лежат.
|
||
const SANDBOX_GROUPS = [
|
||
{
|
||
title: "Зомби",
|
||
keys: ["Zombies", "Distribution", "ZombiesRespawn", "ZombieRespawn", "ZombieMigrate",
|
||
"ZombieVoronoiNoise", "ZombieAttractionMultiplier", "ZombieHealthImpact",
|
||
"ZombiePopLootEffect", "MultiHitZombies", "RearVulnerability", "SirenEffectsZombies",
|
||
"RallyGroupSize", "RallyTravelDistance", "RallyGroupSeparation", "RallyGroupRadius",
|
||
"HoursForCorpseRemoval", "DecayingCorpseHealthImpact", "BloodLevel",
|
||
"BloodSplatLifespanDays"],
|
||
},
|
||
{
|
||
title: "Мир и время",
|
||
keys: ["DayLength", "StartYear", "StartMonth", "StartDay", "StartTime", "DayNightCycle",
|
||
"NightLength", "NightDarkness", "TimeSinceApo", "WaterShut", "ElecShut",
|
||
"WaterShutModifier", "ElecShutModifier", "Alarm", "AlarmDecay", "AlarmDecayModifier",
|
||
"LockedHouses", "ErosionSpeed", "ErosionDays", "EndRegen", "Helicopter", "MetaEvent",
|
||
"SleepingEvent", "AnnotatedMapChance", "VehicleStoryChance", "ZoneStoryChance",
|
||
"SurvivorHouseChance", "MaximumLootedBuildingRooms"],
|
||
},
|
||
{
|
||
title: "Погода",
|
||
keys: ["ClimateCycle", "FogCycle", "Temperature", "TemperatureModifier", "Rain",
|
||
"RainModifier", "MaxFogIntensity", "MaxRainFxIntensity", "EnableSnowOnGround"],
|
||
},
|
||
{
|
||
title: "Лут и предметы",
|
||
keys: ["LootRespawn", "SeenHoursPreventLootRespawn", "HoursForLootRespawn",
|
||
"MaxItemsForLootRespawn", "ConstructionPreventsLootRespawn", "RollsMultiplier",
|
||
"LootItemRemovalList", "RemoveStoryLoot", "RemoveZombieLoot", "WorldItemRemovalList",
|
||
"HoursForWorldItemRemoval", "ItemRemovalListBlacklistToggle", "MaximumLooted",
|
||
"DaysUntilMaximumLooted", "RuralLooted", "MaximumDiminishedLoot",
|
||
"DaysUntilMaximumDiminishedLoot", "SkillBookLoot", "RecipeResourceLoot"],
|
||
// *Loot, *LootNew и *LootFactor — десятки однотипных ключей.
|
||
prefixes: ["Food", "Canned", "Literature", "Medical", "SurvivalGears", "Weapon",
|
||
"RangedWeapon", "Ammo", "Mechanics", "Other", "Clothing", "Container", "Key", "Media",
|
||
"Memento", "Cookware", "Material", "Farming", "Tool"],
|
||
suffixes: ["Loot", "LootNew", "LootFactor"],
|
||
},
|
||
{
|
||
title: "Персонаж и навыки",
|
||
keys: ["XpMultiplier", "XpMultiplierAffectsPassive", "StatsDecrease", "Endurance",
|
||
"Nutrition", "StarterKit", "InjurySeverity", "BoneFracture", "CharacterFreePoints",
|
||
"ConstructionBonusPoints", "NightVisionEnabled", "InjuredHealingModifier",
|
||
"MuscleStrainFactor", "DiscomfortFactor", "WoundInfectionFactor", "NegativeTraitsPenalty",
|
||
"EnablePoisoning", "ClothingDegradation", "AllClothesUnlocked", "NoBlackClothes",
|
||
"EasyClimbing", "AttackBlockMovements", "MetaKnowledge", "SeeNotLearntRecipe",
|
||
"LiteratureCooldown", "MinutesPerPage", "LevelForMediaXPCutoff",
|
||
"LevelForDismantleXPCutoff"],
|
||
},
|
||
{
|
||
title: "Еда, вода и хозяйство",
|
||
keys: ["FoodRotSpeed", "FridgeFactor", "MaggotSpawn", "EnableTaintedWaterText",
|
||
"FishAbundance", "NatureAbundance", "PlantResilience", "PlantAbundance", "Farming",
|
||
"FarmingSpeedNew", "FarmingAmountNew", "CompostTime", "KillInsideCrops",
|
||
"PlantGrowingSeasons", "PlaceDirtAboveground", "ClayLakeChance", "ClayRiverChance",
|
||
"DaysForRottenFoodRemoval", "AidPackage"],
|
||
},
|
||
{
|
||
title: "Животные",
|
||
keys: ["MaximumRatIndex", "DaysUntilMaximumRatIndex"],
|
||
prefixes: ["Animal"],
|
||
},
|
||
{
|
||
title: "Транспорт",
|
||
keys: ["CarSpawnRate", "ChanceHasGas", "InitialGas", "CarGasConsumption", "LockedCar",
|
||
"CarGeneralCondition", "CarDamageOnImpact", "DamageToPlayerFromHitByACar", "TrafficJam",
|
||
"CarAlarm", "PlayerDamageFromCrash", "SirenShutoffHours", "RecentlySurvivorVehicles",
|
||
"EnableVehicles", "VehicleEasyUse", "MassInvasion"],
|
||
prefixes: ["FuelStation"],
|
||
},
|
||
{
|
||
title: "Огнестрельное оружие",
|
||
keys: [],
|
||
prefixes: ["Firearm"],
|
||
},
|
||
{
|
||
title: "Электричество и огонь",
|
||
keys: ["AllowExteriorGenerator", "FireSpread", "MaximumFireFuelHours", "LightBulbLifespan"],
|
||
prefixes: ["Generator"],
|
||
},
|
||
{
|
||
title: "Служебное",
|
||
keys: ["VERSION"],
|
||
},
|
||
];
|
||
|
||
let serverConfigValues = {};
|
||
|
||
async function loadServerConfig() {
|
||
const data = await get("/api/config/server");
|
||
$("#config-path").textContent = data.path;
|
||
$("#config-empty").hidden = data.exists;
|
||
$("#config-fields").innerHTML = "";
|
||
|
||
if (!data.exists) {
|
||
$("#config-empty").textContent = data.hint;
|
||
refreshFieldSaveState(SAVE_TARGETS[0]);
|
||
return;
|
||
}
|
||
serverConfigValues = data.values;
|
||
const descriptions = data.descriptions || {};
|
||
const entries = data.keys.map((key) => ({
|
||
key,
|
||
value: data.values[key],
|
||
description: descriptions[key],
|
||
}));
|
||
renderGroupedFields("#config-fields", entries, CONFIG_GROUPS, CONFIG_HINTS);
|
||
applyFieldFilter("#config-filter", "#config-fields");
|
||
refreshFieldSaveState(SAVE_TARGETS[0]);
|
||
}
|
||
|
||
// groupEntries раскладывает параметры по разделам. Неизвестные ключи не
|
||
// теряются: они собираются в «Прочее» — конфиг PZ меняется от версии к версии.
|
||
function groupEntries(entries, groups) {
|
||
const byKey = new Map();
|
||
entries.forEach((entry) => byKey.set(entry.key, entry));
|
||
|
||
const result = [];
|
||
const used = new Set();
|
||
|
||
groups.forEach((group) => {
|
||
const items = [];
|
||
group.keys.forEach((key) => {
|
||
const entry = byKey.get(key);
|
||
if (entry && !used.has(key)) {
|
||
used.add(key);
|
||
items.push(entry);
|
||
}
|
||
});
|
||
(group.prefixes || []).forEach((prefix) => {
|
||
entries.forEach((entry) => {
|
||
if (used.has(entry.key)) return;
|
||
// Для лута prefixes перечисляет вид припасов, suffixes — вид ключа
|
||
// (FoodLoot, FoodLootNew, RareLootFactor): совпасть должны оба.
|
||
const suffixes = group.suffixes;
|
||
const matches = suffixes
|
||
? suffixes.some((suffix) => entry.key === prefix + suffix)
|
||
: entry.key.startsWith(prefix);
|
||
if (matches) {
|
||
used.add(entry.key);
|
||
items.push(entry);
|
||
}
|
||
});
|
||
});
|
||
// Суффиксы без своей пары в prefixes — например RareLootFactor.
|
||
(group.suffixes || []).forEach((suffix) => {
|
||
entries.forEach((entry) => {
|
||
if (!used.has(entry.key) && entry.key.endsWith(suffix)) {
|
||
used.add(entry.key);
|
||
items.push(entry);
|
||
}
|
||
});
|
||
});
|
||
if (items.length) result.push({ title: group.title, items });
|
||
});
|
||
|
||
// Вложенные параметры песочницы сами собой образуют разделы: у них путь вида
|
||
// ZombieLore.Speed.
|
||
const nested = new Map();
|
||
const rest = [];
|
||
entries.forEach((entry) => {
|
||
if (used.has(entry.key)) return;
|
||
const dot = entry.key.indexOf(".");
|
||
if (dot > 0) {
|
||
const table = entry.key.slice(0, dot);
|
||
if (!nested.has(table)) nested.set(table, []);
|
||
nested.get(table).push(entry);
|
||
return;
|
||
}
|
||
rest.push(entry);
|
||
});
|
||
|
||
Array.from(nested.entries())
|
||
.sort((a, b) => a[0].localeCompare(b[0]))
|
||
.forEach(([table, items]) => result.push({ title: table, items }));
|
||
|
||
if (rest.length) result.push({ title: "Прочее", items: rest });
|
||
return result;
|
||
}
|
||
|
||
// Какие разделы человек раскрыл: вкладка перерисовывается при каждом переходе,
|
||
// и без этого раскрытый раздел схлопывался бы обратно.
|
||
const openedGroups = new Map();
|
||
|
||
function rememberOpenGroups(containerSelector) {
|
||
const opened = new Set();
|
||
$$(`${containerSelector} .cfg-group`).forEach((group) => {
|
||
if (group.open) opened.add(group.dataset.group);
|
||
});
|
||
openedGroups.set(containerSelector, opened);
|
||
}
|
||
|
||
// renderGroupedFields рисует разделы: свёрнутые по умолчанию, кроме первого —
|
||
// иначе сотня параметров снова превращается в простыню.
|
||
function renderGroupedFields(containerSelector, entries, groups, hints) {
|
||
const container = $(containerSelector);
|
||
container.replaceChildren();
|
||
|
||
const opened = openedGroups.get(containerSelector);
|
||
groupEntries(entries, groups).forEach((group, index) => {
|
||
const section = document.createElement("details");
|
||
section.className = "cfg-group";
|
||
section.dataset.group = group.title;
|
||
section.open = opened ? opened.has(group.title) : index === 0;
|
||
|
||
const summary = document.createElement("summary");
|
||
summary.innerHTML =
|
||
`${escapeHTML(group.title)} <span class="cfg-count">${group.items.length}</span>`;
|
||
section.appendChild(summary);
|
||
|
||
const fields = document.createElement("div");
|
||
fields.className = "fields";
|
||
group.items.forEach((entry) => {
|
||
fields.appendChild(buildConfigField(
|
||
entry.key, entry.value, hints ? hints[entry.key] : null, entry.description));
|
||
});
|
||
section.appendChild(fields);
|
||
container.appendChild(section);
|
||
});
|
||
}
|
||
|
||
// buildConfigField выбирает тип поля по текущему значению: булевы значения
|
||
// удобнее переключать списком, числа — числовым полем.
|
||
function buildConfigField(key, value, hint, description) {
|
||
const wrapper = document.createElement("div");
|
||
wrapper.className = "cfg-field";
|
||
wrapper.dataset.key = key.toLowerCase();
|
||
// Поиск идёт и по описанию: по-русски параметр искать привычнее, чем по
|
||
// английскому имени ключа.
|
||
wrapper.dataset.hint = `${hint || ""} ${description || ""}`.toLowerCase();
|
||
|
||
const label = document.createElement("label");
|
||
label.textContent = hint || key;
|
||
if (description) {
|
||
// Полный текст — во всплывающей подсказке: описания бывают в несколько
|
||
// строк, и разворачивать их для каждого параметра значит утопить форму.
|
||
wrapper.title = description;
|
||
}
|
||
wrapper.appendChild(label);
|
||
|
||
let input;
|
||
if (BOOLEAN_VALUES.has(value.toLowerCase())) {
|
||
input = document.createElement("select");
|
||
["true", "false"].forEach((option) => {
|
||
const el = document.createElement("option");
|
||
el.value = option;
|
||
el.textContent = option === "true" ? "да" : "нет";
|
||
input.appendChild(el);
|
||
});
|
||
input.value = value.toLowerCase();
|
||
} else if (/^-?\d+$/.test(value) && value.length < 10) {
|
||
input = document.createElement("input");
|
||
input.type = "number";
|
||
input.value = value;
|
||
} else {
|
||
input = document.createElement("input");
|
||
input.type = key.toLowerCase().includes("password") ? "password" : "text";
|
||
input.value = value;
|
||
}
|
||
input.dataset.original = value;
|
||
input.name = key;
|
||
input.addEventListener("input", () => {
|
||
wrapper.classList.toggle("changed", input.value !== input.dataset.original);
|
||
});
|
||
wrapper.appendChild(input);
|
||
|
||
const keyLabel = document.createElement("div");
|
||
keyLabel.className = "key";
|
||
keyLabel.textContent = key;
|
||
wrapper.appendChild(keyLabel);
|
||
|
||
if (description) {
|
||
const hintLine = document.createElement("div");
|
||
hintLine.className = "hint";
|
||
hintLine.textContent = description;
|
||
wrapper.appendChild(hintLine);
|
||
}
|
||
return wrapper;
|
||
}
|
||
|
||
// collectChanged собирает только изменённые поля: отправлять весь файл целиком
|
||
// рискованно, если его правили ещё и вручную.
|
||
function collectChanged(containerSelector) {
|
||
const changed = {};
|
||
$$(`${containerSelector} .cfg-field`).forEach((field) => {
|
||
const input = field.querySelector("input, select");
|
||
if (input && input.value !== input.dataset.original) {
|
||
changed[input.name] = input.value;
|
||
}
|
||
});
|
||
return changed;
|
||
}
|
||
|
||
// Кнопка «Сохранить» включается, только когда есть что сохранять: на пустой
|
||
// вкладке (файл ещё не создан игрой) или без правок нажимать её незачем.
|
||
const SAVE_TARGETS = [
|
||
{ fields: "#config-fields", button: "#btn-config-save" },
|
||
{ fields: "#sandbox-fields", button: "#btn-sandbox-save" },
|
||
];
|
||
|
||
function refreshFieldSaveState(target) {
|
||
const count = Object.keys(collectChanged(target.fields)).length;
|
||
const button = $(target.button);
|
||
button.disabled = count === 0;
|
||
button.textContent = count ? `Сохранить (${count})` : "Сохранить";
|
||
button.title = count ? `Изменено параметров: ${count}` : "Изменений нет";
|
||
}
|
||
|
||
SAVE_TARGETS.forEach((target) => {
|
||
// Слушаем на контейнере: поля пересоздаются при каждой загрузке вкладки.
|
||
["input", "change"].forEach((event) =>
|
||
$(target.fields).addEventListener(event, () => refreshFieldSaveState(target)));
|
||
});
|
||
|
||
function markSaved(containerSelector) {
|
||
$$(`${containerSelector} .cfg-field`).forEach((field) => {
|
||
const input = field.querySelector("input, select");
|
||
if (input) input.dataset.original = input.value;
|
||
field.classList.remove("changed");
|
||
});
|
||
const target = SAVE_TARGETS.find((t) => t.fields === containerSelector);
|
||
if (target) refreshFieldSaveState(target);
|
||
}
|
||
|
||
$("#btn-config-save").addEventListener("click", async () => {
|
||
const values = collectChanged("#config-fields");
|
||
if (!Object.keys(values).length) {
|
||
toast("Нет изменений");
|
||
return;
|
||
}
|
||
try {
|
||
await put("/api/config/server", { values });
|
||
markSaved("#config-fields");
|
||
ok("Конфиг сохранён. Изменения применятся после перезапуска сервера.");
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
function applyFieldFilter(inputSelector, containerSelector) {
|
||
const filter = $(inputSelector).value.trim().toLowerCase();
|
||
|
||
$$(`${containerSelector} .cfg-field`).forEach((field) => {
|
||
field.hidden = filter && !field.dataset.key.includes(filter) && !field.dataset.hint.includes(filter);
|
||
});
|
||
|
||
// Раздел без совпадений прячем целиком, а с совпадениями — раскрываем:
|
||
// искать параметр по свёрнутым разделам бессмысленно.
|
||
$$(`${containerSelector} .cfg-group`).forEach((group) => {
|
||
const visible = Array.from(group.querySelectorAll(".cfg-field")).filter((f) => !f.hidden);
|
||
group.hidden = visible.length === 0;
|
||
if (filter) {
|
||
group.open = visible.length > 0;
|
||
}
|
||
const count = group.querySelector(".cfg-count");
|
||
if (count) {
|
||
count.textContent = filter ? `${visible.length}` : `${group.querySelectorAll(".cfg-field").length}`;
|
||
}
|
||
});
|
||
}
|
||
|
||
// toggle не всплывает, поэтому слушаем на фазе перехвата.
|
||
["#config-fields", "#sandbox-fields"].forEach((selector) =>
|
||
$(selector).addEventListener("toggle", () => rememberOpenGroups(selector), true));
|
||
|
||
$("#config-filter").addEventListener("input", () => applyFieldFilter("#config-filter", "#config-fields"));
|
||
$("#sandbox-filter").addEventListener("input", () => applyFieldFilter("#sandbox-filter", "#sandbox-fields"));
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Песочница
|
||
// ---------------------------------------------------------------------------
|
||
|
||
async function loadSandbox() {
|
||
const data = await get("/api/config/sandbox");
|
||
$("#sandbox-path").textContent = data.path;
|
||
$("#sandbox-empty").hidden = data.exists;
|
||
$("#sandbox-fields").innerHTML = "";
|
||
|
||
if (!data.exists) {
|
||
$("#sandbox-empty").textContent = data.hint;
|
||
refreshFieldSaveState(SAVE_TARGETS[1]);
|
||
return;
|
||
}
|
||
const entries = data.entries.map((entry) => ({ key: entry.path, value: entry.value }));
|
||
renderGroupedFields("#sandbox-fields", entries, SANDBOX_GROUPS, null);
|
||
applyFieldFilter("#sandbox-filter", "#sandbox-fields");
|
||
refreshFieldSaveState(SAVE_TARGETS[1]);
|
||
}
|
||
|
||
$("#btn-sandbox-save").addEventListener("click", async () => {
|
||
const values = collectChanged("#sandbox-fields");
|
||
if (!Object.keys(values).length) {
|
||
toast("Нет изменений");
|
||
return;
|
||
}
|
||
try {
|
||
await put("/api/config/sandbox", { values });
|
||
markSaved("#sandbox-fields");
|
||
ok("Песочница сохранена. Часть параметров действует только на новый мир.");
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Моды
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// В Project Zomboid список модов задаётся двумя строками конфига:
|
||
// WorkshopItems — что скачать из мастерской, Mods — что включить и в каком
|
||
// порядке. Панель показывает их одним списком: строка на мод, галочка =
|
||
// присутствие в Mods, порядок строк = порядок в Mods.
|
||
// Снимок списков на момент загрузки: по нему видно, есть ли несохранённые
|
||
// правки. Пустая строка означает, что конфига ещё нет и сохранять нечего.
|
||
let modsSnapshot = "";
|
||
|
||
let mods = {
|
||
workshop: [], // WorkshopItems
|
||
enabled: [], // Mods, порядок важен
|
||
maps: [],
|
||
installed: [], // что реально лежит на диске (из mod.info)
|
||
details: {}, // сведения из мастерской по Workshop ID
|
||
};
|
||
|
||
async function loadMods() {
|
||
const data = await get("/api/mods");
|
||
$("#mods-empty").hidden = data.exists;
|
||
$("#mods-body").hidden = !data.exists;
|
||
if (!data.exists) {
|
||
$("#mods-empty").textContent = data.hint;
|
||
modsSnapshot = "";
|
||
refreshModsSaveState();
|
||
return;
|
||
}
|
||
|
||
mods = {
|
||
workshop: data.workshop_items || [],
|
||
enabled: data.mods || [],
|
||
maps: data.map || [],
|
||
installed: data.installed || [],
|
||
details: mods.details,
|
||
};
|
||
$("#map-list").value = mods.maps.join("\n");
|
||
modsSnapshot = modsState();
|
||
renderMods();
|
||
lookupWorkshopTitles().catch(() => {
|
||
/* без интернета останутся идентификаторы — это не ошибка панели */
|
||
});
|
||
}
|
||
|
||
// buildModRows сводит три источника в один список строк: каталог с диска,
|
||
// включённые моды и пакеты мастерской, файлы которых ещё не скачаны.
|
||
function buildModRows() {
|
||
const rows = [];
|
||
const byModID = new Map();
|
||
|
||
const push = (row) => {
|
||
byModID.set(row.modID, row);
|
||
rows.push(row);
|
||
};
|
||
|
||
// 1. Моды, найденные на диске. Показываем только те, чей пакет есть в
|
||
// списке скачиваемых, плюс локальные (без Workshop ID).
|
||
const wanted = new Set(mods.workshop);
|
||
mods.installed.forEach((mod) => {
|
||
if (mod.workshop_id && !wanted.has(mod.workshop_id)) return;
|
||
push({
|
||
modID: mod.mod_id,
|
||
workshopID: mod.workshop_id,
|
||
name: mod.name || mod.mod_id,
|
||
note: mod.workshop_id ? "" : "локальный мод",
|
||
installed: true,
|
||
});
|
||
});
|
||
|
||
// 2. Включённые моды, файлов которых мы не нашли: либо сервер их ещё не
|
||
// скачал, либо мод пропал из мастерской.
|
||
mods.enabled.forEach((modID) => {
|
||
if (byModID.has(modID)) return;
|
||
push({
|
||
modID,
|
||
workshopID: "",
|
||
name: modID,
|
||
note: "файлы не найдены — сервер скачает их при запуске",
|
||
installed: false,
|
||
});
|
||
});
|
||
|
||
// 3. Пакеты мастерской, из которых пока ничего не установлено.
|
||
const covered = new Set(rows.map((row) => row.workshopID).filter(Boolean));
|
||
mods.workshop.forEach((workshopID) => {
|
||
if (covered.has(workshopID)) return;
|
||
const info = mods.details[workshopID] || {};
|
||
rows.push({
|
||
modID: "",
|
||
workshopID,
|
||
name: info.title || `Мод ${workshopID}`,
|
||
note: info.error || "ещё не скачан — включить можно после запуска сервера",
|
||
installed: false,
|
||
});
|
||
});
|
||
|
||
// Включённые идут первыми и в том порядке, в каком их грузит игра.
|
||
const order = (row) => {
|
||
const index = mods.enabled.indexOf(row.modID);
|
||
return index === -1 ? Number.MAX_SAFE_INTEGER : index;
|
||
};
|
||
rows.sort((a, b) => {
|
||
const diff = order(a) - order(b);
|
||
return diff !== 0 ? diff : a.name.localeCompare(b.name, "ru");
|
||
});
|
||
return rows;
|
||
}
|
||
|
||
// modsState сводит списки к строке — так проще всего заметить и переключённую
|
||
// галочку, и переставленный порядок загрузки.
|
||
function modsState() {
|
||
return JSON.stringify({
|
||
enabled: mods.enabled,
|
||
workshop: mods.workshop,
|
||
maps: $("#map-list").value.split("\n").map((line) => line.trim()).filter(Boolean),
|
||
});
|
||
}
|
||
|
||
function refreshModsSaveState() {
|
||
const button = $("#btn-mods-save");
|
||
const changed = modsSnapshot !== "" && modsState() !== modsSnapshot;
|
||
button.disabled = !changed;
|
||
button.title = changed ? "Есть несохранённые изменения" : "Изменений нет";
|
||
}
|
||
|
||
function renderMods() {
|
||
const filter = $("#mod-filter").value.trim().toLowerCase();
|
||
const onlyEnabled = $("#mod-only-enabled").checked;
|
||
const rows = buildModRows();
|
||
|
||
const visible = rows.filter((row) => {
|
||
if (onlyEnabled && !mods.enabled.includes(row.modID)) return false;
|
||
if (!filter) return true;
|
||
return `${row.name} ${row.modID} ${row.workshopID}`.toLowerCase().includes(filter);
|
||
});
|
||
|
||
$("#mod-summary").textContent =
|
||
`Модов: ${rows.length}, включено: ${mods.enabled.length}, пакетов мастерской: ${mods.workshop.length}`;
|
||
|
||
refreshModsSaveState();
|
||
|
||
$("#mod-list").innerHTML = visible
|
||
.map((row) => {
|
||
const on = mods.enabled.includes(row.modID);
|
||
const info = mods.details[row.workshopID] || {};
|
||
const preview = info.preview
|
||
? `<img src="${escapeHTML(info.preview)}" alt="">`
|
||
: `<span class="mod-thumb"></span>`;
|
||
const noteClass = row.note.includes("не найден") ? "error" : "muted";
|
||
const workshopLink = row.workshopID
|
||
? `<a href="https://steamcommunity.com/sharedfiles/filedetails/?id=${escapeHTML(row.workshopID)}"
|
||
target="_blank" rel="noopener noreferrer">${escapeHTML(row.workshopID)}</a>`
|
||
: "";
|
||
|
||
// Перетаскивать можно только включённые моды: порядок хранится в Mods.
|
||
return `<li class="mod-row${on ? " enabled" : ""}" data-mod="${escapeHTML(row.modID)}"
|
||
data-workshop="${escapeHTML(row.workshopID)}" ${on ? 'draggable="true"' : ""}>
|
||
<span class="drag-handle" title="${on ? "Перетащите, чтобы изменить порядок" : "Порядок задаётся у включённых модов"}">⠿</span>
|
||
<input type="checkbox" class="mod-toggle" ${on ? "checked" : ""}
|
||
${row.modID ? "" : "disabled"} title="Включить мод на сервере">
|
||
${preview}
|
||
<div class="mod-title">
|
||
<b>${escapeHTML(row.name)}</b>
|
||
<small>${row.modID ? escapeHTML(row.modID) : "Mod ID неизвестен"}${workshopLink ? " · " + workshopLink : ""}</small>
|
||
${row.note ? `<small class="${noteClass}">${escapeHTML(row.note)}</small>` : ""}
|
||
</div>
|
||
<button class="btn btn-sm btn-ghost" data-move="-1" ${on ? "" : "disabled"} title="Выше">↑</button>
|
||
<button class="btn btn-sm btn-ghost" data-move="1" ${on ? "" : "disabled"} title="Ниже">↓</button>
|
||
<button class="btn btn-sm btn-danger" data-remove="1">Убрать</button>
|
||
</li>`;
|
||
})
|
||
.join("") || `<li class="muted">Ничего не найдено</li>`;
|
||
}
|
||
|
||
async function lookupWorkshopTitles() {
|
||
if (!mods.workshop.length) return;
|
||
const data = await post("/api/mods/lookup", { ids: mods.workshop });
|
||
(data.items || []).forEach((item) => {
|
||
mods.details[item.id] = item;
|
||
});
|
||
renderMods();
|
||
}
|
||
|
||
// moveEnabled двигает мод в списке загрузки на delta позиций.
|
||
function moveEnabled(modID, delta) {
|
||
const from = mods.enabled.indexOf(modID);
|
||
const to = from + delta;
|
||
if (from === -1 || to < 0 || to >= mods.enabled.length) return;
|
||
mods.enabled.splice(to, 0, mods.enabled.splice(from, 1)[0]);
|
||
renderMods();
|
||
}
|
||
|
||
$("#mod-list").addEventListener("change", (event) => {
|
||
const toggle = event.target.closest(".mod-toggle");
|
||
if (!toggle) return;
|
||
|
||
const modID = toggle.closest(".mod-row").dataset.mod;
|
||
if (!modID) return;
|
||
if (toggle.checked) {
|
||
// Новый мод грузится последним: обычно так и надо, а порядок правится
|
||
// перетаскиванием.
|
||
if (!mods.enabled.includes(modID)) mods.enabled.push(modID);
|
||
} else {
|
||
mods.enabled = mods.enabled.filter((id) => id !== modID);
|
||
}
|
||
renderMods();
|
||
});
|
||
|
||
$("#mod-list").addEventListener("click", (event) => {
|
||
const row = event.target.closest(".mod-row");
|
||
if (!row) return;
|
||
|
||
const move = event.target.closest("button[data-move]");
|
||
if (move) {
|
||
moveEnabled(row.dataset.mod, Number(move.dataset.move));
|
||
return;
|
||
}
|
||
|
||
if (!event.target.closest("button[data-remove]")) return;
|
||
|
||
const { mod: modID, workshop: workshopID } = row.dataset;
|
||
// Убираем и пакет мастерской, и все включённые моды из него: иначе сервер
|
||
// продолжит скачивать то, что уже не нужно.
|
||
if (workshopID) {
|
||
mods.workshop = mods.workshop.filter((id) => id !== workshopID);
|
||
const fromPackage = mods.installed
|
||
.filter((mod) => mod.workshop_id === workshopID)
|
||
.map((mod) => mod.mod_id);
|
||
mods.enabled = mods.enabled.filter((id) => id !== modID && !fromPackage.includes(id));
|
||
} else {
|
||
mods.enabled = mods.enabled.filter((id) => id !== modID);
|
||
}
|
||
renderMods();
|
||
});
|
||
|
||
// Перетаскивание порядка загрузки.
|
||
let dragged = null;
|
||
|
||
$("#mod-list").addEventListener("dragstart", (event) => {
|
||
const row = event.target.closest(".mod-row");
|
||
if (!row || !row.classList.contains("enabled")) return;
|
||
dragged = row.dataset.mod;
|
||
row.classList.add("dragging");
|
||
event.dataTransfer.effectAllowed = "move";
|
||
});
|
||
|
||
$("#mod-list").addEventListener("dragend", () => {
|
||
dragged = null;
|
||
$$(".mod-row").forEach((row) => row.classList.remove("dragging", "drop-target"));
|
||
});
|
||
|
||
$("#mod-list").addEventListener("dragover", (event) => {
|
||
if (!dragged) return;
|
||
const row = event.target.closest(".mod-row.enabled");
|
||
if (!row || row.dataset.mod === dragged) return;
|
||
event.preventDefault();
|
||
$$(".mod-row").forEach((el) => el.classList.toggle("drop-target", el === row));
|
||
});
|
||
|
||
$("#mod-list").addEventListener("drop", (event) => {
|
||
if (!dragged) return;
|
||
const row = event.target.closest(".mod-row.enabled");
|
||
if (!row) return;
|
||
event.preventDefault();
|
||
|
||
const from = mods.enabled.indexOf(dragged);
|
||
const to = mods.enabled.indexOf(row.dataset.mod);
|
||
if (from === -1 || to === -1) return;
|
||
mods.enabled.splice(to, 0, mods.enabled.splice(from, 1)[0]);
|
||
dragged = null;
|
||
renderMods();
|
||
});
|
||
|
||
$("#map-list").addEventListener("input", refreshModsSaveState);
|
||
$("#mod-filter").addEventListener("input", renderMods);
|
||
$("#mod-only-enabled").addEventListener("change", renderMods);
|
||
|
||
// extractWorkshopID принимает как голый идентификатор, так и ссылку на
|
||
// страницу мастерской.
|
||
function extractWorkshopID(input) {
|
||
const match = input.match(/(\d{5,})/);
|
||
return match ? match[1] : "";
|
||
}
|
||
|
||
$("#mod-add-form").addEventListener("submit", (event) => {
|
||
event.preventDefault();
|
||
const id = extractWorkshopID($("#mod-input").value.trim());
|
||
if (!id) {
|
||
toast("Не похоже на ссылку или ID мода", "err");
|
||
return;
|
||
}
|
||
if (mods.workshop.includes(id)) {
|
||
toast("Этот мод уже в списке");
|
||
return;
|
||
}
|
||
mods.workshop.push(id);
|
||
$("#mod-input").value = "";
|
||
renderMods();
|
||
lookupWorkshopTitles().catch(() => {});
|
||
});
|
||
|
||
$("#btn-add-collection").addEventListener("click", async () => {
|
||
const input = $("#mod-input").value.trim();
|
||
if (!input) {
|
||
toast("Вставьте ссылку на коллекцию или её ID", "err");
|
||
return;
|
||
}
|
||
try {
|
||
const data = await post("/api/mods/collection", { id: input });
|
||
const items = data.items || [];
|
||
|
||
let added = 0;
|
||
items.forEach((item) => {
|
||
mods.details[item.id] = item;
|
||
if (!mods.workshop.includes(item.id)) {
|
||
mods.workshop.push(item.id);
|
||
added++;
|
||
}
|
||
});
|
||
|
||
$("#mod-input").value = "";
|
||
renderMods();
|
||
ok(added
|
||
? `Из коллекции добавлено модов: ${added} (всего в ней ${items.length})`
|
||
: `Все ${items.length} модов коллекции уже были в списке`);
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
$("#btn-mods-save").addEventListener("click", async () => {
|
||
const maps = $("#map-list").value.split("\n").map((line) => line.trim()).filter(Boolean);
|
||
try {
|
||
await put("/api/mods", {
|
||
mods: mods.enabled,
|
||
workshop_items: mods.workshop,
|
||
map: maps,
|
||
});
|
||
modsSnapshot = modsState();
|
||
refreshModsSaveState();
|
||
ok("Список модов сохранён. Перезапустите сервер, чтобы он их подтянул.");
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Профили серверов
|
||
// ---------------------------------------------------------------------------
|
||
|
||
let profiles = { list: [], active: "" };
|
||
|
||
async function loadProfiles() {
|
||
const data = await get("/api/profiles");
|
||
profiles = { list: data.profiles || [], active: data.active };
|
||
|
||
renderProfileSelect();
|
||
renderProfileCards();
|
||
renderCopySource();
|
||
}
|
||
|
||
function renderProfileSelect() {
|
||
const select = $("#profile-select");
|
||
select.innerHTML = profiles.list
|
||
.map((p) => `<option value="${escapeHTML(p.id)}">${escapeHTML(p.title || p.id)}</option>`)
|
||
.join("");
|
||
select.value = profiles.active;
|
||
}
|
||
|
||
function renderProfileCards() {
|
||
$("#profile-cards").innerHTML = profiles.list
|
||
.map((p) => {
|
||
const badge = p.active ? `<span class="badge">активный</span>` : "";
|
||
const state = p.has_config
|
||
? p.world_ready
|
||
? "мир создан"
|
||
: "настроен, мир ещё не создан"
|
||
: "ни разу не запускался";
|
||
|
||
return `<div class="card profile-card" data-profile="${escapeHTML(p.id)}">
|
||
<h3>${escapeHTML(p.title || p.id)} ${badge}</h3>
|
||
<div class="key">${escapeHTML(p.id)}</div>
|
||
<p class="muted small">${state}</p>
|
||
|
||
<label class="field">
|
||
<span>Название</span>
|
||
<input type="text" data-field="title" value="${escapeHTML(p.title || "")}">
|
||
</label>
|
||
<label class="field">
|
||
<span>Память JVM, максимум</span>
|
||
<input type="text" data-field="java_memory" value="${escapeHTML(p.java_memory || "")}">
|
||
<small>${escapeHTML(memoryHint())}</small>
|
||
</label>
|
||
<label class="field">
|
||
<span>Память JVM, начальная</span>
|
||
<input type="text" data-field="java_memory_min" value="${escapeHTML(p.java_memory_min || "")}"
|
||
placeholder="не задана">
|
||
<small>Пусто — JVM берёт память по мере надобности. Если задать, она
|
||
займёт этот объём сразу при старте и не сможет подняться, когда его нет.</small>
|
||
</label>
|
||
<label class="field">
|
||
<span>Пароль админа игры</span>
|
||
<input type="password" data-field="admin_password" autocomplete="new-password"
|
||
placeholder="${p.has_admin_password ? "пароль задан" : "не задан"}">
|
||
</label>
|
||
|
||
<div class="profile-actions">
|
||
<button class="btn btn-sm btn-primary" data-action="save">Сохранить</button>
|
||
<button class="btn btn-sm" data-action="activate" ${p.active ? "disabled" : ""}>Сделать активным</button>
|
||
<button class="btn btn-sm btn-danger" data-action="delete" ${p.active ? "disabled" : ""}>Удалить</button>
|
||
</div>
|
||
</div>`;
|
||
})
|
||
.join("");
|
||
}
|
||
|
||
// renderCopySource предлагает копировать настройки только с тех профилей, у
|
||
// которых конфиг уже создан игрой.
|
||
// memoryHint подсказывает разумный потолок: JVM должна поместиться в свободную
|
||
// память, иначе сервер не поднимется вовсе.
|
||
function memoryHint() {
|
||
if (!hostStats.mem_total_bytes) return "Например 4g";
|
||
const total = formatBytes(hostStats.mem_total_bytes);
|
||
const free = formatBytes(hostStats.mem_available_bytes);
|
||
return `На машине ${total} ОЗУ, свободно ${free}. Оставьте запас системе.`;
|
||
}
|
||
|
||
function renderCopySource() {
|
||
$("#new-profile-copy").innerHTML =
|
||
`<option value="">не копировать</option>` +
|
||
profiles.list
|
||
.filter((p) => p.has_config)
|
||
.map((p) => `<option value="${escapeHTML(p.id)}">${escapeHTML(p.title || p.id)}</option>`)
|
||
.join("");
|
||
}
|
||
|
||
// switchProfile меняет активный профиль. Все вкладки показывают именно его
|
||
// конфиг, моды и мир, поэтому открытую вкладку перезагружаем.
|
||
async function switchProfile(id) {
|
||
try {
|
||
await post(`/api/profiles/${encodeURIComponent(id)}/activate`);
|
||
await loadProfiles();
|
||
ok("Активный профиль переключён");
|
||
refreshStatus();
|
||
loadTab(currentTab);
|
||
} catch (error) {
|
||
fail(error);
|
||
// Селектор показывает то, чего не произошло, — возвращаем прежнее значение.
|
||
$("#profile-select").value = profiles.active;
|
||
}
|
||
}
|
||
|
||
$("#profile-select").addEventListener("change", (event) => switchProfile(event.target.value));
|
||
|
||
$("#profile-cards").addEventListener("click", async (event) => {
|
||
const button = event.target.closest("button[data-action]");
|
||
if (!button) return;
|
||
|
||
const card = button.closest(".profile-card");
|
||
const id = card.dataset.profile;
|
||
const field = (name) => card.querySelector(`[data-field="${name}"]`).value;
|
||
|
||
try {
|
||
switch (button.dataset.action) {
|
||
case "save":
|
||
await put(`/api/profiles/${encodeURIComponent(id)}`, {
|
||
title: field("title"),
|
||
java_memory: field("java_memory"),
|
||
java_memory_min: field("java_memory_min"),
|
||
admin_password: field("admin_password"),
|
||
});
|
||
ok("Профиль сохранён");
|
||
await loadProfiles();
|
||
break;
|
||
|
||
case "activate":
|
||
await switchProfile(id);
|
||
break;
|
||
|
||
case "delete":
|
||
if (!confirm(`Убрать профиль ${id} из панели?\n\n` +
|
||
`Мир и конфиги останутся на диске — профиль можно вернуть, создав его с тем же идентификатором.`)) {
|
||
return;
|
||
}
|
||
await del(`/api/profiles/${encodeURIComponent(id)}`);
|
||
ok("Профиль удалён");
|
||
await loadProfiles();
|
||
break;
|
||
}
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
$("#profile-add-form").addEventListener("submit", async (event) => {
|
||
event.preventDefault();
|
||
try {
|
||
await post("/api/profiles", {
|
||
id: $("#new-profile-id").value.trim(),
|
||
title: $("#new-profile-title").value.trim(),
|
||
java_memory: $("#new-profile-memory").value.trim(),
|
||
copy_from: $("#new-profile-copy").value,
|
||
});
|
||
$("#new-profile-id").value = "";
|
||
$("#new-profile-title").value = "";
|
||
$("#new-profile-memory").value = "";
|
||
ok("Профиль создан");
|
||
await loadProfiles();
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Бэкапы
|
||
// ---------------------------------------------------------------------------
|
||
|
||
async function loadBackups() {
|
||
const data = await get("/api/backups");
|
||
$("#backup-dir").textContent = data.dir;
|
||
|
||
const rows = (data.backups || []).map(
|
||
(archive) => `<tr>
|
||
<td>${escapeHTML(archive.name)}</td>
|
||
<td>${escapeHTML(profileTitle(archive.profile))}</td>
|
||
<td>${formatBytes(archive.size_bytes)}</td>
|
||
<td>${formatDate(archive.created_at)}</td>
|
||
<td>
|
||
<a class="btn btn-sm btn-ghost" href="/api/backups/${encodeURIComponent(archive.name)}/download">Скачать</a>
|
||
<button class="btn btn-sm" data-restore="${escapeHTML(archive.name)}">Восстановить</button>
|
||
<button class="btn btn-sm btn-danger" data-delete="${escapeHTML(archive.name)}">Удалить</button>
|
||
</td>
|
||
</tr>`
|
||
);
|
||
$("#backup-rows").innerHTML = rows.join("") ||
|
||
`<tr><td colspan="5" class="muted">Пока ни одного архива</td></tr>`;
|
||
}
|
||
|
||
// profileTitle подписывает архив понятным именем профиля. У архивов, снятых до
|
||
// появления профилей, идентификатора в имени нет.
|
||
function profileTitle(id) {
|
||
if (!id) return "—";
|
||
const profile = profiles.list.find((p) => p.id === id);
|
||
return profile ? profile.title || profile.id : id;
|
||
}
|
||
|
||
$("#backup-form").addEventListener("submit", async (event) => {
|
||
event.preventDefault();
|
||
try {
|
||
await post("/api/backups", { note: $("#backup-note").value.trim() });
|
||
$("#backup-note").value = "";
|
||
ok("Бэкап запущен — прогресс во вкладке «Консоль»");
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
$("#backup-rows").addEventListener("click", async (event) => {
|
||
const restore = event.target.closest("button[data-restore]");
|
||
const remove = event.target.closest("button[data-delete]");
|
||
|
||
try {
|
||
if (restore) {
|
||
const name = restore.dataset.restore;
|
||
if (!confirm(`Восстановить мир из ${name}? Текущий мир будет перезаписан.\n` +
|
||
`Перед восстановлением менеджер сам сделает страховочный бэкап.`)) return;
|
||
await post(`/api/backups/${encodeURIComponent(name)}/restore`);
|
||
ok("Восстановление запущено");
|
||
} else if (remove) {
|
||
const name = remove.dataset.delete;
|
||
if (!confirm(`Удалить архив ${name}? Это действие необратимо.`)) return;
|
||
await del(`/api/backups/${encodeURIComponent(name)}`);
|
||
ok("Архив удалён");
|
||
loadBackups();
|
||
}
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Версия панели и обновление
|
||
// ---------------------------------------------------------------------------
|
||
|
||
let updateInfo = null;
|
||
|
||
async function loadUpdateInfo() {
|
||
const info = await get("/api/update");
|
||
updateInfo = info;
|
||
|
||
$("#update-current").textContent = info.current || "?";
|
||
|
||
const state = $("#update-state");
|
||
const applyBtn = $("#btn-update-apply");
|
||
const manual = $("#update-manual");
|
||
|
||
applyBtn.hidden = !info.available;
|
||
manual.hidden = true;
|
||
|
||
if (info.error) {
|
||
state.className = "muted small";
|
||
state.textContent = `Не удалось проверить обновления: ${info.error}`;
|
||
} else if (info.available) {
|
||
state.className = "small update-available";
|
||
state.textContent = `Доступна версия ${info.latest}`;
|
||
applyBtn.textContent = `Обновить до ${info.latest}`;
|
||
// Панель обновляется сама, только если установщик прописал ей права на
|
||
// это. Иначе показываем команду для терминала.
|
||
if (!info.can_apply) {
|
||
applyBtn.hidden = true;
|
||
manual.hidden = false;
|
||
manual.textContent = `Обновить можно командой: ${info.manual_command}`;
|
||
}
|
||
} else {
|
||
state.className = "muted small";
|
||
state.textContent = info.latest
|
||
? `Установлена последняя версия (${info.latest})`
|
||
: "Сведений о релизах нет";
|
||
}
|
||
|
||
const notes = $("#update-notes");
|
||
const changelog = info.changelog || [];
|
||
notes.hidden = !(info.available && changelog.length);
|
||
if (!notes.hidden) {
|
||
notes.querySelector("summary").textContent =
|
||
changelog.length > 1 ? `Что нового (версий: ${changelog.length})` : "Что нового";
|
||
renderChangelog(changelog);
|
||
}
|
||
|
||
$("#btn-manager-restart").disabled = !info.can_apply;
|
||
$("#btn-manager-restart").title = info.can_apply
|
||
? "Перезапустить службу панели"
|
||
: "Недоступно: панель не может управлять своей службой";
|
||
}
|
||
|
||
// Описание релиза приходит из Gitea разметкой Markdown, и показывать её как
|
||
// есть неудобно: первым идёт раздел про установку, который в уже работающей
|
||
// панели ни к чему. Берём только список изменений.
|
||
function releaseItems(text) {
|
||
const changes = text.split(/^##\s+Изменения\s*$/m)[1];
|
||
return (changes ?? text)
|
||
.split("\n")
|
||
.map((line) => line.trim())
|
||
.filter((line) => line.startsWith("- "))
|
||
.map((line) => line.slice(2).trim())
|
||
.filter(Boolean);
|
||
}
|
||
|
||
// renderChangelog показывает изменения всех версий между установленной и
|
||
// последней: пропустив несколько релизов, иначе не узнать, что было в них.
|
||
function renderChangelog(releases) {
|
||
const body = $("#update-notes-body");
|
||
body.replaceChildren();
|
||
|
||
releases.forEach((release) => {
|
||
const heading = document.createElement("h4");
|
||
heading.className = "release-version";
|
||
heading.textContent = release.published
|
||
? `${release.version} — ${formatDate(release.published)}`
|
||
: release.version;
|
||
body.appendChild(heading);
|
||
|
||
const items = releaseItems(release.notes || "");
|
||
if (items.length) {
|
||
const list = document.createElement("ul");
|
||
items.forEach((item) => {
|
||
const li = document.createElement("li");
|
||
li.textContent = item;
|
||
list.appendChild(li);
|
||
});
|
||
body.appendChild(list);
|
||
return;
|
||
}
|
||
|
||
// Непривычный формат описания — показываем как есть, лишь бы не потерять.
|
||
const raw = document.createElement("pre");
|
||
raw.textContent = (release.notes || "").trim() || "Описание не заполнено";
|
||
body.appendChild(raw);
|
||
});
|
||
|
||
const newest = releases[0];
|
||
if (newest && newest.url) {
|
||
const link = document.createElement("a");
|
||
link.href = newest.url;
|
||
link.target = "_blank";
|
||
link.rel = "noopener noreferrer";
|
||
link.className = "release-link";
|
||
link.textContent = "Полное описание релизов";
|
||
body.appendChild(link);
|
||
}
|
||
}
|
||
|
||
$("#btn-update-check").addEventListener("click", async () => {
|
||
const button = $("#btn-update-check");
|
||
button.disabled = true;
|
||
try {
|
||
await loadUpdateInfo();
|
||
ok(updateInfo.available ? `Есть новая версия: ${updateInfo.latest}` : "Обновлений нет");
|
||
} catch (error) {
|
||
fail(error);
|
||
} finally {
|
||
button.disabled = false;
|
||
}
|
||
});
|
||
|
||
$("#btn-update-apply").addEventListener("click", async () => {
|
||
if (!confirm(`Обновить панель до ${updateInfo.latest}?\n\n` +
|
||
`Игровой сервер будет остановлен, панель перезапустится.`)) return;
|
||
try {
|
||
await post("/api/update", { version: updateInfo.latest });
|
||
waitForRestart("Обновление запущено");
|
||
// Обновление выполняется отдельной службой, и её вывод в консоль панели
|
||
// не попадает — панель в это время перезапускается.
|
||
toast("Ход обновления: journalctl -u pzmanager-update -f");
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
$("#btn-manager-restart").addEventListener("click", async () => {
|
||
if (!confirm("Перезапустить панель?\n\nИгровой сервер будет остановлен.")) return;
|
||
try {
|
||
await post("/api/manager/restart");
|
||
waitForRestart("Панель перезапускается");
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
// waitForRestart дожидается, пока служба поднимется заново, и перезагружает
|
||
// страницу: во время перезапуска панель недоступна, и обычные опросы статуса
|
||
// будут только сыпать ошибками.
|
||
function waitForRestart(message) {
|
||
ok(message + " — жду, пока панель поднимется");
|
||
stopPolling();
|
||
closeConsoleStream();
|
||
|
||
const deadline = Date.now() + 5 * 60 * 1000;
|
||
const state = $("#update-state");
|
||
state.className = "small";
|
||
state.textContent = message + "…";
|
||
|
||
const probe = setInterval(async () => {
|
||
if (Date.now() > deadline) {
|
||
clearInterval(probe);
|
||
state.textContent = "Панель не поднялась за пять минут — проверьте journalctl -u pzmanager";
|
||
return;
|
||
}
|
||
try {
|
||
const response = await fetch("/api/session", { credentials: "same-origin" });
|
||
if (!response.ok) return;
|
||
clearInterval(probe);
|
||
location.reload();
|
||
} catch (error) {
|
||
// Служба ещё перезапускается — это ожидаемо.
|
||
}
|
||
}, 3000);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Настройки менеджера и пользователи
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// Описание формы настроек: ключ в API, подпись, тип и пояснение.
|
||
const SETTINGS_FIELDS = [
|
||
["listen", "Адрес веб-панели", "text", "Например 127.0.0.1:8080. Применится после перезапуска pzmanager"],
|
||
["server_dir", "Директория сервера", "text", "Куда SteamCMD ставит файлы Project Zomboid"],
|
||
["zomboid_dir", "Директория данных (~/Zomboid)", "text", "Здесь лежат миры, конфиги и логи игры"],
|
||
["steamcmd_path", "Путь к steamcmd.sh", "text", "Пусто — найти в PATH или скачать автоматически"],
|
||
["autostart", "Запускать сервер вместе с менеджером", "checkbox", ""],
|
||
["autorestart", "Поднимать сервер после падения", "checkbox", ""],
|
||
["stop_timeout_sec", "Таймаут остановки, сек", "number", "Сколько ждать после команды quit до SIGTERM"],
|
||
["log_buffer_lines", "Строк консоли в памяти", "number", ""],
|
||
["backup_dir", "Директория бэкапов", "text", ""],
|
||
["backup_schedule_min", "Автобэкап, минут", "number", "0 — отключить автоматические бэкапы"],
|
||
["backup_keep", "Хранить архивов", "number", "0 — не удалять старые"],
|
||
["backup_stop_server", "Останавливать сервер на время бэкапа", "checkbox",
|
||
"Даёт согласованный снимок, но выкидывает игроков"],
|
||
];
|
||
|
||
async function loadSettings() {
|
||
const config = await get("/api/config/manager");
|
||
const form = $("#settings-form");
|
||
form.innerHTML = "";
|
||
|
||
SETTINGS_FIELDS.forEach(([key, label, type, hint]) => {
|
||
const wrapper = document.createElement("div");
|
||
wrapper.className = "cfg-field";
|
||
|
||
const labelEl = document.createElement("label");
|
||
labelEl.textContent = label;
|
||
wrapper.appendChild(labelEl);
|
||
|
||
const input = document.createElement("input");
|
||
input.type = type;
|
||
input.name = key;
|
||
if (type === "checkbox") {
|
||
input.checked = Boolean(config[key]);
|
||
} else {
|
||
input.value = config[key] ?? "";
|
||
}
|
||
input.dataset.original = type === "checkbox" ? String(input.checked) : input.value;
|
||
wrapper.appendChild(input);
|
||
|
||
if (hint) {
|
||
const hintEl = document.createElement("div");
|
||
hintEl.className = "hint";
|
||
hintEl.textContent = hint;
|
||
wrapper.appendChild(hintEl);
|
||
}
|
||
form.appendChild(wrapper);
|
||
});
|
||
|
||
const pathNote = document.createElement("p");
|
||
pathNote.className = "muted small";
|
||
pathNote.textContent = `Файл конфигурации: ${config.config_path}`;
|
||
form.appendChild(pathNote);
|
||
|
||
refreshSettingsSaveState();
|
||
await loadUsers();
|
||
// Проверка обновления ходит в интернет и может не ответить — она не должна
|
||
// мешать показу остальных настроек.
|
||
loadUpdateInfo().catch((error) => {
|
||
$("#update-state").textContent = "Не удалось проверить обновления: " + error.message;
|
||
});
|
||
}
|
||
|
||
function refreshSettingsSaveState() {
|
||
const changed = $$("#settings-form input").filter((input) => {
|
||
const current = input.type === "checkbox" ? String(input.checked) : input.value;
|
||
return current !== input.dataset.original;
|
||
}).length;
|
||
|
||
const button = $("#btn-settings-save");
|
||
button.disabled = changed === 0;
|
||
button.textContent = changed ? `Сохранить настройки (${changed})` : "Сохранить настройки";
|
||
button.title = changed ? `Изменено полей: ${changed}` : "Изменений нет";
|
||
}
|
||
|
||
["input", "change"].forEach((event) =>
|
||
$("#settings-form").addEventListener(event, refreshSettingsSaveState));
|
||
|
||
$("#btn-settings-save").addEventListener("click", async () => {
|
||
const payload = {};
|
||
SETTINGS_FIELDS.forEach(([key, , type]) => {
|
||
const input = $(`#settings-form [name="${key}"]`);
|
||
if (!input) return;
|
||
if (type === "checkbox") {
|
||
payload[key] = input.checked;
|
||
} else if (type === "number") {
|
||
payload[key] = Number(input.value || 0);
|
||
} else {
|
||
payload[key] = input.value.trim();
|
||
}
|
||
});
|
||
try {
|
||
const result = await put("/api/config/manager", payload);
|
||
ok(result.note || "Настройки сохранены");
|
||
loadSettings();
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
async function loadUsers() {
|
||
const data = await get("/api/users");
|
||
$("#user-list").innerHTML = (data.users || [])
|
||
.map(
|
||
(login) => `<li>
|
||
<span>${escapeHTML(login)}</span>
|
||
<button class="btn btn-sm" data-passwd="${escapeHTML(login)}">Сменить пароль</button>
|
||
<button class="btn btn-sm btn-danger" data-deluser="${escapeHTML(login)}">Удалить</button>
|
||
</li>`
|
||
)
|
||
.join("");
|
||
}
|
||
|
||
$("#user-list").addEventListener("click", async (event) => {
|
||
const passwd = event.target.closest("button[data-passwd]");
|
||
const remove = event.target.closest("button[data-deluser]");
|
||
|
||
try {
|
||
if (passwd) {
|
||
const password = prompt(`Новый пароль для ${passwd.dataset.passwd} (минимум 8 символов):`);
|
||
if (!password) return;
|
||
await post(`/api/users/${encodeURIComponent(passwd.dataset.passwd)}/password`, { password });
|
||
ok("Пароль изменён");
|
||
} else if (remove) {
|
||
if (!confirm(`Удалить пользователя ${remove.dataset.deluser}?`)) return;
|
||
await del(`/api/users/${encodeURIComponent(remove.dataset.deluser)}`);
|
||
ok("Пользователь удалён");
|
||
loadUsers();
|
||
}
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
$("#user-add-form").addEventListener("submit", async (event) => {
|
||
event.preventDefault();
|
||
try {
|
||
await post("/api/users", {
|
||
login: $("#new-user-login").value.trim(),
|
||
password: $("#new-user-password").value,
|
||
});
|
||
$("#new-user-login").value = "";
|
||
$("#new-user-password").value = "";
|
||
ok("Пользователь добавлен");
|
||
loadUsers();
|
||
} catch (error) {
|
||
fail(error);
|
||
}
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
|
||
checkSession().catch((error) => {
|
||
fail(error);
|
||
showAuth(false);
|
||
});
|