Ladebeze66/ft_transcendence
1
0
Fork 0
mirror of https://github.com/AudebertAdrien/ft_transcendence.git synced 2026-02-04 03:30:26 +01:00
Code Issues Packages Projects Releases Wiki Activity

maybelast

Browse Source
This commit is contained in:
Ladebeze66 2024-09-18 14:48:34 +02:00
parent 1932de28cb
commit 029ec14fde
4 changed files with 134 additions and 314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
pong/game/consumers.py
View File

@ -111,41 +111,29 @@ class GameConsumer(AsyncWebsocketConsumer):
###################################################################CHAT################################################################### ###################################################################CHAT###################################################################
class ChatConsumer(AsyncWebsocketConsumer): class ChatConsumer(AsyncWebsocketConsumer):
async def connect(self): async def connect(self):
try:
# Récupérer le nom de la room à partir de l'URL
self.room_group_name = self.scope['url_route']['kwargs']['room_name'] self.room_group_name = self.scope['url_route']['kwargs']['room_name']
# Accepter la connexion WebSocket
await self.accept() await self.accept()
# Ajouter l'utilisateur au groupe (room)
await self.channel_layer.group_add( await self.channel_layer.group_add(
self.room_group_name, self.room_group_name,
self.channel_name self.channel_name
) )
self.username = self.scope['user'].username # Assurez-vous d'avoir un utilisateur lié à la connexion self.username = self.scope['user'].username
logger.info(f"Connexion de l'utilisateur {self.username} à la room {self.room_group_name}")
# Ajouter l'utilisateur à son propre groupe personnel (pour messages directs)
except Exception as e:
logger.error(f"Erreur lors de la connexion WebSocket: {str(e)}")
async def disconnect(self, close_code): async def disconnect(self, close_code):
try:
# Retirer l'utilisateur du groupe (room) # Retirer l'utilisateur du groupe (room)
await self.channel_layer.group_discard( await self.channel_layer.group_discard(
self.room_group_name, self.room_group_name,
self.channel_name self.channel_name
) )
# Retirer l'utilisateur de son groupe personnel # Retirer l'utilisateur de son groupe personnel
await self.channel_layer.group_discard( await self.channel_layer.group_discard(
f"user_{self.username}", f"user_{self.username}",
self.channel_name self.channel_name
) )
# Envoyer un message indiquant que l'utilisateur a quitté la room # Envoyer un message indiquant que l'utilisateur a quitté la room
await self.chat_message( await self.chat_message(
'chat_message', 'chat_message',
@ -153,10 +141,6 @@ class ChatConsumer(AsyncWebsocketConsumer):
f'{self.user.username if hasattr(self, "user") else "Unknown"} a quitté le chat', f'{self.user.username if hasattr(self, "user") else "Unknown"} a quitté le chat',
self.room_group_name self.room_group_name
) )
logger.info(f"{self.user.username if hasattr(self, 'user') else 'Unknown'} déconnecté de la room {self.room_group_name}")
except Exception as e:
logger.error(f"Erreur lors de la déconnexion WebSocket: {str(e)}")
async def receive(self, text_data): async def receive(self, text_data):
try: try:
@ -166,47 +150,26 @@ class ChatConsumer(AsyncWebsocketConsumer):
username = data.get('username') username = data.get('username')
message = data.get('message', None) message = data.get('message', None)
target_user = data.get('target_user', None) target_user = data.get('target_user', None)
logger.info(f"Message reçu: {data}")
# Gestion des différents types de messages # Gestion des différents types de messages
if message_type == 'authenticate': if message_type == 'authenticate':
logger.info(f"Authentification demandée pour {username}")
await self.authenticate(data.get('token'), username) await self.authenticate(data.get('token'), username)
return return
elif message_type == 'chat_message': elif message_type == 'chat_message':
logger.info(f"Message de chat envoyé par {username}: {message}")
await self.chat_message('chat_message', username, message, self.room_group_name) await self.chat_message('chat_message', username, message, self.room_group_name)
elif message_type == 'block_user': elif message_type == 'block_user':
logger.info(f"{username} tente de bloquer {target_user}")
await self.handle_block_user(data) await self.handle_block_user(data)
elif message_type == 'invite': elif message_type == 'invite':
await self.handle_invite_user(data) await self.handle_invite_user(data)
elif message_type == 'invite_response': elif message_type == 'invite_response':
await self.handle_invite_response(data) await self.handle_invite_response(data)
else: else:
logger.warning(f"Type de message non géré: {message_type}")
await self.chat_message('error', 'server', f"Unhandled message type: {message_type}", self.room_group_name) await self.chat_message('error', 'server', f"Unhandled message type: {message_type}", self.room_group_name)
except json.JSONDecodeError as e: except json.JSONDecodeError as e:
logger.error(f"Erreur de décodage JSON : {str(e)} - Données reçues : {text_data}")
await self.chat_message('error', 'server', 'Invalid JSON format', self.room_group_name) await self.chat_message('error', 'server', 'Invalid JSON format', self.room_group_name)
except Exception as e: except Exception as e:
logger.error(f"Erreur lors de la réception du message: {str(e)}")
await self.chat_message('error', 'server', 'Internal server error', self.room_group_name) await self.chat_message('error', 'server', 'Internal server error', self.room_group_name)
async def chat_message(self, message_type, username, message, room): async def chat_message(self, message_type, username, message, room):
"""
Fonction générale pour envoyer tout type de message via WebSocket à tous les utilisateurs dans la room.
"""
logger.info(f"Envoi d'un message de type {message_type} de {username} dans la room {room}")
# Utilisation de channel_layer pour envoyer le message à tout le groupe (room) # Utilisation de channel_layer pour envoyer le message à tout le groupe (room)
await self.channel_layer.group_send( await self.channel_layer.group_send(
room, room,
@ -219,15 +182,10 @@ class ChatConsumer(AsyncWebsocketConsumer):
) )
async def send_group_message(self, event): async def send_group_message(self, event):
"""
Cette fonction est appelée par channel_layer pour envoyer des messages à tous les utilisateurs dans une room.
"""
message = event['message'] message = event['message']
username = event.get('username', 'Anonyme') username = event.get('username', 'Anonyme')
room = event.get('room', 'unknown') room = event.get('room', 'unknown')
logger.info(f"Diffusion d'un message de {username} à la room {room}: {message}")
# Envoi du message à chaque utilisateur dans la room via WebSocket # Envoi du message à chaque utilisateur dans la room via WebSocket
await self.send(text_data=json.dumps({ await self.send(text_data=json.dumps({
'type': 'chat_message', # Le type de message qui sera renvoyé au client 'type': 'chat_message', # Le type de message qui sera renvoyé au client
@ -239,16 +197,10 @@ class ChatConsumer(AsyncWebsocketConsumer):
async def handle_block_user(self, data): async def handle_block_user(self, data):
username = data['username'] username = data['username']
target_user = data['target_user'] target_user = data['target_user']
logger.info(f"handle_block_user appelé avec : {data}")
if target_user == username: if target_user == username:
logger.warning(f"{username} a tenté de se bloquer lui-même.") logger.warning(f"{username} a tenté de se bloquer lui-même.")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'You cannot block yourself'})) await self.send(text_data=json.dumps({'type': 'error', 'message': 'You cannot block yourself'}))
return return
logger.info(f"{username} a bloqué {target_user}")
# Utilisation correcte de l' f-string pour inclure la valeur de target_user # Utilisation correcte de l' f-string pour inclure la valeur de target_user
await self.send(text_data=json.dumps({ await self.send(text_data=json.dumps({
'type': 'block_user', 'type': 'block_user',
@ -260,26 +212,17 @@ class ChatConsumer(AsyncWebsocketConsumer):
inviter = data.get('username') inviter = data.get('username')
target_user = data.get('target_user') target_user = data.get('target_user')
room = data.get('room') room = data.get('room')
# Validation des paramètres # Validation des paramètres
if not inviter: if not inviter:
logger.error("Invitant manquant dans le message d'invitation")
await self.chat_message('error', 'server', 'Invitant manquant', self.room_group_name) await self.chat_message('error', 'server', 'Invitant manquant', self.room_group_name)
return return
if not target_user: if not target_user:
logger.error("Utilisateur cible manquant dans le message d'invitation")
await self.chat_message('error', 'server', 'Utilisateur cible manquant', self.room_group_name) await self.chat_message('error', 'server', 'Utilisateur cible manquant', self.room_group_name)
return return
if not room: if not room:
logger.error("Room manquante dans le message d'invitation")
await self.chat_message('error', 'server', 'Room manquante', self.room_group_name) await self.chat_message('error', 'server', 'Room manquante', self.room_group_name)
return return
logger.info(f"Invitation envoyée de {inviter} à {target_user} dans la room {room}")
await self.chat_message('chat_message', 'server', f'{inviter} a invité {target_user} à rejoindre une partie {room}', room) await self.chat_message('chat_message', 'server', f'{inviter} a invité {target_user} à rejoindre une partie {room}', room)
# Envoi de l'invitation # Envoi de l'invitation
await self.channel_layer.group_send( await self.channel_layer.group_send(
room, room,
@ -298,13 +241,10 @@ class ChatConsumer(AsyncWebsocketConsumer):
response = data.get('response') response = data.get('response')
room = data.get('room') room = data.get('room')
logger.info(f"{username} a répondu '{response}' à l'invitation de {inviter}")
await self.chat_message('chat_message', 'server', f'{username} a répondu {response} à l\'invitation.', room) await self.chat_message('chat_message', 'server', f'{username} a répondu {response} à l\'invitation.', room)
# Si la réponse est 'yes', informer l'invitant que l'invité a accepté
if response.lower() == 'yes': if response.lower() == 'yes':
try: try:
# Informer l'invitant que l'invitation a été acceptée
await self.channel_layer.group_send( await self.channel_layer.group_send(
room, room,
{ {
@ -327,7 +267,6 @@ class ChatConsumer(AsyncWebsocketConsumer):
} }
) )
except Exception as e: except Exception as e:
logger.error(f"Error while sending invite response: {str(e)}")
await self.chat_message('error', 'server', f'Internal server error: {str(e)}', room) await self.chat_message('error', 'server', f'Internal server error: {str(e)}', room)
# Méthode appelée pour envoyer l'invitation à l'utilisateur invité (target_user) # Méthode appelée pour envoyer l'invitation à l'utilisateur invité (target_user)
@ -336,8 +275,6 @@ class ChatConsumer(AsyncWebsocketConsumer):
message = event['message'] message = event['message']
room = event['room'] room = event['room']
target_user = event['target_user'] target_user = event['target_user']
logger.info(f"invite: Envoi de l'invitation à l'utilisateur via WebSocket. Inviter={inviter}, Room={room}, Message={message}")
# Envoyer le message d'invitation via WebSocket # Envoyer le message d'invitation via WebSocket
await self.send(text_data=json.dumps({ await self.send(text_data=json.dumps({
'type': 'invite', 'type': 'invite',
@ -353,7 +290,6 @@ class ChatConsumer(AsyncWebsocketConsumer):
response = data.get('response') response = data.get('response')
room = data.get('room') room = data.get('room')
logger.info(f"{username} a répondu '{response}' à l'invitation de {inviter}")
await self.chat_message('chat_message', 'server', f'{username} a répondu {response} à l\'invitation.', room) await self.chat_message('chat_message', 'server', f'{username} a répondu {response} à l\'invitation.', room)
# Envoi de la réponse directement à l'invitant dans la room # Envoi de la réponse directement à l'invitant dans la room
@ -373,9 +309,6 @@ class ChatConsumer(AsyncWebsocketConsumer):
message = event['message'] message = event['message']
response = event.get('response') response = event.get('response')
inviter = event.get('inviter') # Récupérer l'inviteur inviter = event.get('inviter') # Récupérer l'inviteur
logger.info(f"invite_response: Envoi de la réponse à l'invitation via WebSocket. Message={message}, Response={response}, Inviter={inviter}")
# Envoyer la réponse à l'invitation via WebSocket à l'invitant # Envoyer la réponse à l'invitation via WebSocket à l'invitant
await self.send(text_data=json.dumps({ await self.send(text_data=json.dumps({
'type': 'invite_response', 'type': 'invite_response',
@ -387,32 +320,23 @@ class ChatConsumer(AsyncWebsocketConsumer):
async def authenticate(self, token, username): async def authenticate(self, token, username):
if not token: if not token:
logger.error("Token est manquant, l'authentification ne peut pas se poursuivre.")
await self.chat_message('error', 'server', 'Token is missing', self.room_group_name) await self.chat_message('error', 'server', 'Token is missing', self.room_group_name)
return return
logger.info(f"Tentative d'authentification avec le token: {token} pour l'utilisateur: {username}")
try: try:
user = await self.get_user_from_token(token) user = await self.get_user_from_token(token)
if user: if user:
self.user = user self.user = user
logger.info(f"Utilisateur {username} authentifié avec succès")
await self.chat_message('authenticated', username, 'Authentication successful', self.room_group_name) await self.chat_message('authenticated', username, 'Authentication successful', self.room_group_name)
else: else:
logger.warning(f"Échec de l'authentification pour le token: {token}")
await self.chat_message('error', username, 'Authentication failed', self.room_group_name) await self.chat_message('error', username, 'Authentication failed', self.room_group_name)
except Exception as e: except Exception as e:
logger.error(f"Erreur lors de l'authentification : {str(e)}")
await self.chat_message('error', 'server', 'Internal server error', self.room_group_name) await self.chat_message('error', 'server', 'Internal server error', self.room_group_name)
@sync_to_async @sync_to_async
def get_user_from_token(self, token): def get_user_from_token(self, token):
try: try:
user = User.objects.filter(auth_token=token).first() user = User.objects.filter(auth_token=token).first()
logger.debug(f"Utilisateur trouvé : {user} pour le token : {token}")
return user return user
except User.DoesNotExist: except User.DoesNotExist:
logger.warning(f"Utilisateur non trouvé pour le token : {token}")
return None return None

7
pong/game/routing.py
View File

@ -1,15 +1,8 @@
# /pong/game/routing.py # /pong/game/routing.py
from django.urls import re_path from django.urls import re_path
from . import consumers from . import consumers
import logging
logger = logging.getLogger(__name__)
logger.debug("Configuring WebSocket routing patterns")
websocket_urlpatterns = [ websocket_urlpatterns = [
re_path(r'ws/game/$', consumers.GameConsumer.as_asgi(), name='game_ws'), re_path(r'ws/game/$', consumers.GameConsumer.as_asgi(), name='game_ws'),
re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer.as_asgi()), re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer.as_asgi()),
] ]
logger.info("WebSocket routing patterns configured successfully")

1
pong/static/burger.js
View File

@ -100,6 +100,7 @@ document.addEventListener('DOMContentLoaded', () => {
} }
// Expose fetchPlayers globalement // Expose fetchPlayers globalement
window.fetchPlayers = fetchPlayers; window.fetchPlayers = fetchPlayers;
function fetchTournois(){ function fetchTournois(){
console.log('Fetching tournois...'); console.log('Fetching tournois...');
fetch('/api/tournoi_list/') fetch('/api/tournoi_list/')

216
pong/static/game.js
View File

@ -124,12 +124,10 @@ document.addEventListener('DOMContentLoaded', () => {
}, },
body: JSON.stringify({ username }) body: JSON.stringify({ username })
}); });
if (!response.ok) { if (!response.ok) {
console.error(`HTTP error! Status: ${response.status}`); console.error(`HTTP error! Status: ${response.status}`);
return false; return false;
} }
const data = await response.json(); const data = await response.json();
console.log("User existence check response:", data); console.log("User existence check response:", data);
return data.exists; return data.exists;
@ -145,37 +143,18 @@ document.addEventListener('DOMContentLoaded', () => {
const password = passwordInput.value.trim(); const password = passwordInput.value.trim();
const confirmPassword = confirmPasswordInput.value.trim(); const confirmPassword = confirmPasswordInput.value.trim();
console.log("Nickname:", nickname);
console.log("Password:", password);
console.log("Confirm Password:", confirmPassword);
if (password === confirmPassword) { if (password === confirmPassword) {
try { try {
console.log("Attempting to register user:", nickname);
const result = await registerUser(nickname, password); const result = await registerUser(nickname, password);
console.log("Register result:", result); if (result.registered) {
token = result.token;
if (result.registered) { // Vérifiez que result contient bien un champ registered
token = result.token; // Assurez-vous que le token est bien stocké ici
console.log("Token stored:", token); console.log("Token stored:", token);
console.log("User registered successfully"); console.log("User registered successfully");
registerForm.style.display = 'none'; registerForm.style.display = 'none';
document.getElementById("post-form-buttons").style.display = 'block'; document.getElementById("post-form-buttons").style.display = 'block';
username = nickname; username = nickname;
roomName = 'main_room'; // Nom de la room principale roomName = 'main_room';
console.log("ChatManager initialized:", chatManager); chatManager = new ChatManager(username, token);
console.log("Initializing ChatManager with username:", username, "and token:", token);
chatManager = new ChatManager(username, token); // Initialiser ChatManager
console.log("ChatManager initialized:", chatManager);
// Ajoutez un log pour vérifier si chatManager est défini
if (chatManager) {
console.log("chatManager is defined:", chatManager);
} else {
console.error("chatManager is not defined");
}
console.log("Joining room:", roomName);
chatManager.joinRoom(roomName); // Utilisez ChatManager pour rejoindre la room chatManager.joinRoom(roomName); // Utilisez ChatManager pour rejoindre la room
} else { } else {
console.error('Registration failed. No token received.'); console.error('Registration failed. No token received.');
@ -302,7 +281,6 @@ document.addEventListener('DOMContentLoaded', () => {
console.error(`HTTP error! Status: ${response.status}`); console.error(`HTTP error! Status: ${response.status}`);
return false; return false;
} }
const data = await response.json(); const data = await response.json();
console.log("User existence check response (checkUserExists2):", data); console.log("User existence check response (checkUserExists2):", data);
return data.exists; return data.exists;
@ -418,24 +396,19 @@ document.addEventListener('DOMContentLoaded', () => {
type: 'quick' type: 'quick'
} }
console.log("Starting quick match...(fonction startquickmatch)"); console.log("Starting quick match...(fonction startquickmatch)");
// Masquer les éléments inutiles et afficher le conteneur de jeu
gameContainer.style.display = 'flex'; gameContainer.style.display = 'flex';
logo.style.display = 'none'; logo.style.display = 'none';
pongElements.style.display = 'none'; pongElements.style.display = 'none';
formBlock.style.display = 'none'; formBlock.style.display = 'none';
// Vérification si une connexion WebSocket est déjà active avant d'initialiser document.getElementById('player1-name').textContent = "player 1";
if (roomSockets["quick_match"] && roomSockets["quick_match"].readyState === WebSocket.OPEN) document.getElementById('player2-name').textContent = "player 2";
{ document.getElementById('game-text').textContent = "";
console.warn("WebSocket for quick_match already open."); document.getElementById('player1-score').textContent = 0;
// On laisse startWebSocketConnection se lancer malgré la WebSocket ouverte document.getElementById('player2-score').textContent = 0;
startWebSocketConnection(token, 1);
return;
}
roomName = "quick_match"; // Nom de la room principale
chatManager = new ChatManager(username, token); // Initialiser ChatManager chatManager = new ChatManager(username, token); // Initialiser ChatManager
chatManager.joinRoom(roomName); // Utilisez ChatManager pour rejoindre la room chatManager.joinRoom('quick_match'); // ChatManager pour rejoindre la quick_match
console.log("Starting WebSocket connection for quick match..."); console.log("Starting WebSocket connection for quick match...");
startWebSocketConnection(token, 1); // Le "1" pourrait être un identifiant pour le mode Quick Match startWebSocketConnection(token, 1);
} }
// Fonction pour démarrer un tournoi // Fonction pour démarrer un tournoi
@ -444,105 +417,94 @@ document.addEventListener('DOMContentLoaded', () => {
saveData = { saveData = {
type: 'tournoi' type: 'tournoi'
}; };
// Masquer les éléments inutiles et afficher le conteneur du tournoi
tournamentContainer.style.display = 'flex'; tournamentContainer.style.display = 'flex';
logo.style.display = 'none'; logo.style.display = 'none';
pongElements.style.display = 'none'; pongElements.style.display = 'none';
formBlock.style.display = 'none'; formBlock.style.display = 'none';
// Log pour vérifier le token avant l'authentification WebSocket chatManager = new ChatManager(username, token);
// Vérification si une connexion WebSocket est déjà active avant d'initialiser chatManager.joinRoom('tournament'); // ChatManager pour rejoindre la tournament
if (roomSockets["tournament"] && roomSockets["tournament"].readyState === WebSocket.OPEN)
{
console.warn("WebSocket for tournament already open.");
// On laisse startWebSocketConnection se lancer malgré la WebSocket ouverte
startWebSocketConnection(token, 42);
return;
}
chatManager = new ChatManager(username, token); // Initialiser ChatManager
chatManager.joinRoom('tournament'); // Utilisez ChatManager pour rejoindre la room
console.log("Starting WebSocket connection for tournament..."); console.log("Starting WebSocket connection for tournament...");
startWebSocketConnection(token, 42); // Le "42" pourrait être un identifiant pour le mode tournoi startWebSocketConnection(token, 42);
} }
function startWebSocketConnection(token, players) { function startWebSocketConnection(token, players) {
// Si le socket existe déjà et est ouvert, le fermer if (socket && socket.readyState === WebSocket.OPEN) {
/*if (socket && socket.readyState === WebSocket.OPEN) socket.close();
{ }
console.warn('WebSocket connection already open. Closing and recreating a new one.');
socket.close(); // Fermer le socket ouvert
}*/
socket = new WebSocket(`wss://${window.location.host}/ws/game/`); socket = new WebSocket(`wss://${window.location.host}/ws/game/`);
socket.onopen = function (event) { socket.onopen = function (event) {
console.log('WebSocket connection established'); console.log('WebSocket connection established');
if (players === 1) { if (players === 1) {
console.log("Sending token for a quick match game");
socket.send(JSON.stringify({ type: 'authenticate', token: token })); socket.send(JSON.stringify({ type: 'authenticate', token: token }));
} else if (players === 2) { } else if (players === 2) {
console.log("Sending tokens for a local game");
socket.send(JSON.stringify({ type: 'authenticate2', token_1: token, token_2: token2 })); socket.send(JSON.stringify({ type: 'authenticate2', token_1: token, token_2: token2 }));
} else { } else {
console.log("Sending token for a tournament game");
socket.send(JSON.stringify({ type: 'authenticate3', token: token })); socket.send(JSON.stringify({ type: 'authenticate3', token: token }));
} }
}; };
socket.onmessage = function (event) { socket.onmessage = function (event) {
const data = JSON.parse(event.data); const data = JSON.parse(event.data);
if (data.type === 'authenticated') { switch (data.type) {
case 'authenticated':
console.log('Authentication successful'); console.log('Authentication successful');
} else if (data.type === 'waiting_room') { break;
case 'waiting_room':
console.log('Entered the WAITING ROOM'); console.log('Entered the WAITING ROOM');
} else if (data.type === 'game_start') { break;
case 'game_start':
console.log('Game started:', data.game_id, '(', data.player1, 'vs', data.player2, ')'); console.log('Game started:', data.game_id, '(', data.player1, 'vs', data.player2, ')');
gameContainer.style.display = 'flex'; gameContainer.style.display = 'flex';
document.addEventListener('keydown', handleKeyDown); document.addEventListener('keydown', handleKeyDown);
} else if (data.type === 'game_state_update') { break;
case 'game_state_update':
updateGameState(data.game_state); updateGameState(data.game_state);
} else if (data.type === 'player_disconnected') { break;
case 'player_disconnected':
console.log('Player disconnected:', data.player); console.log('Player disconnected:', data.player);
} else if (data.type === 'game_ended') { break;
case 'game_ended':
console.log('Game ended:', data.game_id); console.log('Game ended:', data.game_id);
} else if (data.type === 'error') { break;
case 'error':
console.error(data.message); console.error(data.message);
} else if (data.type === 'update_tournament_waiting_room') { break;
// Update the HTML content of the tournament bracket case 'update_tournament_waiting_room':
document.getElementById('tournament-bracket').innerHTML = data.html; document.getElementById('tournament-bracket').innerHTML = data.html;
// Reattach the event listener to the "Start Tournament" button
const startButton = document.getElementById('start-tournament-btn'); const startButton = document.getElementById('start-tournament-btn');
if (startButton) { if (startButton) {
startButton.addEventListener('click', function() { startButton.addEventListener('click', function() {
if (typeof socket !== 'undefined' && socket.readyState === WebSocket.OPEN) { if (typeof socket !== 'undefined' && socket.readyState === WebSocket.OPEN) {
console.log('Start TOURNAMENT sent..'); console.log('Start TOURNAMENT sent..');
socket.send(JSON.stringify({type: 'start_tournament'})); socket.send(JSON.stringify({ type: 'start_tournament' }));
} else { } else {
console.error('WebSocket is not open or undefined'); console.error('WebSocket is not open or undefined');
} }
}); });
} }
} else if (data.type === 'update_brackets') { break;
// Update the HTML content of the tournament bracket case 'update_brackets':
document.getElementById('tournament-bracket').innerHTML = data.html; document.getElementById('tournament-bracket').innerHTML = data.html;
} else if (data.type === 'tournament_end') { break;
case 'tournament_end':
console.log('Tournament ended, the winner is:', data.winner); console.log('Tournament ended, the winner is:', data.winner);
// Nouveau cas pour gérer les prochains matchs du tournoi break;
} else if (data.type === 'tournament_match') { case 'tournament_match':
console.log('Prochain match du tournoi:', data.message); console.log('Prochain match du tournoi:', data.message);
// Transmettre le message au chat via WebSocket du chat
if (chatManager.chatSocket && chatManager.chatSocket.readyState === WebSocket.OPEN) { if (chatManager.chatSocket && chatManager.chatSocket.readyState === WebSocket.OPEN) {
chatManager.chatSocket.send(JSON.stringify({ chatManager.chatSocket.send(JSON.stringify({
type: 'chat_message', type: 'chat_message',
message: data.message, message: data.message,
username: 'Server', // Ou le nom d'utilisateur si pertinent username: 'Server',
room: 'tournament' // Ou la room appropriée room: 'tournament'
})); }));
} }
} else { break;
default:
console.log('Message from server:', data.type, data.message); console.log('Message from server:', data.type, data.message);
} }
}; };
// Gestion des fermetures de connexion
socket.onclose = function (event) { socket.onclose = function (event) {
console.log('WebSocket connection closed'); console.log('WebSocket connection closed');
}; };
@ -552,7 +514,6 @@ document.addEventListener('DOMContentLoaded', () => {
}; };
} }
// Gestion des événements de touche
function handleKeyDown(event) { function handleKeyDown(event) {
console.log("Key pressed:", event.key); console.log("Key pressed:", event.key);
if (event.key === 'ArrowUp' || event.key === 'ArrowDown' || event.key === 'w' || event.key === 's') { if (event.key === 'ArrowUp' || event.key === 'ArrowDown' || event.key === 'w' || event.key === 's') {
@ -575,7 +536,6 @@ document.addEventListener('DOMContentLoaded', () => {
checkForWinner(); checkForWinner();
} }
// Fonction pour rendre l'état du jeu à l'écran
function renderGame() { function renderGame() {
console.log("Rendering game state..."); console.log("Rendering game state...");
document.getElementById('player1-name').textContent = `${gameState.player1_name}`; document.getElementById('player1-name').textContent = `${gameState.player1_name}`;
@ -645,23 +605,16 @@ document.addEventListener('DOMContentLoaded', () => {
} }
} }
} }
///////////////////////CHECK STATS//////////////////////////////////////
function sendStatsCommand(targetUser) { function sendStatsCommand(targetUser) {
console.log(`Detected stats command for user: ${targetUser}`); console.log(`Detected stats command for user: ${targetUser}`);
// Appelle fetchPlayers et utilise .then() pour traiter les résultats
fetchPlayers().then((players) => { fetchPlayers().then((players) => {
if (!players) { if (!players) {
console.log('No players found.'); console.log('No players found.');
return; return;
} }
console.log('Players received in sendStatsCommand:', players); // Affiche les joueurs récupérés
// Filtrer et récupérer les informations du joueur spécifique
const playerStats = filterPlayers(targetUser, players); // Passer le tableau players en paramètre const playerStats = filterPlayers(targetUser, players); // Passer le tableau players en paramètre
if (playerStats) { if (playerStats) {
// Si les stats sont trouvées, afficher la popup avec les données
displayPlayerStats(playerStats); displayPlayerStats(playerStats);
} else { } else {
console.log(`Player with username ${targetUser} not found.`); console.log(`Player with username ${targetUser} not found.`);
@ -671,44 +624,34 @@ document.addEventListener('DOMContentLoaded', () => {
}); });
} }
// Modification de filterPlayers pour chercher dans les données reçues (JSON) function filterPlayers(targetUser, players) {
function filterPlayers(targetUser, players) { const searchValue = targetUser.toLowerCase();
const searchValue = targetUser.toLowerCase(); // Utiliser le nom d'utilisateur comme valeur de recherche
for (let i = 0; i < players.length; i++) { for (let i = 0; i < players.length; i++) {
const player = players[i]; const player = players[i];
if (player.name && player.name.toLowerCase() === searchValue) { if (player.name && player.name.toLowerCase() === searchValue) {
// Récupérer les statistiques du joueur à partir des données reçues
const playerStats = { const playerStats = {
username: player.name, username: player.name,
total_matches: player.total_match, total_matches: player.total_match,
total_wins: player.total_win, total_wins: player.total_win,
win_percentage: player.p_win, win_percentage: player.p_win,
best_score: player.best_score || 'N/A' // Ajoute une gestion de cas si best_score n'existe pas best_score: player.best_score || 'N/A'
}; };
return playerStats; // Retourne les stats du joueur return playerStats;
} }
} }
return null;
return null; // Retourne null si le joueur n'est pas trouvé }
}
function displayPlayerStats(stats) { function displayPlayerStats(stats) {
console.log('Displaying player stats:', stats); // Vérifie que la fonction est bien appelée
// Créer ou récupérer l'élément popup
let statsPopup = document.getElementById('player-stats-popup'); let statsPopup = document.getElementById('player-stats-popup');
if (!statsPopup) { if (!statsPopup) {
console.log('Creating stats popup element'); // Vérifie si l'élément est bien créé
statsPopup = document.createElement('div'); statsPopup = document.createElement('div');
statsPopup.id = 'player-stats-popup'; statsPopup.id = 'player-stats-popup';
statsPopup.classList.add('player-stats-popup'); statsPopup.classList.add('player-stats-popup');
document.body.appendChild(statsPopup); document.body.appendChild(statsPopup);
} }
// Mettre à jour le contenu de la popup avec les statistiques
statsPopup.innerHTML = ` statsPopup.innerHTML = `
<h3>Player Stats</h3> <h3>Player Stats</h3>
<p><strong>Username:</strong> ${stats.username}</p> <p><strong>Username:</strong> ${stats.username}</p>
@ -717,95 +660,56 @@ function filterPlayers(targetUser, players) {
<p><strong>Win Percentage:</strong> ${stats.win_percentage}%</p> <p><strong>Win Percentage:</strong> ${stats.win_percentage}%</p>
<p><strong>Best Score:</strong> ${stats.best_score}</p> <p><strong>Best Score:</strong> ${stats.best_score}</p>
`; `;
// Afficher la popup avec une animation
statsPopup.classList.add('show'); statsPopup.classList.add('show');
statsPopup.classList.remove('hide'); statsPopup.classList.remove('hide');
// Masquer la popup après 5 secondes
setTimeout(() => { setTimeout(() => {
statsPopup.classList.remove('show'); statsPopup.classList.remove('show');
statsPopup.classList.add('hide'); statsPopup.classList.add('hide');
}, 3000); }, 5000);
} }
////////////////////////////CHAT//////////////////////////////////// ////////////////////////////CHAT////////////////////////////////////
class ChatManager { class ChatManager {
constructor(username, token) { constructor(username, token) {
this.username = username; this.username = username;
this.token = token; this.token = token;
this.roomSockets = {}; // Stockage des WebSockets par room this.roomSockets = {};
this.blockedUsers = []; // Liste des utilisateurs bloqués this.blockedUsers = [];
this.activeRoom = null; // La room actuellement active this.activeRoom = null;
this.chatSocket = null; // Le WebSocket de chat actif this.chatSocket = null;
console.log(`ChatManager initialized for user: ${username}`);
this.initializeEventListeners(); // Initialiser les gestionnaires d'événements
} }
initializeEventListeners() {
const quitButton = document.getElementById('quit-room-btn');
if (quitButton) {
quitButton.addEventListener('click', () => {
if (this.activeRoom) {
this.leaveRoom(this.activeRoom);
console.log(`User ${this.username} has left the room ${this.activeRoom}`);
} else {
console.warn('No active room to leave.');
}
});
}
}
startChatWebSocket(roomName) { startChatWebSocket(roomName) {
if (!this.username || this.username.trim() === '') { if (!this.username || this.username.trim() === '') {
console.error("Username is not defined or empty. WebSocket connection aborted.");
alert("Username is required to join the chat. Please log in."); alert("Username is required to join the chat. Please log in.");
return; return;
} }
if (this.roomSockets[roomName] && this.roomSockets[roomName].readyState === WebSocket.OPEN) { if (this.roomSockets[roomName] && this.roomSockets[roomName].readyState === WebSocket.OPEN) {
console.warn(`WebSocket for room ${roomName} already open.`); console.warn(`WebSocket for room ${roomName} already open.`);
return; return;
} }
console.log("Initializing chat WebSocket...");
console.log(`Initializing chat WebSocket for room: ${roomName} with username: ${this.username}`);
try { try {
this.chatSocket = new WebSocket(`wss://${window.location.host}/ws/chat/${roomName}/`); this.chatSocket = new WebSocket(`wss://${window.location.host}/ws/chat/${roomName}/`);
this.roomSockets[roomName] = this.chatSocket; // Stockage du WebSocket this.roomSockets[roomName] = this.chatSocket;
console.log(`startChatWebSocket: ${roomName} with username: ${this.username} and token: ${this.token}`); const chatInputInstance = new ChatInput(roomName, this.username, this.chatSocket, this);
const chatInputInstance = new ChatInput(roomName, this.username, this.chatSocket, this); // On passe l'instance du manager
// Gestion de l'ouverture du WebSocket
this.chatSocket.onopen = () => { this.chatSocket.onopen = () => {
console.log(`WebSocket ouvert pour l'utilisateur ${this.username} dans la room ${roomName}`);
this.chatSocket.send(JSON.stringify({ this.chatSocket.send(JSON.stringify({
'type': 'authenticate', 'type': 'authenticate',
'username': this.username, 'username': this.username,
'token': this.token, 'token': this.token,
'room': roomName, 'room': roomName,
})); }));
console.log(`Authentication message sent for room: ${roomName} with username: ${this.username}`);
}; };
// Gestion des messages WebSocket
this.chatSocket.onmessage = (event) => { this.chatSocket.onmessage = (event) => {
const data = JSON.parse(event.data); const data = JSON.parse(event.data);
console.log(`Message received from server in room ${roomName}:`, data); console.log(`Message received from server in room ${roomName}:`, data);
const receivedUsername = data.username || this.username; const receivedUsername = data.username || this.username;
// Assurez-vous que le chat log est bien trouvé pour la room active
let chatLog = document.getElementById(`chat-log-${roomName}`); let chatLog = document.getElementById(`chat-log-${roomName}`);
if (!chatLog) { if (!chatLog) {
console.error(`Chat log element for room ${roomName} not found.`); console.error(`Chat log element for room ${roomName} not found.`);
return; return;
} }
switch (data.type) { switch (data.type) {
case 'authenticated': case 'authenticated':
console.log(`User authenticated successfully in room: ${roomName}`); console.log(`User authenticated successfully in room: ${roomName}`);
@ -815,8 +719,6 @@ function filterPlayers(targetUser, players) {
const message = data.message; const message = data.message;
const receivedUsername = data.username; const receivedUsername = data.username;
const roomName = data.room; const roomName = data.room;
// Si l'utilisateur n'est pas bloqué, afficher le message
if (!this.blockedUsers.includes(receivedUsername)) { if (!this.blockedUsers.includes(receivedUsername)) {
const messageElement = document.createElement('div'); const messageElement = document.createElement('div');
messageElement.textContent = `${receivedUsername}: ${message}`; messageElement.textContent = `${receivedUsername}: ${message}`;
@ -1017,7 +919,7 @@ function filterPlayers(targetUser, players) {
console.log(`Joining new room: ${roomName}`); console.log(`Joining new room: ${roomName}`);
this.createRoomTab(roomName); this.createRoomTab(roomName);
this.showRoomTab(roomName); this.showRoomTab(roomName);
this.startChatWebSocket(roomName); // Utilisation du ChatManager pour démarrer le WebSocket this.startChatWebSocket(roomName); //ChatManager pour démarrer le WebSocket
} }
this.switchRoom(roomName); this.switchRoom(roomName);