Initial Game Logic
This commit is contained in:
Juhn-Vitus Saß
492
django/play/consumers/game.py
Normal file
492
django/play/consumers/game.py
Normal file
@@ -0,0 +1,492 @@
|
||||
import json
|
||||
import asyncio
|
||||
from channels.generic.websocket import AsyncWebsocketConsumer
|
||||
from channels.db import database_sync_to_async
|
||||
from django.utils import timezone
|
||||
from django.urls import reverse
|
||||
from django.db import models
|
||||
from datetime import timedelta
|
||||
|
||||
from play.models import QuizGame, QuizGameParticipant, QuizAnswer
|
||||
|
||||
# Dictionary to track inactive check tasks per game
|
||||
game_check_tasks = {}
|
||||
|
||||
|
||||
class GameConsumer(AsyncWebsocketConsumer):
|
||||
@classmethod
|
||||
async def start_inactive_check(cls, join_code, channel_layer):
|
||||
"""Start the inactive player check for a game if not already running."""
|
||||
if join_code not in game_check_tasks or game_check_tasks[join_code].done():
|
||||
async def check_inactive_players():
|
||||
game_group_name = f'game_{join_code}'
|
||||
while True:
|
||||
try:
|
||||
await asyncio.sleep(30) # Check every 30 seconds
|
||||
try:
|
||||
game = await database_sync_to_async(QuizGame.objects.get)(join_code=join_code)
|
||||
cutoff_time = timezone.now() - timedelta(minutes=1)
|
||||
|
||||
# Get active and inactive participants
|
||||
all_participants = await database_sync_to_async(lambda: list(
|
||||
game.participants.all().values('participant_id', 'display_name', 'last_heartbeat')
|
||||
))()
|
||||
|
||||
# Konvertiere datetime zu ISO Format String
|
||||
for p in all_participants:
|
||||
if p['last_heartbeat']:
|
||||
p['last_heartbeat'] = p['last_heartbeat'].isoformat()
|
||||
|
||||
active_participants = [p for p in all_participants if p['last_heartbeat'] and timezone.datetime.fromisoformat(p['last_heartbeat']) >= cutoff_time]
|
||||
inactive_participants = [p for p in all_participants if not p['last_heartbeat'] or timezone.datetime.fromisoformat(p['last_heartbeat']) < cutoff_time]
|
||||
|
||||
# Remove inactive participants
|
||||
if inactive_participants:
|
||||
for p in inactive_participants:
|
||||
# Benachrichtige andere über den gekickten Spieler
|
||||
await channel_layer.group_send(
|
||||
game_group_name,
|
||||
{
|
||||
'type': 'player_left',
|
||||
'player_name': p['display_name'],
|
||||
'was_kicked': True
|
||||
}
|
||||
)
|
||||
# Lösche den inaktiven Teilnehmer
|
||||
await database_sync_to_async(QuizGameParticipant.objects.filter(
|
||||
participant_id=p['participant_id']
|
||||
).delete)()
|
||||
|
||||
# Broadcast update to all clients
|
||||
if active_participants or inactive_participants:
|
||||
await channel_layer.group_send(
|
||||
game_group_name,
|
||||
{
|
||||
'type': 'participant_list_update',
|
||||
'participants': active_participants
|
||||
}
|
||||
)
|
||||
except QuizGame.DoesNotExist:
|
||||
break # Stop checking if game no longer exists
|
||||
except Exception as e:
|
||||
print(f'Error checking inactive players in game: {e}')
|
||||
await asyncio.sleep(5) # Wait before retry
|
||||
except asyncio.CancelledError:
|
||||
break
|
||||
except Exception as e:
|
||||
print(f'Error in game inactive check loop: {e}')
|
||||
await asyncio.sleep(5)
|
||||
|
||||
game_check_tasks[join_code] = asyncio.create_task(check_inactive_players())
|
||||
|
||||
async def connect(self):
|
||||
self.join_code = self.scope['url_route']['kwargs']['join_code']
|
||||
self.game_group_name = f'game_{self.join_code}'
|
||||
|
||||
# Join game group
|
||||
await self.channel_layer.group_add(
|
||||
self.game_group_name,
|
||||
self.channel_name
|
||||
)
|
||||
|
||||
await self.accept()
|
||||
|
||||
# Ensure inactive check is running for this game
|
||||
await self.start_inactive_check(self.join_code, self.channel_layer)
|
||||
|
||||
async def disconnect(self, close_code):
|
||||
# Leave game group
|
||||
await self.channel_layer.group_discard(
|
||||
self.game_group_name,
|
||||
self.channel_name
|
||||
)
|
||||
|
||||
# Check if game should be deleted
|
||||
await self.cleanup_game()
|
||||
|
||||
async def receive(self, text_data):
|
||||
text_data_json = json.loads(text_data)
|
||||
message_type = text_data_json['type']
|
||||
|
||||
if message_type == 'ping':
|
||||
# Respond with pong to keep connection alive
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'pong'
|
||||
}))
|
||||
return
|
||||
|
||||
if message_type == 'leave_game':
|
||||
participant_id = text_data_json.get('participant_id')
|
||||
if participant_id:
|
||||
try:
|
||||
# Get participant info before deletion
|
||||
participant = await database_sync_to_async(QuizGameParticipant.objects.get)(participant_id=participant_id)
|
||||
display_name = participant.display_name
|
||||
join_code = self.join_code
|
||||
|
||||
# Delete participant
|
||||
await database_sync_to_async(participant.delete)()
|
||||
|
||||
# Update participants list
|
||||
participants = await self.get_participants()
|
||||
await self.channel_layer.group_send(
|
||||
self.game_group_name,
|
||||
{
|
||||
'type': 'participant_list_update',
|
||||
'participants': participants
|
||||
}
|
||||
)
|
||||
|
||||
# Send redirect to home
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'redirect',
|
||||
'url': '/'
|
||||
}))
|
||||
except QuizGameParticipant.DoesNotExist:
|
||||
pass
|
||||
return
|
||||
|
||||
if message_type == 'heartbeat':
|
||||
participant_id = text_data_json.get('participant_id')
|
||||
if participant_id:
|
||||
await self.update_participant_heartbeat(participant_id)
|
||||
# Update participants list after heartbeat
|
||||
participants = await self.get_participants()
|
||||
await self.channel_layer.group_send(
|
||||
self.game_group_name,
|
||||
{
|
||||
'type': 'participant_list_update',
|
||||
'participants': participants
|
||||
}
|
||||
)
|
||||
return
|
||||
|
||||
if message_type == 'submit_rating':
|
||||
participant_id = text_data_json['participant_id']
|
||||
rating = text_data_json['rating']
|
||||
success = await self.save_rating(participant_id, rating)
|
||||
if success:
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'rating_confirmed'
|
||||
}))
|
||||
|
||||
elif message_type == 'submit_answer':
|
||||
participant_id = text_data_json['participant_id']
|
||||
answer = text_data_json['answer']
|
||||
time_remaining = text_data_json.get('time_remaining', 0)
|
||||
|
||||
# Save answer and update participant score
|
||||
await self.save_answer(participant_id, answer, time_remaining)
|
||||
|
||||
# Notify host about the new answer
|
||||
await self.channel_layer.group_send(
|
||||
self.game_group_name,
|
||||
{
|
||||
'type': 'participant_answer',
|
||||
'answer': answer
|
||||
}
|
||||
)
|
||||
|
||||
elif message_type == 'start_game':
|
||||
host_id = text_data_json['host_id']
|
||||
if await self.verify_host(host_id):
|
||||
await self.advance_to_next_question()
|
||||
|
||||
elif message_type == 'get_answer_stats':
|
||||
stats = await self.get_answer_stats()
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'answer_stats',
|
||||
'stats': stats
|
||||
}))
|
||||
|
||||
elif message_type == 'update_participants':
|
||||
participants = await self.get_participants()
|
||||
await self.channel_layer.group_send(
|
||||
self.game_group_name,
|
||||
{
|
||||
'type': 'participant_list_update',
|
||||
'participants': participants
|
||||
}
|
||||
)
|
||||
|
||||
elif message_type == 'next_question':
|
||||
host_id = text_data_json['host_id']
|
||||
if await self.verify_host(host_id):
|
||||
await self.advance_to_next_question()
|
||||
|
||||
elif message_type == 'finish_game':
|
||||
host_id = text_data_json['host_id']
|
||||
if await self.verify_host(host_id):
|
||||
await self.finish_game()
|
||||
|
||||
elif message_type == 'advance_to_scores':
|
||||
host_id = text_data_json['host_id']
|
||||
if await self.verify_host(host_id):
|
||||
await self.show_scores()
|
||||
|
||||
async def participant_answer(self, event):
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'participant_answer',
|
||||
'answer': event['answer']
|
||||
}))
|
||||
|
||||
async def participant_list_update(self, event):
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'participant_list_update',
|
||||
'participants': event['participants']
|
||||
}))
|
||||
|
||||
async def player_left(self, event):
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'player_left',
|
||||
'player_name': event['player_name'],
|
||||
'was_kicked': event.get('was_kicked', False)
|
||||
}))
|
||||
|
||||
async def game_state_update(self, event):
|
||||
await self.send(text_data=json.dumps({
|
||||
'type': 'game_state_update',
|
||||
'action': event['action'],
|
||||
'redirect_url': event.get('redirect_url')
|
||||
}))
|
||||
|
||||
async def update_participant_heartbeat(self, participant_id):
|
||||
"""Update the last heartbeat timestamp for a participant."""
|
||||
try:
|
||||
participant = await database_sync_to_async(QuizGameParticipant.objects.get)(
|
||||
participant_id=participant_id
|
||||
)
|
||||
participant.last_heartbeat = timezone.now()
|
||||
await database_sync_to_async(participant.save)()
|
||||
except QuizGameParticipant.DoesNotExist:
|
||||
pass
|
||||
|
||||
@database_sync_to_async
|
||||
def verify_host(self, host_id):
|
||||
try:
|
||||
quiz_game = QuizGame.objects.get(join_code=self.join_code)
|
||||
return quiz_game.host_id == host_id
|
||||
except QuizGame.DoesNotExist:
|
||||
return False
|
||||
|
||||
@database_sync_to_async
|
||||
def save_answer(self, participant_id, answer_index, time_remaining):
|
||||
try:
|
||||
participant = QuizGameParticipant.objects.get(
|
||||
quiz_game__join_code=self.join_code,
|
||||
participant_id=participant_id
|
||||
)
|
||||
quiz_game = participant.quiz_game
|
||||
current_question = quiz_game.quiz_id.questions.all()[quiz_game.current_question_index]
|
||||
|
||||
# Check if answer is correct
|
||||
is_correct = False
|
||||
if answer_index >= 0: # -1 means timeout
|
||||
question_data = json.loads(current_question.data)
|
||||
is_correct = question_data['options'][answer_index]['is_correct']
|
||||
|
||||
# Calculate score based on correctness and time
|
||||
score = 0
|
||||
if is_correct:
|
||||
base_score = 1000
|
||||
time_factor = time_remaining / 30000 # 30 seconds max
|
||||
score = int(base_score * (0.5 + 0.5 * time_factor))
|
||||
|
||||
# Update or create answer in QuizAnswer table
|
||||
answer_obj, created = QuizAnswer.objects.get_or_create(
|
||||
participant=participant,
|
||||
question_index=quiz_game.current_question_index,
|
||||
defaults={
|
||||
'answer_index': answer_index,
|
||||
'is_correct': is_correct,
|
||||
'score': score,
|
||||
'time_remaining': time_remaining
|
||||
}
|
||||
)
|
||||
|
||||
if not created:
|
||||
answer_obj.answer_index = answer_index
|
||||
answer_obj.is_correct = is_correct
|
||||
answer_obj.score = score
|
||||
answer_obj.time_remaining = time_remaining
|
||||
answer_obj.save()
|
||||
|
||||
participant.score += score
|
||||
participant.last_answer_correct = is_correct
|
||||
participant.save()
|
||||
|
||||
return True
|
||||
except (QuizGameParticipant.DoesNotExist, IndexError):
|
||||
return False
|
||||
|
||||
@database_sync_to_async
|
||||
def get_answer_stats(self):
|
||||
try:
|
||||
quiz_game = QuizGame.objects.get(join_code=self.join_code)
|
||||
|
||||
# Count answers for each option in the current question
|
||||
stats = {}
|
||||
answers = QuizAnswer.objects.filter(
|
||||
participant__quiz_game=quiz_game,
|
||||
question_index=quiz_game.current_question_index
|
||||
)
|
||||
|
||||
for answer in answers:
|
||||
if answer.answer_index >= 0: # Ignore timeouts (-1)
|
||||
stats[answer.answer_index] = stats.get(answer.answer_index, 0) + 1
|
||||
|
||||
return stats
|
||||
except QuizGame.DoesNotExist:
|
||||
return {}
|
||||
|
||||
@database_sync_to_async
|
||||
def save_rating(self, participant_id, rating):
|
||||
from library.models import QuizRating
|
||||
try:
|
||||
game = QuizGame.objects.get(join_code=self.join_code)
|
||||
participant = QuizGameParticipant.objects.get(
|
||||
quiz_game=game,
|
||||
participant_id=participant_id
|
||||
)
|
||||
|
||||
# Update or create rating
|
||||
rating_obj, created = QuizRating.objects.get_or_create(
|
||||
quiz=game.quiz_id,
|
||||
participant_id=participant_id,
|
||||
defaults={'rating': rating}
|
||||
)
|
||||
|
||||
if not created:
|
||||
rating_obj.rating = rating
|
||||
rating_obj.save()
|
||||
|
||||
return True
|
||||
except (QuizGame.DoesNotExist, QuizGameParticipant.DoesNotExist):
|
||||
return False
|
||||
|
||||
@database_sync_to_async
|
||||
def cleanup_game(self):
|
||||
try:
|
||||
game = QuizGame.objects.get(join_code=self.join_code)
|
||||
|
||||
# Get all active participants (heartbeat within last minute)
|
||||
from django.utils import timezone
|
||||
active_participants = QuizGameParticipant.objects.filter(
|
||||
quiz_game=game,
|
||||
last_heartbeat__gte=timezone.now() - timezone.timedelta(minutes=1)
|
||||
).count()
|
||||
|
||||
# If no active participants and game is finished for more than 5 minutes, delete it
|
||||
if active_participants == 0 and game.current_state == 'finished':
|
||||
if game.question_start_time and (timezone.now() - game.question_start_time).total_seconds() > 300:
|
||||
game.delete()
|
||||
except QuizGame.DoesNotExist:
|
||||
pass
|
||||
|
||||
@database_sync_to_async
|
||||
def get_participants(self):
|
||||
try:
|
||||
quiz_game = QuizGame.objects.get(join_code=self.join_code)
|
||||
participants = QuizGameParticipant.objects.filter(quiz_game=quiz_game)
|
||||
return [
|
||||
{
|
||||
'id': p.participant_id,
|
||||
'display_name': p.display_name,
|
||||
'score': p.score
|
||||
}
|
||||
for p in participants
|
||||
]
|
||||
except QuizGame.DoesNotExist:
|
||||
return []
|
||||
|
||||
@database_sync_to_async
|
||||
def _advance_to_next_question(self):
|
||||
try:
|
||||
quiz_game = QuizGame.objects.get(join_code=self.join_code)
|
||||
quiz = quiz_game.quiz_id
|
||||
|
||||
# Move to next question
|
||||
quiz_game.current_question_index += 1
|
||||
|
||||
# Check if we've reached the end
|
||||
if quiz_game.current_question_index >= quiz.questions.count():
|
||||
quiz_game.current_state = 'finished'
|
||||
quiz_game.save()
|
||||
return 'finished'
|
||||
else:
|
||||
# Update game state and start time
|
||||
quiz_game.current_state = 'question'
|
||||
quiz_game.question_start_time = timezone.now()
|
||||
quiz_game.save()
|
||||
return 'question'
|
||||
except QuizGame.DoesNotExist:
|
||||
return None
|
||||
|
||||
async def advance_to_next_question(self):
|
||||
result = await self._advance_to_next_question()
|
||||
if result == 'finished':
|
||||
# Notify clients to redirect to finished page
|
||||
await self.channel_layer.group_send(
|
||||
self.game_group_name,
|
||||
{
|
||||
'type': 'game_state_update',
|
||||
'action': 'finish_game',
|
||||
'redirect_url': reverse('play:finished', kwargs={'join_code': self.join_code})
|
||||
}
|
||||
)
|
||||
elif result == 'question':
|
||||
# Notify clients to redirect to next question
|
||||
await self.channel_layer.group_send(
|
||||
self.game_group_name,
|
||||
{
|
||||
'type': 'game_state_update',
|
||||
'action': 'next_question',
|
||||
'redirect_url': reverse('play:question', kwargs={'join_code': self.join_code})
|
||||
}
|
||||
)
|
||||
|
||||
@database_sync_to_async
|
||||
def _show_scores(self):
|
||||
try:
|
||||
quiz_game = QuizGame.objects.get(join_code=self.join_code)
|
||||
quiz_game.current_state = 'scores'
|
||||
quiz_game.save()
|
||||
return True
|
||||
except QuizGame.DoesNotExist:
|
||||
return False
|
||||
|
||||
async def show_scores(self):
|
||||
success = await self._show_scores()
|
||||
if success:
|
||||
# Notify clients to redirect to scores page
|
||||
await self.channel_layer.group_send(
|
||||
self.game_group_name,
|
||||
{
|
||||
'type': 'game_state_update',
|
||||
'action': 'show_scores',
|
||||
'redirect_url': reverse('play:scores', kwargs={'join_code': self.join_code})
|
||||
}
|
||||
)
|
||||
|
||||
@database_sync_to_async
|
||||
def _finish_game(self):
|
||||
try:
|
||||
quiz_game = QuizGame.objects.get(join_code=self.join_code)
|
||||
quiz_game.current_state = 'finished'
|
||||
quiz_game.save()
|
||||
return True
|
||||
except QuizGame.DoesNotExist:
|
||||
return False
|
||||
|
||||
async def finish_game(self):
|
||||
success = await self._finish_game()
|
||||
if success:
|
||||
# Notify clients to redirect to finished page
|
||||
await self.channel_layer.group_send(
|
||||
self.game_group_name,
|
||||
{
|
||||
'type': 'game_state_update',
|
||||
'action': 'finish_game',
|
||||
'redirect_url': reverse('play:finished', kwargs={'join_code': self.join_code})
|
||||
}
|
||||
)
|
||||
Reference in New Issue
Block a user