game: add: goal statistic

games/config.py

@@ -19,4 +19,6 @@ BALL_SPAWN_POS_Y = MAP_SIZE_Y / 2
 
 SERVER_TPS = 20
 
-STROKE_THICKNESS = 10
+STROKE_THICKNESS = 10
+
+GAME_MAX_SCORE = 7

games/models.py

@@ -1,11 +1,20 @@
+from __future__ import annotations
+
 from django.db import models
 
+from django.db.models import QuerySet
+
+import time
+
 # Create your models here.
+
 class GameModel(models.Model):
 
     finished = models.BooleanField(default = False)
     started = models.BooleanField(default = False)
     winner_id = models.IntegerField(default = -1)
+    start_timestamp = models.BigIntegerField(null = True, blank = True)
+    stop_timestamp = models.BigIntegerField(null = True, blank = True)
     
     def create(self, players_id: [int]):
         self.save()
@@ -14,16 +23,40 @@ class GameModel(models.Model):
         return self.pk
 
     def start(self):
+        self.start_timestamp = round(time.time() * 1000, 1)
         self.started = True
     
     def finish(self, winner_id):
         self.winner_id = winner_id
         self.finished = True
+        self.stop_timestamp = round(time.time() * 1000, 1)
         self.save()
     
     def get_players_id(self):
         return [game_player.player_id for game_player in GameMembersModel.objects.filter(game_id = self.pk)]
+    
+    def get_score_by_player_id(self, player_id: int) -> list[int]:
+        query: QuerySet = GameGoalModel.objects.filter(game_id = self.pk, player_id = player_id)
+        score_data: list[int] = [game_goal.timestamp for game_goal in query]
+        
+        return score_data
+    
+    def add_goal(self, goal_taker_id: int):
+        
+        timestamp: int = round(time.time() * 1000, 1) - self.start_timestamp
+        
+        goal_model: GameGoalModel = GameGoalModel.objects.create(player_id = goal_taker_id, game_id = self.pk, timestamp = timestamp)
+        
+        goal_model.save()
+        
+        return timestamp
 
 class GameMembersModel(models.Model):
     game_id = models.IntegerField()
-    player_id = models.IntegerField()
+    player_id = models.IntegerField()
+    
+class GameGoalModel(models.Model):
+    
+    game_id = models.IntegerField()
+    player_id = models.IntegerField()
+    timestamp = models.IntegerField()

games/objects/Game.py

@@ -97,6 +97,13 @@ class Game(AbstractRoom):
         for member in members:
             member.send(detail, data)      
     
+    def goal(self, goal_taker: Player):
+        
+        timestamp = goal_taker.add_goal()
+        
+        self.broadcast("goal", {"player_id": goal_taker.user_id,
+                                "timestamp": timestamp})
+    
     def get_player_by_user_id(self, user_id: int) -> Player:
         for player in self.players:
             if (player.user_id == user_id):
@@ -144,11 +151,10 @@ class Game(AbstractRoom):
         connected_players: list[Player] = self.get_players_connected()
         
         if (self.model.started):
-            print(len(connected_players))
             if (len(connected_players) == 1):
                 last_player: Player = connected_players[0]
                 print("finish")
-                self.finish(last_player)
+                #self.finish(last_player)
             return
         
         self._update_player(player)

games/objects/Player.py

@@ -25,7 +25,7 @@ class Player(Spectator):
         
         self.position: Position = Position(0.5, 0)
         
-        self.nb_goal: int = 0
+        self.score: list[int] = []
         
         self.rail: Segment = rail
         
@@ -112,13 +112,23 @@ class Player(Spectator):
         print("bozoman")
         self.game.leave(self)
     
