svoboda200786/bc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Свайп панелей

Browse Source
This commit is contained in:
PsiMagistr 2025-05-18 10:33:24 +03:00
parent d7b5d1092e
commit 75dbd40f26
12 changed files with 848 additions and 3440 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

165
bc.js
View File

@ -1,165 +0,0 @@
// bc.js - Главный файл сервера Battle Club
const express = require('express');
const http = require('http'); // Используем HTTP, так как SSL будет на Node.js прокси (server.js)
const { Server } = require('socket.io');
const path = require('path');
//
// Импорт серверных модулей
const auth = require('./server_modules/auth');
const GameManager = require('./server_modules/gameManager');
const db = require('./server_modules/db'); // Импорт для инициализации соединения с БД (хотя пул создается при require)
const GAME_CONFIG = require('./server_modules/config'); // Конфиг игры
// gameData импортируется внутри GameInstance и GameLogic
const app = express();
const server = http.createServer(app);
// Настройка Socket.IO
const io = new Server(server, {
cors: {
origin: "https://pavel-chagovsky.com:3200", // Указываем точный origin, включая порт, откуда придет запрос К ПРОКСИ
// Если доступ будет с нескольких доменов или портов, можно использовать массив:
// origin: ["https://pavel-chagovsky.com:3200", "https://oleg-okhotnikov.ru:3200"],
// Или для разработки можно временно использовать "*", но это менее безопасно:
// origin: "*",
methods: ["GET", "POST"]
}
});
// Раздача статических файлов из папки 'public'
app.use(express.static(path.join(__dirname, 'public')));
// Создаем экземпляр GameManager
const gameManager = new GameManager(io);
// Хранилище информации о залогиненных пользователях по socket.id
const loggedInUsers = {}; // { socket.id: { userId: ..., username: ... } }
// Обработка подключений Socket.IO
io.on('connection', (socket) => {
console.log(`[BC App HTTP] Socket.IO User connected: ${socket.id}`);
socket.userData = null;
socket.on('register', async (data) => {
console.log(`[BC App HTTP Socket.IO] Register attempt for username: "${data?.username}" from ${socket.id}`);
const result = await auth.registerUser(data?.username, data?.password);
if (result.success) {
console.log(`[BC App HTTP Socket.IO] Registration successful for ${result.username} (${result.userId})`);
} else {
console.warn(`[BC App HTTP Socket.IO] Registration failed for "${data?.username}": ${result.message}`);
}
socket.emit('registerResponse', result);
});
socket.on('login', async (data) => {
console.log(`[BC App HTTP Socket.IO] Login attempt for username: "${data?.username}" from ${socket.id}`);
const result = await auth.loginUser(data?.username, data?.password);
if (result.success) {
console.log(`[BC App HTTP Socket.IO] Login successful for ${result.username} (${result.userId}). Assigning to socket ${socket.id}.`);
socket.userData = { userId: result.userId, username: result.username };
loggedInUsers[socket.id] = socket.userData;
gameManager.handleRequestGameState(socket, socket.userData.userId);
} else {
console.warn(`[BC App HTTP Socket.IO] Login failed for "${data?.username}": ${result.message}`);
socket.userData = null;
if (loggedInUsers[socket.id]) delete loggedInUsers[socket.id];
}
socket.emit('loginResponse', result);
});
socket.on('logout', () => {
console.log(`[BC App HTTP Socket.IO] Logout for user ${socket.userData?.username || socket.id}`);
gameManager.handleDisconnect(socket.id, socket.userData?.userId || socket.id);
socket.userData = null;
if (loggedInUsers[socket.id]) delete loggedInUsers[socket.id];
});
socket.on('createGame', (data) => {
const identifier = socket.userData?.userId || socket.id;
const mode = data?.mode || 'ai';
if (mode === 'pvp' && !socket.userData) {
socket.emit('gameError', { message: 'Необходимо войти в систему для создания PvP игры.' });
return;
}
console.log(`[BC App HTTP Socket.IO] Create Game request from ${socket.userData?.username || socket.id} (Identifier: ${identifier}). Mode: ${mode}, Character: ${data?.characterKey}`);
const characterKey = data?.characterKey || 'elena';
gameManager.createGame(socket, mode, characterKey, identifier);
});
socket.on('joinGame', (data) => {
if (!socket.userData) {
socket.emit('gameError', { message: 'Необходимо войти в систему для присоединения к игре.' });
return;
}
console.log(`[BC App HTTP Socket.IO] Join Game request from ${socket.userData.username} (${socket.id}). Game ID: ${data?.gameId}`);
const gameId = data?.gameId;
const identifier = socket.userData.userId;
if (gameId) {
gameManager.joinGame(socket, gameId, identifier);
} else {
socket.emit('gameError', { message: 'Не указан ID игры для присоединения.' });
}
});
socket.on('findRandomGame', (data) => {
if (!socket.userData) {
socket.emit('gameError', { message: 'Необходимо войти в систему для поиска игры.' });
return;
}
console.log(`[BC App HTTP Socket.IO] Find Random Game request from ${socket.userData.username} (${socket.id}). Preferred Character: ${data?.characterKey}`);
const characterKey = data?.characterKey || 'elena';
const identifier = socket.userData.userId;
gameManager.findAndJoinRandomPvPGame(socket, characterKey, identifier);
});
socket.on('requestPvPGameList', () => {
console.log(`[BC App HTTP Socket.IO] Request PvP Game List from ${socket.userData?.username || socket.id}`);
const availableGames = gameManager.getAvailablePvPGamesListForClient();
socket.emit('availablePvPGamesList', availableGames);
});
socket.on('requestGameState', () => {
if (!socket.userData) {
console.log(`[BC App HTTP Socket.IO] Request Game State from unauthenticated socket ${socket.id}.`);
socket.emit('gameNotFound', { message: 'Необходимо войти для восстановления игры.' });
return;
}
console.log(`[BC App HTTP Socket.IO] Request Game State from ${socket.userData.username} (${socket.id}).`);
gameManager.handleRequestGameState(socket, socket.userData.userId);
});
socket.on('playerAction', (actionData) => {
const identifier = socket.userData?.userId || socket.id;
gameManager.handlePlayerAction(identifier, actionData);
});
socket.on('disconnect', (reason) => {
const identifier = socket.userData?.userId || socket.id;
console.log(`[BC App HTTP Socket.IO] User disconnected: ${socket.id} (Причина: ${reason}). Identifier: ${identifier}`);
gameManager.handleDisconnect(socket.id, identifier);
if (loggedInUsers[socket.id]) {
delete loggedInUsers[socket.id];
}
});
});
// Запуск HTTP сервера
const PORT = process.env.BC_INTERNAL_PORT || 3200; // Внутренний порт для bc.js
const HOSTNAME = '127.0.0.1'; // Слушать ТОЛЬКО на localhost
server.listen(PORT, HOSTNAME, () => { // Явно указываем HOSTNAME
console.log(`Battle Club HTTP Application Server running at http://${HOSTNAME}:${PORT}`);
console.log(`This server should only be accessed locally by the reverse proxy.`);
console.log(`Serving static files from: ${path.join(__dirname, 'public')}`);
});
// Обработка необработанных промис-ошибок
process.on('unhandledRejection', (reason, promise) => {
console.error('[BC App HTTP UNHANDLED REJECTION] Unhandled Rejection at:', promise, 'reason:', reason);
});
process.on('uncaughtException', (err) => {
console.error('[BC App HTTP UNCAUGHT EXCEPTION] Caught exception:', err);
});

35
public/index.html
View File

@ -11,14 +11,8 @@
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css"> <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
</head> </head>
<body> <body>
<div id="user-info" style="display:none;"> <!-- Информация о пользователе и кнопка выхода -->
<div>
<p>Привет, <span id="logged-in-username"></span>!</p>
<button id="logout-button"><i class="fas fa-sign-out-alt"></i> Выход</button>
</div>
</div>
<div class="auth-game-setup-wrapper"> <!-- Обертка для экранов до начала игры -->
<div class="auth-game-setup-wrapper"> <!-- Обертка для экранов до начала игры -->
<div id="status-container"> <div id="status-container">
<div id="auth-message"></div> <div id="auth-message"></div>
<div id="game-status-message">Ожидание подключения к серверу...</div> <div id="game-status-message">Ожидание подключения к серверу...</div>
@ -41,7 +35,10 @@
</form> </form>
</div> </div>
<!-- Место для #user-info было здесь, но теперь оно выше для стилизации --> <div id="user-info" style="display:none;"> <!-- Информация о пользователе и кнопка выхода -->
<p>Привет, <span id="logged-in-username"></span>!</p>
<button id="logout-button"><i class="fas fa-sign-out-alt"></i> Выход</button>
</div>
<div id="game-setup" style="display: none;"> <!-- Секция Настройки Игры (после логина) --> <div id="game-setup" style="display: none;"> <!-- Секция Настройки Игры (после логина) -->
<h2>Настройка Игры</h2> <h2>Настройка Игры</h2>
@ -52,6 +49,7 @@
<div> <div>
<h3>PvP (Игрок против Игрока)</h3> <h3>PvP (Игрок против Игрока)</h3>
<!-- === Блок выбора персонажа === -->
<div class="character-selection"> <div class="character-selection">
<h4>Выберите персонажа для PvP:</h4> <h4>Выберите персонажа для PvP:</h4>
<input type="radio" id="char-elena" name="pvp-character" value="elena" checked> <input type="radio" id="char-elena" name="pvp-character" value="elena" checked>
@ -60,6 +58,7 @@
<input type="radio" id="char-almagest" name="pvp-character" value="almagest"> <input type="radio" id="char-almagest" name="pvp-character" value="almagest">
<label for="char-almagest"><i class="fas fa-staff-aesculapius"></i> Альмагест</label> <label for="char-almagest"><i class="fas fa-staff-aesculapius"></i> Альмагест</label>
</div> </div>
<!-- === Конец блока выбора персонажа === -->
<button id="create-pvp-game">Создать PvP Игру</button> <button id="create-pvp-game">Создать PvP Игру</button>
<button id="find-random-pvp-game">Найти случайную PvP Игру</button> <button id="find-random-pvp-game">Найти случайную PvP Игру</button>
@ -77,11 +76,21 @@
<div class="game-wrapper" style="display: none;"> <!-- Игровая арена, изначально скрыта --> <div class="game-wrapper" style="display: none;"> <!-- Игровая арена, изначально скрыта -->
<!-- === ИЗМЕНЕНИЕ: Удален game-header === --> <header class="game-header">
<!-- <header class="game-header">
<h1><span class="title-player">Игрок 1</span> <span class="separator"><i class="fas fa-fist-raised"></i></span> <span class="title-opponent">Игрок 2</span></h1> <h1><span class="title-player">Игрок 1</span> <span class="separator"><i class="fas fa-fist-raised"></i></span> <span class="title-opponent">Игрок 2</span></h1>
</header> --> </header>
<!-- === КОНЕЦ ИЗМЕНЕНИЯ === -->
<!-- === НОВЫЙ БЛОК: Контролы переключения панелей (для мобильных) === -->
<!-- CSS будет управлять видимостью этого блока (display: none по умолчанию, display: flex в медиа-запросе) -->
<div class="panel-switcher-controls" style="display: none;">
<button id="show-player-panel-btn" class="panel-switch-button active">
<i class="fas fa-user"></i> <span class="button-text">Игрок</span>
</button>
<button id="show-opponent-panel-btn" class="panel-switch-button">
<i class="fas fa-ghost"></i> <span class="button-text">Противник</span>
</button>
</div>
<!-- === КОНЕЦ НОВОГО БЛОКА === -->
<main class="battle-arena-container"> <main class="battle-arena-container">
<!-- Колонка Игрока (Панель 1 в UI) --> <!-- Колонка Игрока (Панель 1 в UI) -->
@ -221,7 +230,7 @@
</div> <!-- Конец .game-wrapper --> </div> <!-- Конец .game-wrapper -->
<script src="/socket.io/socket.io.js"></script> <script src="/socket.io/socket.io.js"></script>
<script src="./js/ui.js"></script> <!-- ui.js теперь перед client.js --> <script src="./js/ui.js"></script>
<script src="./js/client.js"></script> <script src="./js/client.js"></script>
</body> </body>
</html> </html>

546
public/js/client.js
View File

