merged broken branches client with master branch and added first statehandling for card placement

Game Server/Classes/Game/Player.py

@@ -7,13 +7,21 @@ class Player:
     __mana:int
     __name:str
     __handCards:list
-    
-    def __init__(self, name:str, hp:int=1000, mana:int=0):
+    __deck:list
+
+    def __init__(self, name:str, deck:list, hp:int=1000, mana:int=0):
         self.__hp = hp
         self.__name = name
         self.__handCards = []
+        self.__deck = deck
         self.__id = random.randint(3, 99999)
 
+    def shuffleDeck(self):
+        self.__deck = random.shuffle(self.__deck)
+
+    def getDeck(self) -> list:
+        return self.__deck
+
     def getName(self) -> str:
         return self.__name
     
@@ -40,6 +48,9 @@ class Player:
         self.__handCards.append(card)
         return self.__handCards
 
+    def setHand(self, hand:list):
+        self.__handCards = hand
+
     def removeFromHand(self, pos:int) -> list:
         self.__handCards.remove(pos)
         return self.__handCards

Game Server/Classes/System/GameManager.py

@@ -1,3 +1,4 @@
+import json
 import socket
 from Classes.Game.Player import Player
 
@@ -38,23 +39,28 @@ class GameManager:
     # this section mostly only used by the networking and event handling classes
     # other parts should never need to interface with this unless really required
     # =============================================================================
-    def startGame(self):
+    def startGame(self, tcpSocket:socket):
         self.__state = "running"
 
         print("game starts")
         for userAddr in self.__users.keys():
             try:
-                user = self.__serverWorld.getPlayers[userAddr]
+                user = self.__serverWorld.getPlayers[userAddr]["player"]
                 user.addMana(1000)
                 user.adjustHP(1000)
+                user.shuffleDeck()
+                cards = user.getDeck()
+                user.setHand(cards[:5])
 
                 payload = {
                     "event":"startgame",
-                    "mana": user.getMana(),
-                    "hp": user.getHP()
+                    "playermana": user.getMana(),
+                    "playerhp": user.getHP(),
+                    "playername": user.getName(),
+                    "hand": user.getHand()
                 }
 
-                self.send(payload, userAddr)
+                tcpSocket.send(json.dumps(payload).encode())
             except Exception as e:
                 print(f"failed to start game due to error: {e}")
                 break
@@ -84,6 +90,6 @@ class GameManager:
 
         # counts participating players and starts the game if enough have joined
         if len(self.__players) == 2:
-            self.startGame()
+            self.startGame(socket)
 
         return self.__players

Game Server/Classes/System/Network/NetworkManger.py

@@ -1,5 +1,6 @@
 import json
 import socket
+import sys
 import threading
 from Classes.Game.Player import Player
 from Classes.System.GameManager import GameManager
@@ -9,82 +10,84 @@ from Classes.System.World import World
 
 class NetworkManager:
 
-    class UDP:
-        __Addr:str
-        __Port:str
-        __BufferSize:int = 1024
-        __udpSocket:socket
-        __users:dict
-        __eventHandler: UDPEventHandler
-        __UDPClientThread:threading.Thread
-        __gameManager:GameManager
-
-        def __init__(self, Addr:str, Port:str, gameManager:GameManager):
-            self.__Addr = Addr
-            self.__Port = int(Port)
-            self.__gameManager = gameManager
-            self.__users = {}
-            self.__eventHandler = {}
-            self.__udpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            
-            try:
-                self.__udpSocket.bind((self.__Addr, self.__Port))
-            except OSError as e:
-                print(f"Error binding UDP socket: {e}")
-            
-            self.__UDPClientThread = threading.Thread(target=self.receive)
-            self.__UDPClientThread.start()
-
-        # handles incoming udp data
-        def receive(self):
-            while True:
-                data, address = self.__udpSocket.recvfrom(self.__BufferSize)
-                message = data.decode()
-                messageJson = json.loads(message)
-                user = messageJson.get("user")
-
-                if user not in self.__users:
-                    self.__users[user] = address  # Storing new user in dictionary
-
-                # Process the message and handle accordingly
-                self.__eventHandler.handleUDPEvents(messageJson, self.__serverWorld)
-                print(f"Received message from {address}: {message}")
-
-        def broadcast(self, payload:dict):
-            for user_address in self.__users.values():
-                self.__udpSocket.sendto(json.dumps(payload).encode(), user_address)
-
-        def send(self, payload:dict, user:str):
-            if user in self.__users:
-                self.__udpSocket.sendto(json.dumps(payload).encode(), self.__users[user])
-                
+#class UDP:
+#    __Addr:str
+#    __Port:str
+#    __BufferSize:int = 1024
+#    __udpSocket:socket
+#    __users:dict
+#    __eventHandler: UDPEventHandler
+#    __UDPClientThread:threading.Thread
+#    __gameManager:GameManager
+#
+#    def __init__(self, Addr:str, Port:str, gameManager:GameManager):
+#        self.__Addr = Addr
+#        self.__Port = int(Port)
+#        self.__gameManager = gameManager
+#        self.__users = {}
+#        self.__eventHandler = {}
+#        self.__udpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+#        
+#        try:
+#            self.__udpSocket.bind((self.__Addr, self.__Port))
+#        except OSError as e:
+#            print(f"Error binding UDP socket: {e}")
+#        
+#        self.__UDPClientThread = threading.Thread(target=self.receive)
+#        self.__UDPClientThread.start()
+#
+#    # handles incoming udp data
+#    def receive(self):
+#        while True:
+#            data, address = self.__udpSocket.recvfrom(self.__BufferSize)
+#            message = data.decode()
+#            messageJson = json.loads(message)
+#            user = messageJson.get("user")
+#
+#            if user not in self.__users:
+#                self.__users[user] = address  # Storing new user in dictionary
+#
+#            # Process the message and handle accordingly
+#            self.__eventHandler.handleUDPEvents(messageJson, self.__serverWorld)
+#            print(f"Received message from {address}: {message}")
+#
+#    def broadcast(self, payload:dict):
+#        for user_address in self.__users.values():
+#            self.__udpSocket.sendto(json.dumps(payload).encode(), user_address)
+#
+#    def send(self, payload:dict, user:str):
+#        if user in self.__users:
+#            self.__udpSocket.sendto(json.dumps(payload).encode(), self.__users[user])
+#            
     class TCP:
         __Addr:str
         __Port:str
         __BufferSize:int = 1024
         __tcpSocket:socket