+    def add_goal(self):
+        
+        timestamp = self.game.model.add_goal(self.user_id)
+        
+        self.score.append(timestamp)
+        
+        print(self.score)
+        
+        return timestamp
+    
     def to_dict(self) -> dict:
         
         data = {
             "username": self.username,
             "user_id": self.user_id,
             "position": self.position.to_dict(),
-            "nb_goal": self.nb_goal,
+            "score": [*self.score],
             
             "rail": self.rail.to_dict(),
             

games/routine.py

@@ -173,7 +173,7 @@ def wall_collision(ball_angle: float, wall: Segment) -> float:
     
     return reflection_angle
 
-async def paddle_collision(ball: Ball, impact: Point, player: Player, inc_x: float, inc_y: float):
+async def paddle_collision(game: Game, impact: Point, player: Player, inc_x: float, inc_y: float):
 
     diff_x: float = player.rail.stop.x - player.rail.start.x
     diff_y: float = player.rail.stop.y - player.rail.start.y
@@ -199,8 +199,7 @@ async def paddle_collision(ball: Ball, impact: Point, player: Player, inc_x: flo
     hit_point: Point = Point(impact.x - inc_x, impact.y - inc_y)
     
     if (not paddle.is_on(hit_point)):
-        player.nb_goal += 1
-        await SyncToAsync(player.game.broadcast)("goal", {"player": player.user_id, "nb_goal": player.nb_goal})
+        await SyncToAsync(game.goal)(player)
         return None
     
     paddle_angle: float = paddle.angle()
@@ -235,7 +234,7 @@ async def collision(game: Game, impact_data: dict) -> bool:
     if (player_hitted is None):
         angle = wall_collision(game.ball.angle, segment)
     else:
-        angle = await paddle_collision(game.ball, impact_data.get("impact"), player_hitted, impact_data.get("inc_x"), impact_data.get("inc_y"))
+        angle = await paddle_collision(game, impact_data.get("impact"), player_hitted, impact_data.get("inc_x"), impact_data.get("inc_y"))
 
     if (angle is None):
         return False

games/serializers.py

@@ -1,17 +1,23 @@
 from rest_framework import serializers
+
+from django.contrib.auth.models import User
+from django.db.models import QuerySet
+
 from .models import GameModel, GameMembersModel
 
 class GameSerializer(serializers.ModelSerializer):
 
-    players_id = serializers.SerializerMethodField()
+    players = serializers.SerializerMethodField()
     winner_id = serializers.ReadOnlyField()
     state = serializers.SerializerMethodField()
     started = serializers.ReadOnlyField()
     finished = serializers.ReadOnlyField()
+    start_timestamp = serializers.ReadOnlyField()
+    stop_timestamp = serializers.ReadOnlyField()
 
     class Meta:
         model = GameModel
-        fields = ["id", "winner_id", "state", "started", "finished", "players_id"]
+        fields = ["id", "winner_id", "state", "started", "finished", "players", "start_timestamp", "stop_timestamp"]
 
     def get_state(self, instance: GameModel):
         if (instance.finished):
@@ -20,6 +26,20 @@ class GameSerializer(serializers.ModelSerializer):
             return "started"
         return "waiting"
 
-    def get_players_id(self, instance: GameModel):
-        players_id = [player_game.player_id for player_game in GameMembersModel.objects.filter(game_id = instance.pk)]
-        return players_id
+    def get_players(self, instance: GameModel):
+        players_data: list = []
+        for player_id in instance.get_players_id():
+            query: QuerySet = User.objects.filter(pk = player_id)
+            username: str = "Deleted User"
+            if (query.exists()):
+                username = query[0].username
+            
+            data: dict = {
+                "id": player_id,
+                "username": username,
+                "score": instance.get_score_by_player_id(player_id)
+            }
+            
+            players_data.append(data)
+        
+        return players_data

games/views.py

@@ -25,5 +25,7 @@ class GameConfigView(APIView):
             "BALL_SPEED_START": config.BALL_SPEED_START,
             
             "STROKE_THICKNESS": config.STROKE_THICKNESS,
+            
+            "GAME_MAX_SCORE": config.GAME_MAX_SCORE,
         }
         return Response(config_data, status = status.HTTP_200_OK)