[DEV] 수 많은 일

backend/game/consumers.py

@@ -10,26 +10,26 @@
 
 SCREEN_HEIGHT = 750
 SCREEN_WIDTH = 1250
+MAX_SCORE = 150
 
 
 class GameState:
     def __init__(self):
         print("initializing game state!")
         self.map = GameMap()
-        self.left_bar = Bar(
-            0,
-            Bar.X_GAP,
-            SCREEN_HEIGHT // 2 - Bar.HEIGHT // 2,
-            0
-        )
+        self.left_bar = Bar(0, Bar.X_GAP, SCREEN_HEIGHT // 2 - Bar.HEIGHT // 2, 0)
         self.right_bar = Bar(
             1,
             SCREEN_WIDTH - Bar.WIDTH - Bar.X_GAP,
             SCREEN_HEIGHT // 2 - Bar.HEIGHT // 2,
-            SCREEN_WIDTH - Bar.WIDTH
+            SCREEN_WIDTH - Bar.WIDTH,
         )
         self.left_ball = Ball(0, SCREEN_HEIGHT, SCREEN_WIDTH, self.left_bar)
         self.right_ball = Ball(1, SCREEN_HEIGHT, SCREEN_WIDTH, self.right_bar)
+        self.score = [0, 0]
+        self.player = ["player1", "player2"]
+        self.penalty_time = [0, 0]
+
 
 class GameConsumer(AsyncWebsocketConsumer):
     game_tasks = {}
@@ -50,7 +50,7 @@ async def receive(self, text_data):
         text_data_json = json.loads(text_data)
         action = text_data_json["action"]
 
-        print("text_data", text_data_json)
+        # print("text_data", text_data_json)
         if action == "authenticate":
             token = text_data_json.get("token")
             if not token or not self.authenticate(token):
@@ -75,7 +75,6 @@ async def receive(self, text_data):
 
             # Start ball movement if not already running
             if self.room_group_name not in GameConsumer.game_tasks:
-                print("starting game loop!")
                 GameConsumer.game_tasks[self.room_group_name] = asyncio.create_task(
                     self.game_loop()
                 )
@@ -113,9 +112,13 @@ def authenticate(self, token):
             # Decode JWT token
             decoded = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
             uid = decoded.get("id")
-            print(f"uid: {uid}", f"room_name: {self.room_name}", str(uid) == str(self.room_name))
+            print(
+                f"uid: {uid}",
+                f"room_name: {self.room_name}",
+                str(uid) == str(self.room_name),
+            )
             # Check if uid matches the room_name
-            if  str(uid) == str(self.room_name):
+            if str(uid) == str(self.room_name):
                 return True
             else:
                 return False
@@ -129,7 +132,9 @@ def authenticate(self, token):
     async def disconnect(self, close_code):
         # Leave room group
         if self.authenticated:
-            await self.channel_layer.group_discard(self.room_group_name, self.channel_name)
+            await self.channel_layer.group_discard(
+                self.room_group_name, self.channel_name
+            )
             # Decrease the client count for this room
             if self.room_group_name in GameConsumer.client_counts:
                 GameConsumer.client_counts[self.room_group_name] -= 1
@@ -141,7 +146,6 @@ async def disconnect(self, close_code):
             else:
                 GameConsumer.client_counts[self.room_group_name] = 0
 
-
     async def send_initialize_game(self):
         state = GameConsumer.game_states[self.room_group_name]
         await self.send(
@@ -163,6 +167,8 @@ async def send_initialize_game(self):
                     "right_ball_y": state.right_ball.y,
                     "ball_radius": Ball.RADIUS,
                     "map": state.map.map,
+                    "player": state.player,
+                    "max_score": MAX_SCORE,
                 }
             )
         )
@@ -175,26 +181,65 @@ async def game_loop(self):
                 state.left_bar.update()
                 state.right_bar.update()
 
-                state.left_ball.move(state.left_bar)
+                state.penalty_time[0] = state.left_ball.move(state.left_bar)
                 state.left_ball.check_bar_collision(state.left_bar)
                 state.left_ball.check_bar_collision(state.right_bar)
-                state.left_ball.check_collision(state.map)
+                state.left_ball.check_collision(state.map, state.score)
 
-                state.right_ball.move(state.right_bar)
+                state.penalty_time[1] = state.right_ball.move(state.right_bar)
                 state.right_ball.check_bar_collision(state.left_bar)
                 state.right_ball.check_bar_collision(state.right_bar)
-                state.right_ball.check_collision(state.map)
+                state.right_ball.check_collision(state.map, state.score)
 
-                if count % 3 == 0:
+                if count % 5 == 0:
                     await self.send_game_state()
-                    await asyncio.sleep(0.005)
+                    await asyncio.sleep(0.00390625)
                     await state.map.init()
+                    if state.score[0] >= MAX_SCORE:
+                        await asyncio.sleep(0.1)
+                        await self.send_game_result(0)
+                        await asyncio.sleep(0.1)
+                        await self.close()
+                        break
+                    elif state.score[1] >= MAX_SCORE:
+                        await asyncio.sleep(0.1)
+                        await self.send_game_result(1)
+                        await asyncio.sleep(0.1)
+                        await self.close()
+                        break
                 else:
-                    await asyncio.sleep(0.005)
+                    await asyncio.sleep(0.00390625)
                 count += 1
         except asyncio.CancelledError:
             # Handle the game loop cancellation
             print("Game loop cancelled for", self.room_group_name)
+            await self.close()
+
+    async def send_game_result(self, winner):
+        state = GameConsumer.game_states[self.room_group_name]
+        await self.channel_layer.group_send(
+            self.room_group_name,
+            {
+                "type": "game_result_message",
+                "score": state.score,
+                "winner": winner,
+            },
+        )
+
+    async def game_result_message(self, event):
+        score = event["score"]
+        winner = event["winner"]
+
+        # Send the game result to the WebSocket
+        await self.send(
+            text_data=json.dumps(
+                {
+                    "type": "game_result",
+                    "score": score,
+                    "winner": winner,
+                }
+            )
+        )
 
     async def send_game_state(self):
         state = GameConsumer.game_states[self.room_group_name]
@@ -211,6 +256,8 @@ async def send_game_state(self):
                 "right_ball_x": state.right_ball.x,
                 "right_ball_y": state.right_ball.y,
                 "map_diff": state.map.diff,
+                "score": state.score,
+                "penalty_time": state.penalty_time,
             },
         )
 
@@ -223,6 +270,8 @@ async def update_game_state_message(self, event):
         left_ball_y = event["left_ball_y"]
         right_ball_x = event["right_ball_x"]
         right_ball_y = event["right_ball_y"]
+        score = event["score"]
+        penalty_time = event["penalty_time"]
 
         # Send the updated game state to the WebSocket
         await self.send(
@@ -238,6 +287,8 @@ async def update_game_state_message(self, event):
                     "right_ball_x": int(right_ball_x),
                     "right_ball_y": int(right_ball_y),
                     "map_diff": GameConsumer.game_states[self.room_group_name].map.diff,
+                    "score": score,
+                    "penalty_time": penalty_time,
                 }
             )
         )