-        __eventHandler: dict        
+        __eventHandler: dict   
+        __users: dict     
         __TCPClientThread:threading.Thread
         __gameManager:GameManager
         
         def __init__(self, Addr:str, Port:str, gameManager:GameManager):
+            self.running = True
             self.__Addr = Addr
             self.__Port = int(Port)
             self.__gameManager = gameManager
             self.__eventHandler = {}
             self.__tcpSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             self.__tcpSocket.bind((self.__Addr, self.__Port))
-            self.__tcpSocket.listen(2)
+            self.__tcpSocket.listen()
                                     
             self.__TCPClientThread = threading.Thread(target=self.accept_connections)
             self.__TCPClientThread.start()
 
         def accept_connections(self):
-            while True:
+            while self.running:
                 try: 
                     client_tcp_socket, client_address = self.__tcpSocket.accept()
                     print(f"Connected with {client_address}")
-                    self.__users[client_address] = client_tcp_socket
+                    self.__gameManager.getPlayers()[client_address] = client_tcp_socket
                     self.__eventHandler[client_address] = TCPEventHandler(client_tcp_socket)
                     client_handler_thread = threading.Thread(
                         target=self.receive,
@@ -96,7 +99,7 @@ class NetworkManager:
                     pass
 
         def receive(self, client_socket, client_address):
-            while True:
+            while self.running:
                 try:
                     data = client_socket.recv(self.__BufferSize)
                     if not data:
@@ -109,10 +112,10 @@ class NetworkManager:
 
                     # creates a user and counts how many currently are connected to  the server
                     # if enough users for a round are connected the server has to start the game
-                    if user not in self.__users:
+                    if user not in self.__gameManager.getPlayers():
                         if messageJson["event"] == "login":
-                            self.__gameManager.addPlayers(Player(messageJson["username"]), self.__tcpSocket, client_address) 
-                            print(f"connected users {len(self.__users)}")
+                            self.__gameManager.addPlayers(Player(messageJson["username"], messageJson["deck"]), client_socket, client_address) 
+                            print(f"connected users {len(self.__gameManager.getPlayers())}")
 
                     self.__eventHandler[client_address].handleTCPEvents(messageJson, self.__gameManager, client_address)
                     print(f"Received message from {client_address}: {message}")
@@ -138,10 +141,10 @@ class NetworkManager:
                 players[user]["socket"].send(json.dumps(payload).encode())
             else:
                 print(f"user '{user}' or socket was not found 'socket' failed to send data.")
-            
+
     tcp: TCP
-    udp: UDP
+    # udp: UDP
 
     def __init__(self, Addr:str, TCPPort:str, UDPPort:str, gameManager:GameManager):
         self.tcp = self.TCP(Addr, TCPPort, gameManager)
-        self.udp = self.UDP(Addr, UDPPort, gameManager)
+        # self.udp = self.UDP(Addr, UDPPort, gameManager)

Game Server/index.py

@@ -1,4 +1,5 @@
 import os
+import sys
 
 from Classes.System.Server import Server
 
@@ -9,6 +10,7 @@ def main():
     UDPPORT = "54323"
 
     Server(HOST, TCPPORT, UDPPORT)
+    sys.exit(0)
 
 
 if __name__ == "__main__":