mirror of
https://github.com/AudebertAdrien/ft_transcendence.git
synced 2026-11-09 18:17:07 +01:00
fernand
This commit is contained in:
@@ -1,465 +0,0 @@
|
||||
import json
|
||||
from channels.generic.websocket import AsyncWebsocketConsumer
|
||||
from asgiref.sync import sync_to_async
|
||||
from django.contrib.auth.models import User
|
||||
from channels.db import database_sync_to_async
|
||||
from .matchmaking import match_maker
|
||||
from .tournament import tournament_match_maker
|
||||
import logging
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
class GameConsumer(AsyncWebsocketConsumer):
|
||||
async def connect(self):
|
||||
try:
|
||||
await self.accept()
|
||||
self.game = None
|
||||
logger.info("User connected via WebSocket")
|
||||
except Exception as e:
|
||||
logger.error(f"Error during WebSocket connection: {str(e)}")
|
||||
|
||||
async def receive(self, text_data):
|
||||
try:
|
||||
logger.debug(f"Received data: {text_data}")
|
||||
data = json.loads(text_data)
|
||||
message_type = data.get('type')
|
||||
|
||||
if message_type == 'authenticate':
|
||||
await self.authenticate(data.get('token'))
|
||||
elif message_type == 'authenticate2':
|
||||
await self.authenticate2(data.get('token_1'), data.get('token_2'))
|
||||
elif message_type == 'authenticate3':
|
||||
await self.authenticate3(data.get('token'))
|
||||
elif message_type == 'key_press':
|
||||
if self.game:
|
||||
await self.game.handle_key_press(self, data.get('key'))
|
||||
else:
|
||||
await match_maker.handle_key_press(self, data.get('key'))
|
||||
else:
|
||||
logger.warning(f"Received unknown message type: {message_type}")
|
||||
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Unknown message type'}))
|
||||
except json.JSONDecodeError as e:
|
||||
logger.error(f"JSON decode error: {str(e)} - Data received: {text_data}")
|
||||
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Invalid JSON format'}))
|
||||
except Exception as e:
|
||||
logger.error(f"Error in WebSocket receive: {str(e)}")
|
||||
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
|
||||
|
||||
async def authenticate(self, token):
|
||||
if not token:
|
||||
logger.error("Token is None, authentication cannot proceed")
|
||||
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Token is missing'}))
|
||||
return
|
||||
try:
|
||||
user = await self.get_user_from_token(token)
|
||||
if user:
|
||||
self.user = user
|
||||
await self.send(text_data=json.dumps({'type': 'authenticated'}))
|
||||
logger.info(f"User {self.user} authenticated")
|
||||
await self.join_waiting_room()
|
||||
else:
|
||||
logger.warning(f"Authentication failed for token: {token}")
|
||||
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed'}))
|
||||
except Exception as e:
|
||||
logger.error(f"Error during authentication: {str(e)}")
|
||||
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
|
||||
|
||||
async def authenticate2(self, token_1, token_2):
|
||||
try:
|
||||
user = await self.get_user_from_token(token_1)
|
||||
if user:
|
||||
self.user = user
|
||||
await self.send(text_data=json.dumps({'type': 'authenticated'}))
|
||||
logger.info(f"User {self.user} authenticated with token_1")
|
||||
|
||||
user2 = await self.get_user_from_token2(token_2)
|
||||
if user2:
|
||||
self.user2 = user2
|
||||
await self.send(text_data=json.dumps({'type': 'authenticated'}))
|
||||
logger.info(f"User {self.user2} authenticated with token_2")
|
||||
await match_maker.create_game(self, None, True)
|
||||
else:
|
||||
logger.warning(f"Authentication failed for token_2: {token_2}")
|
||||
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed for user 2'}))
|
||||
else:
|
||||
logger.warning(f"Authentication failed for token_1: {token_1}")
|
||||
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed for user 1'}))
|
||||
except Exception as e:
|
||||
logger.error(f"Error during dual authentication: {str(e)}")
|
||||
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
|
||||
|
||||
async def authenticate3(self, token):
|
||||
try:
|
||||
user = await self.get_user_from_token(token)
|
||||
if user:
|
||||
self.user = user
|
||||
await self.send(text_data=json.dumps({'type': 'authenticated'}))
|
||||
logger.info(f"User {self.user} authenticated for tournament")
|
||||
await self.join_tournament_waiting_room()
|
||||
else:
|
||||
logger.warning(f"Authentication failed for token: {token}")
|
||||
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed'}))
|
||||
except Exception as e:
|
||||
logger.error(f"Error during tournament authentication: {str(e)}")
|
||||
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
|
||||
|
||||
@database_sync_to_async
|
||||
def get_user_from_token(self, token):
|
||||
try:
|
||||
user = User.objects.filter(auth_token=token).first()
|
||||
logger.debug(f"User found: {user} for token: {token}")
|
||||
return user
|
||||
except User.DoesNotExist:
|
||||
logger.warning(f"User not found for token: {token}")
|
||||
return None
|
||||
|
||||
@database_sync_to_async
|
||||
def get_user_from_token2(self, token):
|
||||
try:
|
||||
user2 = User.objects.filter(auth_token=token).first()
|
||||
logger.debug(f"User2 found: {user2} for token: {token}")
|
||||
return user2
|
||||
except User.DoesNotExist:
|
||||
logger.warning(f"User not found for token_2: {token}")
|
||||
return None
|
||||
|
||||
async def join_waiting_room(self):
|
||||
logger.info("Joining waiting room")
|
||||
await self.send(text_data=json.dumps({'type': 'waiting_room'}))
|
||||
await match_maker.add_player(self)
|
||||
|
||||
async def join_tournament_waiting_room(self):
|
||||
logger.info("Joining tournament waiting room")
|
||||
await tournament_match_maker.add_player(self)
|
||||
|
||||
async def disconnect(self, close_code):
|
||||
try:
|
||||
if self.game:
|
||||
await self.game.end_game(disconnected_player=self)
|
||||
await match_maker.remove_player(self)
|
||||
await tournament_match_maker.remove_player(self)
|
||||
logger.info(f"User {self.user.username if hasattr(self, 'user') else 'Unknown'} disconnected")
|
||||
except Exception as e:
|
||||
logger.error(f"Error during WebSocket disconnection: {str(e)}")
|
||||
|
||||
async def set_game(self, game):
|
||||
logger.info(f"Setting game: {game}")
|
||||
self.game = game
|
||||
|
||||
###################################################################CHAT###################################################################
|
||||
class ChatConsumer(AsyncWebsocketConsumer):
|
||||
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']
|
||||
|
||||
# Accepter la connexion WebSocket
|
||||
await self.accept()
|
||||
# Ajouter l'utilisateur au groupe (room)
|
||||
await self.channel_layer.group_add(
|
||||
self.room_group_name,
|
||||
self.channel_name
|
||||
)
|
||||
|
||||
self.username = self.scope['user'].username # Assurez-vous d'avoir un utilisateur lié à la connexion
|
||||
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):
|
||||
try:
|
||||
# Retirer l'utilisateur du groupe (room)
|
||||
await self.channel_layer.group_discard(
|
||||
self.room_group_name,
|
||||
self.channel_name
|
||||
)
|
||||
|
||||
# Retirer l'utilisateur de son groupe personnel
|
||||
await self.channel_layer.group_discard(
|
||||
f"user_{self.username}",
|
||||
self.channel_name
|
||||
)
|
||||
|
||||
# Envoyer un message indiquant que l'utilisateur a quitté la room
|
||||
await self.chat_message(
|
||||
'chat_message',
|
||||
self.user.username if hasattr(self, "user") else "Unknown",
|
||||
f'{self.user.username if hasattr(self, "user") else "Unknown"} a quitté le chat',
|
||||
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):
|
||||
try:
|
||||
# Convertir les données JSON reçues en dictionnaire Python
|
||||
data = json.loads(text_data)
|
||||
message_type = data.get('type')
|
||||
username = data.get('username')
|
||||
message = data.get('message', None)
|
||||
target_user = data.get('target_user', None)
|
||||
|
||||
logger.info(f"Message reçu: {data}")
|
||||
|
||||
if not username:
|
||||
logger.error(f"Username manquant dans le message: {data}")
|
||||
await self.chat_message('error', 'server', 'Username is missing', self.room_group_name)
|
||||
return
|
||||
|
||||
# Gestion des différents types de messages
|
||||
if message_type == 'authenticate':
|
||||
logger.info(f"Authentification demandée pour {username}")
|
||||
await self.authenticate(data.get('token'), username)
|
||||
return
|
||||
|
||||
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)
|
||||
|
||||
elif message_type == 'block_user':
|
||||
logger.info(f"{username} tente de bloquer {target_user}")
|
||||
await self.handle_block_user(data)
|
||||
|
||||
elif message_type == 'invite':
|
||||
await self.handle_invite_user(data)
|
||||
|
||||
elif message_type == 'invite_response':
|
||||
await self.handle_invite_response(data)
|
||||
|
||||
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)
|
||||
|
||||
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)
|
||||
|
||||
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)
|
||||
|
||||
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)
|
||||
await self.channel_layer.group_send(
|
||||
room,
|
||||
{
|
||||
'type': 'send_group_message', # Nom de la méthode qui va gérer ce message
|
||||
'username': username,
|
||||
'message': message,
|
||||
'room': room
|
||||
}
|
||||
)
|
||||
|
||||
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']
|
||||
username = event.get('username', 'Anonyme')
|
||||
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
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'chat_message', # Le type de message qui sera renvoyé au client
|
||||
'username': username,
|
||||
'message': message,
|
||||
'room': room
|
||||
}))
|
||||
|
||||
async def handle_block_user(self, data):
|
||||
username = data['username']
|
||||
target_user = data['target_user']
|
||||
|
||||
logger.info(f"handle_block_user appelé avec : {data}")
|
||||
|
||||
if target_user == username:
|
||||
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'}))
|
||||
return
|
||||
|
||||
logger.info(f"{username} a bloqué {target_user}")
|
||||
|
||||
# Utilisation correcte de l' f-string pour inclure la valeur de target_user
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'block_user',
|
||||
'message': f'Vous avez bloqué les messages de {target_user}'
|
||||
}))
|
||||
|
||||
async def handle_invite_user(self, data):
|
||||
# Récupération des informations de l'invitation
|
||||
inviter = data.get('username')
|
||||
target_user = data.get('target_user')
|
||||
room = data.get('room')
|
||||
|
||||
# Validation des paramètres
|
||||
if not inviter:
|
||||
logger.error("Invitant manquant dans le message d'invitation")
|
||||
await self.chat_message('error', 'server', 'Invitant manquant', self.room_group_name)
|
||||
return
|
||||
|
||||
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)
|
||||
return
|
||||
|
||||
if not room:
|
||||
logger.error("Room manquante dans le message d'invitation")
|
||||
await self.chat_message('error', 'server', 'Room manquante', self.room_group_name)
|
||||
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)
|
||||
|
||||
# Envoi de l'invitation
|
||||
await self.channel_layer.group_send(
|
||||
room,
|
||||
{
|
||||
'type': 'invite',
|
||||
'inviter': inviter,
|
||||
'target_user': target_user,
|
||||
'room': room,
|
||||
'message': f'{inviter} vous a invité à rejoindre la room {room}.'
|
||||
}
|
||||
)
|
||||
|
||||
async def handle_invite_response(self, data):
|
||||
inviter = data.get('inviter')
|
||||
username = data.get('username') # L'utilisateur invité qui répond
|
||||
response = data.get('response')
|
||||
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)
|
||||
|
||||
# Si la réponse est 'yes', informer l'invitant que l'invité a accepté
|
||||
if response.lower() == 'yes':
|
||||
try:
|
||||
# Informer l'invitant que l'invitation a été acceptée
|
||||
await self.channel_layer.group_send(
|
||||
room,
|
||||
{
|
||||
'type': 'invite_response',
|
||||
'inviter': inviter,
|
||||
'username': username,
|
||||
'response': response,
|
||||
'room': room,
|
||||
'message': f'{username} a accepté l\'invitation.'
|
||||
}
|
||||
)
|
||||
# Informer à la fois l'invité et l'invitant que le jeu va commencer
|
||||
await self.channel_layer.group_send(
|
||||
room,
|
||||
{
|
||||
'type': 'start_quick_match',
|
||||
'inviter': inviter,
|
||||
'username': username,
|
||||
'message': 'La partie va démarrer pour vous deux.',
|
||||
}
|
||||
)
|
||||
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)
|
||||
|
||||
# Méthode appelée pour envoyer l'invitation à l'utilisateur invité (target_user)
|
||||
async def invite(self, event):
|
||||
inviter = event['inviter']
|
||||
message = event['message']
|
||||
room = event['room']
|
||||
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
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'invite',
|
||||
'inviter': inviter,
|
||||
'target_user': target_user,
|
||||
'message': message,
|
||||
'room': room
|
||||
}))
|
||||
|
||||
async def handle_invite_response(self, data):
|
||||
inviter = data.get('inviter')
|
||||
username = data.get('username') # L'utilisateur invité qui répond
|
||||
response = data.get('response')
|
||||
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)
|
||||
|
||||
# Envoi de la réponse directement à l'invitant dans la room
|
||||
await self.channel_layer.group_send(
|
||||
room,
|
||||
{
|
||||
'type': 'invite_response', # Type de message 'invite_response'
|
||||
'inviter': inviter,
|
||||
'username': username,
|
||||
'room': room,
|
||||
'message': f'{username} a répondu {response} à l\'invitation.',
|
||||
'response': response # Ajout de la réponse 'yes' ou 'no'
|
||||
}
|
||||
)
|
||||
|
||||
async def invite_response(self, event):
|
||||
message = event['message']
|
||||
response = event.get('response')
|
||||
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
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'invite_response',
|
||||
'message': message,
|
||||
'response': response,
|
||||
'inviter': inviter
|
||||
}))
|
||||
|
||||
async def authenticate(self, token, username):
|
||||
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)
|
||||
return
|
||||
|
||||
logger.info(f"Tentative d'authentification avec le token: {token} pour l'utilisateur: {username}")
|
||||
|
||||
try:
|
||||
user = await self.get_user_from_token(token)
|
||||
if 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.channel_layer.group_add(
|
||||
f"user_{self.username}", # Group name unique pour cet utilisateur
|
||||
self.channel_name
|
||||
)
|
||||
logger.info(f"Connexion de l'utilisateur {self.username} à son groupe personnel")
|
||||
else:
|
||||
logger.warning(f"Échec de l'authentification pour le token: {token}")
|
||||
await self.chat_message('error', username, 'Authentication failed', self.room_group_name)
|
||||
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)
|
||||
|
||||
@sync_to_async
|
||||
def get_user_from_token(self, token):
|
||||
try:
|
||||
user = User.objects.filter(auth_token=token).first()
|
||||
logger.debug(f"Utilisateur trouvé : {user} pour le token : {token}")
|
||||
return user
|
||||
except User.DoesNotExist:
|
||||
logger.warning(f"Utilisateur non trouvé pour le token : {token}")
|
||||
return None
|
||||
@@ -1,240 +0,0 @@
|
||||
# /pong/game/game.py
|
||||
|
||||
import json
|
||||
import asyncio
|
||||
import random
|
||||
from datetime import datetime
|
||||
from .utils import handle_game_data
|
||||
from asgiref.sync import sync_to_async
|
||||
|
||||
|
||||
class Game:
|
||||
def __init__(self, game_id, player1, player2, localgame):
|
||||
self.game_id = game_id
|
||||
self.player1 = player1
|
||||
self.player2 = player2
|
||||
self.localgame = localgame
|
||||
if self.localgame:
|
||||
self.botgame = False
|
||||
self.game_state = {
|
||||
'player1_name': player1.user.username,
|
||||
'player2_name': player1.user2.username,
|
||||
'player1_position': 150,
|
||||
'player2_position': 150,
|
||||
'ball_position': {'x': 390, 'y': 190},
|
||||
'ball_velocity': {'x': random.choice([-5, 5]), 'y': random.choice([-5, 5])},
|
||||
'player1_score': 0,
|
||||
'player2_score': 0,
|
||||
'game_text': ''
|
||||
}
|
||||
else:
|
||||
self.botgame = player2 is None
|
||||
self.game_state = {
|
||||
'player1_name': player1.user.username,
|
||||
'player2_name': player2.user.username if player2 else 'BOT',
|
||||
'player1_position': 150,
|
||||
'player2_position': 150,
|
||||
'ball_position': {'x': 390, 'y': 190},
|
||||
'ball_velocity': {'x': random.choice([-5, 5]), 'y': random.choice([-5, 5])},
|
||||
'player1_score': 0,
|
||||
'player2_score': 0,
|
||||
'game-text': ''
|
||||
}
|
||||
self.speed = 1
|
||||
self.game_loop_task = None
|
||||
self.ended = False
|
||||
self.p1_mov = 0
|
||||
self.p2_mov = 0
|
||||
self.bt1 = 0
|
||||
self.bt2 = 0
|
||||
self.start_time = None
|
||||
|
||||
async def start_game(self):
|
||||
print(f"- Game #{self.game_id} STARTED")
|
||||
self.game_loop_task = asyncio.create_task(self.game_loop())
|
||||
self.start_time = datetime.now()
|
||||
print(f" Begin MATCH at: {self.start_time}")
|
||||
|
||||
async def game_loop(self):
|
||||
print(" In the game loop..")
|
||||
x = 0
|
||||
while not self.ended:
|
||||
if self.botgame:
|
||||
x += 1
|
||||
if x == 60:
|
||||
await self.update_bot_position()
|
||||
x = 0
|
||||
await self.handle_pad_movement()
|
||||
await self.update_game_state()
|
||||
await self.send_game_state()
|
||||
await asyncio.sleep(1/60) # Around 60 FPS
|
||||
|
||||
async def update_bot_position(self):
|
||||
future_ball_position = self.predict_ball_trajectory()
|
||||
|
||||
target_y = future_ball_position['y']
|
||||
player2_position = self.game_state['player2_position']
|
||||
|
||||
# Adjusts bot position based on expected ball position
|
||||
if player2_position < target_y < player2_position + 80:
|
||||
pass #bot already placed
|
||||
elif player2_position < target_y:
|
||||
self.game_state['player2_position'] = min(player2_position + (50 * self.speed), 300)
|
||||
elif player2_position + 80 > target_y:
|
||||
self.game_state['player2_position'] = max(player2_position - (50 * self.speed), 0)
|
||||
|
||||
def predict_ball_trajectory(self, steps=60):
|
||||
|
||||
future_x = self.game_state['ball_position']['x']
|
||||
future_y = self.game_state['ball_position']['y']
|
||||
velocity_x = self.game_state['ball_velocity']['x']
|
||||
velocity_y = self.game_state['ball_velocity']['y']
|
||||
|
||||
for _ in range(steps):
|
||||
future_x += velocity_x
|
||||
future_y += velocity_y
|
||||
|
||||
# Dealing with bounces off walls
|
||||
if future_y <= 0 or future_y >= 300:
|
||||
velocity_y = -velocity_y # Reverse the direction of vertical movement
|
||||
|
||||
return {'x': future_x, 'y': future_y}
|
||||
|
||||
async def update_game_state(self):
|
||||
if self.ended:
|
||||
return
|
||||
# Update ball position
|
||||
self.game_state['ball_position']['x'] += self.game_state['ball_velocity']['x']
|
||||
self.game_state['ball_position']['y'] += self.game_state['ball_velocity']['y']
|
||||
# Check for collisions with top and bottom walls
|
||||
if self.game_state['ball_position']['y'] <= 10 or self.game_state['ball_position']['y'] >= 390:
|
||||
self.game_state['ball_velocity']['y'] *= -1
|
||||
# Check for collisions with paddles
|
||||
if self.game_state['ball_position']['x'] <= 20 and \
|
||||
self.game_state['player1_position'] - 10 <= self.game_state['ball_position']['y'] <= self.game_state['player1_position'] + 90:
|
||||
if self.game_state['ball_velocity']['x'] < 0:
|
||||
self.game_state['ball_velocity']['x'] *= -1
|
||||
self.bt1 += 1
|
||||
self.update_ball_velocity()
|
||||
elif self.game_state['ball_position']['x'] >= 760 and \
|
||||
self.game_state['player2_position'] - 10 <= self.game_state['ball_position']['y'] <= self.game_state['player2_position'] + 90:
|
||||
if self.game_state['ball_velocity']['x'] > 0:
|
||||
self.game_state['ball_velocity']['x'] *= -1
|
||||
self.bt2 += 1
|
||||
self.update_ball_velocity()
|
||||
# Check if some player won the game
|
||||
if self.game_state['ball_position']['x'] <= 10:
|
||||
self.game_state['player2_score'] += 1
|
||||
if self.game_state['player2_score'] > 2:
|
||||
self.game_state['game_text'] = f"{self.game_state['player2_name']} WINS!"
|
||||
await self.send_game_state()
|
||||
await self.end_game()
|
||||
self.reset_ball()
|
||||
elif self.game_state['ball_position']['x'] >= 790:
|
||||
self.game_state['player1_score'] += 1
|
||||
if self.game_state['player1_score'] > 2:
|
||||
self.game_state['game_text'] = f"{self.game_state['player1_name']} WINS!"
|
||||
await self.send_game_state()
|
||||
await self.end_game()
|
||||
self.reset_ball()
|
||||
|
||||
def reset_ball(self):
|
||||
self.game_state['ball_position'] = {'x': 390, 'y': 190}
|
||||
self.game_state['ball_velocity'] = {'x': random.choice([-5, 5]), 'y': random.choice([-5, 5])}
|
||||
self.speed = 1
|
||||
|
||||
def update_ball_velocity(self):
|
||||
self.speed += 0.05
|
||||
if self.speed > 2:
|
||||
self.speed = 2
|
||||
self.game_state['ball_velocity']['x'] *= self.speed
|
||||
if self.game_state['ball_velocity']['x'] < -10:
|
||||
self.game_state['ball_velocity']['x'] = -10
|
||||
elif self.game_state['ball_velocity']['x'] > 10:
|
||||
self.game_state['ball_velocity']['x'] = 10
|
||||
self.game_state['ball_velocity']['y'] *= self.speed
|
||||
if self.game_state['ball_velocity']['y'] < -10:
|
||||
self.game_state['ball_velocity']['y'] = -10
|
||||
elif self.game_state['ball_velocity']['y'] > 10:
|
||||
self.game_state['ball_velocity']['y'] = 10
|
||||
|
||||
async def send_game_state(self):
|
||||
if self.ended:
|
||||
return
|
||||
message = json.dumps({
|
||||
'type': 'game_state_update',
|
||||
'game_state': self.game_state
|
||||
})
|
||||
await self.player1.send(message)
|
||||
if not self.botgame:
|
||||
if not self.localgame:
|
||||
await self.player2.send(message)
|
||||
|
||||
async def handle_key_press(self, player, key):
|
||||
if self.ended:
|
||||
return
|
||||
if self.localgame:
|
||||
if key == 'arrowup':
|
||||
self.p2_mov = -1
|
||||
elif key == 'arrowdown':
|
||||
self.p2_mov = 1
|
||||
elif key == 'w':
|
||||
self.p1_mov = -1
|
||||
elif key == 's':
|
||||
self.p1_mov = 1
|
||||
elif player == self.player1:
|
||||
if key == 'arrowup':
|
||||
self.p1_mov = -1
|
||||
elif key == 'arrowdown':
|
||||
self.p1_mov = 1
|
||||
elif player == self.player2:
|
||||
if key == 'arrowup':
|
||||
self.p2_mov = -1
|
||||
elif key == 'arrowdown':
|
||||
self.p2_mov = 1
|
||||
|
||||
async def handle_pad_movement(self):
|
||||
if self.ended:
|
||||
return
|
||||
if self.p1_mov == -1:
|
||||
self.game_state['player1_position'] = max(self.game_state['player1_position'] - (5 * self.speed), 0)
|
||||
elif self.p1_mov == 1:
|
||||
self.game_state['player1_position'] = min(self.game_state['player1_position'] + (5 * self.speed), 300)
|
||||
if self.p2_mov == -1:
|
||||
self.game_state['player2_position'] = max(self.game_state['player2_position'] - (5 * self.speed), 0)
|
||||
elif self.p2_mov == 1:
|
||||
self.game_state['player2_position'] = min(self.game_state['player2_position'] + (5 * self.speed), 300)
|
||||
|
||||
async def end_game(self, disconnected_player=None):
|
||||
if not self.ended:
|
||||
self.ended = True
|
||||
if self.game_loop_task:
|
||||
self.game_loop_task.cancel()
|
||||
print(f"- Game #{self.game_id} ENDED")
|
||||
|
||||
end_time = datetime.now()
|
||||
duration = (end_time - self.start_time).total_seconds() / 60
|
||||
|
||||
# Notify that one player left the game
|
||||
if disconnected_player:
|
||||
remaining_player = self.player2 if disconnected_player == self.player1 else self.player1
|
||||
disconnected_name = disconnected_player.user.username
|
||||
message = json.dumps({
|
||||
'type': 'player_disconnected',
|
||||
'player': disconnected_name
|
||||
})
|
||||
if not self.botgame:
|
||||
if not self.localgame:
|
||||
await remaining_player.send(message)
|
||||
# Notify both players that the game has ended
|
||||
end_message = json.dumps({
|
||||
'type': 'game_ended',
|
||||
'game_id': self.game_id
|
||||
})
|
||||
await self.player1.send(end_message)
|
||||
if not self.botgame:
|
||||
if not self.localgame:
|
||||
await self.player2.send(end_message)
|
||||
await sync_to_async(handle_game_data)(self.game_state['player1_name'], self.game_state['player2_name'],
|
||||
self.game_state['player1_score'], self.game_state['player2_score'],
|
||||
self.bt1, self.bt2, duration, False, None)
|
||||
@@ -1,112 +0,0 @@
|
||||
# /pong/game/matchmaking.py
|
||||
|
||||
import json
|
||||
import asyncio
|
||||
from .game import Game
|
||||
|
||||
class MatchMaker:
|
||||
def __init__(self):
|
||||
self.waiting_players = []
|
||||
self.active_games = {}
|
||||
self.matching_task = None
|
||||
self.timer = 0
|
||||
self.botgame = False
|
||||
|
||||
async def add_player(self, player):
|
||||
if player not in self.waiting_players:
|
||||
self.waiting_players.append(player)
|
||||
print(f"User {player.user.username} joins the WAITING ROOM")
|
||||
if not self.matching_task or self.matching_task.done():
|
||||
self.matching_task = asyncio.create_task(self.match_loop())
|
||||
|
||||
async def remove_player(self, player):
|
||||
if player in self.waiting_players:
|
||||
self.waiting_players.remove(player)
|
||||
|
||||
for game in self.active_games.values():
|
||||
if player in [game.player1, game.player2]:
|
||||
await game.end_game(disconnected_player=player)
|
||||
del self.active_games[game.game_id]
|
||||
break
|
||||
|
||||
async def match_loop(self):
|
||||
while True:
|
||||
if len(self.waiting_players) >= 2:
|
||||
player1 = self.waiting_players.pop(0)
|
||||
player2 = self.waiting_players.pop(0)
|
||||
print(f"*** MATCH FOUND: {player1.user.username} vs {player2.user.username}")
|
||||
await self.create_game(player1, player2, False)
|
||||
else:
|
||||
await asyncio.sleep(1)
|
||||
self.timer += 1
|
||||
# Waiting for more than 30s -> BOT game
|
||||
if self.timer >= 15 and self.waiting_players:
|
||||
player1 = self.waiting_players.pop(0)
|
||||
print(f"*** MATCH FOUND: {player1.user.username} vs BOT")
|
||||
self.botgame = True
|
||||
self.timer = 0
|
||||
await self.create_bot_game(player1)
|
||||
if not self.waiting_players:
|
||||
break
|
||||
|
||||
async def create_game(self, player1, player2, localgame):
|
||||
game_id = len(self.active_games) + 1
|
||||
if localgame:
|
||||
print(f"- Creating LOCAL game: #{game_id}")
|
||||
else:
|
||||
print(f"- Creating MATCH game: #{game_id}")
|
||||
new_game = Game(game_id, player1, player2, localgame)
|
||||
self.active_games[game_id] = new_game
|
||||
await player1.set_game(new_game)
|
||||
if not localgame:
|
||||
await player2.set_game(new_game)
|
||||
await self.notify_players(player1, player2, game_id, localgame)
|
||||
asyncio.create_task(new_game.start_game())
|
||||
|
||||
async def create_bot_game(self, player1):
|
||||
game_id = len(self.active_games) + 1
|
||||
print(f"- Creating BOT game: #{game_id}")
|
||||
new_game = Game(game_id, player1, None, False)
|
||||
self.active_games[game_id] = new_game
|
||||
await player1.set_game(new_game)
|
||||
await self.notify_players(player1, None, game_id, False)
|
||||
asyncio.create_task(new_game.start_game())
|
||||
|
||||
async def notify_players(self, player1, player2, game_id, localgame):
|
||||
if player2:
|
||||
await player1.send(json.dumps({
|
||||
'type': 'game_start',
|
||||
'game_id': game_id,
|
||||
'player1': player1.user.username,
|
||||
'player2': player2.user.username
|
||||
}))
|
||||
await player2.send(json.dumps({
|
||||
'type': 'game_start',
|
||||
'game_id': game_id,
|
||||
'player1': player1.user.username,
|
||||
'player2': player2.user.username
|
||||
}))
|
||||
else:
|
||||
if localgame:
|
||||
await player1.send(json.dumps({
|
||||
'type': 'game_start',
|
||||
'game_id': game_id,
|
||||
'player1': player1.user.username,
|
||||
'player2': player1.user2.username
|
||||
}))
|
||||
else:
|
||||
await player1.send(json.dumps({
|
||||
'type': 'game_start',
|
||||
'game_id': game_id,
|
||||
'player1': player1.user.username,
|
||||
'player2': 'BOT'
|
||||
}))
|
||||
|
||||
async def handle_key_press(self, player, key):
|
||||
for game in self.active_games.values():
|
||||
if player in [game.player1, game.player2]:
|
||||
await game.handle_key_press(player, key)
|
||||
break
|
||||
|
||||
# Instance of the class
|
||||
match_maker = MatchMaker()
|
||||
@@ -1,60 +0,0 @@
|
||||
# Generated by Django 5.0.7 on 2024-07-31 16:01
|
||||
|
||||
import django.db.models.deletion
|
||||
from django.db import migrations, models
|
||||
|
||||
|
||||
class Migration(migrations.Migration):
|
||||
|
||||
initial = True
|
||||
|
||||
dependencies = [
|
||||
]
|
||||
|
||||
operations = [
|
||||
migrations.CreateModel(
|
||||
name='Player',
|
||||
fields=[
|
||||
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
|
||||
('name', models.CharField(max_length=100)),
|
||||
('total_match', models.PositiveSmallIntegerField(default=0)),
|
||||
('total_win', models.PositiveSmallIntegerField(default=0)),
|
||||
('p_win', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
|
||||
('m_score_match', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
|
||||
('m_score_adv_match', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
|
||||
('best_score', models.PositiveSmallIntegerField(default=0)),
|
||||
('m_nbr_ball_touch', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
|
||||
('total_duration', models.DecimalField(blank=True, decimal_places=2, max_digits=7, null=True)),
|
||||
('m_duration', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
|
||||
('num_participated_tournaments', models.PositiveSmallIntegerField(default=0)),
|
||||
('num_won_tournaments', models.PositiveSmallIntegerField(default=0)),
|
||||
],
|
||||
),
|
||||
migrations.CreateModel(
|
||||
name='Tournoi',
|
||||
fields=[
|
||||
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
|
||||
('name', models.CharField(max_length=200)),
|
||||
('nbr_player', models.PositiveSmallIntegerField()),
|
||||
('date', models.DateField()),
|
||||
('winner', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, to='game.player')),
|
||||
],
|
||||
),
|
||||
migrations.CreateModel(
|
||||
name='Match',
|
||||
fields=[
|
||||
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
|
||||
('score_player1', models.PositiveSmallIntegerField()),
|
||||
('score_player2', models.PositiveSmallIntegerField()),
|
||||
('nbr_ball_touch_p1', models.PositiveIntegerField()),
|
||||
('nbr_ball_touch_p2', models.PositiveIntegerField()),
|
||||
('duration', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
|
||||
('date', models.DateField(auto_now_add=True)),
|
||||
('is_tournoi', models.BooleanField()),
|
||||
('player1', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='match_as_player1', to='game.player')),
|
||||
('player2', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='match_as_player2', to='game.player')),
|
||||
('winner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='won_matches', to='game.player')),
|
||||
('tournoi', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='matches', to='game.tournoi')),
|
||||
],
|
||||
),
|
||||
]
|
||||
@@ -1,19 +0,0 @@
|
||||
# Generated by Django 5.1.1 on 2024-09-15 16:40
|
||||
|
||||
import django.db.models.deletion
|
||||
from django.db import migrations, models
|
||||
|
||||
|
||||
class Migration(migrations.Migration):
|
||||
|
||||
dependencies = [
|
||||
('game', '0001_initial'),
|
||||
]
|
||||
|
||||
operations = [
|
||||
migrations.AlterField(
|
||||
model_name='match',
|
||||
name='winner',
|
||||
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='won_matches', to='game.player'),
|
||||
),
|
||||
]
|
||||
@@ -1,78 +0,0 @@
|
||||
from django.db import models
|
||||
from django.contrib.auth.models import User
|
||||
from django.core.exceptions import ValidationError
|
||||
import logging
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Ajout d'un champ auth_token à la classe User
|
||||
User.add_to_class('auth_token', models.CharField(max_length=100, null=True, blank=True, unique=True))
|
||||
logger.debug("Ajout du champ auth_token à la classe User")
|
||||
|
||||
class Player(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
total_match = models.PositiveSmallIntegerField(default=0)
|
||||
total_win = models.PositiveSmallIntegerField(default=0)
|
||||
p_win = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
|
||||
m_score_match = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
|
||||
m_score_adv_match = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
|
||||
best_score = models.PositiveSmallIntegerField(default=0)
|
||||
m_nbr_ball_touch = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
|
||||
total_duration = models.DecimalField(max_digits=7, decimal_places=2, null=True, blank=True)
|
||||
m_duration = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
|
||||
num_participated_tournaments = models.PositiveSmallIntegerField(default=0)
|
||||
num_won_tournaments = models.PositiveSmallIntegerField(default=0)
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
def save(self, *args, **kwargs):
|
||||
logger.info(f"Saving player: {self.name}")
|
||||
super().save(*args, **kwargs)
|
||||
logger.info(f"Player {self.name} saved successfully")
|
||||
|
||||
class Tournoi(models.Model):
|
||||
name = models.CharField(max_length=200)
|
||||
nbr_player = models.PositiveSmallIntegerField()
|
||||
date = models.DateField()
|
||||
winner = models.ForeignKey('Player', on_delete=models.SET_NULL, null=True)
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
def save(self, *args, **kwargs):
|
||||
logger.info(f"Saving tournament: {self.name}")
|
||||
super().save(*args, **kwargs)
|
||||
logger.info(f"Tournament {self.name} saved successfully")
|
||||
|
||||
class Match(models.Model):
|
||||
player1 = models.ForeignKey('Player', related_name='match_as_player1', on_delete=models.CASCADE)
|
||||
player2 = models.ForeignKey('Player', related_name='match_as_player2', on_delete=models.CASCADE)
|
||||
score_player1 = models.PositiveSmallIntegerField()
|
||||
score_player2 = models.PositiveSmallIntegerField()
|
||||
winner = models.ForeignKey('Player', related_name='won_matches', on_delete=models.CASCADE, null=True)
|
||||
nbr_ball_touch_p1 = models.PositiveIntegerField()
|
||||
nbr_ball_touch_p2 = models.PositiveIntegerField()
|
||||
duration = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
|
||||
date = models.DateField(auto_now_add=True)
|
||||
is_tournoi = models.BooleanField()
|
||||
tournoi = models.ForeignKey('Tournoi', related_name='matches', on_delete=models.SET_NULL, null=True)
|
||||
|
||||
def clean(self):
|
||||
logger.debug(f"Cleaning match: {self.player1.name} vs {self.player2.name}")
|
||||
if self.score_player1 < 0 or self.score_player2 < 0:
|
||||
raise ValidationError('Les scores doivent être positifs.')
|
||||
if self.score_player1 > self.score_player2 and self.winner != self.player1:
|
||||
raise ValidationError('Le gagnant ne correspond pas aux scores.')
|
||||
if self.score_player2 > self.score_player1 and self.winner != self.player2:
|
||||
raise ValidationError('Le gagnant ne correspond pas aux scores.')
|
||||
super().clean()
|
||||
|
||||
def save(self, *args, **kwargs):
|
||||
logger.info(f"Saving match: {self.player1.name} vs {self.player2.name}")
|
||||
self.clean()
|
||||
super().save(*args, **kwargs)
|
||||
logger.info(f"Match {self.player1.name} vs {self.player2.name} saved successfully")
|
||||
|
||||
def __str__(self):
|
||||
return f"{self.player1.name} vs {self.player2.name}"
|
||||
@@ -1,15 +0,0 @@
|
||||
# /pong/game/routing.py
|
||||
from django.urls import re_path
|
||||
from . import consumers
|
||||
import logging
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
logger.debug("Configuring WebSocket routing patterns")
|
||||
|
||||
websocket_urlpatterns = [
|
||||
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()),
|
||||
]
|
||||
|
||||
logger.info("WebSocket routing patterns configured successfully")
|
||||
@@ -1,10 +0,0 @@
|
||||
<!-- templates/tournament_waiting_room.html -->
|
||||
<div class="tournament-waiting-room">
|
||||
<h2>Tournament Waiting Room</h2>
|
||||
<p>Players currently waiting: {{ players|length }}</p>
|
||||
<ul>
|
||||
{% for player in players %}
|
||||
<li>{{ player }}</li>
|
||||
{% endfor %}
|
||||
</ul>
|
||||
</div>
|
||||
@@ -1,49 +0,0 @@
|
||||
# /pong/game/tournament.py
|
||||
import json
|
||||
from django.template.loader import render_to_string
|
||||
import logging
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
class TournamentMatchMaker:
|
||||
def __init__(self):
|
||||
self.waiting_players = []
|
||||
logger.debug("TournamentMatchMaker initialized with an empty waiting_players list")
|
||||
|
||||
async def add_player(self, player):
|
||||
if player not in self.waiting_players:
|
||||
self.waiting_players.append(player)
|
||||
logger.info(f"User {player.user.username} added to the TOURNAMENT WAITING ROOM")
|
||||
await self.update_waiting_room()
|
||||
else:
|
||||
logger.warning(f"User {player.user.username} is already in the TOURNAMENT WAITING ROOM")
|
||||
|
||||
async def remove_player(self, player):
|
||||
if player in self.waiting_players:
|
||||
self.waiting_players.remove(player)
|
||||
logger.info(f"User {player.user.username} removed from the TOURNAMENT WAITING ROOM")
|
||||
await self.update_waiting_room()
|
||||
else:
|
||||
logger.warning(f"Attempt to remove non-existent user {player.user.username} from the TOURNAMENT WAITING ROOM")
|
||||
|
||||
async def update_waiting_room(self):
|
||||
logger.debug("Updating TOURNAMENT WAITING ROOM")
|
||||
html = self.generate_waiting_room_html()
|
||||
for player in self.waiting_players:
|
||||
await player.send(json.dumps({
|
||||
'type': 'update_waiting_room',
|
||||
'html': html
|
||||
}))
|
||||
logger.info("TOURNAMENT WAITING ROOM updated and sent to all players")
|
||||
|
||||
def generate_waiting_room_html(self):
|
||||
logger.debug("Generating TOURNAMENT WAITING ROOM HTML")
|
||||
context = {
|
||||
'players': [player.user.username for player in self.waiting_players]
|
||||
}
|
||||
html = render_to_string('pong/tournament_waiting_room.html', context)
|
||||
logger.info("TOURNAMENT WAITING ROOM HTML generated successfully")
|
||||
return html
|
||||
|
||||
# Instance of the class
|
||||
tournament_match_maker = TournamentMatchMaker()
|
||||
@@ -1,17 +0,0 @@
|
||||
# /pong/game/urls.py
|
||||
|
||||
from django.urls import path, include
|
||||
from . import views
|
||||
#from rest_framework.routers import DefaultRouter
|
||||
from .views import match_list_json, player_list_json, tournoi_list_json
|
||||
|
||||
urlpatterns = [
|
||||
path('', views.index, name='index'),
|
||||
path('check_user_exists/', views.check_user_exists, name='check_user_exists'),
|
||||
path('register_user/', views.register_user, name='register_user'),
|
||||
path('authenticate_user/', views.authenticate_user, name='authenticate_user'),
|
||||
path('web3/', views.read_data, name='read_data'),
|
||||
path('api/match_list/', match_list_json, name='match_list_json'),
|
||||
path('api/player_list/', player_list_json, name='player_list_json'),
|
||||
path('api/tournoi_list/', tournoi_list_json, name='tournoi_list_json')
|
||||
]
|
||||
@@ -1,192 +0,0 @@
|
||||
import logging
|
||||
from .models import Player, Tournoi, Match
|
||||
from django.core.exceptions import ValidationError
|
||||
from django.shortcuts import get_object_or_404
|
||||
from django.db.models import Max, Sum, F
|
||||
from datetime import timedelta
|
||||
from channels.db import database_sync_to_async
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
def handle_game_data(p1, p2, s_p1, s_p2, bt_p1, bt_2, dur, is_tournoi, name_tournament):
|
||||
logger.info(f"Handling game data for players: {p1} vs {p2}")
|
||||
try:
|
||||
player_1 = get_or_create_player(p1)
|
||||
player_2 = get_or_create_player(p2)
|
||||
logger.debug(f"Players created or retrieved: {player_1}, {player_2}")
|
||||
|
||||
create_match(player_1, player_2, s_p1, s_p2, bt_p1, bt_2, dur, is_tournoi, name_tournament)
|
||||
logger.info("Match created successfully")
|
||||
|
||||
update_player_statistics(p1)
|
||||
update_player_statistics(p2)
|
||||
logger.info("Player statistics updated")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error in handle_game_data: {e}")
|
||||
|
||||
def get_player_by_name(name):
|
||||
logger.debug(f"Checking if player exists with name: {name}")
|
||||
exists = Player.objects.filter(name=name).exists()
|
||||
logger.debug(f"Player exists: {exists}")
|
||||
return exists
|
||||
|
||||
def get_player(name):
|
||||
logger.debug(f"Retrieving player with name: {name}")
|
||||
return Player.objects.get(name=name)
|
||||
|
||||
def get_or_create_player(name):
|
||||
logger.info(f"Getting or creating player with name: {name}")
|
||||
player_exists = get_player_by_name(name)
|
||||
if not player_exists:
|
||||
player = create_player(name)
|
||||
logger.info(f"Player created: {player}")
|
||||
return player
|
||||
else:
|
||||
player = get_player(name)
|
||||
logger.info(f"Player retrieved: {player}")
|
||||
return player
|
||||
|
||||
def create_player(
|
||||
name,
|
||||
total_match=0,
|
||||
total_win=0,
|
||||
p_win=None,
|
||||
m_score_match=None,
|
||||
m_score_adv_match=None,
|
||||
best_score=0,
|
||||
m_nbr_ball_touch=None,
|
||||
total_duration=None,
|
||||
m_duration=None,
|
||||
num_participated_tournaments=0,
|
||||
num_won_tournaments=0
|
||||
):
|
||||
logger.info(f"Creating player: {name}")
|
||||
player = Player(
|
||||
name=name,
|
||||
total_match=total_match,
|
||||
total_win=total_win,
|
||||
p_win=p_win,
|
||||
m_score_match=m_score_match,
|
||||
m_score_adv_match=m_score_adv_match,
|
||||
best_score=best_score,
|
||||
m_nbr_ball_touch=m_nbr_ball_touch,
|
||||
total_duration=total_duration,
|
||||
m_duration=m_duration,
|
||||
num_participated_tournaments=num_participated_tournaments,
|
||||
num_won_tournaments=num_won_tournaments
|
||||
)
|
||||
player.save()
|
||||
logger.info(f"Player {name} saved successfully")
|
||||
return player
|
||||
|
||||
def create_tournoi(name, nbr_player, date, winner):
|
||||
logger.info(f"Creating tournament: {name}")
|
||||
tournoi = Tournoi(name=name, nbr_player=nbr_player, date=date, winner=winner)
|
||||
tournoi.save()
|
||||
logger.info(f"Tournament {name} saved successfully")
|
||||
return tournoi
|
||||
|
||||
def create_match(player1, player2, score_player1, score_player2, nbr_ball_touch_p1, nbr_ball_touch_p2, duration, is_tournoi, tournoi):
|
||||
logger.info(f"Creating match between {player1.name} and {player2.name}")
|
||||
match = Match(
|
||||
player1=player1,
|
||||
player2=player2,
|
||||
score_player1=score_player1,
|
||||
score_player2=score_player2,
|
||||
nbr_ball_touch_p1=nbr_ball_touch_p1,
|
||||
nbr_ball_touch_p2=nbr_ball_touch_p2,
|
||||
duration=duration,
|
||||
is_tournoi=is_tournoi,
|
||||
tournoi=tournoi
|
||||
)
|
||||
|
||||
if score_player1 > score_player2:
|
||||
match.winner = match.player1
|
||||
elif score_player2 > score_player1:
|
||||
match.winner = match.player2
|
||||
else:
|
||||
match.winner = None
|
||||
|
||||
match.save()
|
||||
logger.info(f"Match saved successfully with winner: {match.winner.name if match.winner else 'None'}")
|
||||
return match
|
||||
|
||||
def update_player_statistics(player_name):
|
||||
logger.info(f"Updating statistics for player: {player_name}")
|
||||
player = get_object_or_404(Player, name=player_name)
|
||||
|
||||
matches_as_player1 = Match.objects.filter(player1=player)
|
||||
matches_as_player2 = Match.objects.filter(player2=player)
|
||||
|
||||
total_match = matches_as_player1.count() + matches_as_player2.count()
|
||||
|
||||
if total_match == 0:
|
||||
logger.warning(f"No matches found for player: {player_name}")
|
||||
player.total_match = total_match
|
||||
player.total_win = 0
|
||||
player.p_win = 0
|
||||
player.m_score_match = 0
|
||||
player.m_score_adv_match = 0
|
||||
player.best_score = 0
|
||||
player.m_nbr_ball_touch = 0
|
||||
player.total_duration = 0
|
||||
player.m_duration = 0
|
||||
player.num_participated_tournaments = 0
|
||||
player.num_won_tournaments = 0
|
||||
player.save()
|
||||
logger.info(f"Player statistics reset for {player_name}")
|
||||
return
|
||||
|
||||
won_matches = Match.objects.filter(winner=player)
|
||||
#part_tourn_as_p1 = Tournoi.objects.filter(matches__is_tournoi=True, matches__matches_as_player1=player)
|
||||
#part_tourn_as_p2 = Tournoi.objects.filter(matches__is_tournoi=True, matches__matches_as_player2=player)
|
||||
#won_tourn = Tournoi.objects.filter(winner=player)
|
||||
|
||||
total_score = matches_as_player1.aggregate(Sum('score_player1'))['score_player1__sum'] or 0
|
||||
total_score += matches_as_player2.aggregate(Sum('score_player2'))['score_player2__sum'] or 0
|
||||
|
||||
total_score_adv = matches_as_player1.aggregate(Sum('score_player2'))['score_player2__sum'] or 0
|
||||
total_score_adv += matches_as_player2.aggregate(Sum('score_player1'))['score_player1__sum'] or 0
|
||||
|
||||
total_win = won_matches.count()
|
||||
p_win = (total_win / total_match) * 100
|
||||
|
||||
m_score_match = total_score / total_match
|
||||
m_score_adv_match = total_score_adv / total_match
|
||||
|
||||
nbr_ball_touch = matches_as_player1.aggregate(Sum('nbr_ball_touch_p1'))['nbr_ball_touch_p1__sum'] or 0
|
||||
nbr_ball_touch += matches_as_player2.aggregate(Sum('nbr_ball_touch_p2'))['nbr_ball_touch_p2__sum'] or 0
|
||||
m_nbr_ball_touch = nbr_ball_touch / total_match
|
||||
|
||||
total_duration = matches_as_player1.aggregate(Sum('duration'))['duration__sum'] or 0
|
||||
total_duration += matches_as_player2.aggregate(Sum('duration'))['duration__sum'] or 0
|
||||
m_duration = total_duration / total_match
|
||||
|
||||
#total_tourn_p = part_tourn_as_p1.count() + part_tourn_as_p2.count()
|
||||
#total_win_tourn = won_tourn.count()
|
||||
#p_win_tourn = (total_win_tourn / total_tourn_p) * 100 if total_tourn_p else 0
|
||||
|
||||
best_score_as_player1 = matches_as_player1.aggregate(Max('score_player1'))['score_player1__max'] or 0
|
||||
best_score_as_player2 = matches_as_player2.aggregate(Max('score_player2'))['score_player2__max'] or 0
|
||||
best_score = max(best_score_as_player1, best_score_as_player2)
|
||||
|
||||
player.total_match = total_match
|
||||
player.total_win = total_win
|
||||
player.p_win = p_win
|
||||
player.m_score_match = m_score_match
|
||||
player.m_score_adv_match = m_score_adv_match
|
||||
player.best_score = best_score
|
||||
player.m_nbr_ball_touch = m_nbr_ball_touch
|
||||
player.total_duration = total_duration
|
||||
player.m_duration = m_duration
|
||||
# player.num_participated_tournaments = total_tourn_p
|
||||
#player.num_won_tournaments = total_win_tourn
|
||||
|
||||
player.save()
|
||||
logger.info(f"Statistics updated for player: {player_name}")
|
||||
|
||||
def get_player_p_win(player_name):
|
||||
logger.debug(f"Getting win percentage for player: {player_name}")
|
||||
player = get_object_or_404(Player, name=player_name)
|
||||
return player.p_win
|
||||
@@ -1,228 +0,0 @@
|
||||
# /pong/game/views.py
|
||||
|
||||
from django.shortcuts import render
|
||||
from django.core.exceptions import ObjectDoesNotExist
|
||||
from .models import Player, Tournoi, Match
|
||||
from .utils import create_player, create_tournoi, create_match
|
||||
from django.http import JsonResponse
|
||||
from django.contrib.auth.models import User
|
||||
from django.contrib.auth import authenticate
|
||||
from django.views.decorators.csrf import csrf_exempt
|
||||
from rest_framework import viewsets
|
||||
from django.db import transaction, IntegrityError
|
||||
|
||||
import json
|
||||
import uuid
|
||||
import logging
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
def index(request):
|
||||
logger.info("Accessing index view")
|
||||
return render(request, 'index.html')
|
||||
|
||||
@csrf_exempt
|
||||
def check_user_exists(request):
|
||||
if request.method == 'POST':
|
||||
logger.info("POST request received for checking user existence")
|
||||
data = json.loads(request.body)
|
||||
username = data.get('username')
|
||||
if User.objects.filter(username=username).exists():
|
||||
logger.info(f"User {username} exists")
|
||||
return JsonResponse({'exists': True})
|
||||
logger.info(f"User {username} does not exist")
|
||||
return JsonResponse({'exists': False})
|
||||
logger.warning("Invalid request method for check_user_exists")
|
||||
return JsonResponse({'error': 'Invalid request method'}, status=400)
|
||||
|
||||
@csrf_exempt
|
||||
def register_user(request):
|
||||
if request.method == 'POST':
|
||||
try:
|
||||
logger.info("Received POST request for user registration")
|
||||
data = json.loads(request.body)
|
||||
username = data.get('username')
|
||||
password = data.get('password')
|
||||
|
||||
logger.info(f"Attempting to register user: {username}")
|
||||
|
||||
if not username or not password:
|
||||
logger.warning("Username or password not provided")
|
||||
return JsonResponse({'registered': False, 'error': 'Username and password are required'}, status=400)
|
||||
|
||||
with transaction.atomic():
|
||||
user_exists = User.objects.select_for_update().filter(username=username).exists()
|
||||
|
||||
if user_exists:
|
||||
logger.warning(f"User {username} already exists")
|
||||
return JsonResponse({'registered': False, 'error': 'User already exists'}, status=409)
|
||||
|
||||
user = User.objects.create_user(username=username, password=password)
|
||||
token = get_or_create_token(user)
|
||||
logger.info(f"User {username} registered successfully")
|
||||
return JsonResponse({'registered': True, 'token': token})
|
||||
|
||||
except json.JSONDecodeError as e:
|
||||
logger.error(f"JSON decode error: {str(e)}")
|
||||
return JsonResponse({'error': 'Invalid JSON data'}, status=400)
|
||||
|
||||
except IntegrityError:
|
||||
logger.error(f"IntegrityError: User {username} already exists")
|
||||
return JsonResponse({'registered': False, 'error': 'User already exists'}, status=409)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error in register_user: {str(e)}")
|
||||
return JsonResponse({'error': f'Internal Server Error: {str(e)}'}, status=500)
|
||||
|
||||
logger.warning("Invalid request method for register_user")
|
||||
return JsonResponse({'error': 'Invalid request method'}, status=405)
|
||||
|
||||
def get_or_create_token(user):
|
||||
logger.info(f"Generating or retrieving token for user: {user.username}")
|
||||
if not user.auth_token:
|
||||
while True:
|
||||
token = str(uuid.uuid4())
|
||||
if not User.objects.filter(auth_token=token).exists():
|
||||
user.auth_token = token
|
||||
user.save()
|
||||
logger.info(f"Token generated for user {user.username}: {token}")
|
||||
break
|
||||
return user.auth_token
|
||||
|
||||
@csrf_exempt
|
||||
def authenticate_user(request):
|
||||
if request.method == 'POST':
|
||||
try:
|
||||
logger.info("Received POST request for user authentication")
|
||||
data = json.loads(request.body)
|
||||
username = data.get('username', '')
|
||||
password = data.get('password', '')
|
||||
user = authenticate(username=username, password=password)
|
||||
if user is not None:
|
||||
token = get_or_create_token(user)
|
||||
logger.info(f"User {username} authenticated successfully")
|
||||
return JsonResponse({'authenticated': True, 'token': token, 'user_id': user.id})
|
||||
else:
|
||||
logger.warning(f"Authentication failed for user {username}")
|
||||
return JsonResponse({'authenticated': False}, status=401)
|
||||
except Exception as e:
|
||||
logger.error(f"Error in authenticate_user: {str(e)}")
|
||||
return JsonResponse({'error': str(e)}, status=500)
|
||||
else:
|
||||
logger.warning("Invalid request method for authenticate_user")
|
||||
return JsonResponse({'error': 'Method not allowed'}, status=405)
|
||||
|
||||
def match_list_json(request):
|
||||
logger.info("Fetching match list")
|
||||
matches = Match.objects.all()
|
||||
data = {
|
||||
'matches': list(matches.values(
|
||||
'id', 'player1__name', 'player2__name', 'score_player1', 'score_player2',
|
||||
'winner__name', 'nbr_ball_touch_p1', 'nbr_ball_touch_p2', 'duration', 'date',
|
||||
'is_tournoi', 'tournoi__name'
|
||||
))
|
||||
}
|
||||
logger.info(f"Match list fetched successfully: {len(data['matches'])} matches found")
|
||||
return JsonResponse(data)
|
||||
|
||||
def player_list_json(request):
|
||||
logger.info("Fetching player list")
|
||||
players = Player.objects.all()
|
||||
|
||||
data = {
|
||||
'players': list(players.values(
|
||||
'id', 'name', 'total_match', 'total_win', 'p_win',
|
||||
'm_score_match', 'm_score_adv_match', 'best_score',
|
||||
'm_nbr_ball_touch', 'total_duration', 'm_duration',
|
||||
'num_participated_tournaments', 'num_won_tournaments'
|
||||
))
|
||||
}
|
||||
logger.info(f"Player list fetched successfully: {len(data['players'])} players found")
|
||||
return JsonResponse(data)
|
||||
|
||||
def tournoi_list_json(request):
|
||||
logger.info("Fetching tournoi list")
|
||||
tournois = Tournoi.objects.all()
|
||||
|
||||
data = {
|
||||
'tournois': list(tournois.values(
|
||||
'id', 'name', 'nbr_player', 'date', 'winner'
|
||||
))
|
||||
}
|
||||
logger.info(f"Tournoi list fetched successfully: {len(data['tournois'])} tournois found")
|
||||
return JsonResponse(data)
|
||||
|
||||
def tournoi_list_json(request):
|
||||
tournois = Tournoi.objects.all()
|
||||
|
||||
data = {
|
||||
'tournois': list(tournois.values(
|
||||
'id', 'name', 'nbr_player', 'date', 'winner'
|
||||
))
|
||||
}
|
||||
return JsonResponse(data)
|
||||
|
||||
from web3 import Web3
|
||||
|
||||
provider = Web3.HTTPProvider("https://sepolia.infura.io/v3/60e51df7c97c4f4c8ab41605a4eb9907")
|
||||
web3 = Web3(provider)
|
||||
eth_gas_price = web3.eth.gas_price/1000000000
|
||||
print(eth_gas_price)
|
||||
|
||||
contract_address = "0x078D04Eb6fb97Cd863361FC86000647DC876441B"
|
||||
contract_abi = [{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"uint256","name":"_timecode","type":"uint256"},{"internalType":"uint256","name":"_participantCount","type":"uint256"},{"internalType":"string[]","name":"_playerPseudonyms","type":"string[]"},{"internalType":"string[]","name":"_finalOrder","type":"string[]"}],"name":"addTournament","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAllTournaments","outputs":[{"components":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"string","name":"name","type":"string"},{"internalType":"uint256","name":"timecode","type":"uint256"},{"internalType":"uint256","name":"participantCount","type":"uint256"},{"internalType":"string[]","name":"playerPseudonyms","type":"string[]"},{"internalType":"string[]","name":"finalOrder","type":"string[]"}],"internalType":"struct PongTournament.Tournament[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getTournament","outputs":[{"components":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"string","name":"name","type":"string"},{"internalType":"uint256","name":"timecode","type":"uint256"},{"internalType":"uint256","name":"participantCount","type":"uint256"},{"internalType":"string[]","name":"playerPseudonyms","type":"string[]"},{"internalType":"string[]","name":"finalOrder","type":"string[]"}],"internalType":"struct PongTournament.Tournament","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tournamentCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tournaments","outputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"string","name":"name","type":"string"},{"internalType":"uint256","name":"timecode","type":"uint256"},{"internalType":"uint256","name":"participantCount","type":"uint256"}],"stateMutability":"view","type":"function"}]
|
||||
|
||||
contract = web3.eth.contract(address=contract_address, abi=contract_abi)
|
||||
|
||||
def read_data(request):
|
||||
# Créer une instance du contrat
|
||||
|
||||
# Appeler une fonction du contrat pour obtenir tous les tournois
|
||||
tournaments = contract.functions.getAllTournaments().call()
|
||||
|
||||
# Afficher les résultats
|
||||
json_data = []
|
||||
for tournament in tournaments:
|
||||
tournament_data = []
|
||||
for item in tournament:
|
||||
print(f"{item}")
|
||||
tournament_data.append(item)
|
||||
json_data.append(tournament_data)
|
||||
|
||||
# Retourner le JSON comme réponse HTTP
|
||||
# print(f"Tournament ID: {tournament[0]}")
|
||||
# print(f"Name: {tournament[1]}")
|
||||
# print(f"Timecode: {tournament[2]}")
|
||||
# print(f"Participant Count: {tournament[3]}")
|
||||
# print(f"Player Pseudonyms: {', '.join(tournament[4])}")
|
||||
# print(f"Final Order: {', '.join(tournament[5])}")
|
||||
print("-----------------------------")
|
||||
return JsonResponse(json_data, safe=False)
|
||||
|
||||
|
||||
def write_data(request):
|
||||
# addTournament(string,uint256,uint256,string[],string[])
|
||||
|
||||
# # Configuration de la transaction pour la fonction store
|
||||
# account = "0x66CeBE2A1F7dae0F6AdBAad2c15A56A9121abfEf"
|
||||
# private_key = "beb16ee3434ec5abec8b799549846cc04443c967b8d3643b943e2e969e7d25be"
|
||||
|
||||
# nonce = web3.eth.get_transaction_count(account)
|
||||
# transaction = contract.functions.addTournament("test",1721830559,6,["aaudeber", "tlorne", "ocassany", "yestello", "jcheca", "toto"],["toto", "jcheca", "yestello", "tlorne", "ocassany", "aaudeber"]).build_transaction({
|
||||
# 'chainId': 11155111, # ID de la chaîne Sepolia
|
||||
# 'gas': 2000000,
|
||||
# 'gasPrice': web3.to_wei(eth_gas_price, 'gwei'),
|
||||
# 'nonce': nonce
|
||||
# })
|
||||
|
||||
# # Signature de la transaction
|
||||
# signed_txn = web3.eth.account.sign_transaction(transaction, private_key)
|
||||
|
||||
# # Envoi de la transaction
|
||||
# tx_hash = web3.eth.send_raw_transaction(signed_txn.rawTransaction)
|
||||
# print("Transaction hash:", web3.to_hex(tx_hash))
|
||||
|
||||
# # Attente de la confirmation de la transaction
|
||||
# tx_receipt = web3.eth.wait_for_transaction_receipt(tx_hash)
|
||||
# print("Transaction receipt:", tx_receipt)
|
||||
print("-----------------------------")
|
||||
Reference in New Issue
Block a user