refix room class

Author: MinhTriet0612

rac/servertest.py

@@ -4,23 +4,13 @@
 from flask import Flask, json, request
 from flask_socketio import SocketIO, emit
 
-from dto.room import RoomDTO
-from src.room.room import Room
-import src.room.room as room
-from src.room.user import User
-import src.room.user as user
 
 app = Flask(__name__)
 app.config["SECRET_KEY"] = "secret!"
 CORS(app, resources={r"/*": {"origins": "*"}})
 socketio = SocketIO(app, cors_allowed_origins="*")
 
 
-def serialization(data):
-    if isinstance(data, dict):
-        return json.dumps(data)
-    return data.__dict__
-
 
 @socketio.on("connect")
 def connect():
@@ -32,23 +22,6 @@ def disconnect():
     print(">> client {} disconnected to server".format(request.sid))
 
 
-@socketio.on("hehe")
-def hehe(payload):
-    user1 = User(request.sid, "triet dep trai")
-    #
-    room = Room("room1", user1)
-    # socketio.emit
-    #
-    # socketio.emit("hehe", {"room": serialization(room), "user": serialization(user1)}, to=request.sid)
-    socketio.emit(
-        "hehe",
-        {
-            "room": RoomDTO.to_dto(room),
-            "user": User.to_dto(user1),
-        },
-        to=request.sid,
-    )
-
 
 if __name__ == "__main__":
     socketio.run(app, debug=False)

src/game/Game.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 from abc import ABC, abstractmethod
-from src.util.cell import Cell
-from src.util.point import Point
+from util.point import Point
 from typing import List
 from rich.console import Console
 from rich.table import Table
 
+from util.cell import Cell
+
 
 if TYPE_CHECKING:
     from src.player.Player import Player

src/game/TicTacToe.py

@@ -27,6 +27,7 @@ def getWinnerSymbol(self) -> Cell:
         if self.board[0][2] == self.board[1][1] == self.board[2][0] != Cell.NONE:
             return self.board[0][2]
         return Cell.NONE
+    
 
 
 

src/model/CaroModel.py renamed to src/model/SumokuModel.py

@@ -1,12 +1,12 @@
 import time
-from src.util.cell import Cell
+from util.cell import Cell
 
 
 class CaroModel:
     board = []
     start = time.time()
 
-    time_limit = 3
+    time_limit = 6
 
     def __init__(self):
         pass
@@ -39,8 +39,8 @@ def player(self, board):
         x_count = 0
         o_count = 0
 
-        for i in range(self.sizeMatrix):
-            for j in range(self.sizeMatrix):
+        for i in range(board.__len__()):
+            for j in range(board[i].__len__()):
                 if board[j][i] == Cell.X:
                     x_count += 1
                 elif board[j][i] == Cell.O:
@@ -184,28 +184,28 @@ def min_alpha_beta(self, alpha, beta, board):
                 return (0, 0, 0)
         start = time.time()
 
-        for i in range(0, board.__len__()):
-            for j in range(0, board[i].__len__()):
-                if (time.time() - start) > self.time_limit:
-                    return (minv, qx, qy)
+        for action in self.actions(board):
+            (i, j) = action
+            if (time.time() - start) > self.time_limit:
+                return (minv, qx, qy)
 
-                if board[i][j] == Cell.NONE:
-                    board[i][j] = Cell.O
-                    (m, max_i, max_j) = self.max_alpha_beta(alpha, beta, board)
-                    if m == -1:
-                        board[i][j] = Cell.NONE
-                        return (-1, i, j)
-
-                    if m < minv:
-                        minv = m
-                        qx = i
-                        qy = j
+            if board[i][j] == Cell.NONE:
+                board[i][j] = Cell.O
+                (m, max_i, max_j) = self.max_alpha_beta(alpha, beta, board)
+                if m == -1:
                     board[i][j] = Cell.NONE
+                    return (-1, i, j)
+
+                if m < minv:
+                    minv = m
+                    qx = i
+                    qy = j
+                board[i][j] = Cell.NONE
 
-                    if minv <= alpha:
-                        return (minv, qx, qy)
+                if minv <= alpha:
+                    return (minv, qx, qy)
 
-                    if minv < beta:
-                        beta = minv
+                if minv < beta:
+                    beta = minv
 
         return (minv, qx, qy)

src/model/TictactoeModel.py

@@ -1,6 +1,6 @@
 from typing import List
 
-from src.util.cell import Cell
+from util.cell import Cell
 
 
 class TictactoeModel:
@@ -9,16 +9,32 @@ def __init__(self):
 
     def checkWinner(self, board: List[List[Cell]]):
         for i in range(3):
-            if board[i][0] == board[i][1] and board[i][1] == board[i][2] and board[i][0] != Cell.NONE:
+            if (
+                board[i][0] == board[i][1]
+                and board[i][1] == board[i][2]
+                and board[i][0] != Cell.NONE
+            ):
                 return board[i][0]
 
-            if board[0][i] == board[1][i] and board[1][i] == board[2][i] and board[0][i] != Cell.NONE:
+            if (
+                board[0][i] == board[1][i]
+                and board[1][i] == board[2][i]
+                and board[0][i] != Cell.NONE
+            ):
                 return board[0][i]
 
-        if board[0][0] == board[1][1] and board[1][1] == board[2][2] and board[0][0] != Cell.NONE:
+        if (
+            board[0][0] == board[1][1]
+            and board[1][1] == board[2][2]
+            and board[0][0] != Cell.NONE
+        ):
             return board[0][0]
 