@ -3,11 +3,13 @@
document.addEventListener('DOMContentLoaded', () => { document.addEventListener('DOMContentLoaded', () => {
const socket = io({ const socket = io({
// Опции Socket.IO, если нужны // Опции Socket.IO, если нужны
// transports: ['websocket'], // Можно попробовать для отладки, если есть проблемы с polling
}); });
// --- Состояние клиента --- // --- Состояние клиента ---
let currentGameState = null; let currentGameState = null;
let myPlayerId = null; let myPlayerId = null; // Технический ID слота в игре ('player' или 'opponent')
let myUserId = null; // ID залогиненного пользователя (из БД)
let myCharacterKey = null; let myCharacterKey = null;
let opponentCharacterKey = null; let opponentCharacterKey = null;
let currentGameId = null; let currentGameId = null;
@ -20,7 +22,6 @@ document.addEventListener('DOMContentLoaded', () => {
let isInGame = false; let isInGame = false;
// --- DOM Элементы --- // --- DOM Элементы ---
// Аутентификация
const authSection = document.getElementById('auth-section'); const authSection = document.getElementById('auth-section');
const registerForm = document.getElementById('register-form'); const registerForm = document.getElementById('register-form');
const loginForm = document.getElementById('login-form'); const loginForm = document.getElementById('login-form');
@ -30,125 +31,97 @@ document.addEventListener('DOMContentLoaded', () => {
const loggedInUsernameSpan = document.getElementById('logged-in-username'); const loggedInUsernameSpan = document.getElementById('logged-in-username');
const logoutButton = document.getElementById('logout-button'); const logoutButton = document.getElementById('logout-button');
// Настройка игры
const gameSetupDiv = document.getElementById('game-setup'); const gameSetupDiv = document.getElementById('game-setup');
const createAIGameButton = document.getElementById('create-ai-game'); const createAIGameButton = document.getElementById('create-ai-game');
const createPvPGameButton = document.getElementById('create-pvp-game'); const createPvPGameButton = document.getElementById('create-pvp-game');
const joinPvPGameButton = document.getElementById('join-pvP-game'); // Опечатка в ID, должно быть join-pvp-game const joinPvPGameButton = document.getElementById('join-pvp-game'); // Убедитесь, что ID в HTML 'join-pvp-game'
const findRandomPvPGameButton = document.getElementById('find-random-pvp-game'); const findRandomPvPGameButton = document.getElementById('find-random-pvp-game');
const gameIdInput = document.getElementById('game-id-input'); const gameIdInput = document.getElementById('game-id-input');
const availableGamesDiv = document.getElementById('available-games-list'); const availableGamesDiv = document.getElementById('available-games-list');
const gameStatusMessage = document.getElementById('game-status-message'); const gameStatusMessage = document.getElementById('game-status-message');
const pvpCharacterRadios = document.querySelectorAll('input[name="pvp-character"]'); const pvpCharacterRadios = document.querySelectorAll('input[name="pvp-character"]');
// Игровая Арена
const gameWrapper = document.querySelector('.game-wrapper'); const gameWrapper = document.querySelector('.game-wrapper');
const attackButton = document.getElementById('button-attack'); const attackButton = document.getElementById('button-attack');
const returnToMenuButton = document.getElementById('return-to-menu-button'); const returnToMenuButton = document.getElementById('return-to-menu-button');
const gameOverScreen = document.getElementById('game-over-screen'); const gameOverScreen = document.getElementById('game-over-screen');
const abilitiesGrid = document.getElementById('abilities-grid'); const abilitiesGrid = document.getElementById('abilities-grid');
// === ИЗМЕНЕНИЕ: DOM элемент для таймера === const turnTimerSpan = document.getElementById('turn-timer');
const turnTimerSpan = document.getElementById('turn-timer'); // Элемент для отображения времени const turnTimerContainer = document.getElementById('turn-timer-container');
const turnTimerContainer = document.getElementById('turn-timer-container'); // Контейнер таймера для управления видимостью
// === КОНЕЦ ИЗМЕНЕНИЯ ===
console.log('Client.js DOMContentLoaded. Initializing elements...');
// --- Функции управления UI --- // --- Функции управления UI ---
function showAuthScreen() { function showAuthScreen() {
console.log('[UI] Showing Auth Screen'); authSection.style.display = 'block';
if (authSection) authSection.style.display = 'block'; userInfoDiv.style.display = 'none';
if (userInfoDiv) userInfoDiv.style.display = 'none'; gameSetupDiv.style.display = 'none';
if (gameSetupDiv) gameSetupDiv.style.display = 'none'; gameWrapper.style.display = 'none';
if (gameWrapper) gameWrapper.style.display = 'none';
hideGameOverModal(); hideGameOverModal();
setAuthMessage("Ожидание подключения к серверу..."); setAuthMessage("Ожидание подключения к серверу...");
if (statusContainer) statusContainer.style.display = 'block'; statusContainer.style.display = 'block';
isInGame = false; isInGame = false;
disableGameControls(); disableGameControls();
resetGameVariables(); resetGameVariables();
// === ИЗМЕНЕНИЕ: Скрываем таймер при выходе на экран аутентификации ===
if (turnTimerContainer) turnTimerContainer.style.display = 'none'; if (turnTimerContainer) turnTimerContainer.style.display = 'none';
if (turnTimerSpan) turnTimerSpan.textContent = '--'; if (turnTimerSpan) turnTimerSpan.textContent = '--';
// === КОНЕЦ ИЗМЕНЕНИЯ ===
} }
function showGameSelectionScreen(username) { function showGameSelectionScreen(username) {
console.log('[UI] Showing Game Selection Screen for:', username); authSection.style.display = 'none';
if (authSection) authSection.style.display = 'none';
if (userInfoDiv) {
userInfoDiv.style.display = 'block'; userInfoDiv.style.display = 'block';
if (loggedInUsernameSpan) loggedInUsernameSpan.textContent = username; loggedInUsernameSpan.textContent = username;
} gameSetupDiv.style.display = 'block';
if (gameSetupDiv) gameSetupDiv.style.display = 'block'; gameWrapper.style.display = 'none';
if (gameWrapper) gameWrapper.style.display = 'none';
hideGameOverModal(); hideGameOverModal();
setGameStatusMessage("Выберите режим игры или присоединитесь к существующей."); setGameStatusMessage("Выберите режим игры или присоединитесь к существующей.");
if (statusContainer) statusContainer.style.display = 'block'; statusContainer.style.display = 'block';
socket.emit('requestPvPGameList'); socket.emit('requestPvPGameList');
updateAvailableGamesList([]); updateAvailableGamesList([]); // Очищаем перед запросом
if (gameIdInput) gameIdInput.value = ''; if (gameIdInput) gameIdInput.value = '';
const elenaRadio = document.getElementById('char-elena'); const elenaRadio = document.getElementById('char-elena');
if (elenaRadio) elenaRadio.checked = true; if (elenaRadio) elenaRadio.checked = true;
isInGame = false; isInGame = false;
disableGameControls(); disableGameControls();
resetGameVariables(); resetGameVariables(); // Сбрасываем игровые переменные при выходе в меню
// === ИЗМЕНЕНИЕ: Скрываем таймер при выходе на экран выбора игры ===
if (turnTimerContainer) turnTimerContainer.style.display = 'none'; if (turnTimerContainer) turnTimerContainer.style.display = 'none';
if (turnTimerSpan) turnTimerSpan.textContent = '--'; if (turnTimerSpan) turnTimerSpan.textContent = '--';
// === КОНЕЦ ИЗМЕНЕНИЯ === enableSetupButtons(); // Включаем кнопки на экране выбора игры
} }
function showGameScreen() { function showGameScreen() {
console.log('[UI] Showing Game Screen');
hideGameOverModal(); hideGameOverModal();
if (authSection) authSection.style.display = 'none'; authSection.style.display = 'none';
if (userInfoDiv) userInfoDiv.style.display = 'block'; // Оставляем видимым, чтобы видеть "Привет, username" userInfoDiv.style.display = 'block'; // Оставляем инфо о пользователе
if (gameSetupDiv) gameSetupDiv.style.display = 'none'; gameSetupDiv.style.display = 'none';
if (gameWrapper) gameWrapper.style.display = 'flex'; gameWrapper.style.display = 'flex';
setGameStatusMessage(""); setGameStatusMessage(""); // Очищаем статус, т.к. есть индикатор хода
if (statusContainer) statusContainer.style.display = 'none'; statusContainer.style.display = 'none'; // Скрываем общий статус контейнер
isInGame = true; isInGame = true;
disableGameControls(); disableGameControls(); // Кнопки включатся, когда будет ход игрока
// === ИЗМЕНЕНИЕ: Показываем контейнер таймера, когда игра начинается === if (turnTimerContainer) turnTimerContainer.style.display = 'block'; // Показываем таймер
if (turnTimerContainer) turnTimerContainer.style.display = 'block';
if (turnTimerSpan) turnTimerSpan.textContent = '--'; // Начальное значение if (turnTimerSpan) turnTimerSpan.textContent = '--'; // Начальное значение
// === КОНЕЦ ИЗМЕНЕНИЯ ===
} }
function resetGameVariables() { function resetGameVariables() {
currentGameId = null; currentGameId = null; currentGameState = null; myPlayerId = null;
currentGameState = null; myCharacterKey = null; opponentCharacterKey = null;
myPlayerId = null; playerBaseStatsServer = null; opponentBaseStatsServer = null;
myCharacterKey = null; playerAbilitiesServer = null; opponentAbilitiesServer = null;
opponentCharacterKey = null; window.gameState = null; window.gameData = null; window.myPlayerId = null;
playerBaseStatsServer = null;
opponentBaseStatsServer = null;
playerAbilitiesServer = null;
opponentAbilitiesServer = null;
window.gameState = null;
window.gameData = null;
window.myPlayerId = null;
} }
function hideGameOverModal() { function hideGameOverModal() {
const hiddenClass = (window.GAME_CONFIG && window.GAME_CONFIG.CSS_CLASS_HIDDEN) ? window.GAME_CONFIG.CSS_CLASS_HIDDEN : 'hidden'; const hiddenClass = window.GAME_CONFIG?.CSS_CLASS_HIDDEN || 'hidden';
if (gameOverScreen && !gameOverScreen.classList.contains(hiddenClass)) { if (gameOverScreen && !gameOverScreen.classList.contains(hiddenClass)) {
console.log('[Client.js DEBUG] Hiding GameOver Modal.');
gameOverScreen.classList.add(hiddenClass); gameOverScreen.classList.add(hiddenClass);
if (window.gameUI?.uiElements?.gameOver?.modalContent) { if (window.gameUI?.uiElements?.gameOver?.modalContent) {
window.gameUI.uiElements.gameOver.modalContent.style.transform = 'scale(0.8) translateY(30px)'; window.gameUI.uiElements.gameOver.modalContent.style.transform = 'scale(0.8) translateY(30px)';
window.gameUI.uiElements.gameOver.modalContent.style.opacity = '0'; window.gameUI.uiElements.gameOver.modalContent.style.opacity = '0';
} }
if (window.gameUI?.uiElements?.opponent?.panel) { const opponentPanel = window.gameUI?.uiElements?.opponent?.panel;
const opponentPanel = window.gameUI.uiElements.opponent.panel; if (opponentPanel?.classList.contains('dissolving')) {
if (opponentPanel.classList.contains('dissolving')) {
opponentPanel.classList.remove('dissolving'); opponentPanel.classList.remove('dissolving');
opponentPanel.style.opacity = '1'; opponentPanel.style.opacity = '1'; opponentPanel.style.transform = 'scale(1) translateY(0)';
opponentPanel.style.transform = 'scale(1) translateY(0)';
}
} }
} }
} }
@ -183,143 +156,102 @@ document.addEventListener('DOMContentLoaded', () => {
function enableGameControls(enableAttack = true, enableAbilities = true) { function enableGameControls(enableAttack = true, enableAbilities = true) {
if (attackButton) attackButton.disabled = !enableAttack; if (attackButton) attackButton.disabled = !enableAttack;
if (abilitiesGrid) { if (abilitiesGrid) {
const abilityButtonClass = window.GAME_CONFIG?.CSS_CLASS_ABILITY_BUTTON || 'ability-button'; const cls = window.GAME_CONFIG?.CSS_CLASS_ABILITY_BUTTON || 'ability-button';
abilitiesGrid.querySelectorAll(`.${abilityButtonClass}`).forEach(button => { button.disabled = !enableAbilities; }); abilitiesGrid.querySelectorAll(`.${cls}`).forEach(b => { b.disabled = !enableAbilities; });
} }
if (window.gameUI?.uiElements?.controls?.buttonBlock) window.gameUI.uiElements.controls.buttonBlock.disabled = true; if (window.gameUI?.uiElements?.controls?.buttonBlock) window.gameUI.uiElements.controls.buttonBlock.disabled = true;
} }
function disableGameControls() { enableGameControls(false, false); }
function disableGameControls() {
enableGameControls(false, false);
}
// Инициализация кнопок и обработчиков
if (registerForm) {
registerForm.addEventListener('submit', (e) => {
e.preventDefault();
const usernameInput = document.getElementById('register-username');
const passwordInput = document.getElementById('register-password');
if (usernameInput && passwordInput) {
registerForm.querySelector('button').disabled = true;
if (loginForm) loginForm.querySelector('button').disabled = true;
socket.emit('register', { username: usernameInput.value, password: passwordInput.value });
} else { setAuthMessage("Ошибка: поля ввода не найдены.", true); }
});
}
if (loginForm) {
loginForm.addEventListener('submit', (e) => {
e.preventDefault();
const usernameInput = document.getElementById('login-username');
const passwordInput = document.getElementById('login-password');
if (usernameInput && passwordInput) {
if (registerForm) registerForm.querySelector('button').disabled = true;
loginForm.querySelector('button').disabled = true;
socket.emit('login', { username: usernameInput.value, password: passwordInput.value });
} else { setAuthMessage("Ошибка: поля ввода не найдены.", true); }
});
}
if (logoutButton) {
logoutButton.addEventListener('click', () => {
logoutButton.disabled = true;
socket.emit('logout');
isLoggedIn = false; loggedInUsername = '';
resetGameVariables(); isInGame = false; disableGameControls();
showAuthScreen();
setGameStatusMessage("Вы вышли из системы.");
logoutButton.disabled = false;
});
}
if (createAIGameButton) {
createAIGameButton.addEventListener('click', () => {
if (!isLoggedIn) { setGameStatusMessage("Пожалуйста, войдите, чтобы начать игру.", true); return; }
disableSetupButtons();
socket.emit('createGame', { mode: 'ai', characterKey: 'elena' });
setGameStatusMessage("Создание игры против AI...");
});
}
if (createPvPGameButton) {
createPvPGameButton.addEventListener('click', () => {
if (!isLoggedIn) { setGameStatusMessage("Пожалуйста, войдите, чтобы начать игру.", true); return; }
disableSetupButtons();
const selectedCharacter = getSelectedCharacterKey();
socket.emit('createGame', { mode: 'pvp', characterKey: selectedCharacter });
setGameStatusMessage(`Создание PvP игры за ${selectedCharacter === 'elena' ? 'Елену' : 'Альмагест'}...`);
});
}
// Исправляем селектор для joinPvPGameButton, если ID в HTML был join-pvP-game
const actualJoinPvPGameButton = document.getElementById('join-pvp-game') || document.getElementById('join-pvP-game');
if (actualJoinPvPGameButton && gameIdInput) {
actualJoinPvPGameButton.addEventListener('click', () => {
if (!isLoggedIn) { setGameStatusMessage("Пожалуйста, войдите, чтобы присоединиться к игре.", true); return; }
const gameIdToJoin = gameIdInput.value.trim();
if (gameIdToJoin) {
disableSetupButtons();
socket.emit('joinGame', { gameId: gameIdToJoin });
setGameStatusMessage(`Присоединение к игре ${gameIdToJoin}...`);
} else { setGameStatusMessage("Пожалуйста, введите ID игры для присоединения.", true); }
});
}
if (findRandomPvPGameButton) {
findRandomPvPGameButton.addEventListener('click', () => {
if (!isLoggedIn) { setGameStatusMessage("Пожалуйста, войдите, чтобы найти игру.", true); return; }
disableSetupButtons();
const selectedCharacter = getSelectedCharacterKey();
socket.emit('findRandomGame', { characterKey: selectedCharacter });
setGameStatusMessage(`Поиск случайной PvP игры (предпочтение: ${selectedCharacter === 'elena' ? 'Елена' : 'Альмагест'})...`);
});
}
function disableSetupButtons() { function disableSetupButtons() {
if(createAIGameButton) createAIGameButton.disabled = true; if(createAIGameButton) createAIGameButton.disabled = true;
if(createPvPGameButton) createPvPGameButton.disabled = true; if(createPvPGameButton) createPvPGameButton.disabled = true;
if (actualJoinPvPGameButton) actualJoinPvPGameButton.disabled = true; if(joinPvPGameButton) joinPvPGameButton.disabled = true;
if(findRandomPvPGameButton) findRandomPvPGameButton.disabled = true; if(findRandomPvPGameButton) findRandomPvPGameButton.disabled = true;
if(availableGamesDiv) availableGamesDiv.querySelectorAll('button').forEach(btn => btn.disabled = true); if(availableGamesDiv) availableGamesDiv.querySelectorAll('button').forEach(btn => btn.disabled = true);
} }
function enableSetupButtons() { function enableSetupButtons() {
if(createAIGameButton) createAIGameButton.disabled = false; if(createAIGameButton) createAIGameButton.disabled = false;
if(createPvPGameButton) createPvPGameButton.disabled = false; if(createPvPGameButton) createPvPGameButton.disabled = false;
if (actualJoinPvPGameButton) actualJoinPvPGameButton.disabled = false; if(joinPvPGameButton) joinPvPGameButton.disabled = false;
if(findRandomPvPGameButton) findRandomPvPGameButton.disabled = false; if(findRandomPvPGameButton) findRandomPvPGameButton.disabled = false;
// Кнопки в списке игр включаются в updateAvailableGamesList
} }
if (attackButton) { // --- Инициализация обработчиков событий ---
attackButton.addEventListener('click', () => { if (registerForm) registerForm.addEventListener('submit', (e) => {
e.preventDefault();
const u = document.getElementById('register-username').value;
const p = document.getElementById('register-password').value;
registerForm.querySelector('button').disabled = true;
if(loginForm) loginForm.querySelector('button').disabled = true;
socket.emit('register', { username: u, password: p });
});
if (loginForm) loginForm.addEventListener('submit', (e) => {
e.preventDefault();
const u = document.getElementById('login-username').value;
const p = document.getElementById('login-password').value;
if(registerForm) registerForm.querySelector('button').disabled = true;
loginForm.querySelector('button').disabled = true;
socket.emit('login', { username: u, password: p });
});
if (logoutButton) logoutButton.addEventListener('click', () => {
logoutButton.disabled = true; socket.emit('logout');
isLoggedIn = false; loggedInUsername = ''; myUserId = null;
resetGameVariables(); isInGame = false; disableGameControls();
showAuthScreen(); setGameStatusMessage("Вы вышли из системы.");
logoutButton.disabled = false;
});
if (createAIGameButton) createAIGameButton.addEventListener('click', () => {
if (!isLoggedIn) { setGameStatusMessage("Пожалуйста, войдите.", true); return; }
disableSetupButtons();
socket.emit('createGame', { mode: 'ai', characterKey: 'elena' }); // AI всегда за Елену
setGameStatusMessage("Создание игры против AI...");
});
if (createPvPGameButton) createPvPGameButton.addEventListener('click', () => {
if (!isLoggedIn) { setGameStatusMessage("Пожалуйста, войдите.", true); return; }
disableSetupButtons();
socket.emit('createGame', { mode: 'pvp', characterKey: getSelectedCharacterKey() });
setGameStatusMessage("Создание PvP игры...");
});
if (joinPvPGameButton) joinPvPGameButton.addEventListener('click', () => { // Убедитесь, что ID кнопки 'join-pvp-game'
if (!isLoggedIn) { setGameStatusMessage("Пожалуйста, войдите.", true); return; }
const gameId = gameIdInput.value.trim();
if (gameId) {
disableSetupButtons();
socket.emit('joinGame', { gameId: gameId });
setGameStatusMessage(`Присоединение к игре ${gameId}...`);
} else setGameStatusMessage("Введите ID игры.", true);
});
if (findRandomPvPGameButton) findRandomPvPGameButton.addEventListener('click', () => {
if (!isLoggedIn) { setGameStatusMessage("Пожалуйста, войдите.", true); return; }
disableSetupButtons();
socket.emit('findRandomGame', { characterKey: getSelectedCharacterKey() });
setGameStatusMessage("Поиск случайной PvP игры...");
});
if (attackButton) attackButton.addEventListener('click', () => {
if (isLoggedIn && isInGame && currentGameId && currentGameState && !currentGameState.isGameOver) { if (isLoggedIn && isInGame && currentGameId && currentGameState && !currentGameState.isGameOver) {
socket.emit('playerAction', { actionType: 'attack' }); socket.emit('playerAction', { actionType: 'attack' });
} else { } else { /* обработка ошибки/некорректного состояния */ }
console.warn('[Client] Попытка действия (атака) вне допустимого состояния игры. isLogged:', isLoggedIn, 'isInGame:', isInGame);
disableGameControls();
if (isLoggedIn && !isInGame) showGameSelectionScreen(loggedInUsername);
else if (!isLoggedIn) showAuthScreen();
}
}); });
}
function handleAbilityButtonClick(event) { function handleAbilityButtonClick(event) {
const button = event.currentTarget; const abilityId = event.currentTarget.dataset.abilityId;
const abilityId = button.dataset.abilityId;
if (isLoggedIn && isInGame && currentGameId && abilityId && currentGameState && !currentGameState.isGameOver) { if (isLoggedIn && isInGame && currentGameId && abilityId && currentGameState && !currentGameState.isGameOver) {
socket.emit('playerAction', { actionType: 'ability', abilityId: abilityId }); socket.emit('playerAction', { actionType: 'ability', abilityId: abilityId });
} else { } else { /* обработка ошибки/некорректного состояния */ }
console.warn('[Client] Попытка действия (способность) вне допустимого состояния игры. isLogged:', isLoggedIn, 'isInGame:', isInGame);
disableGameControls();
if (isLoggedIn && !isInGame) showGameSelectionScreen(loggedInUsername);
else if (!isLoggedIn) showAuthScreen();
} }
} if (returnToMenuButton) returnToMenuButton.addEventListener('click', () => {
if (returnToMenuButton) {
returnToMenuButton.addEventListener('click', () => {
if (!isLoggedIn) { showAuthScreen(); return; } if (!isLoggedIn) { showAuthScreen(); return; }
returnToMenuButton.disabled = true; returnToMenuButton.disabled = true;
console.log('[Client] Return to menu button clicked. Resetting game state and showing selection screen.');
resetGameVariables(); isInGame = false; disableGameControls(); hideGameOverModal(); resetGameVariables(); isInGame = false; disableGameControls(); hideGameOverModal();
showGameSelectionScreen(loggedInUsername); showGameSelectionScreen(loggedInUsername); // Возвращаемся на экран выбора
// Кнопка включится при следующем показе модалки
}); });
}
function initializeAbilityButtons() { function initializeAbilityButtons() {
// ... (код без изменений, как был)
if (!abilitiesGrid || !window.gameUI || !window.GAME_CONFIG) { if (!abilitiesGrid || !window.gameUI || !window.GAME_CONFIG) {
if (abilitiesGrid) abilitiesGrid.innerHTML = '<p class="placeholder-text">Ошибка загрузки способностей.</p>'; if (abilitiesGrid) abilitiesGrid.innerHTML = '<p class="placeholder-text">Ошибка загрузки способностей.</p>';
console.error('[Client.js] initializeAbilityButtons failed: abilitiesGrid, gameUI, or GAME_CONFIG not found.');
return; return;
} }
abilitiesGrid.innerHTML = ''; abilitiesGrid.innerHTML = '';
@ -363,28 +295,44 @@ document.addEventListener('DOMContentLoaded', () => {
const li = document.createElement('li'); const li = document.createElement('li');
li.textContent = `ID: ${game.id.substring(0, 8)}... - ${game.status || 'Ожидает игрока'}`; li.textContent = `ID: ${game.id.substring(0, 8)}... - ${game.status || 'Ожидает игрока'}`;
const joinBtn = document.createElement('button'); const joinBtn = document.createElement('button');
joinBtn.textContent = 'Присоединиться'; joinBtn.dataset.gameId = game.id; joinBtn.textContent = 'Присоединиться';
joinBtn.dataset.gameId = game.id;
// === ИЗМЕНЕНИЕ: Деактивация кнопки "Присоединиться" для своих игр ===
if (isLoggedIn && myUserId && game.ownerIdentifier === myUserId) {
joinBtn.disabled = true;
joinBtn.title = "Вы не можете присоединиться к своей же ожидающей игре.";
} else {
joinBtn.disabled = false;
}
// === КОНЕЦ ИЗМЕНЕНИЯ ===
joinBtn.addEventListener('click', (e) => { joinBtn.addEventListener('click', (e) => {
if (!isLoggedIn) { setGameStatusMessage("Пожалуйста, войдите, чтобы присоединиться к игре.", true); return; } if (!isLoggedIn) { setGameStatusMessage("Пожалуйста, войдите.", true); return; }
if (e.target.disabled) return; // Не обрабатывать клик по отключенной кнопке
disableSetupButtons(); disableSetupButtons();
socket.emit('joinGame', { gameId: e.target.dataset.gameId }); socket.emit('joinGame', { gameId: e.target.dataset.gameId });
}); });
li.appendChild(joinBtn); ul.appendChild(li); li.appendChild(joinBtn);
ul.appendChild(li);
} }
}); });
availableGamesDiv.appendChild(ul); availableGamesDiv.appendChild(ul);
availableGamesDiv.querySelectorAll('button').forEach(btn => btn.disabled = false); } else {
} else { availableGamesDiv.innerHTML += '<p>Нет доступных игр. Создайте свою!</p>'; } availableGamesDiv.innerHTML += '<p>Нет доступных игр. Создайте свою!</p>';
enableSetupButtons();
} }
enableSetupButtons(); // Включаем основные кнопки создания/поиска
}
// --- Обработчики событий Socket.IO --- // --- Обработчики событий Socket.IO ---
socket.on('connect', () => { socket.on('connect', () => {
console.log('[Client] Socket connected to server! Socket ID:', socket.id); console.log('[Client] Socket connected:', socket.id);
if (isLoggedIn) { if (isLoggedIn && myUserId) { // Проверяем и isLoggedIn и myUserId
console.log(`[Client] Reconnected as ${loggedInUsername}. Requesting state.`); socket.emit('requestGameState'); // Запрашиваем состояние, если были залогинены
socket.emit('requestGameState'); } else {
} else { showAuthScreen(); } showAuthScreen(); // Иначе показываем экран логина
}
}); });
socket.on('registerResponse', (data) => { socket.on('registerResponse', (data) => {
@ -397,44 +345,54 @@ document.addEventListener('DOMContentLoaded', () => {
socket.on('loginResponse', (data) => { socket.on('loginResponse', (data) => {
setAuthMessage(data.message, !data.success); setAuthMessage(data.message, !data.success);
if (data.success) { if (data.success) {
isLoggedIn = true; loggedInUsername = data.username; setAuthMessage(""); isLoggedIn = true;
loggedInUsername = data.username;
myUserId = data.userId; // === ИЗМЕНЕНИЕ: Сохраняем ID пользователя ===
setAuthMessage("");
showGameSelectionScreen(data.username); showGameSelectionScreen(data.username);
} else { } else {
isLoggedIn = false; loggedInUsername = ''; isLoggedIn = false; loggedInUsername = ''; myUserId = null;
if(registerForm) registerForm.querySelector('button').disabled = false; if(registerForm) registerForm.querySelector('button').disabled = false;
if(loginForm) loginForm.querySelector('button').disabled = false; if(loginForm) loginForm.querySelector('button').disabled = false;
} }
}); });
socket.on('gameNotFound', (data) => { socket.on('gameNotFound', (data) => {
console.log('[Client] Game not found response:', data?.message); console.log('[Client] Game not found/ended:', data?.message);
resetGameVariables(); isInGame = false; disableGameControls(); hideGameOverModal(); resetGameVariables(); isInGame = false; disableGameControls(); hideGameOverModal();
if (turnTimerContainer) turnTimerContainer.style.display = 'none'; // Скрываем таймер if (turnTimerContainer) turnTimerContainer.style.display = 'none';
if (turnTimerSpan) turnTimerSpan.textContent = '--';
if (isLoggedIn) { if (isLoggedIn) {
showGameSelectionScreen(loggedInUsername); showGameSelectionScreen(loggedInUsername);
setGameStatusMessage("Выберите режим игры или присоединитесь к существующей."); setGameStatusMessage(data?.message || "Активная игровая сессия не найдена.");
enableSetupButtons();
} else { } else {
showAuthScreen(); showAuthScreen();
setAuthMessage(data?.message || "Пожалуйста, войдите, чтобы начать новую игру.", false); setAuthMessage(data?.message || "Пожалуйста, войдите.");
} }
}); });
socket.on('disconnect', (reason) => { socket.on('disconnect', (reason) => {
console.log('[Client] Disconnected from server:', reason); console.log('[Client] Disconnected:', reason);
setGameStatusMessage(`Отключено от сервера: ${reason}. Пожалуйста, обновите страницу.`, true); setGameStatusMessage(`Отключено: ${reason}. Обновите страницу.`, true);
disableGameControls(); disableGameControls();
// === ИЗМЕНЕНИЕ: При дисконнекте останавливаем таймер (если он виден) === if (turnTimerSpan) turnTimerSpan.textContent = 'Откл.';
if (turnTimerSpan) turnTimerSpan.textContent = 'Отключено'; // Не сбрасываем isLoggedIn, чтобы при переподключении можно было восстановить сессию
// Не скрываем контейнер, чтобы было видно сообщение "Отключено"
// === КОНЕЦ ИЗМЕНЕНИЯ ===
}); });
socket.on('gameStarted', (data) => { socket.on('gameCreated', (data) => { // Сервер присылает это после успешного createGame
if (!isLoggedIn) { console.warn('[Client] Ignoring gameStarted: Not logged in.'); return; } console.log('[Client] Game created by this client:', data);
console.log('[Client] Event "gameStarted" received:', data); currentGameId = data.gameId;
myPlayerId = data.yourPlayerId; // Сервер должен прислать роль создателя
// Остальные данные (gameState, baseStats) придут с gameStarted или gameState (если это PvP ожидание)
// Если это PvP и игра ожидает, сервер может прислать waitingForOpponent
});
socket.on('gameStarted', (data) => {
if (!isLoggedIn) return;
console.log('[Client] Game started:', data);
// ... (остальной код gameStarted без изменений, как был)
if (window.gameUI?.uiElements?.opponent?.panel) { if (window.gameUI?.uiElements?.opponent?.panel) {
const opponentPanel = window.gameUI.uiElements.opponent.panel; const opponentPanel = window.gameUI.uiElements.opponent.panel;
if (opponentPanel.classList.contains('dissolving')) { if (opponentPanel.classList.contains('dissolving')) {
@ -450,7 +408,6 @@ document.addEventListener('DOMContentLoaded', () => {
if (data.clientConfig) window.GAME_CONFIG = { ...data.clientConfig }; if (data.clientConfig) window.GAME_CONFIG = { ...data.clientConfig };
else if (!window.GAME_CONFIG) { else if (!window.GAME_CONFIG) {
window.GAME_CONFIG = { PLAYER_ID: 'player', OPPONENT_ID: 'opponent', CSS_CLASS_HIDDEN: 'hidden' }; window.GAME_CONFIG = { PLAYER_ID: 'player', OPPONENT_ID: 'opponent', CSS_CLASS_HIDDEN: 'hidden' };
console.warn('[Client.js gameStarted] No clientConfig received from server. Using fallback.');
} }
window.gameState = currentGameState; window.gameState = currentGameState;
window.gameData = { playerBaseStats: playerBaseStatsServer, opponentBaseStats: opponentBaseStatsServer, playerAbilities: playerAbilitiesServer, opponentAbilities: opponentAbilitiesServer }; window.gameData = { playerBaseStats: playerBaseStatsServer, opponentBaseStats: opponentBaseStatsServer, playerAbilities: playerAbilitiesServer, opponentAbilities: opponentAbilitiesServer };
@ -463,108 +420,131 @@ document.addEventListener('DOMContentLoaded', () => {
} }
requestAnimationFrame(() => { requestAnimationFrame(() => {
if (window.gameUI && typeof window.gameUI.updateUI === 'function') { if (window.gameUI && typeof window.gameUI.updateUI === 'function') {
console.log('[Client] Calling gameUI.updateUI() after gameStarted.');
window.gameUI.updateUI(); window.gameUI.updateUI();
} }
}); });
hideGameOverModal(); setGameStatusMessage(""); hideGameOverModal(); setGameStatusMessage("");
}); });
socket.on('gameStateUpdate', (data) => { // Используется для восстановления состояния уже идущей игры
if (!isLoggedIn || !isInGame || !currentGameId || !window.GAME_CONFIG) { socket.on('gameState', (data) => {
console.warn('[Client] Ignoring gameStateUpdate: Not logged in or not in game context.'); if (!isLoggedIn) return;
return; console.log('[Client] Received full gameState (e.g. on reconnect):', data);
// Это событие теперь может дублировать 'gameStarted' для переподключения.
// Убедимся, что логика похожа на gameStarted.
currentGameId = data.gameId;
myPlayerId = data.yourPlayerId;
currentGameState = data.gameState; // Используем gameState вместо initialGameState
playerBaseStatsServer = data.playerBaseStats;
opponentBaseStatsServer = data.opponentBaseStats;
playerAbilitiesServer = data.playerAbilities;
opponentAbilitiesServer = data.opponentAbilities;
myCharacterKey = playerBaseStatsServer?.characterKey;
opponentCharacterKey = opponentBaseStatsServer?.characterKey;
if (data.clientConfig) window.GAME_CONFIG = { ...data.clientConfig };
else if (!window.GAME_CONFIG) {
window.GAME_CONFIG = { PLAYER_ID: 'player', OPPONENT_ID: 'opponent', CSS_CLASS_HIDDEN: 'hidden' };
}
window.gameState = currentGameState;
window.gameData = { playerBaseStats: playerBaseStatsServer, opponentBaseStats: opponentBaseStatsServer, playerAbilities: playerAbilitiesServer, opponentAbilities: opponentAbilitiesServer };
window.myPlayerId = myPlayerId;
if (!isInGame) showGameScreen(); // Показываем экран игры, если еще не там
initializeAbilityButtons(); // Переинициализируем кнопки
// Лог при 'gameState' может быть уже накопленным, добавляем его
if (window.gameUI?.uiElements?.log?.list && data.log) { // Очищаем лог перед добавлением нового при полном обновлении
window.gameUI.uiElements.log.list.innerHTML = '';
} }
currentGameState = data.gameState; window.gameState = currentGameState;
if (window.gameUI && typeof window.gameUI.updateUI === 'function') window.gameUI.updateUI();
if (window.gameUI && typeof window.gameUI.addToLog === 'function' && data.log) { if (window.gameUI && typeof window.gameUI.addToLog === 'function' && data.log) {
data.log.forEach(logEntry => window.gameUI.addToLog(logEntry.message, logEntry.type)); data.log.forEach(logEntry => window.gameUI.addToLog(logEntry.message, logEntry.type));
} }
requestAnimationFrame(() => {
if (window.gameUI && typeof window.gameUI.updateUI === 'function') {
window.gameUI.updateUI();
}
});
hideGameOverModal();
// Таймер будет обновлен следующим событием 'turnTimerUpdate'
});
socket.on('gameStateUpdate', (data) => {
if (!isLoggedIn || !isInGame || !currentGameId || !window.GAME_CONFIG) return;
currentGameState = data.gameState; window.gameState = currentGameState;
if (window.gameUI?.updateUI) window.gameUI.updateUI();
if (window.gameUI?.addToLog && data.log) {
data.log.forEach(log => window.gameUI.addToLog(log.message, log.type));
}
}); });
socket.on('logUpdate', (data) => { socket.on('logUpdate', (data) => {
if (!isLoggedIn || !isInGame || !currentGameId || !window.GAME_CONFIG) { if (!isLoggedIn || !isInGame || !currentGameId || !window.GAME_CONFIG) return;
console.warn('[Client] Ignoring logUpdate: Not logged in or not in game context.'); if (window.gameUI?.addToLog && data.log) {
return; data.log.forEach(log => window.gameUI.addToLog(log.message, log.type));
}
if (window.gameUI && typeof window.gameUI.addToLog === 'function' && data.log) {
data.log.forEach(logEntry => window.gameUI.addToLog(logEntry.message, logEntry.type));
} }
}); });
socket.on('gameOver', (data) => { socket.on('gameOver', (data) => {
// ... (код без изменений, как был)
if (!isLoggedIn || !currentGameId || !window.GAME_CONFIG) { if (!isLoggedIn || !currentGameId || !window.GAME_CONFIG) {
console.warn('[Client] Ignoring gameOver: Not logged in or currentGameId is null/stale.');
if (!currentGameId && isLoggedIn) socket.emit('requestGameState'); if (!currentGameId && isLoggedIn) socket.emit('requestGameState');
else if (!isLoggedIn) showAuthScreen(); else if (!isLoggedIn) showAuthScreen();
return; return;
} }
console.log(`[Client gameOver] Received for game ${currentGameId}. My technical slot ID (myPlayerId): ${myPlayerId}, Winner's slot ID from server (data.winnerId): ${data.winnerId}`);
const playerWon = data.winnerId === myPlayerId; const playerWon = data.winnerId === myPlayerId;
console.log(`[Client gameOver] Calculated playerWon for this client: ${playerWon}`);
currentGameState = data.finalGameState; window.gameState = currentGameState; currentGameState = data.finalGameState; window.gameState = currentGameState;
console.log('[Client gameOver] Final GameState:', currentGameState); if (window.gameUI?.updateUI) window.gameUI.updateUI();
if (window.gameData) console.log(`[Client gameOver] For ui.js, myName: ${window.gameData.playerBaseStats?.name}, opponentName: ${window.gameData.opponentBaseStats?.name}`); if (window.gameUI?.addToLog && data.log) {
if (window.gameUI && typeof window.gameUI.updateUI === 'function') window.gameUI.updateUI(); data.log.forEach(log => window.gameUI.addToLog(log.message, log.type));
if (window.gameUI && typeof window.gameUI.addToLog === 'function' && data.log) {
data.log.forEach(logEntry => window.gameUI.addToLog(logEntry.message, logEntry.type));
} }
if (window.gameUI && typeof window.gameUI.showGameOver === 'function') { if (window.gameUI?.showGameOver) {
const opponentKeyForModal = window.gameData?.opponentBaseStats?.characterKey; const oppKey = window.gameData?.opponentBaseStats?.characterKey;
window.gameUI.showGameOver(playerWon, data.reason, opponentKeyForModal, data); window.gameUI.showGameOver(playerWon, data.reason, oppKey, data);
} }
if (returnToMenuButton) returnToMenuButton.disabled = false; if (returnToMenuButton) returnToMenuButton.disabled = false;
setGameStatusMessage("Игра окончена. " + (playerWon ? "Вы победили!" : "Вы проиграли.")); setGameStatusMessage("Игра окончена. " + (playerWon ? "Вы победили!" : "Вы проиграли."));
// === ИЗМЕНЕНИЕ: При gameOver скрываем таймер или показываем "Игра окончена" === if (window.gameUI?.updateTurnTimerDisplay) { // Обновляем UI таймера
if (turnTimerContainer) turnTimerContainer.style.display = 'block'; // Оставляем видимым window.gameUI.updateTurnTimerDisplay(null, false, currentGameState?.gameMode); // Передаем null, чтобы показать "Конец" или скрыть
if (turnTimerSpan) turnTimerSpan.textContent = 'Конец'; }
// === КОНЕЦ ИЗМЕНЕНИЯ ===
}); });
socket.on('waitingForOpponent', () => { socket.on('waitingForOpponent', () => {
if (!isLoggedIn) return; if (!isLoggedIn) return;
setGameStatusMessage("Ожидание присоединения оппонента..."); setGameStatusMessage("Ожидание присоединения оппонента...");
disableGameControls(); disableGameControls(); // Боевые кнопки неактивны
enableSetupButtons(); // Можно оставить возможность отменить, если долго ждет disableSetupButtons(); // Кнопки создания/присоединения тоже, пока ждем
// === ИЗМЕНЕНИЕ: При ожидании оппонента таймер неактивен === if (createPvPGameButton) createPvPGameButton.disabled = false; // Оставляем активной "Создать PvP" для отмены
if (turnTimerContainer) turnTimerContainer.style.display = 'none'; if (window.gameUI?.updateTurnTimerDisplay) {
if (turnTimerSpan) turnTimerSpan.textContent = '--'; window.gameUI.updateTurnTimerDisplay(null, false, 'pvp'); // Таймер неактивен
// === КОНЕЦ ИЗМЕНЕНИЯ === }
}); });
socket.on('opponentDisconnected', (data) => { socket.on('opponentDisconnected', (data) => {
if (!isLoggedIn || !isInGame || !currentGameId || !window.GAME_CONFIG) { if (!isLoggedIn || !isInGame || !currentGameId || !window.GAME_CONFIG) return;
console.warn('[Client] Ignoring opponentDisconnected: Not logged in or not in game context.'); const name = data.disconnectedCharacterName || 'Противник';
return; if (window.gameUI?.addToLog) window.gameUI.addToLog(`🔌 Противник (${name}) отключился.`, 'system');
}
const systemLogType = (window.GAME_CONFIG?.LOG_TYPE_SYSTEM) || 'system';
const disconnectedCharacterName = data.disconnectedCharacterName || 'Противник';
if (window.gameUI && typeof window.gameUI.addToLog === 'function') {
window.gameUI.addToLog(`🔌 Противник (${disconnectedCharacterName}) отключился.`, systemLogType);
}
if (currentGameState && !currentGameState.isGameOver) { if (currentGameState && !currentGameState.isGameOver) {
setGameStatusMessage(`Противник (${disconnectedCharacterName}) отключился. Ожидание завершения игры сервером...`, true); setGameStatusMessage(`Противник (${name}) отключился. Ожидание...`, true);
disableGameControls(); disableGameControls();
} }
}); });
socket.on('gameError', (data) => { socket.on('gameError', (data) => {
console.error('[Client] Server error:', data.message); console.error('[Client] Server error:', data.message);
const systemLogType = (window.GAME_CONFIG?.LOG_TYPE_SYSTEM) || 'system'; if (isLoggedIn && isInGame && currentGameState && !currentGameState.isGameOver && window.gameUI?.addToLog) {
if (isLoggedIn && isInGame && currentGameId && currentGameState && !currentGameState.isGameOver && window.gameUI && typeof window.gameUI.addToLog === 'function') { window.gameUI.addToLog(`❌ Ошибка игры: ${data.message}`, 'system');
window.gameUI.addToLog(`❌ Ошибка игры: ${data.message}`, systemLogType); disableGameControls(); setGameStatusMessage(`Ошибка: ${data.message}.`, true);
disableGameControls();
setGameStatusMessage(`Ошибка в игре: ${data.message}.`, true);
} else { } else {
setGameStatusMessage(`❌ Ошибка игры: ${data.message}`, true); setGameStatusMessage(`❌ Ошибка: ${data.message}`, true);
resetGameVariables(); isInGame = false; disableGameControls(); if (isLoggedIn) enableSetupButtons(); // Если на экране выбора игры, включаем кнопки
if (isLoggedIn && loggedInUsername) showGameSelectionScreen(loggedInUsername); else { // Если на экране логина
else showAuthScreen();
}
if (!isLoggedIn) {
if(registerForm) registerForm.querySelector('button').disabled = false; if(registerForm) registerForm.querySelector('button').disabled = false;
if(loginForm) loginForm.querySelector('button').disabled = false; if(loginForm) loginForm.querySelector('button').disabled = false;
} else if (!isInGame) { enableSetupButtons(); } }
}
}); });
socket.on('availablePvPGamesList', (games) => { socket.on('availablePvPGamesList', (games) => {
@ -572,58 +552,32 @@ document.addEventListener('DOMContentLoaded', () => {
updateAvailableGamesList(games); updateAvailableGamesList(games);
}); });
socket.on('noPendingGamesFound', (data) => { socket.on('noPendingGamesFound', (data) => { // Вызывается, когда создается новая игра после поиска
if (!isLoggedIn) return; if (!isLoggedIn) return;
setGameStatusMessage(data.message || "Свободных игр не найдено. Создана новая для вас, ожидайте оппонента."); setGameStatusMessage(data.message || "Свободных игр не найдено. Создана новая для вас.");
updateAvailableGamesList([]); updateAvailableGamesList([]); // Очищаем список
isInGame = false; disableGameControls(); disableSetupButtons(); // currentGameId и myPlayerId должны были прийти с gameCreated
// === ИЗМЕНЕНИЕ: При ожидании оппонента (создана новая игра) таймер неактивен === isInGame = false; // Еще не в активной фазе боя
if (turnTimerContainer) turnTimerContainer.style.display = 'none'; disableGameControls();
if (turnTimerSpan) turnTimerSpan.textContent = '--'; disableSetupButtons(); // Мы в ожидающей игре
// === КОНЕЦ ИЗМЕНЕНИЯ === if (window.gameUI?.updateTurnTimerDisplay) {
window.gameUI.updateTurnTimerDisplay(null, false, 'pvp');
}
}); });
// === ИЗМЕНЕНИЕ: Обработчик события обновления таймера ===
socket.on('turnTimerUpdate', (data) => { socket.on('turnTimerUpdate', (data) => {
if (!isInGame || !currentGameState || currentGameState.isGameOver) { if (!isInGame || !currentGameState || currentGameState.isGameOver) {
// Если игра не активна, или уже завершена, или нет состояния, игнорируем обновление таймера if (window.gameUI?.updateTurnTimerDisplay && !currentGameState?.isGameOver) { // Только если не game over
if (turnTimerContainer && !currentGameState?.isGameOver) turnTimerContainer.style.display = 'none'; // Скрываем, если не game over window.gameUI.updateTurnTimerDisplay(null, false, currentGameState?.gameMode);
if (turnTimerSpan && !currentGameState?.isGameOver) turnTimerSpan.textContent = '--'; }
return; return;
} }
if (window.gameUI && typeof window.gameUI.updateTurnTimerDisplay === 'function') {
if (turnTimerSpan && turnTimerContainer) { // Определяем, является ли текущий ход ходом этого клиента
if (data.remainingTime === null || data.remainingTime === undefined) {
// Сервер сигнализирует, что таймер неактивен (например, ход AI)
turnTimerContainer.style.display = 'block'; // Контейнер может быть видимым
// Определяем, чей ход, чтобы показать соответствующее сообщение
const isMyActualTurn = myPlayerId && currentGameState.isPlayerTurn === (myPlayerId === GAME_CONFIG.PLAYER_ID); const isMyActualTurn = myPlayerId && currentGameState.isPlayerTurn === (myPlayerId === GAME_CONFIG.PLAYER_ID);
window.gameUI.updateTurnTimerDisplay(data.remainingTime, isMyActualTurn, currentGameState.gameMode);
if (!data.isPlayerTurn && currentGameState.gameMode === 'ai') { // Ход AI
turnTimerSpan.textContent = 'Ход ИИ';
turnTimerSpan.classList.remove('low-time');
} else if (!isMyActualTurn && currentGameState.gameMode === 'pvp' && !data.isPlayerTurn !== (myPlayerId === GAME_CONFIG.PLAYER_ID)) { // Ход оппонента в PvP
turnTimerSpan.textContent = 'Ход оппонента';
turnTimerSpan.classList.remove('low-time');
} else { // Ход текущего игрока, но сервер прислал null - странно, но покажем '--'
turnTimerSpan.textContent = '--';
turnTimerSpan.classList.remove('low-time');
}
} else {
turnTimerContainer.style.display = 'block'; // Убедимся, что контейнер виден
const seconds = Math.ceil(data.remainingTime / 1000);
turnTimerSpan.textContent = `0:${seconds < 10 ? '0' : ''}${seconds}`;
// Добавляем/удаляем класс для предупреждения, если времени мало
if (seconds <= 10) { // Например, 10 секунд - порог
turnTimerSpan.classList.add('low-time');
} else {
turnTimerSpan.classList.remove('low-time');
}
}
} }
}); });
// === КОНЕЦ ИЗМЕНЕНИЯ ===
showAuthScreen(); showAuthScreen(); // Начальный экран
}); });

85
public/js/ui.js
View File

@ -32,10 +32,8 @@
buttonAttack: document.getElementById('button-attack'), buttonAttack: document.getElementById('button-attack'),
buttonBlock: document.getElementById('button-block'), buttonBlock: document.getElementById('button-block'),
abilitiesGrid: document.getElementById('abilities-grid'), abilitiesGrid: document.getElementById('abilities-grid'),
// === ИЗМЕНЕНИЕ: Добавлены элементы таймера ===
turnTimerContainer: document.getElementById('turn-timer-container'), turnTimerContainer: document.getElementById('turn-timer-container'),
turnTimerSpan: document.getElementById('turn-timer') turnTimerSpan: document.getElementById('turn-timer')
// === КОНЕЦ ИЗМЕНЕНИЯ ===
}, },
log: { log: {
list: document.getElementById('log-list'), list: document.getElementById('log-list'),
@ -51,6 +49,15 @@
opponentResourceTypeIcon: document.getElementById('opponent-resource-bar')?.closest('.stat-bar-container')?.querySelector('.bar-icon i'), opponentResourceTypeIcon: document.getElementById('opponent-resource-bar')?.closest('.stat-bar-container')?.querySelector('.bar-icon i'),
playerResourceBarContainer: document.getElementById('player-resource-bar')?.closest('.stat-bar-container'), playerResourceBarContainer: document.getElementById('player-resource-bar')?.closest('.stat-bar-container'),
opponentResourceBarContainer: document.getElementById('opponent-resource-bar')?.closest('.stat-bar-container'), opponentResourceBarContainer: document.getElementById('opponent-resource-bar')?.closest('.stat-bar-container'),
// === НОВЫЕ ЭЛЕМЕНТЫ для переключателя панелей ===
panelSwitcher: {
controlsContainer: document.querySelector('.panel-switcher-controls'),
showPlayerBtn: document.getElementById('show-player-panel-btn'),
showOpponentBtn: document.getElementById('show-opponent-panel-btn')
},
battleArenaContainer: document.querySelector('.battle-arena-container')
// === КОНЕЦ НОВЫХ ЭЛЕМЕНТОВ ===
}; };
function addToLog(message, type = 'info') { function addToLog(message, type = 'info') {
@ -91,9 +98,9 @@
if (elements.name) { if (elements.name) {
let iconClass = 'fa-question'; let iconClass = 'fa-question';
const characterKey = fighterBaseStats.characterKey; const characterKey = fighterBaseStats.characterKey;
if (characterKey === 'elena') { iconClass = 'fa-hat-wizard icon-elena'; } // Используем специфичный класс для цвета if (characterKey === 'elena') { iconClass = 'fa-hat-wizard icon-elena'; }
else if (characterKey === 'almagest') { iconClass = 'fa-staff-aesculapius icon-almagest'; } else if (characterKey === 'almagest') { iconClass = 'fa-staff-aesculapius icon-almagest'; }
else if (characterKey === 'balard') { iconClass = 'fa-khanda icon-balard'; } // Для Баларда тоже специфичный else if (characterKey === 'balard') { iconClass = 'fa-khanda icon-balard'; }
let nameHtml = `<i class="fas ${iconClass}"></i> ${fighterBaseStats.name || 'Неизвестно'}`; let nameHtml = `<i class="fas ${iconClass}"></i> ${fighterBaseStats.name || 'Неизвестно'}`;
if (isControlledByThisClient) nameHtml += " (Вы)"; if (isControlledByThisClient) nameHtml += " (Вы)";
elements.name.innerHTML = nameHtml; elements.name.innerHTML = nameHtml;
@ -140,7 +147,7 @@
else if (fighterBaseStats.characterKey === 'balard') { elements.panel.classList.add('panel-balard'); borderColorVar = 'var(--accent-opponent)'; } else if (fighterBaseStats.characterKey === 'balard') { elements.panel.classList.add('panel-balard'); borderColorVar = 'var(--accent-opponent)'; }
let glowColorVar = 'rgba(0, 0, 0, 0.4)'; let glowColorVar = 'rgba(0, 0, 0, 0.4)';
if (fighterBaseStats.characterKey === 'elena') glowColorVar = 'var(--panel-glow-player)'; if (fighterBaseStats.characterKey === 'elena') glowColorVar = 'var(--panel-glow-player)';
else if (fighterBaseStats.characterKey === 'almagest') glowColorVar = 'var(--panel-glow-almagest)'; // Отдельный цвет для Альмагест else if (fighterBaseStats.characterKey === 'almagest') glowColorVar = 'var(--panel-glow-almagest)';
else if (fighterBaseStats.characterKey === 'balard') glowColorVar = 'var(--panel-glow-opponent)'; else if (fighterBaseStats.characterKey === 'balard') glowColorVar = 'var(--panel-glow-opponent)';
elements.panel.style.borderColor = borderColorVar; elements.panel.style.borderColor = borderColorVar;
elements.panel.style.boxShadow = `0 0 15px ${glowColorVar}, inset 0 0 10px rgba(0, 0, 0, 0.3)`; elements.panel.style.boxShadow = `0 0 15px ${glowColorVar}, inset 0 0 10px rgba(0, 0, 0, 0.3)`;
@ -207,22 +214,14 @@
} }
} }
// === ИЗМЕНЕНИЕ: Новая функция для обновления таймера ===
/**
* Обновляет отображение таймера хода.
* @param {number|null} remainingTimeMs - Оставшееся время в миллисекундах, или null если таймер неактивен.
* @param {boolean} isCurrentPlayerActualTurn - Флаг, является ли текущий ход ходом этого клиента.
* @param {string} gameMode - Режим игры ('ai' или 'pvp').
*/
function updateTurnTimerDisplay(remainingTimeMs, isCurrentPlayerActualTurn, gameMode) { function updateTurnTimerDisplay(remainingTimeMs, isCurrentPlayerActualTurn, gameMode) {
const timerSpan = uiElements.controls.turnTimerSpan; const timerSpan = uiElements.controls.turnTimerSpan;
const timerContainer = uiElements.controls.turnTimerContainer; const timerContainer = uiElements.controls.turnTimerContainer;
const config = window.GAME_CONFIG || {};
if (!timerSpan || !timerContainer) return; if (!timerSpan || !timerContainer) return;
if (window.gameState && window.gameState.isGameOver) { if (window.gameState && window.gameState.isGameOver) {
timerContainer.style.display = 'block'; // Может быть 'flex' или другой, в зависимости от CSS timerContainer.style.display = 'block';
timerSpan.textContent = 'Конец'; timerSpan.textContent = 'Конец';
timerSpan.classList.remove('low-time'); timerSpan.classList.remove('low-time');
return; return;
@ -231,11 +230,11 @@
if (remainingTimeMs === null || remainingTimeMs === undefined) { if (remainingTimeMs === null || remainingTimeMs === undefined) {
timerContainer.style.display = 'block'; timerContainer.style.display = 'block';
timerSpan.classList.remove('low-time'); timerSpan.classList.remove('low-time');
if (gameMode === 'ai' && !isCurrentPlayerActualTurn) { // Предполагаем, что если не ход игрока в AI, то ход AI if (gameMode === 'ai' && !isCurrentPlayerActualTurn) {
timerSpan.textContent = 'Ход ИИ'; timerSpan.textContent = 'Ход ИИ';
} else if (gameMode === 'pvp' && !isCurrentPlayerActualTurn) { } else if (gameMode === 'pvp' && !isCurrentPlayerActualTurn) {
timerSpan.textContent = 'Ход оппонента'; timerSpan.textContent = 'Ход оппонента';
} else { // Ход текущего игрока, но нет времени (например, ожидание первого хода) } else {
timerSpan.textContent = '--'; timerSpan.textContent = '--';
} }
} else { } else {
@ -243,14 +242,13 @@
const seconds = Math.ceil(remainingTimeMs / 1000); const seconds = Math.ceil(remainingTimeMs / 1000);
timerSpan.textContent = `0:${seconds < 10 ? '0' : ''}${seconds}`; timerSpan.textContent = `0:${seconds < 10 ? '0' : ''}${seconds}`;
if (seconds <= 10 && isCurrentPlayerActualTurn) { // Предупреждение только если это мой ход if (seconds <= 10 && isCurrentPlayerActualTurn) {
timerSpan.classList.add('low-time'); timerSpan.classList.add('low-time');
} else { } else {
timerSpan.classList.remove('low-time'); timerSpan.classList.remove('low-time');
} }
} }
} }
// === КОНЕЦ ИЗМЕНЕНИЯ ===
function updateUI() { function updateUI() {
@ -267,13 +265,11 @@
if(uiElements.controls.buttonAttack) uiElements.controls.buttonAttack.disabled = true; if(uiElements.controls.buttonAttack) uiElements.controls.buttonAttack.disabled = true;
if(uiElements.controls.buttonBlock) uiElements.controls.buttonBlock.disabled = true; if(uiElements.controls.buttonBlock) uiElements.controls.buttonBlock.disabled = true;
if(uiElements.controls.abilitiesGrid) uiElements.controls.abilitiesGrid.innerHTML = '<p class="placeholder-text">Загрузка способностей...</p>'; if(uiElements.controls.abilitiesGrid) uiElements.controls.abilitiesGrid.innerHTML = '<p class="placeholder-text">Загрузка способностей...</p>';
// === ИЗМЕНЕНИЕ: Сбрасываем таймер, если нет данных ===
if (uiElements.controls.turnTimerContainer) uiElements.controls.turnTimerContainer.style.display = 'none'; if (uiElements.controls.turnTimerContainer) uiElements.controls.turnTimerContainer.style.display = 'none';
if (uiElements.controls.turnTimerSpan) { if (uiElements.controls.turnTimerSpan) {
uiElements.controls.turnTimerSpan.textContent = '--'; uiElements.controls.turnTimerSpan.textContent = '--';
uiElements.controls.turnTimerSpan.classList.remove('low-time'); uiElements.controls.turnTimerSpan.classList.remove('low-time');
} }
// === КОНЕЦ ИЗМЕНЕНИЯ ===
return; return;
} }
if (!uiElements.player.panel || !uiElements.opponent.panel || !uiElements.controls.turnIndicator || !uiElements.controls.abilitiesGrid || !uiElements.log.list) { if (!uiElements.player.panel || !uiElements.opponent.panel || !uiElements.controls.turnIndicator || !uiElements.controls.abilitiesGrid || !uiElements.log.list) {
@ -423,8 +419,7 @@
const currentActualGameState = window.gameState; const currentActualGameState = window.gameState;
const gameOverScreenElement = uiElements.gameOver.screen; const gameOverScreenElement = uiElements.gameOver.screen;
console.log(`[UI.JS DEBUG] showGameOver CALLED. PlayerWon: ${playerWon}, Reason: ${reason}`); if (!gameOverScreenElement) { return; }
if (!gameOverScreenElement) { console.warn("[UI.JS DEBUG] showGameOver: gameOverScreenElement not found."); return; }
const resultMsgElement = uiElements.gameOver.message; const resultMsgElement = uiElements.gameOver.message;
const myNameForResult = clientSpecificGameData?.playerBaseStats?.name || "Игрок"; const myNameForResult = clientSpecificGameData?.playerBaseStats?.name || "Игрок";
@ -433,19 +428,16 @@
if (resultMsgElement) { if (resultMsgElement) {
let winText = `Победа! ${myNameForResult} празднует!`; let winText = `Победа! ${myNameForResult} празднует!`;
let loseText = `Поражение! ${opponentNameForResult} оказался(лась) сильнее!`; let loseText = `Поражение! ${opponentNameForResult} оказался(лась) сильнее!`;
// === ИЗМЕНЕНИЕ: Добавляем обработку причины 'turn_timeout' ===
if (reason === 'opponent_disconnected') { if (reason === 'opponent_disconnected') {
let disconnectedName = data?.disconnectedCharacterName || opponentNameForResult; let disconnectedName = data?.disconnectedCharacterName || opponentNameForResult;
winText = `${disconnectedName} покинул(а) игру. Победа присуждается вам!`; winText = `${disconnectedName} покинул(а) игру. Победа присуждается вам!`;
} else if (reason === 'turn_timeout') { } else if (reason === 'turn_timeout') {
// Если текущий игрок (чей ход был) проиграл по таймауту if (!playerWon) {
if (!playerWon) { // playerWon здесь будет false, если победил оппонент (т.е. мой таймаут)
loseText = `Время на ход истекло! Поражение. ${opponentNameForResult} побеждает!`; loseText = `Время на ход истекло! Поражение. ${opponentNameForResult} побеждает!`;
} else { // Если я победил, потому что у оппонента истекло время } else {
winText = `Время на ход у ${opponentNameForResult} истекло! Победа!`; winText = `Время на ход у ${opponentNameForResult} истекло! Победа!`;
} }
} }
// === КОНЕЦ ИЗМЕНЕНИЯ ===
resultMsgElement.textContent = playerWon ? winText : loseText; resultMsgElement.textContent = playerWon ? winText : loseText;
resultMsgElement.style.color = playerWon ? 'var(--heal-color)' : 'var(--damage-color)'; resultMsgElement.style.color = playerWon ? 'var(--heal-color)' : 'var(--damage-color)';
} }
@ -468,7 +460,7 @@
opponentPanelElement.style.transition = ''; opponentPanelElement.style.transition = '';
} }
setTimeout((finalStateInTimeout, wonInTimeout, reasonInTimeout, keyInTimeout, dataInTimeout) => { setTimeout((finalStateInTimeout) => {
if (gameOverScreenElement && finalStateInTimeout && finalStateInTimeout.isGameOver === true) { if (gameOverScreenElement && finalStateInTimeout && finalStateInTimeout.isGameOver === true) {
if (gameOverScreenElement.classList.contains(config.CSS_CLASS_HIDDEN || 'hidden')) { if (gameOverScreenElement.classList.contains(config.CSS_CLASS_HIDDEN || 'hidden')) {
gameOverScreenElement.classList.remove(config.CSS_CLASS_HIDDEN || 'hidden'); gameOverScreenElement.classList.remove(config.CSS_CLASS_HIDDEN || 'hidden');
@ -496,16 +488,47 @@
gameOverScreenElement.offsetHeight; gameOverScreenElement.offsetHeight;
} }
} }
}, config.DELAY_BEFORE_VICTORY_MODAL || 1500, currentActualGameState, playerWon, reason, opponentCharacterKeyFromClient, data); }, config.DELAY_BEFORE_VICTORY_MODAL || 1500, currentActualGameState);
} }
// === НОВАЯ ФУНКЦИЯ для настройки переключателя панелей ===
function setupPanelSwitcher() {
const { showPlayerBtn, showOpponentBtn } = uiElements.panelSwitcher;
const battleArena = uiElements.battleArenaContainer;
if (showPlayerBtn && showOpponentBtn && battleArena) {
showPlayerBtn.addEventListener('click', () => {
battleArena.classList.remove('show-opponent-panel');
showPlayerBtn.classList.add('active');
showOpponentBtn.classList.remove('active');
});
showOpponentBtn.addEventListener('click', () => {
battleArena.classList.add('show-opponent-panel');
showOpponentBtn.classList.add('active');
showPlayerBtn.classList.remove('active');
});
// По умолчанию при загрузке (если кнопки видимы) панель игрока активна
// CSS уже должен это обеспечивать, но для надежности можно убедиться
if (window.getComputedStyle(uiElements.panelSwitcher.controlsContainer).display !== 'none') {
battleArena.classList.remove('show-opponent-panel');
showPlayerBtn.classList.add('active');
showOpponentBtn.classList.remove('active');
}
}
}
// === КОНЕЦ НОВОЙ ФУНКЦИИ ===
window.gameUI = { window.gameUI = {
uiElements, uiElements,
addToLog, addToLog,
updateUI, updateUI,
showGameOver, showGameOver,
// === ИЗМЕНЕНИЕ: Экспортируем функцию обновления таймера ===
updateTurnTimerDisplay updateTurnTimerDisplay
// === КОНЕЦ ИЗМЕНЕНИЯ ===
}; };
// Настраиваем переключатель панелей при загрузке скрипта
setupPanelSwitcher();
})(); })();

713
public/style_alt.css
View File

File diff suppressed because it is too large Load Diff

127
server_modules/auth.js
View File

@ -1,127 +0,0 @@
// /server_modules/auth.js
const bcrypt = require('bcryptjs'); // Для хеширования паролей
const db = require('./db'); // Ваш модуль для работы с базой данных
const SALT_ROUNDS = 10; // Количество раундов для генерации соли bcrypt
/**
* Регистрирует нового пользователя.
* @param {string} username - Имя пользователя.
* @param {string} password - Пароль пользователя.
* @returns {Promise<object>} Объект с результатом: { success: boolean, message: string, userId?: number }
*/
async function registerUser(username, password) {
console.log(`[Auth DEBUG] registerUser called with username: "${username}"`); // 1. Начало функции
if (!username || !password) {
console.warn('[Auth DEBUG] Validation failed: Username or password empty.');
return { success: false, message: 'Имя пользователя и пароль не могут быть пустыми.' };
}
if (password.length < 6) {
console.warn(`[Auth DEBUG] Validation failed for "${username}": Password too short.`);
return { success: false, message: 'Пароль должен содержать не менее 6 символов.' };
}
try {
// Этап A: Проверка существующего пользователя
console.log(`[Auth DEBUG] Stage A: Checking if user "${username}" exists...`);
const [existingUsers] = await db.query('SELECT id FROM users WHERE username = ?', [username]);
console.log(`[Auth DEBUG] Stage A: existingUsers query result length: ${existingUsers.length}`);
if (existingUsers.length > 0) {
console.warn(`[Auth DEBUG] Registration declined for "${username}": Username already taken.`);
return { success: false, message: 'Это имя пользователя уже занято.' };
}
console.log(`[Auth DEBUG] Stage A: Username "${username}" is available.`);
// Этап B: Хеширование пароля
console.log(`[Auth DEBUG] Stage B: Hashing password for user "${username}"...`);
const hashedPassword = await bcrypt.hash(password, SALT_ROUNDS);
console.log(`[Auth DEBUG] Stage B: Password for "${username}" hashed successfully.`);
// Этап C: Сохранение пользователя в БД
console.log(`[Auth DEBUG] Stage C: Attempting to insert user "${username}" into DB...`);
const [result] = await db.query(
'INSERT INTO users (username, password_hash) VALUES (?, ?)',
[username, hashedPassword]
);
console.log(`[Auth DEBUG] Stage C: DB insert result for "${username}":`, result);
if (result && result.insertId) { // Добавлена проверка на существование result
console.log(`[Auth] Пользователь "${username}" успешно зарегистрирован с ID: ${result.insertId}.`);
return { success: true, message: 'Регистрация прошла успешно!', userId: result.insertId };
} else {
console.error(`[Auth] Ошибка БД при регистрации пользователя "${username}": Запись не была вставлена или insertId отсутствует. Result:`, result);
return { success: false, message: 'Ошибка сервера при регистрации (данные не сохранены). Попробуйте позже.' };
}
} catch (error) {
console.error(`[Auth] КРИТИЧЕСКАЯ ОШИБКА (catch block) при регистрации пользователя "${username}":`, error);
// Логируем более детальную информацию об ошибке, если это ошибка MySQL
if (error.sqlMessage) {
console.error(`[Auth] MySQL Error Message: ${error.sqlMessage}`);
console.error(`[Auth] MySQL Error Code: ${error.code}`);
console.error(`[Auth] MySQL Errno: ${error.errno}`);
}
return { success: false, message: 'Внутренняя ошибка сервера при регистрации.' };
}
}
/**
* Выполняет вход пользователя.
* @param {string} username - Имя пользователя.
* @param {string} password - Пароль пользователя.
* @returns {Promise<object>} Объект с результатом: { success: boolean, message: string, userId?: number, username?: string }
*/
async function loginUser(username, password) {
console.log(`[Auth DEBUG] loginUser called with username: "${username}"`);
if (!username || !password) {
console.warn('[Auth DEBUG] Login validation failed: Username or password empty.');
return { success: false, message: 'Имя пользователя и пароль не могут быть пустыми.' };
}
try {
console.log(`[Auth DEBUG] Searching for user "${username}" in DB...`);
const [users] = await db.query('SELECT id, username, password_hash FROM users WHERE username = ?', [username]);
console.log(`[Auth DEBUG] DB query result for user "${username}" (length): ${users.length}`);
if (users.length === 0) {
console.warn(`[Auth DEBUG] Login failed: User "${username}" not found.`);
return { success: false, message: 'Неверное имя пользователя или пароль.' };
}
const user = users[0];
console.log(`[Auth DEBUG] User "${username}" found. ID: ${user.id}. Comparing password...`);
const passwordMatch = await bcrypt.compare(password, user.password_hash);
console.log(`[Auth DEBUG] Password comparison result for "${username}": ${passwordMatch}`);
if (passwordMatch) {
console.log(`[Auth] Пользователь "${user.username}" (ID: ${user.id}) успешно вошел в систему.`);
return {
success: true,
message: 'Вход выполнен успешно!',
userId: user.id,
username: user.username
};
} else {
console.warn(`[Auth DEBUG] Login failed for user "${user.username}": Incorrect password.`);
return { success: false, message: 'Неверное имя пользователя или пароль.' };
}
} catch (error) {
console.error(`[Auth] КРИТИЧЕСКАЯ ОШИБКА (catch block) при входе пользователя "${username}":`, error);
if (error.sqlMessage) {
console.error(`[Auth] MySQL Error Message: ${error.sqlMessage}`);
console.error(`[Auth] MySQL Error Code: ${error.code}`);
console.error(`[Auth] MySQL Errno: ${error.errno}`);
}
return { success: false, message: 'Внутренняя ошибка сервера при входе.' };
}
}
module.exports = {
registerUser,
loginUser
};

117
server_modules/config.js
View File

@ -1,117 +0,0 @@
// /server_modules/config.js
const GAME_CONFIG = {
// --- Баланс Игры ---
BLOCK_DAMAGE_REDUCTION: 0.5, // Множитель урона при блоке (0.5 = 50% снижение)
DAMAGE_VARIATION_MIN: 0.9, // Минимальный множитель урона (0.9 = 90%)
DAMAGE_VARIATION_RANGE: 0.2, // Диапазон вариации урона (0.2 = от 90% до 110%)
HEAL_VARIATION_MIN: 0.8, // Минимальный множитель лечения (0.8 = 80%)
HEAL_VARIATION_RANGE: 0.4, // Диапазон вариации лечения (0.4 = от 80% до 120%)
NATURE_STRENGTH_MANA_REGEN: 10, // Количество маны, восстанавливаемое "Силой природы" (и ее аналогом)
// --- Условия ИИ и Игрока ---
OPPONENT_HEAL_THRESHOLD_PERCENT: 50, // Процент HP Баларда, НИЖЕ которого он будет пытаться лечиться (для AI)
PLAYER_MERCY_TAUNT_THRESHOLD_PERCENT: 60, // Процент HP Баларда, НИЖЕ которого Елена использует "доминирующие" насмешки (для AI/текстов)
PLAYER_HP_BLEED_THRESHOLD_PERCENT: 60, // % HP Елены, НИЖЕ которого Балард предпочитает Кровотечение Безмолвию (для AI)
BALARD_MANA_DRAIN_HIGH_MANA_THRESHOLD: 60, // % Маны Елены, ВЫШЕ которого Балард может использовать "Похищение Света" (для AI)
// --- Способности Баларда (AI) - Конфигурация ---
SILENCE_DURATION: 3, // Длительность Безмолвия в ходах Елены (после хода Баларда)
SILENCE_SUCCESS_RATE: 0.7, // Шанс успеха наложения Безмолвия (70%)
BALARD_SILENCE_ABILITY_COST: 15, // Стоимость "Эха Безмолвия" в Ярости
BALARD_SILENCE_INTERNAL_COOLDOWN: 5, // К-во ходов Баларда КД ПОСЛЕ успешного использования Безмолвия
// BALARD_BLEED_COST: 15, // Если будете добавлять способность Кровотечение
// BALARD_BLEED_POWER: 5,
// BALARD_BLEED_DURATION: 2,
// BALARD_BLEED_COOLDOWN: 3,
// --- Таймер Хода ---
TURN_DURATION_SECONDS: 60, // Длительность хода в секундах
TURN_DURATION_MS: 60 * 1000, // Длительность хода в миллисекундах
TIMER_UPDATE_INTERVAL_MS: 1000, // Интервал обновления таймера на клиенте (в мс)
// --- Идентификаторы и Типы ---
PLAYER_ID: 'player', // Технический идентификатор для слота 'Игрок 1'
OPPONENT_ID: 'opponent', // Технический идентификатор для слота 'Игрок 2' / 'Противник'
ACTION_TYPE_HEAL: 'heal',
ACTION_TYPE_DAMAGE: 'damage',
ACTION_TYPE_BUFF: 'buff',
ACTION_TYPE_DISABLE: 'disable', // Тип для контроля (безмолвие, стан и т.п.)
ACTION_TYPE_DEBUFF: 'debuff', // Тип для ослаблений, DoT и т.п.
ACTION_TYPE_DRAIN: 'drain', // Тип для Похищения Света
// --- Строки для UI (могут быть полезны и на сервере для логов) ---
STATUS_READY: 'Готов(а)', // Сделал универсальным
STATUS_BLOCKING: 'Защищается',
// --- Типы Логов (для CSS классов на клиенте, и для структурирования на сервере) ---
LOG_TYPE_INFO: 'info',
LOG_TYPE_DAMAGE: 'damage',
LOG_TYPE_HEAL: 'heal',
LOG_TYPE_TURN: 'turn',
LOG_TYPE_SYSTEM: 'system',
LOG_TYPE_BLOCK: 'block',
LOG_TYPE_EFFECT: 'effect',
// --- CSS Классы (в основном для клиента, но константы могут быть полезны для согласованности) ---
CSS_CLASS_BLOCKING: 'blocking',
CSS_CLASS_NOT_ENOUGH_RESOURCE: 'not-enough-resource',
CSS_CLASS_BUFF_IS_ACTIVE: 'buff-is-active',
CSS_CLASS_ATTACK_BUFFED: 'attack-buffed',
CSS_CLASS_SHAKING: 'is-shaking',
CSS_CLASS_CASTING_PREFIX: 'is-casting-', // Например: is-casting-fireball
CSS_CLASS_HIDDEN: 'hidden',
CSS_CLASS_ABILITY_BUTTON: 'ability-button',
CSS_CLASS_ABILITY_SILENCED: 'is-silenced',
CSS_CLASS_ABILITY_ON_COOLDOWN: 'is-on-cooldown', // Для отображения кулдауна
// --- Задержки (в миллисекундах) ---
// Эти задержки теперь в основном будут управляться сервером при отправке событий или планировании AI ходов
DELAY_OPPONENT_TURN: 1200, // Задержка перед ходом AI
DELAY_AFTER_PLAYER_ACTION: 500, // Сервер может использовать это для паузы перед следующим событием
// DELAY_AFTER_BLOCK: 500, // Менее релевантно для сервера напрямую
DELAY_INIT: 100, // Для клиентской инициализации, если нужна
DELAY_BEFORE_VICTORY_MODAL: 1500, // Для клиента, после получения gameOver
MODAL_TRANSITION_DELAY: 10, // Для анимации модалки на клиенте
// --- Длительности анимаций (в миллисекундах, в основном для клиента, но сервер может знать для таймингов) ---
ANIMATION_SHAKE_DURATION: 400,
ANIMATION_CAST_DURATION: 600,
ANIMATION_DISSOLVE_DURATION: 6000, // var(--dissolve-duration) из CSS
// --- Внутренние ID способностей (для удобства в логике, нужны и на сервере, и на клиенте) ---
// Игрока (Елена)
ABILITY_ID_HEAL: 'heal', // Малое Исцеление
ABILITY_ID_FIREBALL: 'fireball', // Огненный Шар
ABILITY_ID_NATURE_STRENGTH: 'naturesStrength', // Сила Природы
ABILITY_ID_DEFENSE_AURA: 'defenseAura', // Аура Защиты
ABILITY_ID_HYPNOTIC_GAZE: 'hypnoticGaze', // Гипнотический взгляд
ABILITY_ID_SEAL_OF_WEAKNESS: 'sealOfWeakness', // Печать Слабости
// Противника (Балард - AI)
ABILITY_ID_BALARD_HEAL: 'darkPatronage', // Покровительство Тьмы
ABILITY_ID_BALARD_SILENCE: 'echoesOfSilence', // Эхо Безмолвия
ABILITY_ID_BALARD_MANA_DRAIN: 'manaDrainHeal', // Похищение Света
// ABILITY_ID_BALARD_BLEED: 'balardBleed', // Если будете добавлять
// Противника (Альмагест - PvP - зеркало Елены)
ABILITY_ID_ALMAGEST_HEAL: 'darkHeal', // Темное Восстановление (Аналог heal)
ABILITY_ID_ALMAGEST_DAMAGE: 'shadowBolt', // Теневой Сгусток (Аналог fireball)
ABILITY_ID_ALMAGEST_BUFF_ATTACK: 'shadowEmpowerment', // Усиление Тьмой (Аналог naturesStrength)
ABILITY_ID_ALMAGEST_BUFF_DEFENSE: 'voidShield', // Щит Пустоты (Аналог defenseAura)
ABILITY_ID_ALMAGEST_DISABLE: 'mindShatter', // Раскол Разума (Аналог hypnoticGaze)
ABILITY_ID_ALMAGEST_DEBUFF: 'curseOfDecay', // Проклятие Увядания (Аналог sealOfWeakness)
};
// Для использования в Node.js модулях (например, server_modules/gameInstance.js)
if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
module.exports = GAME_CONFIG;
}
// Для использования в браузере (если этот файл подключается напрямую через <script>)
// В нашем случае, для клиента, мы будем передавать нужные конфиги от сервера,
// либо создадим урезанный config_client.js.
// else {
// window.GAME_CONFIG = GAME_CONFIG;
// }
// console.log("config.js loaded and GAME_CONFIG object created/exported.");

370
server_modules/data.js
View File

@ -1,370 +0,0 @@
// /server_modules/data.js
const GAME_CONFIG = require('./config'); // Подключаем конфиг для ID способностей и других значений
// --- Базовые Статы Персонажей ---
const playerBaseStats = {
id: GAME_CONFIG.PLAYER_ID, // Технический ID слота
characterKey: 'elena', // Уникальный ключ персонажа
name: "Елена",
maxHp: 120,
maxResource: 150,
attackPower: 15,
resourceName: "Мана",
avatarPath: 'images/elena_avatar.webp' // Пример пути к аватару
};
const opponentBaseStats = { // Балард (для AI)
id: GAME_CONFIG.OPPONENT_ID, // Технический ID слота
characterKey: 'balard', // Уникальный ключ персонажа
name: "Балард",
maxHp: 140,
maxResource: 100,
attackPower: 20,
resourceName: "Ярость",
avatarPath: 'images/balard_avatar.jpg' // Пример пути к аватару
};
const almagestBaseStats = { // Альмагест (для PvP)
id: GAME_CONFIG.OPPONENT_ID, // Технический ID слота (занимает слот оппонента)
characterKey: 'almagest', // Уникальный ключ персонажа
name: "Альмагест",
maxHp: 120, // Статы как у Елены для зеркальности
maxResource: 150,
attackPower: 15,
resourceName: "Темная Энергия",
avatarPath: 'images/almagest_avatar.webp' // Пример пути к аватару (нужно создать изображение)
};
// --- Способности Персонажей ---
// Способности Игрока (Елена)
const playerAbilities = [
{
id: GAME_CONFIG.ABILITY_ID_HEAL,
name: 'Малое Исцеление',
cost: 20,
type: GAME_CONFIG.ACTION_TYPE_HEAL,
power: 30,
description: 'Восстанавливает ~30 HP'
},
{
id: GAME_CONFIG.ABILITY_ID_FIREBALL,
name: 'Огненный Шар',
cost: 30,
type: GAME_CONFIG.ACTION_TYPE_DAMAGE,
power: 25,
description: 'Наносит ~25 урона врагу'
},
{
id: GAME_CONFIG.ABILITY_ID_NATURE_STRENGTH,
name: 'Сила Природы',
cost: 15,
type: GAME_CONFIG.ACTION_TYPE_BUFF,
duration: 4,
descriptionFunction: (config) => `Восст. ${config.NATURE_STRENGTH_MANA_REGEN} маны при след. атаке (${4 - 1} хода)`,
isDelayed: true // Этот эффект применяется ПОСЛЕ следующей атаки, а не сразу
},
{
id: GAME_CONFIG.ABILITY_ID_DEFENSE_AURA,
name: 'Аура Защиты',
cost: 15,
type: GAME_CONFIG.ACTION_TYPE_BUFF,
duration: 3,
grantsBlock: true, // Дает эффект блока на время действия
descriptionFunction: (config) => `Снижает урон на ${config.BLOCK_DAMAGE_REDUCTION * 100}% (${3} хода)`
},
{
id: GAME_CONFIG.ABILITY_ID_HYPNOTIC_GAZE,
name: 'Гипнотический взгляд',
cost: 30,
type: GAME_CONFIG.ACTION_TYPE_DISABLE,
effectDuration: 2, // Длительность безмолвия в ходах противника
cooldown: 6,
power: 5, // Урон в ход от взгляда
description: 'Накладывает на противника полное безмолвие на 2 хода и наносит 5 урона каждый его ход. КД: 6 х.'
},
{
id: GAME_CONFIG.ABILITY_ID_SEAL_OF_WEAKNESS,
name: 'Печать Слабости',
cost: 30,
type: GAME_CONFIG.ACTION_TYPE_DEBUFF,
effectDuration: 3, // Длительность дебаффа
power: 10, // Количество ресурса противника, сжигаемое каждый ход
cooldown: 5,
// Описание теперь может адаптироваться к ресурсу оппонента
descriptionFunction: (config, oppStats) => `Накладывает печать, сжигающую 10 ${oppStats.resourceName} противника каждый его ход в течение 3 ходов. КД: 5 х.'`
}
];
// Способности Противника (Балард - AI)
const opponentAbilities = [
{
id: GAME_CONFIG.ABILITY_ID_BALARD_HEAL,
name: 'Покровительство Тьмы',
cost: 20,
type: GAME_CONFIG.ACTION_TYPE_HEAL,
power: 25,
successRate: 0.60, // Шанс успеха
description: 'Исцеляет ~25 HP с 60% шансом',
// Условие для AI: HP ниже порога
condition: (opSt, plSt, currentGameState, config) => {
return (opSt.currentHp / opSt.maxHp) * 100 < config.OPPONENT_HEAL_THRESHOLD_PERCENT;
}
},
{
id: GAME_CONFIG.ABILITY_ID_BALARD_SILENCE,
name: 'Эхо Безмолвия',
cost: GAME_CONFIG.BALARD_SILENCE_ABILITY_COST,
type: GAME_CONFIG.ACTION_TYPE_DISABLE,
// Описание с адаптацией
descriptionFunction: (config) => `Шанс ${config.SILENCE_SUCCESS_RATE * 100}% заглушить случайное заклинание Елены на ${config.SILENCE_DURATION} х.`,
// Условие для AI: HP выше порога лечения, Елена не заглушена, не на спец. КД
condition: (opSt, plSt, currentGameState, config) => {
const hpPercent = (opSt.currentHp / opSt.maxHp) * 100;
const isElenaAlreadySilenced = currentGameState?.player.disabledAbilities?.length > 0 ||
currentGameState?.player.activeEffects?.some(eff => eff.id.startsWith('playerSilencedOn_'));
return hpPercent >= config.OPPONENT_HEAL_THRESHOLD_PERCENT && !isElenaAlreadySilenced && opSt.silenceCooldownTurns <= 0;
},
successRateFromConfig: 'SILENCE_SUCCESS_RATE', // Шанс берется из конфига
durationFromConfig: 'SILENCE_DURATION', // Длительность берется из конфига
internalCooldownFromConfig: 'BALARD_SILENCE_INTERNAL_COOLDOWN' // Спец. КД берется из конфига
},
{
id: GAME_CONFIG.ABILITY_ID_BALARD_MANA_DRAIN,
name: 'Похищение Света',
cost: 10,
type: GAME_CONFIG.ACTION_TYPE_DRAIN,
powerManaDrain: 5, // Сколько маны вытягивает
powerDamage: 5, // Сколько урона наносит дополнительно
powerHealthGainFactor: 1.0, // Множитель для расчета лечения от вытянутой маны
description: `Вытягивает 5 Маны у Елены, наносит 5 урона и восстанавливает себе здоровье (100% от украденного).`,
// Условие для AI: У Елены достаточно маны, не на спец. КД
condition: (opSt, plSt, currentGameState, config) => {
const playerManaPercent = (plSt.currentResource / plSt.maxResource) * 100;
const playerHasHighMana = playerManaPercent > (config.BALARD_MANA_DRAIN_HIGH_MANA_THRESHOLD || 60);
return playerHasHighMana && opSt.manaDrainCooldownTurns <= 0;
},
internalCooldownValue: 3 // Спец. КД задается здесь
}
];
// Способности Альмагест (PvP - зеркало Елены)
const almagestAbilities = [
{
id: GAME_CONFIG.ABILITY_ID_ALMAGEST_HEAL,
name: 'Темное Восстановление',
cost: 20,
type: GAME_CONFIG.ACTION_TYPE_HEAL,
power: 30,
description: 'Поглощает жизненные тени, восстанавливая ~30 HP'
},
{
id: GAME_CONFIG.ABILITY_ID_ALMAGEST_DAMAGE,
name: 'Теневой Сгусток',
cost: 30,
type: GAME_CONFIG.ACTION_TYPE_DAMAGE,
power: 25,
description: 'Запускает сгусток чистой тьмы, нанося ~25 урона врагу'
},
{
id: GAME_CONFIG.ABILITY_ID_ALMAGEST_BUFF_ATTACK,
name: 'Усиление Тьмой',
cost: 15,
type: GAME_CONFIG.ACTION_TYPE_BUFF,
duration: 4,
// Аналогично Силе Природы, но использует Темную Энергию
descriptionFunction: (config) => `Восст. ${config.NATURE_STRENGTH_MANA_REGEN} Темной Энергии при след. атаке (${4 - 1} хода)`,
isDelayed: true // Этот эффект применяется ПОСЛЕ следующей атаки
},
{
id: GAME_CONFIG.ABILITY_ID_ALMAGEST_BUFF_DEFENSE,
name: 'Щит Пустоты',
cost: 15,
type: GAME_CONFIG.ACTION_TYPE_BUFF,
duration: 3,
grantsBlock: true, // Дает эффект блока на время действия
descriptionFunction: (config) => `Создает щит, снижающий урон на ${config.BLOCK_DAMAGE_REDUCTION * 100}% (${3} хода)`
},
{
id: GAME_CONFIG.ABILITY_ID_ALMAGEST_DISABLE,
name: 'Раскол Разума',
cost: 30,
type: GAME_CONFIG.ACTION_TYPE_DISABLE,
effectDuration: 2,
cooldown: 6,
power: 5, // Урон от ментального воздействия
description: 'Вторгается в разум противника, накладывая полное безмолвие на 2 хода и нанося 5 урона каждый его ход. КД: 6 х.'
},
{
id: GAME_CONFIG.ABILITY_ID_ALMAGEST_DEBUFF,
name: 'Проклятие Увядания',
cost: 30,
type: GAME_CONFIG.ACTION_TYPE_DEBUFF,
effectDuration: 3,
power: 10, // Количество ресурса противника, сжигаемое/истощаемое
cooldown: 5,
descriptionFunction: (config, oppStats) => `Накладывает проклятие, истощающее 10 ${oppStats.resourceName} противника каждый его ход в течение 3 ходов. КД: 5 х.`
}
];
// --- Система Насмешек ---
// Ключи верхнего уровня: characterKey того, кто произносит насмешку ('elena', 'almagest')
// Внутри каждого characterKey: ключи characterKey противника ('balard', 'almagest', 'elena')
// Внутри каждого противника: секции по триггерам (battleStart, selfCastAbility, onOpponentAction, etc.)
const tauntSystem = {
elena: { // Насмешки Елены
balard: { // Против Баларда (AI)
// Триггер: Елена использует СВОЮ способность
selfCastAbility: {
[GAME_CONFIG.ABILITY_ID_HEAL]: [ "Свет лечит, Балард. Но не искаженную завистью искру.", "Я черпаю силы в Истине." ],
[GAME_CONFIG.ABILITY_ID_FIREBALL]: [ "Прими очищающее пламя Света!", "Пусть твой мрак сгорит!" ],
[GAME_CONFIG.ABILITY_ID_NATURE_STRENGTH]: [ "Сама земля отвергает тебя, я черпаю её силу!", "Гармония природы со мной." ],
[GAME_CONFIG.ABILITY_ID_DEFENSE_AURA]: [ "Порядок восторжествует над твоим хаосом.", "Моя вера - моя защита." ],
[GAME_CONFIG.ABILITY_ID_HYPNOTIC_GAZE]: [ "Смотри мне в глаза, Балард. И слушай тишину.", "Твой разум - в моей власти." ],
[GAME_CONFIG.ABILITY_ID_SEAL_OF_WEAKNESS]: [ "Твоя ярость иссякнет, как вода в песке, Балард!", "Твоя сила угасает." ]
},
// Триггер: Противник (Балард) совершает действие
onOpponentAction: {
[GAME_CONFIG.ABILITY_ID_BALARD_HEAL]: [ "Пытаешься отсрочить неизбежное жалкой темной силой?" ],
[GAME_CONFIG.ABILITY_ID_BALARD_SILENCE]: {
success: [ "(Сдавленный вздох)... Ничтожная попытка заглушить Слово!" ],
fail: [ "Твой шепот Тьмы слаб против Света Истины!" ]
},
[GAME_CONFIG.ABILITY_ID_BALARD_MANA_DRAIN]: [ "Ты питаешься Светом, как паразит?!" ],
attackBlocked: [ "Твои удары тщетны перед щитом Порядка." ], // При блоке атаки Баларда
attackHits: [ "(Шипение боли)... Боль – лишь напоминание о твоем предательстве." ] // При попадании атаки Баларда
},
// Триггер: Базовая атака Елены
basicAttack: {
merciful: [ "Балард, прошу, остановись. Еще не поздно.", "Подумай о том, что потерял." ],
dominating: [ // Когда HP Баларда ниже порога PLAYER_MERCY_TAUNT_THRESHOLD_PERCENT
"Глина не спорит с гончаром, Балард!",
"Ты ИЗБРАЛ эту гниль! Получай возмездие!",
"Самый страшный грех - грех неблагодарности!",
"Я сотру тебя с лика этой земли!"
]
},
// Триггер: Изменение состояния боя (например, начало, оппонент почти побежден)
onBattleState: {
start: [ "Балард, есть ли еще путь назад?" ], // Начало AI боя с Балардом
opponentNearDefeat: [ "Конец близок, Балард. Прими свою судьбу." ] // Балард почти побежден
}
},
almagest: { // Против Альмагест (PvP)
// Триггер: Елена использует СВОЮ способность
selfCastAbility: {
[GAME_CONFIG.ABILITY_ID_HEAL]: [ "Я исцеляюсь Светом, который ты отвергла.", "Жизнь восторжествует над твоей некромантией!", "Мое сияние не померкнет." ],
[GAME_CONFIG.ABILITY_ID_FIREBALL]: [ "Очищающий огонь для твоей тьмы!", "Почувствуй гнев праведного Света!", "Это пламя ярче твоих теней!" ],
[GAME_CONFIG.ABILITY_ID_NATURE_STRENGTH]: [ "Природа дает мне силу, а тебе - лишь презрение.", "Я черпаю из источника жизни, ты - из могилы." ],
[GAME_CONFIG.ABILITY_ID_DEFENSE_AURA]: [ "Мой щит отразит твою злобу.", "Свет - лучшая защита.", "Твои темные чары не пройдут!" ],
[GAME_CONFIG.ABILITY_ID_HYPNOTIC_GAZE]: [ "Смотри в глаза Истине, колдунья!", "Твои лживые речи умолкнут!", "Хватит прятаться за иллюзиями!" ],
[GAME_CONFIG.ABILITY_ID_SEAL_OF_WEAKNESS]: [ "Твоя темная сила иссякнет!", "Я ослабляю твою связь с бездной!", "Почувствуй, как тает твоя энергия!" ]
},
// Триггер: Противник (Альмагест) совершает действие
onOpponentAction: {
[GAME_CONFIG.ABILITY_ID_ALMAGEST_HEAL]: [ "Лечишь раны тьмой? Она лишь глубже проникнет в тебя.", "Твоя магия несет лишь порчу, даже исцеляя." ],
[GAME_CONFIG.ABILITY_ID_ALMAGEST_DAMAGE]: [ "Твоя тень лишь царапает, не ранит.", "Слабый удар! Тьма делает тебя немощной." ],
[GAME_CONFIG.ABILITY_ID_ALMAGEST_BUFF_ATTACK]: [ "Черпаешь силы из бездны? Она поглотит и тебя.", "Твое усиление - лишь агония искаженной энергии." ],
[GAME_CONFIG.ABILITY_ID_ALMAGEST_BUFF_DEFENSE]: [ "Щит из теней? Он рассыпется прахом!", "Твоя защита иллюзорна, как и твоя сила." ],
[GAME_CONFIG.ABILITY_ID_ALMAGEST_DISABLE]: [ "(Сдавленно) Твои ментальные атаки отвратительны!", "Тьма в моей голове... я вырвусь!" ], // Если Елена попадает под Раскол Разума Альмагест
[GAME_CONFIG.ABILITY_ID_ALMAGEST_DEBUFF]: [ "Истощаешь мою силу? Я восстановлю ее Светом!", "Твое проклятие слабо." ], // Если Елена попадает под Проклятие Увядания Альмагест
attackBlocked: [ "Твоя атака разбилась о мой щит Света!", "Предсказуемо и слабо, Альмагест." ], // При блоке атаки Альмагест
attackHits: [ "(Резкий вздох) Коснулась... Но Свет исцелит рану.", "Эта царапина - ничто!", "Ты заплатишь за это!" ] // При попадании атаки Альмагест
},
// Триггер: Базовая атака Елены (PvP)
basicAttack: {
general: [ "Тьма не победит, Альмагест!", "Твои иллюзии рассеются перед Светом!", "Пока я стою, порядок будет восстановлен!" ]
},
// Триггер: Изменение состояния боя
onBattleState: {
start: [ "Альмагест! Твоим темным делам пришел конец!", "Во имя Света, я остановлю тебя!", "Приготовься к битве, служительница тьмы!" ], // Начало PvP боя с Альмагест
opponentNearDefeat: [ "Твоя тьма иссякает, колдунья!", "Сдавайся, пока Свет не испепелил тебя!", "Конец твоим злодеяниям близок!" ] // Альмагест почти побеждена
}
}
},
almagest: { // Насмешки Альмагест
elena: { // Против Елены (PvP)
// Триггер: Альмагест использует СВОЮ способность
selfCastAbility: {
[GAME_CONFIG.ABILITY_ID_ALMAGEST_HEAL]: [ "Я питаюсь слабостью, Елена!", "Тьма дает мне силу!" ],
[GAME_CONFIG.ABILITY_ID_ALMAGEST_DAMAGE]: [ "Почувствуй холод бездны!", "Твой Свет померкнет перед моей тенью!" ],
[GAME_CONFIG.ABILITY_ID_ALMAGEST_BUFF_ATTACK]: [ "Силы Бездны со мной!", "Моя тень становится гуще!" ],
[GAME_CONFIG.ABILITY_ID_ALMAGEST_BUFF_DEFENSE]: [ "Мой щит выкован из самой тьмы!", "Попробуй пробить это, служительница Света!" ],
[GAME_CONFIG.ABILITY_ID_ALMAGEST_DISABLE]: [ "Твой разум сломлен!", "Умолкни, Светлая!", "Я владею твоими мыслями!" ],
[GAME_CONFIG.ABILITY_ID_ALMAGEST_DEBUFF]: [ "Твоя сила тает!", "Почувствуй гниль!", "Я истощаю твой Свет!" ]
},
// Триггер: Противник (Елена) совершает действие
onOpponentAction: {
[GAME_CONFIG.ABILITY_ID_HEAL]: [ "Исцеляешься? Твои раны слишком глубоки!" ],
[GAME_CONFIG.ABILITY_ID_FIREBALL]: [ "Жалкое пламя! Мои тени поглотят его!" ],
[GAME_CONFIG.ABILITY_ID_NATURE_STRENGTH]: [ "Сила земли? Смешно! Бездну ничто не остановит." ],
[GAME_CONFIG.ABILITY_ID_DEFENSE_AURA]: [ "Твой щит из Света не спасет тебя от Тьмы!" ],
[GAME_CONFIG.ABILITY_ID_HYPNOTIC_GAZE]: [ "(Сдавленно, затем смех) Попытка управлять моим разумом? Жалко!", "Ты пытаешься заглянуть в Бездну?!" ], // Если Альмагест попадает под Гипнотический взгляд Елены
[GAME_CONFIG.ABILITY_ID_SEAL_OF_WEAKNESS]: [ "Моя энергия вечна, дура!", "Это лишь раздражение!" ], // Если Альмагест попадает под Печать Слабости Елены
attackBlocked: [ "Твой блок не спасет тебя вечно, Елена!", "Это лишь задержка." ], // При блоке атаки Елены
attackHits: [ "Ха! Чувствуешь силу Тьмы?", "Это только начало!", "Слабость!" ] // При попадании атаки Елены
},
// Триггер: Базовая атака Альмагест
basicAttack: {
general: [ "Почувствуй мою силу!", "Тени атакуют!", "Я наношу удар!" ]
},
// Триггер: Изменение состояния боя
onBattleState: {
start: [ "Тысяча лет в заточении лишь усилили меня, Елена!", "Твой Свет скоро погаснет!", "Пора положить конец твоему господству!" ], // Начало PvP боя с Еленой
opponentNearDefeat: [ "Твой Свет гаснет!", "Ты побеждена!", "Бездне нужен твой дух!" ] // Елена почти побеждена
}
}
}
};
// --- Экспорт Данных ---
const gameData = {
// Базовые статы
playerBaseStats,
opponentBaseStats, // Балард
almagestBaseStats, // Альмагест
// Способности
playerAbilities, // Елена
opponentAbilities, // Балард
almagestAbilities, // Альмагест
// Система насмешек (с разделением по персонажам и противникам)
tauntSystem // Переименовали для лучшей структуры
};
// --- Вспомогательные функции для использования ВНУТРИ data.js или модулей, которые его используют ---
// Эти функции НЕ являются частью экспортируемого объекта gameData,
// но могут быть вызваны внутри этого файла, например, в descriptionFunction
// Или их можно было бы экспортировать отдельно, если они нужны другим модулям, не имеющим gameData в аргументах.
// Но в текущей структуре gameLogic они не нужны, так как gameLogic получает gameData и имеет свои локальные хелперы.
// function _getCharacterData(key) {
// if (!key) return null;
// switch (key) {
// case 'elena': return { baseStats: playerBaseStats, abilities: playerAbilities };
// case 'balard': return { baseStats: opponentBaseStats, abilities: opponentAbilities };
// case 'almagest': return { baseStats: almagestBaseStats, abilities: almagestAbilities };
// default: console.error(`data.js::_getCharacterData: Unknown character key "${key}"`); return null;
// }
// }
// function _getCharacterBaseData(key) {
// const charData = _getCharacterData(key);
// return charData ? charData.baseStats : null;
// }
// function _getCharacterAbilities(key) {
// const charData = _getCharacterData(key);
// return charData ? charData.abilities : null;
// }
if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
module.exports = gameData;
}
// console.log("data.js загружен и gameData объект создан/экспортирован.");

92
server_modules/db.js
View File

@ -1,92 +0,0 @@
// /server_modules/db.js
const mysql = require('mysql2'); // Используем mysql2 для поддержки промисов и улучшенной производительности
// Конфигурация подключения к вашей базе данных MySQL
// ЗАМЕНИТЕ значения на ваши реальные данные!
const dbConfig = {
host: 'localhost', // или IP-адрес вашего MySQL сервера
user: 'phpmyadmin', // Имя пользователя MySQL (например, 'root' для локальной разработки)
password: 'Innamorato8Art', // Пароль пользователя MySQL (убедитесь, что он правильный)
database: 'your_game_db', // Имя вашей базы данных (например, 'your_game_db')
port: 3306, // Стандартный порт MySQL, измените если у вас другой
waitForConnections: true, // Ожидать доступного соединения, если все заняты
connectionLimit: 10, // Максимальное количество соединений в пуле
queueLimit: 0 // Максимальное количество запросов в очереди (0 = безлимитно)
};
// Создаем пул соединений. Пул более эффективен для веб-приложений,
// чем создание нового соединения для каждого запроса.
let pool;
try {
pool = mysql.createPool(dbConfig);
} catch (error) {
console.error('[DB FATAL] Не удалось создать пул соединений MySQL. Проверьте конфигурацию `dbConfig`. Ошибка:', error);
// Если пул не создался, дальнейшая работа с БД невозможна.
// Можно завершить приложение или попытаться пересоздать пул позже.
// Для простоты, мы просто выведем ошибку. Приложение, скорее всего, упадет при попытке использовать `pool`.
// В реальном приложении здесь нужна более надежная обработка.
process.exit(1); // Завершаем приложение, так как без БД оно не сможет работать
}
// Обертка для выполнения запросов с использованием промисов из пула
// Мы экспортируем именно эту обертку.
const promisePool = pool.promise();
// Проверка соединения (опционально, но полезно для отладки при запуске)
// Делаем это после экспорта, чтобы модуль мог быть загружен даже если проверка упадет,
// хотя в данном случае мы завершаем процесс, если пул не создался.
if (promisePool) { // Проверяем, что promisePool был успешно создан
promisePool.getConnection()
.then(connection => {
console.log('[DB] Успешно подключено к базе данных MySQL и получено соединение из пула.');
connection.release(); // Важно!!! Возвращаем соединение в пул
console.log('[DB] Соединение возвращено в пул.');
})
.catch(err => {
console.error('[DB] Ошибка при попытке получить соединение из пула или при подключении к MySQL:', err.message);
console.error('[DB] Полные детали ошибки:', err); // Выводим полный объект ошибки для диагностики
if (err.code === 'PROTOCOL_CONNECTION_LOST') {
console.error('[DB] Соединение с БД было потеряно.');
} else if (err.code === 'ER_CON_COUNT_ERROR') {
console.error('[DB] В БД слишком много соединений.');
} else if (err.code === 'ECONNREFUSED') {
console.error('[DB] Соединение с БД было отклонено. Убедитесь, что сервер MySQL запущен и доступен по указанному хосту и порту.');
} else if (err.code === 'ER_ACCESS_DENIED_ERROR') {
console.error(`[DB] Доступ к БД запрещен для пользователя '${dbConfig.user}'. Проверьте имя пользователя и пароль в db.js.`);
} else if (err.code === 'ER_BAD_DB_ERROR') {
console.error(`[DB] База данных "${dbConfig.database}" не найдена. Убедитесь, что она создана.`);
} else {
console.error(`[DB] Неизвестная ошибка подключения к MySQL. Код: ${err.code}`);
}
// В продакшене здесь может быть логика переподключения или более изящного завершения работы.
// Для отладки сейчас важно видеть эти ошибки.
// process.exit(1); // Можно раскомментировать, если хотите жестко падать при ошибке подключения
});
} else {
console.error('[DB FATAL] promisePool не был создан. Проверьте создание `pool`.');
}
// Экспортируем пул с промисами, чтобы его можно было использовать в других модулях (например, в auth.js)
module.exports = promisePool;
/*
Пример использования в другом файле (например, auth.js):
const db = require('./db'); // db здесь будет promisePool
async function getUser(username) {
if (!db) { // Дополнительная проверка на случай, если db не экспортировался
console.error("DB модуль не загружен или не экспортировал promisePool!");
throw new Error("DB connection is not available.");
}
try {
const [rows, fields] = await db.query('SELECT * FROM users WHERE username = ?', [username]);
return rows[0]; // Возвращаем первого найденного пользователя или undefined
} catch (error) {
console.error("Ошибка при получении пользователя:", error);
throw error; // или обработать ошибку иначе
}
}
*/

788
server_modules/gameInstance.js
View File

@ -1,788 +0,0 @@
// /server_modules/gameInstance.js
const { v4: uuidv4 } = require('uuid');
const gameData = require('./data');
const GAME_CONFIG = require('./config');
const serverGameLogic = require('./gameLogic');
class GameInstance {
constructor(gameId, io, mode = 'ai', gameManager) {
this.id = gameId;
this.io = io;
this.mode = mode;
this.players = {}; // { socket.id: { id: 'player'/'opponent', socket: socketObject, chosenCharacterKey?: 'elena'/'almagest', identifier: userId|socketId } }
this.playerSockets = {}; // { 'player': socketObject, 'opponent': socketObject }
this.playerCount = 0;
this.gameState = null;
this.aiOpponent = (mode === 'ai');
this.logBuffer = [];
this.playerCharacterKey = null;
this.opponentCharacterKey = null;
this.ownerIdentifier = null;
this.gameManager = gameManager;
// --- Свойства для таймера хода ---
this.turnTimerId = null; // ID для setTimeout (обработка таймаута)
this.turnTimerUpdateIntervalId = null; // ID для setInterval (обновление клиента)
this.turnStartTime = 0; // Время начала текущего хода (Date.now())
if (!this.gameManager || typeof this.gameManager._cleanupGame !== 'function') {
console.error(`[Game ${this.id}] CRITICAL ERROR: GameInstance created without valid GameManager reference! Cleanup will fail.`);
}
}
addPlayer(socket, chosenCharacterKey = 'elena', identifier) {
if (this.players[socket.id]) {
socket.emit('gameError', { message: 'Ваш сокет уже зарегистрирован в этой игре.' });
return false;
}
const existingPlayerByIdentifier = Object.values(this.players).find(p => p.identifier === identifier);
if (existingPlayerByIdentifier) {
socket.emit('gameError', { message: 'Вы уже находитесь в этой игре под другим подключением.' });
return false;
}
if (this.playerCount >= 2) {
socket.emit('gameError', { message: 'Эта игра уже заполнена.' });
return false;
}
let assignedPlayerId;
let actualCharacterKey;
if (this.mode === 'ai') {
if (this.playerCount > 0) {
socket.emit('gameError', { message: 'Нельзя присоединиться к AI игре как второй игрок.' });
return false;
}
assignedPlayerId = GAME_CONFIG.PLAYER_ID;
actualCharacterKey = 'elena'; // В AI режиме игрок всегда Елена
this.ownerIdentifier = identifier;
} else { // PvP режим
if (this.playerCount === 0) {
assignedPlayerId = GAME_CONFIG.PLAYER_ID;
actualCharacterKey = (chosenCharacterKey === 'almagest') ? 'almagest' : 'elena';
this.ownerIdentifier = identifier;
} else {
assignedPlayerId = GAME_CONFIG.OPPONENT_ID;
const firstPlayerInfo = Object.values(this.players).find(p => p.id === GAME_CONFIG.PLAYER_ID);
actualCharacterKey = (firstPlayerInfo?.chosenCharacterKey === 'elena') ? 'almagest' : 'elena';
}
}
this.players[socket.id] = {
id: assignedPlayerId,
socket: socket,
chosenCharacterKey: actualCharacterKey,
identifier: identifier
};
this.playerSockets[assignedPlayerId] = socket;
this.playerCount++;
socket.join(this.id);
const characterData = this._getCharacterBaseData(actualCharacterKey);
console.log(`[Game ${this.id}] Игрок ${identifier} (сокет ${socket.id}) (${characterData?.name || 'Неизвестно'}) присоединился как ${assignedPlayerId} (персонаж: ${actualCharacterKey}). Всего игроков: ${this.playerCount}. Owner: ${this.ownerIdentifier || 'N/A'}`);
return true;
}
removePlayer(socketId) {
const playerInfo = this.players[socketId];
if (playerInfo) {
const playerRole = playerInfo.id;
const identifierOfLeavingPlayer = playerInfo.identifier;
const characterKeyOfLeavingPlayer = playerInfo.chosenCharacterKey;
const characterData = this._getCharacterBaseData(characterKeyOfLeavingPlayer);
console.log(`[Game ${this.id}] Игрок ${identifierOfLeavingPlayer} (сокет: ${socketId}, роль: ${playerRole}, персонаж: ${characterKeyOfLeavingPlayer || 'N/A'}) покинул игру.`);
if (playerInfo.socket) {
const actualSocket = this.io.sockets.sockets.get(socketId);
if (actualSocket && actualSocket.id === socketId) {
actualSocket.leave(this.id);
} else if (playerInfo.socket.id === socketId) {
try { playerInfo.socket.leave(this.id); } catch (e) { console.warn(`[Game ${this.id}] Error leaving room for old socket ${socketId}: ${e.message}`); }
}
}
delete this.players[socketId];
this.playerCount--;
if (this.playerSockets[playerRole] && this.playerSockets[playerRole].id === socketId) {
delete this.playerSockets[playerRole];
}
// Если игра не окончена и это был ход отключившегося игрока, очищаем таймер
if (this.gameState && !this.gameState.isGameOver) {
const isTurnOfDisconnectedPlayer = (this.gameState.isPlayerTurn && playerRole === GAME_CONFIG.PLAYER_ID) ||
(!this.gameState.isPlayerTurn && playerRole === GAME_CONFIG.OPPONENT_ID);
if (isTurnOfDisconnectedPlayer) {
this.clearTurnTimer();
}
}
} else {
console.warn(`[Game ${this.id}] removePlayer called for unknown socketId ${socketId}.`);
}
}
initializeGame() {
console.log(`[Game ${this.id}] Initializing game state. Mode: ${this.mode}. Current PlayerCount: ${this.playerCount}.`);
if (this.mode === 'ai' && this.playerCount === 1) {
this.playerCharacterKey = 'elena';
this.opponentCharacterKey = 'balard';
} else if (this.mode === 'pvp' && this.playerCount === 2) {
const player1Info = Object.values(this.players).find(p => p.id === GAME_CONFIG.PLAYER_ID);
const player2Info = Object.values(this.players).find(p => p.id === GAME_CONFIG.OPPONENT_ID);
this.playerCharacterKey = player1Info?.chosenCharacterKey || 'elena';
const expectedOpponentKey = (this.playerCharacterKey === 'elena') ? 'almagest' : 'elena';
if (player2Info && player2Info.chosenCharacterKey !== expectedOpponentKey) {
console.warn(`[Game ${this.id}] initializeGame: Expected opponent character ${expectedOpponentKey} but player2Info had ${player2Info.chosenCharacterKey}.`);
}
this.opponentCharacterKey = expectedOpponentKey;
} else if (this.mode === 'pvp' && this.playerCount === 1) {
const player1Info = Object.values(this.players).find(p => p.id === GAME_CONFIG.PLAYER_ID);
this.playerCharacterKey = player1Info?.chosenCharacterKey || 'elena';
this.opponentCharacterKey = null;
} else {
console.error(`[Game ${this.id}] Unexpected state for initialization! Mode: ${this.mode}, PlayerCount: ${this.playerCount}. Cannot initialize gameState.`);
this.gameState = null;
return false;
}
console.log(`[Game ${this.id}] Finalizing characters for gameState - Player Slot ('${GAME_CONFIG.PLAYER_ID}'): ${this.playerCharacterKey}, Opponent Slot ('${GAME_CONFIG.OPPONENT_ID}'): ${this.opponentCharacterKey || 'N/A (Waiting)'}`);
const playerBase = this._getCharacterBaseData(this.playerCharacterKey);
const playerAbilities = this._getCharacterAbilities(this.playerCharacterKey);
let opponentBase = null;
let opponentAbilities = null;
const isOpponentDefined = !!this.opponentCharacterKey;
if (isOpponentDefined) {
opponentBase = this._getCharacterBaseData(this.opponentCharacterKey);
opponentAbilities = this._getCharacterAbilities(this.opponentCharacterKey);
}
if (!playerBase || !playerAbilities || (isOpponentDefined && (!opponentBase || !opponentAbilities))) {
const errorMsg = `[Game ${this.id}] CRITICAL ERROR: initializeGame - Failed to load character data! PlayerKey: ${this.playerCharacterKey}, OpponentKey: ${this.opponentCharacterKey}.`;
console.error(errorMsg);
this.logBuffer = [];
this.addToLog('Критическая ошибка сервера при инициализации персонажей!', GAME_CONFIG.LOG_TYPE_SYSTEM);
Object.values(this.players).forEach(p => p.socket.emit('gameError', { message: 'Критическая ошибка сервера: не удалось загрузить данные персонажей.' }));
this.gameState = null;
return false;
}
if (isOpponentDefined && (!opponentBase.maxHp || opponentBase.maxHp <= 0)) {
console.error(`[Game ${this.id}] CRITICAL ERROR: initializeGame - Opponent has invalid maxHp (${opponentBase.maxHp}) for key ${this.opponentCharacterKey}.`);
this.logBuffer = [];
this.addToLog('Критическая ошибка сервера: некорректные данные оппонента!', GAME_CONFIG.LOG_TYPE_SYSTEM);
Object.values(this.players).forEach(p => p.socket.emit('gameError', { message: 'Критическая ошибка сервера: некорректные данные персонажа оппонента.' }));
this.gameState = null;
return false;
}
this.gameState = {
player: {
id: GAME_CONFIG.PLAYER_ID, characterKey: this.playerCharacterKey, name: playerBase.name,
currentHp: playerBase.maxHp, maxHp: playerBase.maxHp,
currentResource: playerBase.maxResource, maxResource: playerBase.maxResource,
resourceName: playerBase.resourceName, attackPower: playerBase.attackPower,
isBlocking: false, activeEffects: [], disabledAbilities: [], abilityCooldowns: {}
},
opponent: {
id: GAME_CONFIG.OPPONENT_ID, characterKey: this.opponentCharacterKey,
name: opponentBase?.name || 'Ожидание игрока...',
currentHp: opponentBase?.maxHp || 1, maxHp: opponentBase?.maxHp || 1,
currentResource: opponentBase?.maxResource || 0, maxResource: opponentBase?.maxResource || 0,
resourceName: opponentBase?.resourceName || 'Ресурс', attackPower: opponentBase?.attackPower || 0,
isBlocking: false, activeEffects: [], disabledAbilities: [], abilityCooldowns: {},
silenceCooldownTurns: (this.opponentCharacterKey === 'balard') ? 0 : undefined,
manaDrainCooldownTurns: (this.opponentCharacterKey === 'balard') ? 0 : undefined,
},
isPlayerTurn: isOpponentDefined ? Math.random() < 0.5 : true,
isGameOver: false,
turnNumber: 1,
gameMode: this.mode
};
if (playerAbilities) {
playerAbilities.forEach(ability => {
if (typeof ability.cooldown === 'number' && ability.cooldown >= 0) {
this.gameState.player.abilityCooldowns[ability.id] = 0;
}
});
}
if (isOpponentDefined && opponentAbilities) {
opponentAbilities.forEach(ability => {
let cd = 0;
if (typeof ability.cooldown === 'number' && ability.cooldown >= 0) cd = ability.cooldown;
if (this.opponentCharacterKey === 'balard') {
if (ability.id === GAME_CONFIG.ABILITY_ID_BALARD_SILENCE && typeof GAME_CONFIG.BALARD_SILENCE_INTERNAL_COOLDOWN === 'number') cd = GAME_CONFIG.BALARD_SILENCE_INTERNAL_COOLDOWN;
else if (ability.id === GAME_CONFIG.ABILITY_ID_BALARD_MANA_DRAIN && typeof ability.internalCooldownValue === 'number') cd = ability.internalCooldownValue;
}
if (cd > 0) this.gameState.opponent.abilityCooldowns[ability.id] = 0;
});
}
if (isOpponentDefined) {
const isRestart = this.logBuffer.length > 0;
this.logBuffer = [];
this.addToLog(isRestart ? '⚔️ Игра перезапущена! ⚔️' : '⚔️ Новая битва начинается! ⚔️', GAME_CONFIG.LOG_TYPE_SYSTEM);
const playerCharKey = this.gameState.player.characterKey;
if (playerCharKey === 'elena' || playerCharKey === 'almagest') {
const startTaunt = serverGameLogic.getRandomTaunt(playerCharKey, 'battleStart', {}, GAME_CONFIG, gameData, this.gameState);
if (startTaunt !== "(Молчание)") this.addToLog(`${this.gameState.player.name}: "${startTaunt}"`, GAME_CONFIG.LOG_TYPE_INFO);
}
}
console.log(`[Game ${this.id}] Game state initialized. isGameOver: ${this.gameState?.isGameOver}. First turn (if ready): ${this.gameState?.isPlayerTurn ? this.gameState?.player?.name : (this.gameState?.opponent?.name || 'Оппонент')}. Opponent Defined (Ready for Start): ${isOpponentDefined}`);
return isOpponentDefined;
}
startGame() {
if (!this.gameState || !this.gameState.player || !this.gameState.opponent || !this.opponentCharacterKey || this.gameState.opponent.name === 'Ожидание игрока...' || !this.gameState.opponent.maxHp || this.gameState.opponent.maxHp <= 0) {
console.error(`[Game ${this.id}] startGame: Game state is not fully ready for start. Aborting.`);
return;
}
if (this.playerCount === 0 || (this.mode === 'pvp' && this.playerCount === 1)) {
console.warn(`[Game ${this.id}] startGame called with insufficient players (${this.playerCount}). Mode: ${this.mode}. Aborting start.`);
return;
}
console.log(`[Game ${this.id}] Starting game. Broadcasting 'gameStarted' to players. isGameOver: ${this.gameState.isGameOver}`);
const playerCharDataForSlotPlayer = this._getCharacterData(this.playerCharacterKey);
const opponentCharDataForSlotOpponent = this._getCharacterData(this.opponentCharacterKey);
if (!playerCharDataForSlotPlayer || !opponentCharDataForSlotOpponent) {
console.error(`[Game ${this.id}] CRITICAL ERROR: startGame - Failed to load character data! PlayerKey: ${this.playerCharacterKey}, OpponentKey: ${this.opponentCharacterKey}`);
this.io.to(this.id).emit('gameError', { message: 'Критическая ошибка сервера при старте игры (не удалось загрузить данные персонажей).' });
if (this.gameManager && typeof this.gameManager._cleanupGame === 'function') {
this.gameManager._cleanupGame(this.id, 'start_data_load_failed');
}
return;
}
Object.values(this.players).forEach(playerInfo => {
if (playerInfo.socket && playerInfo.socket.connected) {
let dataForThisClient;
if (playerInfo.id === GAME_CONFIG.PLAYER_ID) {
dataForThisClient = {
gameId: this.id, yourPlayerId: playerInfo.id, initialGameState: this.gameState,
playerBaseStats: playerCharDataForSlotPlayer.baseStats, opponentBaseStats: opponentCharDataForSlotOpponent.baseStats,
playerAbilities: playerCharDataForSlotPlayer.abilities, opponentAbilities: opponentCharDataForSlotOpponent.abilities,
log: this.consumeLogBuffer(), clientConfig: { ...GAME_CONFIG }
};
} else {
dataForThisClient = {
gameId: this.id, yourPlayerId: playerInfo.id, initialGameState: this.gameState,
playerBaseStats: opponentCharDataForSlotOpponent.baseStats, opponentBaseStats: playerCharDataForSlotPlayer.baseStats,
playerAbilities: opponentCharDataForSlotOpponent.abilities, opponentAbilities: playerCharDataForSlotPlayer.abilities,
log: this.consumeLogBuffer(), clientConfig: { ...GAME_CONFIG }
};
}
playerInfo.socket.emit('gameStarted', dataForThisClient);
console.log(`[Game ${this.id}] Sent gameStarted to ${playerInfo.identifier} (socket ${playerInfo.socket.id}).`);
} else {
console.warn(`[Game ${this.id}] Player ${playerInfo.identifier} (socket ${playerInfo.socket?.id}) is disconnected. Cannot send gameStarted.`);
}
});
const firstTurnActorState = this.gameState.isPlayerTurn ? this.gameState.player : this.gameState.opponent;
this.addToLog(`--- Начинается ход ${this.gameState.turnNumber} для: ${firstTurnActorState.name} ---`, GAME_CONFIG.LOG_TYPE_TURN);
this.broadcastLogUpdate(); // Отправляем лог с сообщением о начале хода
this.startTurnTimer(); // Запускаем таймер для первого хода
if (!this.gameState.isPlayerTurn && this.aiOpponent && this.opponentCharacterKey === 'balard') {
console.log(`[Game ${this.id}] AI (Балард) ходит первым. Запускаем AI turn.`);
setTimeout(() => this.processAiTurn(), GAME_CONFIG.DELAY_OPPONENT_TURN || 1200);
} else {
console.log(`[Game ${this.id}] Ход реального игрока ${firstTurnActorState.name} (роль: ${firstTurnActorState.id}).`);
}
}
processPlayerAction(requestingSocketId, actionData) {
if (!this.gameState || this.gameState.isGameOver) {
const playerSocket = this.io.sockets.sockets.get(requestingSocketId);
if (playerSocket) playerSocket.emit('gameError', { message: 'Игра уже завершена или неактивна.' });
return;
}
const actingPlayerInfo = this.players[requestingSocketId];
if (!actingPlayerInfo) {
console.error(`[Game ${this.id}] Action from socket ${requestingSocketId} not found in players map.`);
const playerSocket = this.io.sockets.sockets.get(requestingSocketId);
if (playerSocket && playerSocket.connected) playerSocket.disconnect(true);
return;
}
const actingPlayerRole = actingPlayerInfo.id;
const isCorrectTurn = (this.gameState.isPlayerTurn && actingPlayerRole === GAME_CONFIG.PLAYER_ID) ||
(!this.gameState.isPlayerTurn && actingPlayerRole === GAME_CONFIG.OPPONENT_ID);
if (!isCorrectTurn) {
console.warn(`[Game ${this.id}] Action from ${actingPlayerInfo.identifier} (socket ${requestingSocketId}): Not their turn.`);
return; // Игнорируем действие, таймер хода не сбрасывается и не перезапускается
}
// Игрок сделал ход, очищаем таймер
this.clearTurnTimer();
const attackerState = this.gameState[actingPlayerRole];
const defenderRole = actingPlayerRole === GAME_CONFIG.PLAYER_ID ? GAME_CONFIG.OPPONENT_ID : GAME_CONFIG.PLAYER_ID;
const defenderState = this.gameState[defenderRole];
const attackerData = this._getCharacterData(attackerState.characterKey);
const defenderData = this._getCharacterData(defenderState.characterKey);
if (!attackerData || !defenderData) {
console.error(`[Game ${this.id}] CRITICAL ERROR: processPlayerAction - Failed to load character data! AttackerKey: ${attackerState.characterKey}, DefenderKey: ${defenderState.characterKey}`);
this.addToLog('Критическая ошибка сервера при обработке действия (не найдены данные персонажа)!', GAME_CONFIG.LOG_TYPE_SYSTEM);
this.broadcastLogUpdate();
if (this.gameManager && typeof this.gameManager._cleanupGame === 'function') {
this.gameManager._cleanupGame(this.id, 'action_data_load_failed');
}
return;
}
let actionValid = true;
if (actionData.actionType === 'attack') {
const taunt = serverGameLogic.getRandomTaunt(attackerState.characterKey, 'basicAttack', {}, GAME_CONFIG, gameData, this.gameState);
if (taunt !== "(Молчание)") this.addToLog(`${attackerState.name}: "${taunt}"`, GAME_CONFIG.LOG_TYPE_INFO);
serverGameLogic.performAttack(attackerState, defenderState, attackerData.baseStats, defenderData.baseStats, this.gameState, this.addToLog.bind(this), GAME_CONFIG, gameData);
const delayedAttackBuffEffect = attackerState.activeEffects.find(eff => eff.isDelayed && (eff.id === GAME_CONFIG.ABILITY_ID_NATURE_STRENGTH || eff.id === GAME_CONFIG.ABILITY_ID_ALMAGEST_BUFF_ATTACK));
if (delayedAttackBuffEffect && !delayedAttackBuffEffect.justCast) {
const actualRegen = Math.min(GAME_CONFIG.NATURE_STRENGTH_MANA_REGEN, attackerData.baseStats.maxResource - attackerState.currentResource);
if (actualRegen > 0) {
attackerState.currentResource = Math.round(attackerState.currentResource + actualRegen);
this.addToLog(`🌿 ${attackerState.name} восстанавливает ${actualRegen} ${attackerState.resourceName} от эффекта "${delayedAttackBuffEffect.name}"!`, GAME_CONFIG.LOG_TYPE_HEAL);
}
}
} else if (actionData.actionType === 'ability' && actionData.abilityId) {
const ability = attackerData.abilities.find(ab => ab.id === actionData.abilityId);
if (!ability) {
actingPlayerInfo.socket.emit('gameError', { message: "Неизвестная способность." });
console.warn(`[Game ${this.id}] Игрок ${actingPlayerInfo.identifier} (сокет ${requestingSocketId}) попытался использовать неизвестную способность ID: ${actionData.abilityId}.`);
this.startTurnTimer(); // Перезапускаем таймер, так как ход не был совершен
return;
}
const hasEnoughResource = attackerState.currentResource >= ability.cost;
const isOnCooldown = (attackerState.abilityCooldowns?.[ability.id] || 0) > 0;
const isCasterFullySilenced = attackerState.activeEffects.some(eff => eff.isFullSilence && eff.turnsLeft > 0);
const isAbilitySpecificallySilenced = attackerState.disabledAbilities?.some(dis => dis.abilityId === ability.id && dis.turnsLeft > 0);
const isSilenced = isCasterFullySilenced || isAbilitySpecificallySilenced;
let isOnSpecialCooldown = false;
if (attackerState.characterKey === 'balard') {
if (ability.id === GAME_CONFIG.ABILITY_ID_BALARD_SILENCE && attackerState.silenceCooldownTurns !== undefined && attackerState.silenceCooldownTurns > 0) isOnSpecialCooldown = true;
if (ability.id === GAME_CONFIG.ABILITY_ID_BALARD_MANA_DRAIN && attackerState.manaDrainCooldownTurns !== undefined && attackerState.manaDrainCooldownTurns > 0) isOnSpecialCooldown = true;
}
const isBuffAlreadyActive = ability.type === GAME_CONFIG.ACTION_TYPE_BUFF && attackerState.activeEffects.some(e => e.id === ability.id);
const isTargetedDebuff = ability.id === GAME_CONFIG.ABILITY_ID_SEAL_OF_WEAKNESS || ability.id === GAME_CONFIG.ABILITY_ID_ALMAGEST_DEBUFF;
const effectIdForDebuff = 'effect_' + ability.id;
const isDebuffAlreadyOnTarget = isTargetedDebuff && defenderState.activeEffects.some(e => e.id === effectIdForDebuff);
if (!hasEnoughResource) { this.addToLog(`${attackerState.name} пытается применить "${ability.name}", но не хватает ${attackerState.resourceName}!`, GAME_CONFIG.LOG_TYPE_INFO); actionValid = false; }
if (actionValid && (isOnCooldown || isOnSpecialCooldown)) { this.addToLog(`"${ability.name}" еще на перезарядке.`, GAME_CONFIG.LOG_TYPE_INFO); actionValid = false; }
if (actionValid && isSilenced) { this.addToLog(`${attackerState.name} не может использовать способности из-за безмолвия!`, GAME_CONFIG.LOG_TYPE_INFO); actionValid = false; }
if (actionValid && isBuffAlreadyActive) { this.addToLog(`Эффект "${ability.name}" уже активен!`, GAME_CONFIG.LOG_TYPE_INFO); actionValid = false; }
if (actionValid && isDebuffAlreadyOnTarget) { this.addToLog(`Эффект "${ability.name}" уже наложен на ${defenderState.name}!`, GAME_CONFIG.LOG_TYPE_INFO); actionValid = false; }
if (actionValid) {
attackerState.currentResource = Math.round(attackerState.currentResource - ability.cost);
const taunt = serverGameLogic.getRandomTaunt(attackerState.characterKey, 'selfCastAbility', { abilityId: ability.id }, GAME_CONFIG, gameData, this.gameState);
if (taunt !== "(Молчание)") this.addToLog(`${attackerState.name}: "${taunt}"`, GAME_CONFIG.LOG_TYPE_INFO);
serverGameLogic.applyAbilityEffect(ability, attackerState, defenderState, attackerData.baseStats, defenderData.baseStats, this.gameState, this.addToLog.bind(this), GAME_CONFIG, gameData);
let baseCooldown = 0;
if (typeof ability.cooldown === 'number' && ability.cooldown >= 0) baseCooldown = ability.cooldown;
if (attackerState.characterKey === 'balard') {
if (ability.id === GAME_CONFIG.ABILITY_ID_BALARD_SILENCE && typeof GAME_CONFIG.BALARD_SILENCE_INTERNAL_COOLDOWN === 'number') { attackerState.silenceCooldownTurns = GAME_CONFIG.BALARD_SILENCE_INTERNAL_COOLDOWN; baseCooldown = GAME_CONFIG.BALARD_SILENCE_INTERNAL_COOLDOWN; }
else if (ability.id === GAME_CONFIG.ABILITY_ID_BALARD_MANA_DRAIN && typeof ability.internalCooldownValue === 'number') { attackerState.manaDrainCooldownTurns = ability.internalCooldownValue; baseCooldown = ability.internalCooldownValue; }
}
if (baseCooldown > 0 && attackerState.abilityCooldowns) attackerState.abilityCooldowns[ability.id] = baseCooldown + 1;
}
} else {
actingPlayerInfo.socket.emit('gameError', { message: `Неизвестный тип действия: ${actionData?.actionType}` });
console.warn(`[Game ${this.id}] Получен неизвестный тип действия от ${actingPlayerInfo.identifier} (сокет ${requestingSocketId}): ${actionData?.actionType}`);
actionValid = false;
}
if (this.checkGameOver()) {
this.broadcastGameStateUpdate(); // Отправляем финальное состояние, включая лог
// Очистка игры и таймеров происходит в checkGameOver
return;
}
if (actionValid) {
console.log(`[Game ${this.id}] Player action valid. Switching turn in ${GAME_CONFIG.DELAY_AFTER_PLAYER_ACTION || 500}ms.`);
setTimeout(() => { this.switchTurn(); }, GAME_CONFIG.DELAY_AFTER_PLAYER_ACTION || 500);
} else {
// Если действие было невалидным, ход не передается.
// Отправляем лог и перезапускаем таймер для текущего игрока.
console.log(`[Game ${this.id}] Player action invalid. Broadcasting log update and restarting timer for current player.`);
this.broadcastLogUpdate();
this.startTurnTimer(); // Перезапускаем таймер, так как ход не был совершен
}
}
switchTurn() {
if (!this.gameState || this.gameState.isGameOver) return;
// Очищаем таймер предыдущего хода ПЕРЕД обработкой эффектов,
// так как эффекты могут изменить состояние игры и повлиять на следующий запуск таймера.
this.clearTurnTimer();
const endingTurnActorRole = this.gameState.isPlayerTurn ? GAME_CONFIG.PLAYER_ID : GAME_CONFIG.OPPONENT_ID;
const endingTurnActorState = this.gameState[endingTurnActorRole];
const endingTurnCharacterData = this._getCharacterData(endingTurnActorState.characterKey);
if (!endingTurnCharacterData) {
console.error(`[Game ${this.id}] SwitchTurn Error: No character data found for ending turn actor role ${endingTurnActorRole} with key ${endingTurnActorState.characterKey}. Cannot process end-of-turn effects.`);
if (this.gameManager && typeof this.gameManager._cleanupGame === 'function') {
this.gameManager._cleanupGame(this.id, 'switch_turn_data_error');
}
return;
} else {
serverGameLogic.processEffects(endingTurnActorState.activeEffects, endingTurnActorState, endingTurnCharacterData.baseStats, endingTurnActorRole, this.gameState, this.addToLog.bind(this), GAME_CONFIG, gameData);
serverGameLogic.updateBlockingStatus(this.gameState.player);
serverGameLogic.updateBlockingStatus(this.gameState.opponent);
if (endingTurnActorState.abilityCooldowns) serverGameLogic.processPlayerAbilityCooldowns(endingTurnActorState.abilityCooldowns, endingTurnCharacterData.abilities, endingTurnActorState.name, this.addToLog.bind(this));
if (endingTurnActorState.characterKey === 'balard') {
if (endingTurnActorState.silenceCooldownTurns !== undefined && endingTurnActorState.silenceCooldownTurns > 0) endingTurnActorState.silenceCooldownTurns--;
if (endingTurnActorState.manaDrainCooldownTurns !== undefined && endingTurnActorState.manaDrainCooldownTurns > 0) endingTurnActorState.manaDrainCooldownTurns--;
}
if (endingTurnActorState.disabledAbilities?.length > 0) {
const charAbilitiesForDisabledCheck = this._getCharacterAbilities(endingTurnActorState.characterKey);
if (charAbilitiesForDisabledCheck) serverGameLogic.processDisabledAbilities(endingTurnActorState.disabledAbilities, charAbilitiesForDisabledCheck, endingTurnActorState.name, this.addToLog.bind(this));
else console.warn(`[Game ${this.id}] SwitchTurn: Cannot process disabledAbilities for ${endingTurnActorState.name}: character abilities data not found.`);
}
}
if (this.checkGameOver()) {
this.broadcastGameStateUpdate(); // Отправляем финальное состояние, включая лог
// Очистка игры и таймеров происходит в checkGameOver
return;
}
this.gameState.isPlayerTurn = !this.gameState.isPlayerTurn;
if (this.gameState.isPlayerTurn) this.gameState.turnNumber++;
const currentTurnActorState = this.gameState.isPlayerTurn ? this.gameState.player : this.gameState.opponent;
this.addToLog(`--- Начинается ход ${this.gameState.turnNumber} для: ${currentTurnActorState.name} ---`, GAME_CONFIG.LOG_TYPE_TURN);
this.broadcastGameStateUpdate(); // Отправляем обновленное состояние и лог
this.startTurnTimer(); // Запускаем таймер для нового хода
if (!this.gameState.isPlayerTurn && this.aiOpponent && this.opponentCharacterKey === 'balard') {
console.log(`[Game ${this.id}] Ход AI (Балард). Запускаем AI turn.`);
setTimeout(() => this.processAiTurn(), GAME_CONFIG.DELAY_OPPONENT_TURN || 1200);
} else {
console.log(`[Game ${this.id}] Ход реального игрока ${currentTurnActorState.name} (роль: ${currentTurnActorState.id}).`);
}
}
processAiTurn() {
if (!this.gameState || this.gameState.isGameOver || this.gameState.isPlayerTurn || !this.aiOpponent || this.gameState.opponent?.characterKey !== 'balard') {
if (!this.gameState || this.gameState.isGameOver) return;
// Если по какой-то причине сюда попали не во время хода AI, переключаем ход
console.warn(`[Game ${this.id}] processAiTurn called incorrectly. Attempting to switch turn.`);
this.switchTurn(); // Это запустит таймер для игрока, если это его ход
return;
}
// AI не использует таймер, поэтому this.clearTurnTimer() не нужен перед его действием.
// Таймер для игрока был очищен в switchTurn(), когда ход перешел к AI.
const attackerState = this.gameState.opponent;
const defenderState = this.gameState.player;
const attackerData = this._getCharacterData('balard');
const defenderData = this._getCharacterData('elena');
if (!attackerData || !defenderData) {
console.error(`[Game ${this.id}] CRITICAL ERROR: processAiTurn - Failed to load character data!`);
this.addToLog("AI не может действовать: ошибка данных персонажа.", GAME_CONFIG.LOG_TYPE_SYSTEM);
this.broadcastLogUpdate();
if (this.gameManager && typeof this.gameManager._cleanupGame === 'function') {
this.gameManager._cleanupGame(this.id, 'ai_data_load_failed');
}
this.switchTurn(); // Переключаем ход обратно (запустит таймер для игрока)
return;
}
const isBalardFullySilenced = attackerState.activeEffects.some(eff => eff.isFullSilence && eff.turnsLeft > 0);
if (isBalardFullySilenced) {
serverGameLogic.performAttack(attackerState, defenderState, attackerData.baseStats, defenderData.baseStats, this.gameState, this.addToLog.bind(this), GAME_CONFIG, gameData);
if (this.checkGameOver()) { this.broadcastGameStateUpdate(); return; }
console.log(`[Game ${this.id}] AI (Балард) attacked while silenced. Switching turn in ${GAME_CONFIG.DELAY_AFTER_PLAYER_ACTION || 500}ms.`);
setTimeout(() => { this.switchTurn(); }, GAME_CONFIG.DELAY_AFTER_PLAYER_ACTION || 500); // switchTurn запустит таймер для игрока
return;
}
const aiDecision = serverGameLogic.decideAiAction(this.gameState, gameData, GAME_CONFIG, this.addToLog.bind(this));
if (aiDecision.actionType === 'attack') {
serverGameLogic.performAttack(attackerState, defenderState, attackerData.baseStats, defenderData.baseStats, this.gameState, this.addToLog.bind(this), GAME_CONFIG, gameData);
} else if (aiDecision.actionType === 'ability' && aiDecision.ability) {
const ability = aiDecision.ability;
attackerState.currentResource = Math.round(attackerState.currentResource - ability.cost);
serverGameLogic.applyAbilityEffect(ability, attackerState, defenderState, attackerData.baseStats, defenderData.baseStats, this.gameState, this.addToLog.bind(this), GAME_CONFIG, gameData);
let baseCooldown = 0;
if (typeof ability.cooldown === 'number' && ability.cooldown >= 0) baseCooldown = ability.cooldown;
if (ability.id === GAME_CONFIG.ABILITY_ID_BALARD_SILENCE && typeof GAME_CONFIG.BALARD_SILENCE_INTERNAL_COOLDOWN === 'number') { attackerState.silenceCooldownTurns = GAME_CONFIG.BALARD_SILENCE_INTERNAL_COOLDOWN; baseCooldown = GAME_CONFIG.BALARD_SILENCE_INTERNAL_COOLDOWN; }
else if (ability.id === GAME_CONFIG.ABILITY_ID_BALARD_MANA_DRAIN && typeof ability.internalCooldownValue === 'number') { attackerState.manaDrainCooldownTurns = ability.internalCooldownValue; baseCooldown = ability.internalCooldownValue; }
if (baseCooldown > 0 && attackerState.abilityCooldowns) attackerState.abilityCooldowns[ability.id] = baseCooldown + 1;
} else if (aiDecision.actionType === 'pass') {
if (aiDecision.logMessage) this.addToLog(aiDecision.logMessage.message, aiDecision.logMessage.type);
else this.addToLog(`${attackerState.name} обдумывает свой следующий ход...`, GAME_CONFIG.LOG_TYPE_INFO);
} else {
console.error(`[Game ${this.id}] AI (Балард) chose an invalid action type: ${aiDecision.actionType}. Defaulting to pass and logging error.`);
this.addToLog(`AI ${attackerState.name} не смог выбрать действие из-за ошибки. Пропускает ход.`, GAME_CONFIG.LOG_TYPE_INFO);
}
if (this.checkGameOver()) {
this.broadcastGameStateUpdate(); // Отправляем финальное состояние, включая лог
// Очистка игры и таймеров происходит в checkGameOver
return;
}
console.log(`[Game ${this.id}] AI action complete. Switching turn in ${GAME_CONFIG.DELAY_AFTER_PLAYER_ACTION || 500}ms.`);
setTimeout(() => { this.switchTurn(); }, GAME_CONFIG.DELAY_AFTER_PLAYER_ACTION || 500); // switchTurn запустит таймер для игрока
}
checkGameOver() {
if (!this.gameState || this.gameState.isGameOver) return this.gameState ? this.gameState.isGameOver : true;
if (!this.gameState.player || !this.gameState.opponent || this.gameState.opponent.maxHp <= 0) return false;
const isOver = serverGameLogic.checkGameOverInternal(this.gameState, GAME_CONFIG, gameData);
if (isOver && !this.gameState.isGameOver) { // Игра только что завершилась
this.gameState.isGameOver = true;
this.clearTurnTimer(); // Очищаем все таймеры
const playerDead = this.gameState.player?.currentHp <= 0;
const opponentDead = this.gameState.opponent?.currentHp <= 0;
let winnerRole = null; let loserRole = null;
if (this.mode === 'ai') {
winnerRole = playerDead ? null : GAME_CONFIG.PLAYER_ID; // В AI игре AI не "побеждает", побеждает только игрок
loserRole = playerDead ? GAME_CONFIG.PLAYER_ID : GAME_CONFIG.OPPONENT_ID;
} else { // PvP
if (playerDead && opponentDead) { winnerRole = GAME_CONFIG.PLAYER_ID; loserRole = GAME_CONFIG.OPPONENT_ID; } // Ничья - победа игрока 1
else if (playerDead) { winnerRole = GAME_CONFIG.OPPONENT_ID; loserRole = GAME_CONFIG.PLAYER_ID; }
else if (opponentDead) { winnerRole = GAME_CONFIG.PLAYER_ID; loserRole = GAME_CONFIG.OPPONENT_ID; }
else { this.gameState.isGameOver = false; this.startTurnTimer(); return false; } // Ошибка, игра не окончена, перезапускаем таймер
}
const winnerState = this.gameState[winnerRole];
const loserState = this.gameState[loserRole];
const winnerName = winnerState?.name || (winnerRole === GAME_CONFIG.PLAYER_ID ? "Игрок" : "Противник");
const loserName = loserState?.name || (loserRole === GAME_CONFIG.PLAYER_ID ? "Игрок" : "Противник");
const loserCharacterKey = loserState?.characterKey || 'unknown';
if (this.mode === 'ai') {
if (winnerRole === GAME_CONFIG.PLAYER_ID) this.addToLog(`🏁 ПОБЕДА! Вы одолели ${loserName}! 🏁`, GAME_CONFIG.LOG_TYPE_SYSTEM);
else this.addToLog(`😭 ПОРАЖЕНИЕ! ${winnerName} оказался(лась) сильнее! 😭`, GAME_CONFIG.LOG_TYPE_SYSTEM);
} else {
this.addToLog(`🏁 ПОБЕДА! ${winnerName} одолел(а) ${loserName}! 🏁`, GAME_CONFIG.LOG_TYPE_SYSTEM);
}
const winningCharacterKey = winnerState?.characterKey;
if (this.mode === 'ai' && winningCharacterKey === 'elena') {
const taunt = serverGameLogic.getRandomTaunt(winningCharacterKey, 'opponentNearDefeatCheck', {}, GAME_CONFIG, gameData, this.gameState);
if (taunt && taunt !== "(Молчание)") this.addToLog(`${winnerName}: "${taunt}"`, GAME_CONFIG.LOG_TYPE_INFO);
} else if (this.mode === 'pvp' && (winningCharacterKey === 'elena' || winningCharacterKey === 'almagest')) {
const taunt = serverGameLogic.getRandomTaunt(winningCharacterKey, 'opponentNearDefeatCheck', {}, GAME_CONFIG, gameData, this.gameState);
if (taunt && taunt !== "(Молчание)") this.addToLog(`${winnerName}: "${taunt}"`, GAME_CONFIG.LOG_TYPE_INFO);
}
if (loserCharacterKey === 'balard') this.addToLog(`Елена исполнила свой тяжкий долг. ${loserName} развоплощен...`, GAME_CONFIG.LOG_TYPE_SYSTEM);
else if (loserCharacterKey === 'almagest') this.addToLog(`Над полем битвы воцаряется тишина. ${loserName} побежден(а).`, GAME_CONFIG.LOG_TYPE_SYSTEM);
else if (loserCharacterKey === 'elena') this.addToLog(`Свет погас. ${loserName} повержен(а).`, GAME_CONFIG.LOG_TYPE_SYSTEM);
console.log(`[Game ${this.id}] Game is over. Winner: ${winnerName} (${winnerRole}). Loser: ${loserName} (${loserRole}). Reason: HP <= 0.`);
this.io.to(this.id).emit('gameOver', {
winnerId: this.mode === 'ai' ? (winnerRole === GAME_CONFIG.PLAYER_ID ? winnerRole : null) : winnerRole,
reason: 'hp_zero', // Используем стандартизированную причину
finalGameState: this.gameState,
log: this.consumeLogBuffer(),
loserCharacterKey: loserCharacterKey
});
if (this.gameManager && typeof this.gameManager._cleanupGame === 'function') {
this.gameManager._cleanupGame(this.id, 'hp_zero');
}
return true;
}
return isOver;
}
endGameDueToDisconnect(disconnectedSocketId, disconnectedPlayerRole, disconnectedCharacterKey) {
if (this.gameState && !this.gameState.isGameOver) {
this.gameState.isGameOver = true;
this.clearTurnTimer(); // Очищаем все таймеры
const winnerRole = disconnectedPlayerRole === GAME_CONFIG.PLAYER_ID ? GAME_CONFIG.OPPONENT_ID : GAME_CONFIG.PLAYER_ID;
const disconnectedCharacterData = this._getCharacterBaseData(disconnectedCharacterKey);
const winnerCharacterKey = (winnerRole === GAME_CONFIG.PLAYER_ID) ? this.playerCharacterKey : this.opponentCharacterKey;
const winnerCharacterData = this._getCharacterBaseData(winnerCharacterKey);
this.addToLog(`🔌 Игрок ${disconnectedCharacterData?.name || 'Неизвестный'} (${disconnectedPlayerRole}) отключился. Игра завершена.`, GAME_CONFIG.LOG_TYPE_SYSTEM);
if (this.mode === 'pvp') { // Только в PvP присуждаем победу оставшемуся
this.addToLog(`🏁 Победа присуждается ${winnerCharacterData?.name || winnerRole}! 🏁`, GAME_CONFIG.LOG_TYPE_SYSTEM);
} else { // В AI игре, если игрок отключается, AI не "побеждает"
this.addToLog(`Игра завершена досрочно.`, GAME_CONFIG.LOG_TYPE_SYSTEM);
}
this.io.to(this.id).emit('gameOver', {
winnerId: this.mode === 'pvp' ? winnerRole : null, // В AI режиме нет победителя при дисконнекте игрока
reason: 'opponent_disconnected',
finalGameState: this.gameState,
log: this.consumeLogBuffer(),
loserCharacterKey: disconnectedCharacterKey
});
console.log(`[Game ${this.id}] Game ended due to disconnect. Winner (PvP only): ${winnerCharacterData?.name || winnerRole}. Disconnected: ${disconnectedCharacterData?.name || disconnectedPlayerRole}.`);
if (this.gameManager && typeof this.gameManager._cleanupGame === 'function') {
this.gameManager._cleanupGame(this.id, 'opponent_disconnected');
}
}
}
// --- Методы для управления таймером хода ---
startTurnTimer() {
this.clearTurnTimer();
if (!this.gameState || this.gameState.isGameOver) return;
// Определяем, является ли текущий ход ходом реального игрока
let isRealPlayerTurn = false;
if (this.gameState.isPlayerTurn) { // Ход слота 'player'
const playerInSlot = Object.values(this.players).find(p => p.id === GAME_CONFIG.PLAYER_ID);
// Если это AI режим, и в слоте 'player' не Балард (т.е. это человек), то это ход реального игрока
if (this.mode === 'ai' && playerInSlot?.chosenCharacterKey !== 'balard') isRealPlayerTurn = true;
// Если это PvP режим, и в слоте 'player' есть игрок, это ход реального игрока
else if (this.mode === 'pvp' && playerInSlot) isRealPlayerTurn = true;
} else { // Ход слота 'opponent'
const opponentInSlot = Object.values(this.players).find(p => p.id === GAME_CONFIG.OPPONENT_ID);
// Если это AI режим, то в слоте 'opponent' всегда AI, это НЕ ход реального игрока
// Если это PvP режим, и в слоте 'opponent' есть игрок, это ход реального игрока
if (this.mode === 'pvp' && opponentInSlot) isRealPlayerTurn = true;
}
if (!isRealPlayerTurn) { // Если это ход AI или слот пуст
// console.log(`[Game ${this.id}] AI's turn or empty slot. Timer not started for player.`);
// Сообщаем клиентам, что таймер неактивен или это ход AI
// Передаем isPlayerTurn, чтобы клиент знал, чей ход вообще.
// Если isPlayerTurn=true, но isRealPlayerTurn=false (не должно быть, но на всякий),
// то это ошибка, и таймер все равно не стартует.
this.io.to(this.id).emit('turnTimerUpdate', { remainingTime: null, isPlayerTurn: this.gameState.isPlayerTurn });
return;
}
this.turnStartTime = Date.now();
const turnDuration = GAME_CONFIG.TURN_DURATION_MS;
const currentTurnActor = this.gameState.isPlayerTurn ? this.gameState.player : this.gameState.opponent;
console.log(`[Game ${this.id}] Starting turn timer (${turnDuration / 1000}s) for ${currentTurnActor.name}.`);
this.turnTimerId = setTimeout(() => {
this.handleTurnTimeout();
}, turnDuration);
this.turnTimerUpdateIntervalId = setInterval(() => {
if (!this.gameState || this.gameState.isGameOver) {
this.clearTurnTimer();
return;
}
const elapsedTime = Date.now() - this.turnStartTime;
const remainingTime = Math.max(0, turnDuration - elapsedTime);
// Отправляем оставшееся время и чей сейчас ход
this.io.to(this.id).emit('turnTimerUpdate', { remainingTime, isPlayerTurn: this.gameState.isPlayerTurn });
}, GAME_CONFIG.TIMER_UPDATE_INTERVAL_MS);
// Отправляем начальное значение таймера сразу
this.io.to(this.id).emit('turnTimerUpdate', { remainingTime: turnDuration, isPlayerTurn: this.gameState.isPlayerTurn });
}
clearTurnTimer() {
if (this.turnTimerId) {
clearTimeout(this.turnTimerId);
this.turnTimerId = null;
}
if (this.turnTimerUpdateIntervalId) {
clearInterval(this.turnTimerUpdateIntervalId);
this.turnTimerUpdateIntervalId = null;
}
// console.log(`[Game ${this.id}] Turn timer cleared.`);
}
handleTurnTimeout() {
if (!this.gameState || this.gameState.isGameOver) return;
this.clearTurnTimer();
const timedOutPlayerRole = this.gameState.isPlayerTurn ? GAME_CONFIG.PLAYER_ID : GAME_CONFIG.OPPONENT_ID;
const timedOutPlayerState = this.gameState[timedOutPlayerRole];
const winnerPlayerRole = timedOutPlayerRole === GAME_CONFIG.PLAYER_ID ? GAME_CONFIG.OPPONENT_ID : GAME_CONFIG.PLAYER_ID;
const winnerPlayerState = this.gameState[winnerPlayerRole];
// Убедимся, что у победителя есть имя
if (!winnerPlayerState || !winnerPlayerState.name || winnerPlayerState.name === 'Ожидание игрока...') {
// Это может произойти, если игрок выходит из игры PvP, когда он один, и его таймер истекает
// (хотя дисконнект должен был обработать это раньше).
// Или если в AI игре timedOutPlayer был AI (что не должно случаться с текущей логикой таймера).
console.error(`[Game ${this.id}] Turn timeout, but winner state is invalid. Timed out: ${timedOutPlayerState?.name}. Game will be cleaned up.`);
this.gameState.isGameOver = true; // Помечаем как оконченную
this.addToLog(`⏱️ Время хода для ${timedOutPlayerState?.name || 'игрока'} истекло. Игра завершена некорректно.`, GAME_CONFIG.LOG_TYPE_SYSTEM);
this.io.to(this.id).emit('gameOver', {
winnerId: null, // Неопределенный победитель
reason: 'timeout_error_state',
finalGameState: this.gameState,
log: this.consumeLogBuffer(),
loserCharacterKey: timedOutPlayerState?.characterKey || 'unknown'
});
if (this.gameManager && typeof this.gameManager._cleanupGame === 'function') {
this.gameManager._cleanupGame(this.id, 'timeout_error_state');
}
return;
}
this.gameState.isGameOver = true;
this.addToLog(`⏱️ Время хода для ${timedOutPlayerState.name} истекло!`, GAME_CONFIG.LOG_TYPE_SYSTEM);
this.addToLog(`🏁 Победа присуждается ${winnerPlayerState.name}! 🏁`, GAME_CONFIG.LOG_TYPE_SYSTEM);
console.log(`[Game ${this.id}] Turn timed out for ${timedOutPlayerState.name}. Winner: ${winnerPlayerState.name}.`);
this.io.to(this.id).emit('gameOver', {
winnerId: winnerPlayerRole,
reason: 'turn_timeout',
finalGameState: this.gameState,
log: this.consumeLogBuffer(),
loserCharacterKey: timedOutPlayerState.characterKey
});
if (this.gameManager && typeof this.gameManager._cleanupGame === 'function') {
this.gameManager._cleanupGame(this.id, 'turn_timeout');
}
}
addToLog(message, type = GAME_CONFIG.LOG_TYPE_INFO) {
if (!message) return;
this.logBuffer.push({ message, type, timestamp: Date.now() });
}
consumeLogBuffer() {
const logs = [...this.logBuffer];
this.logBuffer = [];
return logs;
}
broadcastGameStateUpdate() {
if (!this.gameState) return;
this.io.to(this.id).emit('gameStateUpdate', { gameState: this.gameState, log: this.consumeLogBuffer() });
}
broadcastLogUpdate() {
if (this.logBuffer.length > 0) {
this.io.to(this.id).emit('logUpdate', { log: this.consumeLogBuffer() });
}
}
_getCharacterData(key) {
if (!key) { console.warn("GameInstance::_getCharacterData called with null/undefined key."); return null; }
switch (key) {
case 'elena': return { baseStats: gameData.playerBaseStats, abilities: gameData.playerAbilities };
case 'balard': return { baseStats: gameData.opponentBaseStats, abilities: gameData.opponentAbilities };
case 'almagest': return { baseStats: gameData.almagestBaseStats, abilities: gameData.almagestAbilities };
default: console.error(`GameInstance::_getCharacterData: Unknown character key "${key}"`); return null;
}
}
_getCharacterBaseData(key) {
const charData = this._getCharacterData(key);
return charData ? charData.baseStats : null;
}
_getCharacterAbilities(key) {
const charData = this._getCharacterData(key);
return charData ? charData.abilities : null;
}
}
module.exports = GameInstance;

727
server_modules/gameLogic.js
View File

@ -1,727 +0,0 @@
// /server_modules/gameLogic.js
const GAME_CONFIG = require('./config');
const gameData = require('./data'); // Загружаем один раз на уровне модуля
// --- Вспомогательные Функции для gameLogic ---
// Вспомогательная функция для получения данных персонажа (baseStats и abilities)
// Нужна здесь, так как объект gameData сам по себе не имеет этих методов.
// Принимает gameDataForLogic как аргумент для гибкости, по умолчанию использует глобальный gameData.
function _getCharacterDataForLogic(key, gameDataForLogic = gameData) {
if (!key) return null;
switch (key) {
case 'elena': return { baseStats: gameDataForLogic.playerBaseStats, abilities: gameDataForLogic.playerAbilities };
case 'balard': return { baseStats: gameDataForLogic.opponentBaseStats, abilities: gameDataForLogic.opponentAbilities }; // Балард использует opponentAbilities
case 'almagest': return { baseStats: gameDataForLogic.almagestBaseStats, abilities: gameDataForLogic.almagestAbilities }; // Альмагест использует almagestAbilities
default: console.error(`_getCharacterDataForLogic: Неизвестный ключ персонажа "${key}"`); return null;
}
}
// Вспомогательная функция для получения только базовых статов персонажа
function _getCharacterBaseDataForLogic(key, gameDataForLogic = gameData) {
const charData = _getCharacterDataForLogic(key, gameDataForLogic);
return charData ? charData.baseStats : null;
}
// Вспомогательная функция для получения только способностей персонажа
function _getCharacterAbilitiesForLogic(key, gameDataForLogic = gameData) {
const charData = _getCharacterDataForLogic(key, gameDataForLogic);
return charData ? charData.abilities : null;
}
/**
* Обрабатывает активные эффекты (баффы/дебаффы) для бойца в конце его хода.
* Длительность эффекта уменьшается на 1.
* Периодические эффекты (DoT, ресурсный дебафф и т.п.) срабатывают, если эффект не "justCast" в этом ходу.
* @param {Array} effectsArray - Массив активных эффектов бойца.
* @param {Object} ownerState - Состояние бойца (currentHp, currentResource и т.д.).
* @param {Object} ownerBaseStats - Базовые статы бойца (включая characterKey).
* @param {String} ownerId - Технический ID слота бойца ('player' или 'opponent').
* @param {Object} currentGameState - Полное состояние игры.
* @param {Function} addToLogCallback - Функция для добавления сообщений в лог игры.
* @param {Object} configToUse - Конфигурационный объект игры.
* @param {Object} gameDataForLogic - Полный объект gameData (для доступа к способностям и т.д.).
* @returns {void} - Модифицирует effectsArray и ownerState напрямую.
*/
function processEffects(effectsArray, ownerState, ownerBaseStats, ownerId, currentGameState, addToLogCallback, configToUse, gameDataForLogic = gameData) {
if (!effectsArray) return;
const ownerName = ownerBaseStats.name;
let effectsToRemoveIndexes = [];
// Важно: Сначала обрабатываем эффекты, затем уменьшаем длительность, затем удаляем.
for (let i = 0; i < effectsArray.length; i++) {
const eff = effectsArray[i];
// --- Применяем эффект (DoT, сжигание ресурса и т.п.), если он не только что наложен в этом ходу ---
if (!eff.justCast) {
// Обработка урона от эффектов полного безмолвия (Гипнотический Взгляд, Раскол Разума)
// Эти эффекты наносят урон цели В КОНЦЕ ее хода
if (eff.isFullSilence && typeof eff.power === 'number' && eff.power > 0) {
const damage = eff.power;
// ИСПРАВЛЕНО: Округляем результат вычитания HP
ownerState.currentHp = Math.max(0, Math.round(ownerState.currentHp - damage));
if (addToLogCallback) addToLogCallback(`😵 Эффект "${eff.name}" наносит ${damage} урона ${ownerName}!`, configToUse.LOG_TYPE_DAMAGE);
}
// Обработка сжигания ресурса (Печать Слабости, Проклятие Увядания)
// Эти эффекты сжигают ресурс цели В КОНЦЕ ее хода
if ((eff.id === 'effect_' + configToUse.ABILITY_ID_SEAL_OF_WEAKNESS || eff.id === 'effect_' + configToUse.ABILITY_ID_ALMAGEST_DEBUFF) && eff.power > 0) {
const resourceToBurn = eff.power;
if (ownerState.currentResource > 0) {
const actualBurn = Math.min(ownerState.currentResource, resourceToBurn);
// ИСПРАВЛЕНО: Округляем результат вычитания ресурса
ownerState.currentResource = Math.max(0, Math.round(ownerState.currentResource - actualBurn));
if (addToLogCallback) addToLogCallback(`🔥 Эффект "${eff.name}" сжигает ${actualBurn} ${ownerBaseStats.resourceName} у ${ownerName}!`, configToUse.LOG_TYPE_EFFECT);
}
}
// Примечание: Отложенные эффекты (например, Сила Природы) применяют свою силу в gameInstance.processPlayerAction (после атаки), а не здесь.
}
// --- Уменьшаем длительность ---
eff.turnsLeft--;
eff.justCast = false; // Эффект больше не считается "just cast" после обработки этого хода
// --- Отмечаем для удаления, если длительность закончилась ---
if (eff.turnsLeft <= 0) {
effectsToRemoveIndexes.push(i);
if (addToLogCallback) {
addToLogCallback(`Эффект "${eff.name}" на ${ownerName} закончился.`, configToUse.LOG_TYPE_EFFECT);
}
}
}
// Удаляем эффекты с конца, чтобы не нарушить индексы
for (let i = effectsToRemoveIndexes.length - 1; i >= 0; i--) {
effectsArray.splice(effectsToRemoveIndexes[i], 1);
}
}
/**
* Обрабатывает отсчет для отключенных (заглушенных) способностей игрока в конце его хода.
* Длительность заглушения уменьшается на 1.
* @param {Array<object>} disabledAbilitiesArray - Массив объектов заглушенных способностей.
* @param {Array<object>} characterAbilities - Полный список способностей персонажа (для получения имени).
* @param {string} characterName - Имя персонажа (для лога).
* @param {function} addToLogCallback - Функция для добавления лога.
* @returns {void} - Модифицирует disabledAbilitiesArray напрямую.
*/
function processDisabledAbilities(disabledAbilitiesArray, characterAbilities, characterName, addToLogCallback) {
if (!disabledAbilitiesArray || disabledAbilitiesArray.length === 0) return;
const stillDisabled = [];
disabledAbilitiesArray.forEach(dis => {
dis.turnsLeft--; // Уменьшаем длительность заглушения
if (dis.turnsLeft > 0) {
stillDisabled.push(dis);
} else {
if (addToLogCallback) {
const ability = characterAbilities.find(ab => ab.id === dis.abilityId);
// Проверка на заглушающий эффект тоже должна быть удалена из activeEffects в processEffects
// Здесь мы только обрабатываем список disabledAbilities, удаляя запись
if (ability) addToLogCallback(`Способность ${characterName} "${ability.name}" больше не заглушена!`, GAME_CONFIG.LOG_TYPE_INFO);
}
}
});
// Очищаем исходный массив и добавляем только те, что еще активны
disabledAbilitiesArray.length = 0;
disabledAbilitiesArray.push(...stillDisabled);
}
/**
* Обрабатывает отсчет общих кулдаунов для способностей в конце хода.
* Длительность кулдауна уменьшается на 1.
* @param {object} cooldownsObject - Объект с кулдаунами способностей ({ abilityId: turnsLeft }).
* @param {Array<object>} abilitiesList - Полный список способностей персонажа (для получения имени).
* @param {string} ownerName - Имя персонажа (для лога).
* @param {function} addToLogCallback - Функция для добавления лога.
* @returns {void} - Модифицирует cooldownsObject напрямую.
*/
function processPlayerAbilityCooldowns(cooldownsObject, abilitiesList, ownerName, addToLogCallback) {
if (!cooldownsObject || !abilitiesList) return;
for (const abilityId in cooldownsObject) {
if (cooldownsObject.hasOwnProperty(abilityId) && cooldownsObject[abilityId] > 0) {
cooldownsObject[abilityId]--; // Уменьшаем кулдаун
if (cooldownsObject[abilityId] === 0) {
const ability = abilitiesList.find(ab => ab.id === abilityId);
if (ability && addToLogCallback) {
addToLogCallback(`Способность ${ownerName} "${ability.name}" снова готова!`, GAME_CONFIG.LOG_TYPE_INFO);
}
}
}
}
}
/**
* Обновляет статус 'isBlocking' на основе активных эффектов.
* @param {object} fighterState - Состояние бойца.
* @returns {void} - Модифицирует fighterState.isBlocking.
*/
function updateBlockingStatus(fighterState) {
if (!fighterState) return;
// Боец считается блокирующим, если у него есть активный эффект, дающий блок (grantsBlock: true) с turnsLeft > 0
fighterState.isBlocking = fighterState.activeEffects.some(eff => eff.grantsBlock && eff.turnsLeft > 0);
}
/**
* Получает случайную насмешку из системы насмешек для определенного персонажа.
* Ищет фразу в gameData.tauntSystem[speakerCharacterKey][opponentCharacterKey][trigger][context].
* @param {string} speakerCharacterKey - Ключ персонажа, который произносит насмешку ('elena' или 'almagest' или 'balard').
* @param {string} trigger - Тип события, вызвавшего насмешку (например, 'selfCastAbility', 'onOpponentAction', 'battleStart', 'basicAttack', 'opponentNearDefeatCheck').
* @param {object} context - Дополнительный контекст (например, { abilityId: 'fireball' }, { outcome: 'success' }).
* @param {object} configToUse - Конфигурационный объект игры.
* @param {object} gameDataForLogic - Полный объект gameData.
* @param {object} currentGameState - Текущее состояние игры.
* @returns {string} Текст насмешки или "(Молчание)".
*/
function getRandomTaunt(speakerCharacterKey, trigger, context = {}, configToUse, gameDataForLogic = gameData, currentGameState) {
// Проверяем наличие системы насмешек для говорящего персонажа
const speakerTauntSystem = gameDataForLogic?.tauntSystem?.[speakerCharacterKey];
if (!speakerTauntSystem) return "(Молчание)"; // Нет насмешек для этого персонажа
// Определяем противника, чтобы выбрать соответствующую ветку насмешек
// Для этого нужно найти в gameState, кто из player/opponent имеет characterKey говорящего,
// и взять characterKey другого.
const speakerRole = currentGameState?.player?.characterKey === speakerCharacterKey ?
GAME_CONFIG.PLAYER_ID :
(currentGameState?.opponent?.characterKey === speakerCharacterKey ?
GAME_CONFIG.OPPONENT_ID : null);
if (speakerRole === null) {
console.warn(`getRandomTaunt: Speaker character key "${speakerCharacterKey}" not found in current game state roles.`);
return "(Молчание)";
}
const opponentRole = speakerRole === GAME_CONFIG.PLAYER_ID ? GAME_CONFIG.OPPONENT_ID : GAME_CONFIG.PLAYER_ID;
const opponentCharacterKey = currentGameState?.[opponentRole]?.characterKey;
const tauntBranch = speakerTauntSystem[opponentCharacterKey];
if (!tauntBranch) {
// console.warn(`getRandomTaunt: No taunt branch found for speaker "${speakerCharacterKey}" against opponent "${opponentCharacterKey}".`);
return "(Молчание)"; // Нет насмешек против этого оппонента
}
let potentialTaunts = [];
// Навигация по структуре tauntSystem в зависимости от триггера и контекста
if (trigger === 'battleStart') {
potentialTaunts = tauntBranch.onBattleState?.start;
}
else if (trigger === 'opponentNearDefeatCheck') { // Проверка на низкое HP противника для специальных фраз
const opponentState = currentGameState?.[opponentRole]; // Состояние противника для проверки HP
// Проверяем, что состояние оппонента существует и его HP ниже порога (например, 20%)
if (opponentState && opponentState.maxHp > 0 && opponentState.currentHp / opponentState.maxHp < 0.20) {
potentialTaunts = tauntBranch.onBattleState?.opponentNearDefeat;
}
}
else if (trigger === 'selfCastAbility' && context.abilityId) {
potentialTaunts = tauntBranch.selfCastAbility?.[context.abilityId];
}
else if (trigger === 'basicAttack' && tauntBranch.basicAttack) {
const opponentState = currentGameState?.[opponentRole]; // Состояние противника
// Специальная логика для базовой атаки Елены против Баларда (милосердие/доминирование)
if (speakerCharacterKey === 'elena' && opponentCharacterKey === 'balard' && opponentState) {
const opponentHpPerc = (opponentState.currentHp / opponentState.maxHp) * 100;
if (opponentHpPerc <= configToUse.PLAYER_MERCY_TAUNT_THRESHOLD_PERCENT) {
potentialTaunts = tauntBranch.basicAttack.dominating;
} else {
potentialTaunts = tauntBranch.basicAttack.merciful;
}
} else { // Общая логика для PvP или Елена/Балард вне порога
potentialTaunts = tauntBranch.basicAttack.general;
}
}
// Реакция на действие противника
else if (trigger === 'onOpponentAction' && context.abilityId) {
const actionResponses = tauntBranch.onOpponentAction?.[context.abilityId];
if (actionResponses) {
// Если структура содержит вложенные результаты (например, успех/провал Безмолвия)
if (typeof actionResponses === 'object' && !Array.isArray(actionResponses) && context.outcome && context.outcome in actionResponses) {
potentialTaunts = actionResponses[context.outcome]; // Например, onOpponentAction.silence.success
} else if (Array.isArray(actionResponses)) {
potentialTaunts = actionResponses; // Прямой массив фраз для способности
}
}
}
// Реакция на попадание/блок атаки противника
// Примечание: Эти триггеры срабатывают, когда по ГОВОРЯЩЕМУ попала атака или он ее заблокировал.
// Вызываются из performAttack, где известно, кто атакует и кто защищается.
else if (trigger === 'onOpponentAttackBlocked' && tauntBranch.onOpponentAction?.attackBlocked) {
potentialTaunts = tauntBranch.onOpponentAction.attackBlocked;
}
else if (trigger === 'onOpponentAttackHit' && tauntBranch.onOpponentAction?.attackHits) {
potentialTaunts = tauntBranch.onOpponentAction.attackHits;
}
// Если по прямому триггеру не найдено, возвращаем "(Молчание)".
// Можно добавить фоллбэк на общие фразы, если требуется более разговорчивый персонаж.
// Например: if ((!potentialTaunts || potentialTaunts.length === 0) && tauntBranch.basicAttack?.general) { potentialTaunts = tauntBranch.basicAttack.general; }
if (!Array.isArray(potentialTaunts) || potentialTaunts.length === 0) {
return "(Молчание)"; // Возвращаем молчание, если ничего не найдено
}
// Возвращаем случайную фразу из найденного массива
const selectedTaunt = potentialTaunts[Math.floor(Math.random() * potentialTaunts.length)];
return selectedTaunt || "(Молчание)"; // Фоллбэк на "(Молчание)" если массив был пуст после всех проверок
}
// --- Основные Игровые Функции ---
/**
* Обрабатывает базовую атаку одного бойца по другому.
* @param {object} attackerState - Состояние атакующего бойца.
* @param {object} defenderState - Состояние защищающегося бойца.
* @param {object} attackerBaseStats - Базовые статы атакующего.
* @param {object} defenderBaseStats - Базовые статы защищающегося.
* @param {object} currentGameState - Текущее состояние игры (для насмешек).
* @param {function} addToLogCallback - Функция для добавления лога.
* @param {object} configToUse - Конфигурация игры.
* @param {object} gameDataForLogic - Данные игры (для насмешек).
*/
function performAttack(attackerState, defenderState, attackerBaseStats, defenderBaseStats, currentGameState, addToLogCallback, configToUse, gameDataForLogic = gameData) {
// Расчет базового урона с вариацией
let damage = Math.floor(attackerBaseStats.attackPower * (configToUse.DAMAGE_VARIATION_MIN + Math.random() * configToUse.DAMAGE_VARIATION_RANGE));
let tauntMessagePart = ""; // Переменная для насмешки защищающегося
// Проверка на блок
if (defenderState.isBlocking) {
const initialDamage = damage;
damage = Math.floor(damage * configToUse.BLOCK_DAMAGE_REDUCTION);
// Проверка на насмешку ОТ защищающегося (Елены или Альмагест) при блокировании атаки
if (defenderState.characterKey === 'elena' || defenderState.characterKey === 'almagest') {
// getRandomTaunt принимает speaker (защищающийся), trigger, context, config, gameData, gameState
const blockTaunt = getRandomTaunt(defenderState.characterKey, 'onOpponentAttackBlocked', {}, configToUse, gameDataForLogic, currentGameState);
if (blockTaunt !== "(Молчание)") tauntMessagePart = ` (${blockTaunt})`;
}
if (addToLogCallback) addToLogCallback(`🛡️ ${defenderBaseStats.name} блокирует атаку ${attackerBaseStats.name}! Урон снижен (${initialDamage} -> ${damage}).${tauntMessagePart}`, configToUse.LOG_TYPE_BLOCK);
} else {
let hitMessage = `${attackerBaseStats.name} атакует ${defenderBaseStats.name}! Наносит ${damage} урона.`;
// Проверка на насмешку ОТ защищающегося (Елены или Альмагест) при попадании атаки
if (defenderState.characterKey === 'elena' || defenderState.characterKey === 'almagest') {
// getRandomTaunt принимает speaker (защищающийся), trigger, context, config, gameData, gameState
const hitTaunt = getRandomTaunt(defenderState.characterKey, 'onOpponentAttackHit', {}, configToUse, gameDataForLogic, currentGameState);
if (hitTaunt !== "(Молчание)") hitMessage += ` (${hitTaunt})`;
}
if (addToLogCallback) addToLogCallback(hitMessage, configToUse.LOG_TYPE_DAMAGE);
}
// Применяем урон, убеждаемся, что HP не ниже нуля
// ИСПРАВЛЕНО: Округляем результат вычитания HP
defenderState.currentHp = Math.max(0, Math.round(defenderState.currentHp - damage));
}
/**
* Применяет эффект способности.
* @param {object} ability - Объект способности.
* @param {object} casterState - Состояние бойца, применившего способность.
* @param {object} targetState - Состояние цели способности.
* @param {object} casterBaseStats - Базовые статы кастера.
* @param {object} targetBaseStats - Базовые статы цели.
* @param {object} currentGameState - Текущее состояние игры (для насмешек).
* @param {function} addToLogCallback - Функция для добавления лога.
* @param {object} configToUse - Конфигурация игры.
* @param {object} gameDataForLogic - Данные игры (для насмешек).
*/
function applyAbilityEffect(ability, casterState, targetState, casterBaseStats, targetBaseStats, currentGameState, addToLogCallback, configToUse, gameDataForLogic = gameData) {
let tauntMessagePart = ""; // Переменная для насмешки, если она связана с результатом эффекта или реакцией цели
// Проверка на насмешку ОТ цели (Елены или Альмагест), если она попадает под способность противника
if (targetState.characterKey === 'elena' || targetState.characterKey === 'almagest') {
// Триггер 'onOpponentAction' с abilityId противника
const reactionTaunt = getRandomTaunt(targetState.characterKey, 'onOpponentAction', { abilityId: ability.id }, configToUse, gameDataForLogic, currentGameState);
if (reactionTaunt !== "(Молчание)") tauntMessagePart = ` (${reactionTaunt})`;
} else {
tauntMessagePart = ""; // Другие персонажи (Балард) не имеют реакционных насмешек такого типа
}
switch (ability.type) {
case configToUse.ACTION_TYPE_HEAL:
const healAmount = Math.floor(ability.power * (configToUse.HEAL_VARIATION_MIN + Math.random() * configToUse.HEAL_VARIATION_RANGE));
const actualHeal = Math.min(healAmount, casterBaseStats.maxHp - casterState.currentHp);
if (actualHeal > 0) {
// ИСПРАВЛЕНО: Округляем результат прибавления HP
casterState.currentHp = Math.round(casterState.currentHp + actualHeal);
// --- ИЗМЕНЕНИЕ: Добавляем название способности в лог лечения ---
if (addToLogCallback) addToLogCallback(`💚 ${casterBaseStats.name} применяет "${ability.name}" и восстанавливает ${actualHeal} HP!${tauntMessagePart}`, configToUse.LOG_TYPE_HEAL);
// --- КОНЕЦ ИЗМЕНЕНИЯ ---
} else {
if (addToLogCallback) addToLogCallback(`✨ ${casterBaseStats.name} применяет "${ability.name}", но не получает лечения.${tauntMessagePart}`, configToUse.LOG_TYPE_INFO);
}
break;
case configToUse.ACTION_TYPE_DAMAGE:
let damage = Math.floor(ability.power * (configToUse.DAMAGE_VARIATION_MIN + Math.random() * configToUse.DAMAGE_VARIATION_RANGE));
// Проверка на блок цели
if (targetState.isBlocking) {
const initialDamage = damage;
damage = Math.floor(damage * configToUse.BLOCK_DAMAGE_REDUCTION);
// Проверка на насмешку ОТ цели (Елены или Альмагест), если она заблокировала урон от способности - перенесено наверх
// if (targetState.characterKey === 'elena' || targetState.characterKey === 'almagest') {
// const blockTaunt = getRandomTaunt(targetState.characterKey, 'onOpponentAttackBlocked', {abilityId: ability.id} , configToUse, gameDataForLogic, currentGameState);
// if (blockTaunt !== "(Молчание)") tauntMessagePart = ` (${blockTaunt})`;
// }
if (addToLogCallback) addToLogCallback(`🛡️ ${targetBaseStats.name} блокирует "${ability.name}" от ${casterBaseStats.name}! Урон снижен (${initialDamage} -> ${damage}).${tauntMessagePart}`, configToUse.LOG_TYPE_BLOCK);
}
// Применяем урон, убеждаемся, что HP не ниже нуля
// ИСПРАВЛЕНО: Округляем результат вычитания HP
targetState.currentHp = Math.max(0, Math.round(targetState.currentHp - damage));
if (addToLogCallback && !targetState.isBlocking) {
let hitMessage = `💥 ${casterBaseStats.name} применяет "${ability.name}" на ${targetBaseStats.name}, нанося ${damage} урона!${tauntMessagePart}`;
// Проверка на насмешку ОТ цели (Елены или Альмагест), если по ней попала способность - перенесено наверх
// if (targetState.characterKey === 'elena' || targetState.characterKey === 'almagest') {
// const hitTaunt = getRandomTaunt(targetState.characterKey, 'onOpponentAction', {abilityId: ability.id}, configToUse, gameDataForLogic, currentGameState);
// if (hitTaunt !== "(Молчание)") hitMessage += ` (${hitTaunt})`;
// }
addToLogCallback(hitMessage, configToUse.LOG_TYPE_DAMAGE);
}
break;
case configToUse.ACTION_TYPE_BUFF:
// Если бафф уже активен, не применяем его повторно (эта проверка уже есть в gameInstance)
// Проверка на .some здесь опциональна, т.к. вызывающий код должен гарантировать уникальность
if (!casterState.activeEffects.some(e => e.id === ability.id)) {
let effectDescription = ability.description;
if (typeof ability.descriptionFunction === 'function') {
// Для описания баффа может потребоваться информация о противнике
const opponentRole = casterState.id === configToUse.PLAYER_ID ? configToUse.OPPONENT_ID : configToUse.PLAYER_ID;
const opponentCurrentState = currentGameState[opponentRole];
// Получаем базовые статы противника, если он определен, для функции описания
const opponentDataForDesc = opponentCurrentState?.characterKey ? _getCharacterBaseDataForLogic(opponentCurrentState.characterKey, gameDataForLogic) : null; // ИСПОЛЬЗУЕМ _getCharacterBaseDataForLogic
effectDescription = ability.descriptionFunction(configToUse, opponentDataForDesc);
}
// isDelayed: true используется для эффектов, которые срабатывают ПОСЛЕ следующего действия (например, Сила Природы).
// duration: исходная длительность из данных, turnsLeft: сколько ходов осталось (включая текущий, если !justCast)
casterState.activeEffects.push({
id: ability.id, name: ability.name, description: effectDescription,
type: ability.type, duration: ability.duration, // Сохраняем исходную длительность для отображения в UI или логики
turnsLeft: ability.duration, // Длительность жизни эффекта в ходах владельца
grantsBlock: !!ability.grantsBlock,
isDelayed: !!ability.isDelayed, // Флаг, что эффект отложенный (срабатывает после действия)
justCast: true // Флаг, что эффект только что наложен (для логики processEffects)
});
if (ability.grantsBlock) updateBlockingStatus(casterState); // Обновляем статус блока кастера, если бафф его дает
// Насмешки при применении баффа (selfCastAbility) добавляются в GameInstance перед вызовом applyAbilityEffect
if (addToLogCallback) addToLogCallback(`✨ ${casterBaseStats.name} накладывает эффект "${ability.name}"!${tauntMessagePart}`, configToUse.LOG_TYPE_EFFECT);
} else {
// Сообщение "уже активен" отправляется из gameInstance перед вызовом applyAbilityEffect
}
break;
case configToUse.ACTION_TYPE_DISABLE: // Безмолвие, Стан и т.п.
// Проверка на насмешку ОТ цели (Елены или Альмагест), если она попадает под дизейбл противника - перенесено наверх
// if (targetState.characterKey === 'elena' || targetState.characterKey === 'almagest') {
// const disableTaunt = getRandomTaunt(targetState.characterKey, 'onOpponentAction', {abilityId: ability.id}, configToUse, gameDataForLogic, currentGameState);
// if (disableTaunt !== "(Молчание)") tauntMessagePart = ` (${disableTaunt})`;
// }
// Гипнотический взгляд Елены / Раскол Разума Альмагест (полное безмолвие)
if (ability.id === configToUse.ABILITY_ID_HYPNOTIC_GAZE || ability.id === configToUse.ABILITY_ID_ALMAGEST_DISABLE) {
const effectId = ability.id === configToUse.ABILITY_ID_HYPNOTIC_GAZE ? 'fullSilenceByElena' : 'fullSilenceByAlmagest';
// Не накладываем повторно, если эффект уже есть на цели
if (!targetState.activeEffects.some(e => e.id === effectId)) {
targetState.activeEffects.push({
id: effectId, name: ability.name, description: ability.description,
type: ability.type, duration: ability.effectDuration, turnsLeft: ability.effectDuration, // Длительность в ходах цели
power: ability.power, // Урон от эффекта (применяется в конце хода цели)
isFullSilence: true,
justCast: true // Эффект только что наложен
});
if (addToLogCallback) addToLogCallback(`🌀 ${casterBaseStats.name} применяет "${ability.name}" на ${targetBaseStats.name}! Способности ${targetBaseStats.name} заблокированы на ${ability.effectDuration} хода, и он(а) получает урон!${tauntMessagePart}`, configToUse.LOG_TYPE_EFFECT);
} else {
if (addToLogCallback) addToLogCallback(`${casterBaseStats.name} пытается применить "${ability.name}", но эффект уже активен на ${targetState.name}!${tauntMessagePart}`, configToUse.LOG_TYPE_INFO);
}
}
// Эхо Безмолвия Баларда (заглушает случайную абилку)
else if (ability.id === configToUse.ABILITY_ID_BALARD_SILENCE && casterState.characterKey === 'balard') {
const success = Math.random() < configToUse.SILENCE_SUCCESS_RATE;
const silenceOutcome = success ? 'success' : 'fail';
// Реакция цели (Елены) на успех/провал безмолвия Баларда - перенесено наверх, но с context.outcome
// if (targetState.characterKey === 'elena') { // Балард применяет это только на Елену
// const specificSilenceTaunt = getRandomTaunt(targetState.characterKey, 'onOpponentAction', { abilityId: ability.id, outcome: silenceOutcome }, configToUse, gameDataForLogic, currentGameState);
// tauntMessagePart = (specificSilenceTaunt !== "(Молчание)") ? ` (${specificSilenceTaunt})` : "";
// } else {
// tauntMessagePart = ""; // Другие персонажи не реагируют на Безмолвие Баларда
// }
// Нужно получить насмешку с outcome здесь, так как она зависит от результата броска шанса
// Временно сохраняем общую насмешку и получаем специфичную
let specificSilenceTaunt = "(Молчание)";
if (targetState.characterKey === 'elena') { // Балард применяет это только на Елену
specificSilenceTaunt = getRandomTaunt(targetState.characterKey, 'onOpponentAction', { abilityId: ability.id, outcome: silenceOutcome }, configToUse, gameDataForLogic, currentGameState);
}
tauntMessagePart = (specificSilenceTaunt !== "(Молчание)") ? ` (${specificSilenceTaunt})` : tauntMessagePart; // Используем специфичную, если найдена, иначе общую (хотя общая для этого абилки вряд ли есть)
if (success) {
const targetAbilities = _getCharacterAbilitiesForLogic(targetState.characterKey, gameDataForLogic); // Глушим абилки цели
// Фильтруем способности, которые еще не заглушены этим типом безмолвия
const availableAbilities = targetAbilities.filter(pa =>
!targetState.disabledAbilities?.some(d => d.abilityId === pa.id) &&
!targetState.activeEffects?.some(eff => eff.id === `playerSilencedOn_${pa.id}`) // Проверка на эффект заглушения для UI/ProcessEffects
);
if (availableAbilities.length > 0) {
const abilityToSilence = availableAbilities[Math.floor(Math.random() * availableAbilities.length)];
const turns = configToUse.SILENCE_DURATION; // Длительность из конфига (в ходах цели)
// Добавляем запись о заглушенной способности в disabledAbilities цели
targetState.disabledAbilities.push({ abilityId: abilityToSilence.id, turnsLeft: turns + 1 }); // +1, т.к. длительность уменьшается в конце хода цели
// Добавляем эффект заглушения в activeEffects цели (для UI и ProcessEffects)
const silenceEffectIdOnPlayer = `playerSilencedOn_${abilityToSilence.id}`;
targetState.activeEffects.push({
id: silenceEffectIdOnPlayer, name: `Безмолвие: ${abilityToSilence.name}`,
description: `Способность "${abilityToSilence.name}" временно недоступна.`,
type: configToUse.ACTION_TYPE_DISABLE, sourceAbilityId: ability.id, // Добавлено sourceAbilityId
duration: turns, turnsLeft: turns + 1,
justCast: true // Эффект только что наложен
});
if (addToLogCallback) addToLogCallback(`🔇 Эхо Безмолвия! "${abilityToSilence.name}" ${targetBaseStats.name} заблокировано на ${turns} хода!${tauntMessagePart}`, configToUse.LOG_TYPE_EFFECT);
} else {
if (addToLogCallback) addToLogCallback(`${casterBaseStats.name} пытается наложить Безмолвие, но у ${targetBaseStats.name} нечего глушить!${tauntMessagePart}`, configToUse.LOG_TYPE_INFO);
}
} else {
if (addToLogCallback) addToLogCallback(`💨 Попытка ${casterBaseStats.name} наложить Безмолвие на ${targetBaseStats.name} провалилась!${tauntMessagePart}`, configToUse.LOG_TYPE_INFO);
}
}
break;
case configToUse.ACTION_TYPE_DEBUFF: // Ослабления, DoT и т.п.
// Проверка на насмешку ОТ цели (Елены или Альмагест), если она попадает под дебафф противника - перенесено наверх
// if (targetState.characterKey === 'elena' || targetState.characterKey === 'almagest') {
// const debuffTaunt = getRandomTaunt(targetState.characterKey, 'onOpponentAction', {abilityId: ability.id}, configToUse, gameDataForLogic, currentGameState);
// if (debuffTaunt !== "(Молчание)") tauntMessagePart = ` (${debuffTaunt})`;
// }
// Печать Слабости Елены / Проклятие Увядания Альмагест (сжигание ресурса)
if (ability.id === configToUse.ABILITY_ID_SEAL_OF_WEAKNESS || ability.id === configToUse.ABILITY_ID_ALMAGEST_DEBUFF) {
const effectIdForDebuff = 'effect_' + ability.id; // Уникальный ID эффекта на цели
// Не накладываем повторно, если эффект уже есть на цели
if (!targetState.activeEffects.some(e => e.id === effectIdForDebuff)) {
let effectDescription = ability.description;
if (typeof ability.descriptionFunction === 'function') {
effectDescription = ability.descriptionFunction(configToUse, targetBaseStats); // Описание может зависеть от цели
}
targetState.activeEffects.push({
id: effectIdForDebuff, name: ability.name, description: effectDescription,
type: configToUse.ACTION_TYPE_DEBUFF, sourceAbilityId: ability.id,
duration: ability.effectDuration, turnsLeft: ability.effectDuration, // Длительность в ходах цели
power: ability.power, // Количество сжигаемого ресурса в ход (применяется в конце хода цели)
justCast: true // Эффект только что наложен
});
if (addToLogCallback) addToLogCallback(`📉 ${casterBaseStats.name} накладывает "${ability.name}" на ${targetBaseStats.name}! Ресурс будет сжигаться.${tauntMessagePart}`, configToUse.LOG_TYPE_EFFECT);
} else {
if (addToLogCallback) addToLogCallback(`${casterBaseStats.name} пытается применить "${ability.name}", но эффект уже активен на ${targetState.name}!${tauntMessagePart}`, configToUse.LOG_TYPE_INFO);
}
}
break;
case configToUse.ACTION_TYPE_DRAIN: // Похищение Света Баларда (наносит урон, вытягивает ресурс, лечит кастера)
if (casterState.characterKey === 'balard') { // Это способность только Баларда
let manaDrained = 0; let healthGained = 0; let damageDealtDrain = 0;
// tauntMessagePart уже получена в начале функции
// Сначала урон от способности
if (ability.powerDamage > 0) {
let baseDamageDrain = ability.powerDamage;
// Проверка на блок цели
if (targetState.isBlocking) {
baseDamageDrain = Math.floor(baseDamageDrain * configToUse.BLOCK_DAMAGE_REDUCTION);
let blockDrainTaunt = "";
// Реакция цели (Елены/Альмагест) на блок урона от дрейна
if (targetState.characterKey === 'elena' || targetState.characterKey === 'almagest') {
blockDrainTaunt = getRandomTaunt(targetState.characterKey, 'onOpponentAttackBlocked', {}, configToUse, gameDataForLogic, currentGameState);
if (blockDrainTaunt !== "(Молчание)") blockDrainTaunt = ` (${blockDrainTaunt})`;
}
if (addToLogCallback) addToLogCallback(`🛡️ ${targetBaseStats.name} блокирует часть урона от "${ability.name}" от ${casterBaseStats.name}! Урон снижен до ${baseDamageDrain}.${blockDrainTaunt}`, configToUse.LOG_TYPE_BLOCK);
}
damageDealtDrain = Math.max(0, baseDamageDrain);
// ИСПРАВЛЕНО: Округляем результат вычитания HP
targetState.currentHp = Math.max(0, Math.round(targetState.currentHp - damageDealtDrain));
}
// Затем вытягивание ресурса и лечение кастера
const potentialDrain = ability.powerManaDrain;
const actualDrain = Math.min(potentialDrain, targetState.currentResource);
if (actualDrain > 0) {
// ИСПРАВЛЕНО: Округляем результат вычитания ресурса
targetState.currentResource = Math.max(0, Math.round(targetState.currentResource - actualDrain));
manaDrained = actualDrain;
const potentialHeal = Math.floor(manaDrained * ability.powerHealthGainFactor);
const actualHealGain = Math.min(potentialHeal, casterBaseStats.maxHp - casterState.currentHp);
// ИСПРАВЛЕНО: Округляем результат прибавления HP
casterState.currentHp = Math.round(casterState.currentHp + actualHealGain);
healthGained = actualHealGain;
}
let logMsgDrain = `⚡ ${casterBaseStats.name} применяет "${ability.name}"! `;
if (damageDealtDrain > 0) logMsgDrain += `Наносит ${damageDealtDrain} урона. `;
if (manaDrained > 0) {
logMsgDrain += `Вытягивает ${manaDrained} ${targetBaseStats.resourceName} у ${targetBaseStats.name} и исцеляется на ${healthGained} HP!`;
} else if (damageDealtDrain > 0) {
logMsgDrain += `У ${targetBaseStats.name} нет ${targetBaseStats.resourceName} для похищения.`; // Урон прошел, но ресурс не вытянулся
} else { // Ни урона, ни вытягивания ресурса
// ИСПРАВЛЕНО: targetBaseStats.resourceName -> targetState.resourceName (или defenderBaseStats.resourceName, если он передается)
logMsgDrain += `У ${targetBaseStats.name} нет ${targetBaseStats.resourceName} для похищения.`; // Оставляем targetBaseStats.resourceName, т.к. он точнее для лога
// Если урон был 0, и ресурса нет, можно уточнить лог
if(damageDealtDrain === 0 && potentialDrain > 0) logMsgDrain += ` Урон не прошел или равен нулю, ресурс не похищен.`;
}
logMsgDrain += tauntMessagePart; // Добавляем насмешку цели, если была
if (addToLogCallback) addToLogCallback(logMsgDrain, manaDrained > 0 || damageDealtDrain > 0 ? configToUse.LOG_TYPE_DAMAGE : configToUse.LOG_TYPE_INFO);
} else {
console.warn(`applyAbilityEffect: Drain type ability ${ability?.name} used by non-Balard character ${casterState.characterKey}`);
}
break;
default:
console.warn(`applyAbilityEffect: Неизвестный тип способности: ${ability?.type} для "${ability?.name}"`);
}
}
/**
* Логика принятия решения для AI (Балард).
* @param {object} currentGameState - Текущее состояние игры.
* @param {object} gameDataForLogic - Данные игры.
* @param {object} configToUse - Конфигурация игры.
* @param {function} addToLogCallback - Функция для добавления лога.
* @returns {object} Объект с действием AI ({ actionType: 'attack' | 'ability', ability?: object }).
*/
function decideAiAction(currentGameState, gameDataForLogic = gameData, configToUse, addToLogCallback) {
const opponentState = currentGameState.opponent; // AI Балард всегда в слоте opponent
const playerState = currentGameState.player; // Игрок всегда в слоте player (в AI режиме)
// Убеждаемся, что это AI Балард
if (opponentState.characterKey !== 'balard') {
console.warn("[AI DEBUG] decideAiAction called for non-Balard opponent. This should not happen.");
return { actionType: 'pass', logMessage: { message: `${opponentState.name} (не AI) пропускает ход.`, type: configToUse.LOG_TYPE_INFO } };
}
// Проверка полного безмолвия Баларда (от Гипнотического Взгляда Елены или Раскола Разума Альмагест)
const isBalardFullySilenced = opponentState.activeEffects.some(
eff => eff.isFullSilence && eff.turnsLeft > 0
);
if (isBalardFullySilenced) {
// AI под полным безмолвием просто атакует
// Лог о безмолвии и атаке в смятении добавляется в processAiTurn перед вызовом performAttack.
// decideAiAction просто возвращает действие.
return { actionType: 'attack' };
}
const availableActions = [];
const opponentAbilities = gameDataForLogic.opponentAbilities; // Способности Баларда
// Проверяем доступность способностей AI и добавляем их в список возможных действий с весом
// Вес определяет приоритет: выше вес -> выше шанс выбора (после сортировки)
const healAbility = opponentAbilities.find(a => a.id === configToUse.ABILITY_ID_BALARD_HEAL);
if (healAbility && opponentState.currentResource >= healAbility.cost &&
(opponentState.abilityCooldowns?.[healAbility.id] || 0) <= 0 && // Проверка общего КД (хотя у Баларда могут быть только спец. КД)
healAbility.condition(opponentState, playerState, currentGameState, configToUse)) {
availableActions.push({ weight: 80, type: 'ability', ability: healAbility, requiresSuccessCheck: true, successRate: healAbility.successRate });
}
const silenceAbility = opponentAbilities.find(a => a.id === configToUse.ABILITY_ID_BALARD_SILENCE);
if (silenceAbility && opponentState.currentResource >= silenceAbility.cost &&
(opponentState.silenceCooldownTurns === undefined || opponentState.silenceCooldownTurns <= 0) && // Проверка спец. КД безмолвия
(opponentState.abilityCooldowns?.[silenceAbility.id] || 0) <= 0 && // Проверка общего КД
silenceAbility.condition(opponentState, playerState, currentGameState, configToUse)) {
const playerHpPercent = (playerState.currentHp / playerState.maxHp) * 100;
// Балард предпочитает безмолвие, если HP Елены не слишком низкое (позволяет ей лечиться, чтобы игра длилась дольше)
if (playerHpPercent > (configToUse.PLAYER_HP_BLEED_THRESHOLD_PERCENT || 60)) { // Используем порог для текстов Елены как пример
availableActions.push({ weight: 60, type: 'ability', ability: silenceAbility, requiresSuccessCheck: true, successRate: configToUse.SILENCE_SUCCESS_RATE });
}
}
const drainAbility = opponentAbilities.find(a => a.id === configToUse.ABILITY_ID_BALARD_MANA_DRAIN);
if (drainAbility && opponentState.currentResource >= drainAbility.cost &&
(opponentState.manaDrainCooldownTurns === undefined || opponentState.manaDrainCooldownTurns <= 0) && // Проверка спец. КД дрейна
(opponentState.abilityCooldowns?.[drainAbility.id] || 0) <= 0 && // Проверка общего КД
drainAbility.condition(opponentState, playerState, currentGameState, configToUse)) {
availableActions.push({ weight: 50, type: 'ability', ability: drainAbility });
}
// Базовая атака - всегда доступна как запасной вариант с низким весом
availableActions.push({ weight: 30, type: 'attack' });
// Если по какой-то причине список доступных действий пуст (не должно быть, т.к. атака всегда есть)
if (availableActions.length === 0) {
return { actionType: 'pass', logMessage: { message: `${opponentState.name} не может совершить действие.`, type: configToUse.LOG_TYPE_INFO } };
}
// Сортируем действия по весу в порядке убывания
availableActions.sort((a, b) => b.weight - a.weight);
// Перебираем действия в порядке приоритета и выбираем первое возможное
for (const action of availableActions) {
if (action.type === 'ability') {
// Если способность требует проверки успеха (например, Безмолвие Баларда)
if (action.requiresSuccessCheck) {
if (Math.random() < action.successRate) {
// Успех, добавляем лог о попытке (чтобы было видно, что AI пытался)
if (addToLogCallback) addToLogCallback(`⭐ ${opponentState.name} пытается использовать "${action.ability.name}"...`, configToUse.LOG_TYPE_INFO);
return { actionType: action.type, ability: action.ability }; // Успех, выбираем эту способность
} else {
// Провал, добавляем лог о провале и переходим к следующему возможному действию в цикле
if (addToLogCallback) addToLogCallback(`💨 Попытка ${opponentState.name} использовать "${action.ability.name}" провалилась!`, configToUse.LOG_TYPE_INFO);
continue; // Пробуем следующее действие в списке
}
} else {
// Нет проверки успеха, добавляем лог о попытке и выбираем способность
if (addToLogCallback) addToLogCallback(`⭐ ${opponentState.name} использует "${action.ability.name}"...`, configToUse.LOG_TYPE_INFO);
return { actionType: action.type, ability: action.ability };
}
} else if (action.type === 'attack') {
// Атака - всегда возможна (если нет полного безмолвия, проверено выше)
if (addToLogCallback) addToLogCallback(`🦶 ${opponentState.name} готовится к атаке...`, configToUse.LOG_TYPE_INFO);
return { actionType: 'attack' };
}
// 'pass' не должен быть в доступных действиях, если атака всегда доступна
}
// Если все попытки выбрать способность или атаку провалились (очень маловероятно, если атака всегда в списке), пропуск хода
console.warn("[AI DEBUG] AI failed to select any action. Defaulting to pass.");
return { actionType: 'pass', logMessage: { message: `${opponentState.name} не смог выбрать подходящее действие. Пропускает ход.`, type: configToUse.LOG_TYPE_INFO } };
}
/**
* Внутренняя проверка условий конца игры (основано на HP).
* @param {object} currentGameState - Текущее состояние игры.
* @param {object} configToUse - Конфигурация игры.
* @param {object} gameDataForLogic - Данные игры.
* @returns {boolean} true, если игра окончена, иначе false.
*/
function checkGameOverInternal(currentGameState, configToUse, gameDataForLogic = gameData) {
// Проверка на конец игры происходит только если gameState существует и игра еще не помечена как оконченная
if (!currentGameState || currentGameState.isGameOver) return currentGameState ? currentGameState.isGameOver : true;
// Убеждаемся, что оба бойца определены в gameState и не являются плейсхолдерами
// Проверка maxHp > 0 в gameState.opponent гарантирует, что оппонент не плейсхолдер
if (!currentGameState.player || !currentGameState.opponent || currentGameState.opponent.maxHp <= 0) {
// Если один из бойцов не готов (например, PvP игра ожидает второго игрока), игра не может закончиться по HP
return false;
}
const playerDead = currentGameState.player.currentHp <= 0;
const opponentDead = currentGameState.opponent.currentHp <= 0;
// Игра окончена, если один или оба бойца мертвы
return playerDead || opponentDead;
}
// Экспортируем все функции, которые используются в других модулях
module.exports = {
processEffects,
processDisabledAbilities,
processPlayerAbilityCooldowns,
updateBlockingStatus,
getRandomTaunt, // Экспортируем переименованную функцию
performAttack,
applyAbilityEffect,
decideAiAction,
checkGameOverInternal
};

479
server_modules/gameManager.js
View File

@ -1,479 +0,0 @@
// /server_modules/gameManager.js
const { v4: uuidv4 } = require('uuid');
const GameInstance = require('./gameInstance');
const gameData = require('./data');
const GAME_CONFIG = require('./config');
class GameManager {
constructor(io) {
this.io = io;
this.games = {}; // { gameId: GameInstance }
this.userIdentifierToGameId = {}; // { userId|socketId: gameId }
this.pendingPvPGames = []; // [gameId]
}
_removePreviousPendingGames(currentSocketId, identifier, excludeGameId = null) {
const oldPendingGameId = this.userIdentifierToGameId[identifier];
if (oldPendingGameId && oldPendingGameId !== excludeGameId && this.games[oldPendingGameId]) {
const gameToRemove = this.games[oldPendingGameId];
if (gameToRemove.mode === 'pvp' && gameToRemove.playerCount === 1 && this.pendingPvPGames.includes(oldPendingGameId)) {
const oldOwnerInfo = Object.values(gameToRemove.players).find(p => p.id === GAME_CONFIG.PLAYER_ID);
if (oldOwnerInfo && (oldOwnerInfo.identifier === identifier)) {
console.log(`[GameManager] Пользователь ${identifier} (сокет: ${currentSocketId}) создал/присоединился к новой игре. Удаляем его предыдущую ожидающую игру: ${oldPendingGameId}`);
this._cleanupGame(oldPendingGameId, 'replaced_by_new_game');
}
} else {
if (this.userIdentifierToGameId[identifier] !== excludeGameId) {
console.warn(`[GameManager] Удаление потенциально некорректной ссылки userIdentifierToGameId[${identifier}] на игру ${oldPendingGameId}.`);
delete this.userIdentifierToGameId[identifier];
}
}
}
}
createGame(socket, mode = 'ai', chosenCharacterKey = 'elena', identifier) {
this._removePreviousPendingGames(socket.id, identifier);
if (this.userIdentifierToGameId[identifier] && this.games[this.userIdentifierToGameId[identifier]]) {
console.warn(`[GameManager] Пользователь ${identifier} (сокет: ${socket.id}) уже в игре ${this.userIdentifierToGameId[identifier]}. Игнорируем запрос на создание.`);
socket.emit('gameError', { message: 'Вы уже находитесь в активной или ожидающей игре.' });
this.handleRequestGameState(socket, identifier);
return;
}
const gameId = uuidv4();
const game = new GameInstance(gameId, this.io, mode, this);
game.ownerIdentifier = identifier;
this.games[gameId] = game;
const charKeyForInstance = (mode === 'pvp') ? chosenCharacterKey : 'elena';
if (game.addPlayer(socket, charKeyForInstance, identifier)) {
this.userIdentifierToGameId[identifier] = gameId;
console.log(`[GameManager] Игра создана: ${gameId} (режим: ${mode}) игроком ${identifier} (сокет: ${socket.id}, выбран: ${charKeyForInstance})`);
const assignedPlayerId = game.players[socket.id]?.id;
if (!assignedPlayerId) {
this._cleanupGame(gameId, 'player_add_failed');
console.error(`[GameManager] Ошибка при создании игры ${gameId}: Не удалось назначить ID игрока сокету ${socket.id} (идентификатор ${identifier}).`);
socket.emit('gameError', { message: 'Ошибка сервера при создании игры.' });
return;
}
socket.emit('gameCreated', { gameId: gameId, mode: mode, yourPlayerId: assignedPlayerId });
if ((game.mode === 'ai' && game.playerCount === 1) || (game.mode === 'pvp' && game.playerCount === 2)) {
console.log(`[GameManager] Игра ${gameId} готова к старту. Инициализация и запуск.`);
const isInitialized = game.initializeGame();
if (isInitialized) {
game.startGame();
} else {
console.error(`[GameManager] Не удалось запустить игру ${gameId}: initializeGame вернул false или gameState некорректен после инициализации.`);
this._cleanupGame(gameId, 'initialization_failed');
}
if (game.mode === 'pvp' && game.playerCount === 2) {
const gameIndex = this.pendingPvPGames.indexOf(gameId);
if (gameIndex > -1) this.pendingPvPGames.splice(gameIndex, 1);
this.broadcastAvailablePvPGames();
}
} else if (mode === 'pvp' && game.playerCount === 1) {
if (!this.pendingPvPGames.includes(gameId)) {
this.pendingPvPGames.push(gameId);
}
game.initializeGame(); // Частичная инициализация
this.broadcastAvailablePvPGames();
}
} else {
this._cleanupGame(gameId, 'player_add_failed');
console.warn(`[GameManager] Не удалось добавить игрока ${socket.id} (идентификатор ${identifier}) в игру ${gameId}. Игра удалена.`);
}
}
joinGame(socket, gameId, identifier) {
const game = this.games[gameId];
if (!game) { socket.emit('gameError', { message: 'Игра с таким ID не найдена.' }); return; }
if (game.mode !== 'pvp') { socket.emit('gameError', { message: 'К этой игре нельзя присоединиться как к PvP.' }); return; }
if (game.playerCount >= 2) { socket.emit('gameError', { message: 'Эта PvP игра уже заполнена.' }); return; }
if (this.userIdentifierToGameId[identifier] && this.games[this.userIdentifierToGameId[identifier]] && this.userIdentifierToGameId[identifier] !== gameId) {
console.warn(`[GameManager] Пользователь ${identifier} (сокет: ${socket.id}) уже в игре ${this.userIdentifierToGameId[identifier]}. Игнорируем запрос на присоединение.`);
socket.emit('gameError', { message: 'Вы уже находитесь в активной или ожидающей игре.' });
this.handleRequestGameState(socket, identifier);
return;
}
if (game.players[socket.id]) { socket.emit('gameError', { message: 'Вы уже в этой игре.' }); return; }
this._removePreviousPendingGames(socket.id, identifier, gameId);
if (game.addPlayer(socket, null, identifier)) {
this.userIdentifierToGameId[identifier] = gameId;
console.log(`[GameManager] Игрок ${identifier} (сокет: ${socket.id}) присоединился к PvP игре ${gameId}`);
if (game.mode === 'pvp' && game.playerCount === 2) {
console.log(`[GameManager] Игра ${gameId} готова к старту. Инициализация и запуск.`);
const isInitialized = game.initializeGame();
if (isInitialized) {
game.startGame();
} else {
console.error(`[GameManager] Не удалось запустить игру ${gameId}: initializeGame вернул false или gameState некорректен после инициализации.`);
this._cleanupGame(gameId, 'initialization_failed');
}
const gameIndex = this.pendingPvPGames.indexOf(gameId);
if (gameIndex > -1) this.pendingPvPGames.splice(gameIndex, 1);
this.broadcastAvailablePvPGames();
}
} else {
console.warn(`[GameManager] Не удалось добавить игрока ${socket.id} (идентификатор ${identifier}) в игру ${gameId}.`);
}
}
findAndJoinRandomPvPGame(socket, chosenCharacterKeyForCreation = 'elena', identifier) {
this._removePreviousPendingGames(socket.id, identifier);
if (this.userIdentifierToGameId[identifier] && this.games[this.userIdentifierToGameId[identifier]]) {
console.warn(`[GameManager] Пользователь ${identifier} (сокет: ${socket.id}) уже в игре ${this.userIdentifierToGameId[identifier]}. Игнорируем запрос на поиск.`);
socket.emit('gameError', { message: 'Вы уже находитесь в активной или ожидающей игре.' });
this.handleRequestGameState(socket, identifier);
return;
}
let gameIdToJoin = null;
const preferredOpponentKey = chosenCharacterKeyForCreation === 'elena' ? 'almagest' : 'elena';
for (const id of this.pendingPvPGames) {
const pendingGame = this.games[id];
if (pendingGame && pendingGame.mode === 'pvp' && pendingGame.playerCount === 1 && pendingGame.ownerIdentifier !== identifier) {
const firstPlayerInfo = Object.values(pendingGame.players).find(p => p.id === GAME_CONFIG.PLAYER_ID);
if (firstPlayerInfo && firstPlayerInfo.chosenCharacterKey === preferredOpponentKey) {
gameIdToJoin = id;
break;
}
if (!gameIdToJoin) gameIdToJoin = id;
}
}
if (gameIdToJoin) {
console.log(`[GameManager] Игрок ${identifier} (сокет: ${socket.id}) нашел игру ${gameIdToJoin} и присоединяется.`);
this.joinGame(socket, gameIdToJoin, identifier);
} else {
console.log(`[GameManager] Игрок ${identifier} (сокет: ${socket.id}) не нашел свободных игр. Создает новую.`);
this.createGame(socket, 'pvp', chosenCharacterKeyForCreation, identifier);
socket.emit('noPendingGamesFound', {
message: 'Свободных PvP игр не найдено. Создана новая игра для вас. Ожидайте противника.',
gameId: this.userIdentifierToGameId[identifier],
yourPlayerId: GAME_CONFIG.PLAYER_ID
});
}
}
handlePlayerAction(identifier, actionData) {
const gameId = this.userIdentifierToGameId[identifier];
const game = this.games[gameId];
if (game && game.players) {
const playerInfo = Object.values(game.players).find(p => p.identifier === identifier);
const currentSocketId = playerInfo?.socket?.id;
if (playerInfo && currentSocketId) {
const actualSocket = this.io.sockets.sockets.get(currentSocketId);
if (actualSocket && actualSocket.connected) {
game.processPlayerAction(currentSocketId, actionData);
} else {
console.warn(`[GameManager] Игрок ${identifier} отправил действие (${actionData?.actionType}), но его текущий сокет (${currentSocketId}) не найден или отключен.`);
}
} else {
console.warn(`[GameManager] Игрок ${identifier} отправил действие (${actionData?.actionType}) для игры ${gameId}, но его запись не найдена в game.players.`);
delete this.userIdentifierToGameId[identifier];
const playerSocket = this.io.sockets.sockets.get(identifier) || playerInfo?.socket;
if (playerSocket) {
playerSocket.emit('gameNotFound', { message: 'Ваша игровая сессия не найдена или завершена.' });
}
}
} else {
console.warn(`[GameManager] Игрок ${identifier} отправил действие (${actionData?.actionType}), но его игра (ID: ${gameId}) не найдена в GameManager.`);
delete this.userIdentifierToGameId[identifier];
const playerSocket = this.io.sockets.sockets.get(identifier);
if (playerSocket) {
playerSocket.emit('gameNotFound', { message: 'Ваша игровая сессия не найдена или завершена.' });
}
}
}
handleDisconnect(socketId, identifier) {
const gameId = this.userIdentifierToGameId[identifier];
const game = this.games[gameId];
if (game && game.players) {
const playerInfo = Object.values(game.players).find(p => p.identifier === identifier);
if (playerInfo) {
console.log(`[GameManager] Игрок ${identifier} (сокет: ${socketId}) отключился. В игре ${gameId}.`);
const disconnectedPlayerRole = playerInfo.id;
const disconnectedCharacterKey = playerInfo.chosenCharacterKey;
game.removePlayer(socketId); // Удаляем именно этот сокет
if (game.playerCount === 0) {
console.log(`[GameManager] Игра ${gameId} пуста после дисконнекта ${socketId} (идентификатор ${identifier}). Удаляем.`);
this._cleanupGame(gameId, 'player_count_zero_on_disconnect');
} else if (game.mode === 'pvp' && game.playerCount === 1 && game.gameState && !game.gameState.isGameOver) {
// Если это PvP игра и остался 1 игрок, и игра НЕ была завершена дисконнектом этого игрока
// (т.е. другой игрок еще в игре)
// Тогда игра переходит в состояние ожидания.
const remainingPlayerInfo = Object.values(game.players)[0]; // Единственный оставшийся игрок
if (remainingPlayerInfo) {
// Проверяем, что это не тот же игрок, что и отключившийся
if (remainingPlayerInfo.identifier !== identifier) {
game.endGameDueToDisconnect(socketId, disconnectedPlayerRole, disconnectedCharacterKey);
// _cleanupGame будет вызван из endGameDueToDisconnect
} else {
// Отключился единственный оставшийся игрок в ожидающей игре.
// _cleanupGame должен быть вызван.
console.log(`[GameManager] Отключился единственный игрок ${identifier} из ожидающей PvP игры ${gameId}. Удаляем игру.`);
this._cleanupGame(gameId, 'last_player_disconnected_from_pending');
}
} else {
// Оставшегося игрока нет, хотя playerCount > 0 - это ошибка, очищаем.
console.error(`[GameManager] Ошибка: playerCount > 0 в игре ${gameId}, но не найден оставшийся игрок после дисконнекта ${identifier}. Очищаем.`);
this._cleanupGame(gameId, 'error_no_remaining_player');
}
} else if (game.gameState && !game.gameState.isGameOver) {
// Если игра была активна (не ожидала) и еще не была завершена,
// дисконнект одного из игроков завершает игру.
game.endGameDueToDisconnect(socketId, disconnectedPlayerRole, disconnectedCharacterKey);
// _cleanupGame будет вызван из endGameDueToDisconnect
} else if (game.gameState?.isGameOver) {
// Если игра уже была завершена до этого дисконнекта, просто удаляем ссылку на игру для отключившегося.
console.log(`[GameManager] Игрок ${identifier} отключился из уже завершенной игры ${gameId}. Удаляем ссылку.`);
delete this.userIdentifierToGameId[identifier];
// _cleanupGame уже был вызван при завершении игры.
} else {
// Другие случаи (например, AI игра, где игрок остался, или ошибка)
console.log(`[GameManager] Игрок ${identifier} отключился из активной игры ${gameId} (mode: ${game.mode}, players: ${game.playerCount}). Удаляем ссылку.`);
delete this.userIdentifierToGameId[identifier];
}
} else {
console.warn(`[GameManager] Игрок с идентификатором ${identifier} (сокет: ${socketId}) не найден в game.players для игры ${gameId}.`);
delete this.userIdentifierToGameId[identifier];
}
} else {
console.log(`[GameManager] Отключился сокет ${socketId} (идентификатор ${identifier}). Игровая сессия по этому идентификатору не найдена.`);
delete this.userIdentifierToGameId[identifier];
}
}
_cleanupGame(gameId, reason = 'unknown_reason') {
const game = this.games[gameId];
if (!game) {
console.warn(`[GameManager] _cleanupGame called for unknown game ID: ${gameId}`);
return false;
}
console.log(`[GameManager] Cleaning up game ${gameId} (Mode: ${game.mode}, Reason: ${reason})...`);
// Очищаем таймеры, если они были активны
if (typeof game.clearTurnTimer === 'function') {
game.clearTurnTimer();
}
Object.values(game.players).forEach(playerInfo => {
if (playerInfo && playerInfo.identifier && this.userIdentifierToGameId[playerInfo.identifier] === gameId) {
delete this.userIdentifierToGameId[playerInfo.identifier];
console.log(`[GameManager] Removed userIdentifierToGameId for ${playerInfo.identifier}.`);
}
});
const pendingIndex = this.pendingPvPGames.indexOf(gameId);
if (pendingIndex > -1) {
this.pendingPvPGames.splice(pendingIndex, 1);
console.log(`[GameManager] Removed game ${gameId} from pendingPvPGames.`);
}
delete this.games[gameId];
console.log(`[GameManager] Deleted GameInstance for game ${gameId}.`);
this.broadcastAvailablePvPGames();
return true;
}
getAvailablePvPGamesListForClient() {
return this.pendingPvPGames
.map(gameId => {
const game = this.games[gameId];
if (game && game.mode === 'pvp' && game.playerCount === 1 && game.gameState && !game.gameState.isGameOver) {
let firstPlayerUsername = 'Игрок';
let firstPlayerCharacterName = '';
const firstPlayerInfo = Object.values(game.players).find(p => p.id === GAME_CONFIG.PLAYER_ID);
if (firstPlayerInfo) {
if (firstPlayerInfo.socket?.userData?.username) {
firstPlayerUsername = firstPlayerInfo.socket.userData.username;
} else {
firstPlayerUsername = `User#${String(firstPlayerInfo.identifier).substring(0, 6)}`;
}
const charKey = firstPlayerInfo.chosenCharacterKey;
if (charKey) {
const charBaseStats = this._getCharacterBaseData(charKey);
if (charBaseStats && charBaseStats.name) {
firstPlayerCharacterName = charBaseStats.name;
} else {
firstPlayerCharacterName = charKey;
}
}
} else {
console.warn(`[GameManager] getAvailablePvPGamesList: firstPlayerInfo (Player 1) не найдена для ожидающей игры ${gameId}.`);
firstPlayerUsername = 'Неизвестный игрок';
}
let statusString = `Ожидает 1 игрока (Создал: ${firstPlayerUsername}`;
if (firstPlayerCharacterName) statusString += ` за ${firstPlayerCharacterName}`;
statusString += `)`;
return { id: gameId, status: statusString };
}
if (game && !this.pendingPvPGames.includes(gameId)) { /* Game not pending */ }
else if (game && game.playerCount === 1 && (game.gameState?.isGameOver || !game.gameState)) { /* Game over or not initialized */ }
else if (game && game.playerCount === 2) { /* Game full */ }
else if (game && game.playerCount === 0) {
console.warn(`[GameManager] getAvailablePvPGamesList: Найдена пустая игра ${gameId} в games. Удаляем.`);
delete this.games[gameId];
}
return null;
})
.filter(info => info !== null);
}
broadcastAvailablePvPGames() {
const availableGames = this.getAvailablePvPGamesListForClient();
this.io.emit('availablePvPGamesList', availableGames);
console.log(`[GameManager] Обновлен список доступных PvP игр. Всего: ${availableGames.length}`);
}
getActiveGamesList() {
return Object.values(this.games).map(game => {
let playerSlotCharName = game.gameState?.player?.name || (game.playerCharacterKey ? this._getCharacterBaseData(game.playerCharacterKey)?.name : 'N/A (ожидание)');
let opponentSlotCharName = game.gameState?.opponent?.name || (game.opponentCharacterKey ? this._getCharacterBaseData(game.opponentCharacterKey)?.name : 'N/A (ожидание)');
const playerInSlot1 = Object.values(game.players).find(p => p.id === GAME_CONFIG.PLAYER_ID);
const playerInSlot2 = Object.values(game.players).find(p => p.id === GAME_CONFIG.OPPONENT_ID);
if (!playerInSlot1) playerSlotCharName = 'Пусто';
if (!playerInSlot2 && game.mode === 'pvp') opponentSlotCharName = 'Ожидание...';
if (!playerInSlot2 && game.mode === 'ai' && game.aiOpponent) opponentSlotCharName = 'Балард (AI)';
return {
id: game.id.substring(0, 8),
mode: game.mode,
playerCount: game.playerCount,
isGameOver: game.gameState ? game.gameState.isGameOver : 'N/A (Не инициализирована)',
playerSlot: playerSlotCharName,
opponentSlot: opponentSlotCharName,
ownerIdentifier: game.ownerIdentifier || 'N/A',
pending: this.pendingPvPGames.includes(game.id),
turn: game.gameState ? `Ход ${game.gameState.turnNumber}, ${game.gameState.isPlayerTurn ? (playerInSlot1?.identifier || 'Player Slot') : (playerInSlot2?.identifier || 'Opponent Slot')}` : 'N/A'
};
});
}
handleRequestGameState(socket, identifier) {
const gameId = this.userIdentifierToGameId[identifier];
let game = gameId ? this.games[gameId] : null;
if (game && game.players) {
const playerInfo = Object.values(game.players).find(p => p.identifier === identifier);
if (playerInfo) {
if (game.gameState?.isGameOver) {
console.log(`[GameManager] Reconnected user ${identifier} to game ${gameId} which is already over. Sending gameNotFound.`);
delete this.userIdentifierToGameId[identifier];
socket.emit('gameNotFound', { message: 'Ваша предыдущая игровая сессия уже завершена.' });
return;
}
console.log(`[GameManager] Found game ${gameId} for identifier ${identifier} (role ${playerInfo.id}). Reconnecting socket ${socket.id}.`);
const oldSocketId = playerInfo.socket?.id;
if (oldSocketId && oldSocketId !== socket.id && game.players[oldSocketId]) {
console.log(`[GameManager] Updating socket ID for player ${identifier} from ${oldSocketId} to ${socket.id} in game ${gameId}.`);
delete game.players[oldSocketId];
if (game.playerSockets[playerInfo.id]?.id === oldSocketId) {
delete game.playerSockets[playerInfo.id];
}
}
game.players[socket.id] = playerInfo;
game.players[socket.id].socket = socket;
game.playerSockets[playerInfo.id] = socket;
socket.join(game.id);
const playerCharDataForClient = this._getCharacterData(playerInfo.chosenCharacterKey);
const opponentActualSlotId = playerInfo.id === GAME_CONFIG.PLAYER_ID ? GAME_CONFIG.OPPONENT_ID : GAME_CONFIG.PLAYER_ID;
let opponentCharacterKeyForClient = game.gameState?.[opponentActualSlotId]?.characterKey || null;
if (!opponentCharacterKeyForClient) {
opponentCharacterKeyForClient = playerInfo.id === GAME_CONFIG.PLAYER_ID ? game.opponentCharacterKey : game.playerCharacterKey;
}
const opponentCharDataForClient = this._getCharacterData(opponentCharacterKeyForClient);
if (playerCharDataForClient && opponentCharDataForClient && game.gameState) {
const isGameReadyForPlay = (game.mode === 'ai' && game.playerCount === 1) || (game.mode === 'pvp' && game.playerCount === 2);
const isOpponentDefinedInState = game.gameState.opponent?.characterKey && game.gameState.opponent?.name !== 'Ожидание игрока...';
socket.emit('gameState', {
gameId: game.id, yourPlayerId: playerInfo.id, gameState: game.gameState,
playerBaseStats: playerCharDataForClient.baseStats, opponentBaseStats: opponentCharDataForClient.baseStats,
playerAbilities: playerCharDataForClient.abilities, opponentAbilities: opponentCharDataForClient.abilities,
log: game.consumeLogBuffer(), clientConfig: { ...GAME_CONFIG }
});
console.log(`[GameManager] Sent gameState to socket ${socket.id} (identifier: ${identifier}) for game ${game.id}.`);
if (!game.gameState.isGameOver && isGameReadyForPlay && !isOpponentDefinedInState) {
console.log(`[GameManager] Game ${game.id} found ready but not fully started on reconnect. Initializing/Starting.`);
const isInitialized = game.initializeGame();
if (isInitialized) {
game.startGame();
} else {
console.error(`[GameManager] Failed to initialize game ${game.id} on reconnect. Cannot start.`);
this.io.to(game.id).emit('gameError', { message: 'Ошибка сервера при старте игры после переподключения.' });
this._cleanupGame(gameId, 'reconnect_initialization_failed');
}
} else if (!isGameReadyForPlay) {
console.log(`[GameManager] Reconnected user ${identifier} to pending game ${gameId}. Sending gameState and waiting status.`);
socket.emit('waitingForOpponent');
} else if (game.gameState.isGameOver) { // Повторная проверка, т.к. startGame мог завершить игру
console.log(`[GameManager] Reconnected to game ${gameId} which is now over (after re-init). Sending gameNotFound.`);
delete this.userIdentifierToGameId[identifier];
socket.emit('gameNotFound', { message: 'Ваша игровая сессия завершилась во время переподключения.' });
} else {
console.log(`[GameManager] Reconnected user ${identifier} to active game ${gameId}. gameState sent.`);
// Важно: если игра активна, нужно отправить и текущее состояние таймера.
// Это можно сделать, вызвав game.startTurnTimer() (он отправит update),
// но только если это ход этого игрока и игра не AI (или ход игрока в AI).
// Или добавить отдельный метод в GameInstance для отправки текущего состояния таймера.
if (typeof game.startTurnTimer === 'function') { // Проверяем, что метод существует
// Перезапуск таймера здесь может быть некорректным, если ход не этого игрока
// Лучше, чтобы gameInstance сам отправлял 'turnTimerUpdate' при gameState
// Либо добавить специальный метод в gameInstance для отправки текущего значения таймера
// Пока оставим так, startTurnTimer сам проверит, чей ход.
game.startTurnTimer();
}
}
} else {
console.error(`[GameManager] Failed to send gameState to ${socket.id} (identifier ${identifier}) for game ${gameId}: missing character data or gameState.`);
socket.emit('gameError', { message: 'Ошибка сервера при восстановлении состояния игры.' });
this._cleanupGame(gameId, 'reconnect_send_failed');
socket.emit('gameNotFound', { message: 'Ваша игровая сессия в некорректном состоянии и была завершена.' });
}
} else {
console.warn(`[GameManager] Found game ${gameId} by identifier ${identifier}, but player with this identifier not found in game.players.`);
delete this.userIdentifierToGameId[identifier];
socket.emit('gameNotFound', { message: 'Ваша игровая сессия не найдена. Возможно, идентификатор пользователя некорректен.' });
}
} else {
console.log(`[GameManager] No active or pending game found for identifier ${identifier}.`);
socket.emit('gameNotFound', { message: 'Игровая сессия не найдена.' });
}
}
_getCharacterData(key) {
if (!key) { console.warn("GameManager::_getCharacterData called with null/undefined key."); return null; }
switch (key) {
case 'elena': return { baseStats: gameData.playerBaseStats, abilities: gameData.playerAbilities };
case 'balard': return { baseStats: gameData.opponentBaseStats, abilities: gameData.opponentAbilities };
case 'almagest': return { baseStats: gameData.almagestBaseStats, abilities: gameData.almagestAbilities };
default: console.error(`GameManager::_getCharacterData: Unknown character key "${key}"`); return null;
}
}
_getCharacterBaseData(key) {
const charData = this._getCharacterData(key);
return charData ? charData.baseStats : null;
}
_getCharacterAbilities(key) {
const charData = this._getCharacterData(key);
return charData ? charData.abilities : null;
}
}
module.exports = GameManager;