removed false accept calls and cleaned up tcp code

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

@@ -12,22 +12,32 @@ class NetworkManager:
         __BufferSize:int = 1024
         __udpSocket:socket
         __users:list
+        __eventHandler: list
         __UDPClientThread:threading.Thread
-        __eventHandler: UDPEventHandler
         
         def __init__(self, Addr:str, Port:str):
-            clientUdpSocket, clientUdpAddress = self.__udpSocket.accept()
             self.__Addr = Addr
             self.__Port = int(Port)
 
             self.__users = {}
+            self.__eventHandler = {}
             self.__udpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
             self.__udpSocket.bind((self.__Addr, self.__Port))
-            self.__eventHandler = UDPEventHandler(clientUdpSocket)
                                     
-            self.__UDPClientThread = threading.Thread(target=self.receive)
+            self.__UDPClientThread = threading.Thread(target=self.accept_connections)
             self.__UDPClientThread.start()
 
+        def accept_connections(self):
+            while True:
+                client_udp_socket, client_address = self.__udpSocket.accept()
+                print(f"Connected with {client_address}")
+                
+                self.__users[client_address] = client_udp_socket
+                self.__eventHandler[client_address] = TCPEventHandler(client_udp_socket)
+                
+                client_handler_thread = threading.Thread(target=self.receive, args=(client_udp_socket, client_address))
+                client_handler_thread.start()
+
         # handles incomming udp data
         def receive(self):
             while True:
@@ -52,63 +62,57 @@ class NetworkManager:
                 self.__udpSocket.sendto(json.dumps(payload).encode(), self.__users[user])
                 
     class TCP:
-        def __init__(self, Addr: str, Port: str):
+        __Addr:str
+        __Port:str
+        __BufferSize:int = 1024
+        __tcpSocket:socket
+        __users:list
+        __eventHandler: list        
+        __TCPClientThread:threading.Thread
+        
+        def __init__(self, Addr:str, Port:str):
             self.__Addr = Addr
             self.__Port = int(Port)
+
             self.__users = {}
+            self.__eventHandler = {}
             self.__tcpSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             self.__tcpSocket.bind((self.__Addr, self.__Port))
-            self.__tcpSocket.listen()
                                     
-            self.__eventHandler = TCPEventHandler()
-
-            self.__receive_thread = threading.Thread(target=self.accept_connections)
-            self.__receive_thread.start()
+            self.__TCPClientThread = threading.Thread(target=self.accept_connections)
+            self.__TCPClientThread.start()
 
         def accept_connections(self):
             while True:
                 client_tcp_socket, client_address = self.__tcpSocket.accept()
                 print(f"Connected with {client_address}")
                 self.__users[client_address] = client_tcp_socket
+                self.__eventHandler[client_address] = TCPEventHandler(client_tcp_socket)
                 client_handler_thread = threading.Thread(target=self.receive, args=(client_tcp_socket, client_address))
                 client_handler_thread.start()
 
-        def receive(self, __tcpSocket: socket.socket, address):
+        # handles incomming udp data
+        def receive(self):
             while True:
-                try:
-                    data = __tcpSocket.recv(1024)
-                    if not data:
-                        break
+                data, address = self.__tcpSocket.recvfrom(self.__BufferSize)
+                message = data.decode()
+                messageJson = json.loads(message)
+                user = messageJson.get("user")
 
-                    message = data.decode()
-                    message_json = json.loads(message)
-                    user = message_json.get("user")
+                if user not in self.__users:
+                    self.__users[user] = address  # Storing new user in dictionary
 
-                    if user not in self.__users:
-                        self.__users[user] = address  # Storing new user in dictionary
+                # Process the message and handle accordingly
+                self.__eventHandler.handleTCPEvents(messageJson)
+                print(f"Received message from {address}: {message}")
 
-                    # Process the message and handle accordingly
-                    self.__eventHandler.handleTCPEvents(message_json)
-                    print(f"Received message from {address}: {message}")
+        def broadcast(self, payload:dict):
+            for user_address in self.__users.values():
+                self.__tcpSocket.sendto(json.dumps(payload).encode(), user_address)
 
-                except ConnectionResetError:
-                    print(f"Connection with {address} closed.")
-                    del self.__users[address]
-                    break
-
-        def broadcast(self, payload: dict):
-            for user_socket in self.__users.values():
-                user_socket.send(json.dumps(payload).encode())
-
-        def send(self, payload: dict, user_address):
-            if user_address in self.__users:
-                user_socket = self.__users[user_address]
-                user_socket.send(json.dumps(payload).encode())
-            else:
-                print(f"User {user_address} is not connected.")
-
-        def close(self):
-            self.__tcpSocket.close()
+        def send(self, payload:dict, user:str):
+            if user in self.__users:
+                self.__tcpSocket.sendto(json.dumps(payload).encode(), self.__users[user])
             
     tcp: TCP
     udp: UDP