-        if board[0][2] == board[1][1] and board[1][1] == board[2][0] and board[0][2] != Cell.NONE:
+        if (
+            board[0][2] == board[1][1]
+            and board[1][1] == board[2][0]
+            and board[0][2] != Cell.NONE
+        ):
             return board[0][2]
 
         return None
@@ -74,6 +90,7 @@ def min_alpha_beta(self, alpha: int, beta: int, board: List[List[Cell]]):
         for action in self.actions(board):
             (i, j) = action
             board[i][j] = Cell.O
+
             (m, max_i, max_j) = self.max_alpha_beta(alpha, beta, board)
             if m == -1:
                 board[i][j] = Cell.NONE
@@ -118,8 +135,8 @@ def max_alpha_beta(self, alpha: int, beta: int, board: List[List[Cell]]):
 
         for action in self.actions(board):
             (i, j) = action
-            print(i, j)
             board[i][j] = Cell.X
+
             (m, min_i, min_j) = self.min_alpha_beta(alpha, beta, board)
             if m == 1:
                 board[i][j] = Cell.NONE

src/player/AIPlayer.py

@@ -1,13 +1,14 @@
-from src.model.TictactoeModel import TictactoeModel
-from src.model.CaroModel import CaroModel
-from src.player.Player import Player
-from src.util.point import Point
-from src.util.cell import Cell
+from User import User
+from model.TictactoeModel import TictactoeModel
+from model.SumokuModel import CaroModel
+from player.Player import Player
+from util.point import Point
+from util.cell import Cell
 
 
 class AIPlayer(Player):
-    def __init__(self):
-        super().__init__()
+    def __init__(self, user: User | None):
+        super().__init__(user)
         self.caroModel = CaroModel()
         self.tictactoeModel = TictactoeModel()
         return

src/player/Player.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 from abc import ABC, abstractmethod
-from src.util.point import Point
-from src.util.cell import Cell
-from src.User import User
+from util.point import Point
+from util.cell import Cell
+from User import User
 
 if TYPE_CHECKING:
     from src.game.Game import Game

src/room/Room.py

@@ -1,54 +1,81 @@
-from typing import List
+from typing import Dict, List
 import uuid
 
-from src.game import Game
-from src.User import User
+from flask import request
+
+from game.Game import Game
+from game.TicTacToe import TicTacToe
+from game.CasualGame import CasualGame
+from User import User
+from player.AIPlayer import AIPlayer
+from player.PersonPlayer import PersonPlayer
+from player.Player import Player
 
 
 class Room:
     def __init__(self, name, owner: User):
         self.id: str = str(uuid.uuid4())
         self.name: str = name
-        # self.users:List[User] = []
-        # self.game:Game
-        self.owner = owner
+        self.competitor: User
+        self.owner: User = owner
+        self.guests: List[User] = []
+        self.game: Game
+
+    def kick(self, userId: str):
+        requestId = request.sid
+        if requestId != self.owner.id:
+            raise Exception("You are not the owner")
+
+        if self.competitor is not None and self.competitor.id == userId:
+            self.competitor = None
 
-    def kick(self, uuid: str):
-        self.users.remove(uuid)
+        else:
+            for user in self.guests:
+                if user.id == userId:
+                    self.guests.remove(user)
+                    break
 
-    def add_user(self, user: User):
-        self.users.append(user.id)
+    def addGuest(self, user: User):
+        self.guests.append(user)
 
-    def add_game(self, game: Game):
+    def addCompetitor(self, user: User):
+        self.competitor = user
+
+    def addGame(self, game: Game):
         self.game = game
+        player1: Player = PersonPlayer(self.owner)
+        player2: Player 
+
+        if(self.competitor.id == "bot"): 
+            player2 = AIPlayer(self.competitor)
+        else: 
+            player2 = PersonPlayer(self.competitor)
+        
+        self.game.addPlayer(player1)
+        self.game.addPlayer(player2)
+        
+
+    def getOwner(self) -> User:
+        return self.owner
+
+    def onLeave(self, userId: str) -> None:
+        if userId == self.owner.id:
+            self.owner = self.competitor
+            self.competitor = None
+        elif userId == self.competitor.id:
+            self.competitor = None
+        else:
+            userTmp = None
+            for user in self.guests:
+                if user.id == userId:
+                    userTmp = user
+                    break
+
+            if userTmp is not None:
+                self.guests.remove(userTmp)
+
+    def onJoin(self, user: User) -> None:
+        self.guests[user.id] = user
 
-        # self.lead = None
-        # self.guest = None
-        # self.status = None
-        # self.ready_player = []
-        # self.game = []
-        # self.watchers = []
-        # self.users = []
-
-    #
-    # def leave_room(self, id):
-    #     if self.lead == id:
-    #         self.lead = None
-    #         if self.guest != None:
-    #             self.lead = self.guest
-    #             self.guest = None
-    #     elif self.guest == id:
-    #         self.guest = None
-    #     elif id in self.watchers:
-    #         self.watchers.remove(id)
-    #     if id in self.ready_player:
-    #         self.ready_player.remove(id)
-    #
-    # def is_in_room(self, id):
-    #     return self.lead == id or self.guest == id or id in self.watchers
-    #
-    # def is_ready(self):
-    #     return len(self.ready_player) == 2
-    #
-    # def is_full(self):
-    #     return self.lead != None and self.guest != None
+    def onDispose(self) -> None:
+        pass