removed messy code dupes

Game Server/.env

@@ -1,3 +1,4 @@
 HOST="127.0.0.1"
-PORT=54321
+TCPPORT=54322
+UDPPORT=54323
 ENV="DEV"

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

@@ -12,7 +12,7 @@ class NetworkManager:
         __BufferSize:int = 1024
         __udpSocket:socket
         __users:list
-        __eventHandler: list
+        __eventHandler: UDPEventHandler
         __UDPClientThread:threading.Thread
         
         def __init__(self, Addr:str, Port:str):
@@ -23,20 +23,10 @@ class NetworkManager:
             self.__eventHandler = {}
             self.__udpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
             self.__udpSocket.bind((self.__Addr, self.__Port))
-                                    
-            self.__UDPClientThread = threading.Thread(target=self.accept_connections)
-            self.__UDPClientThread.start()
 
-        def accept_connections(self):
+            # Starten eines Threads für das Empfangen von UDP-Daten
-            while True:
+            self.__UDPClientThread = threading.Thread(target=self.receive)
-                client_udp_socket, client_address = self.__udpSocket.accept()
+            self.__UDPClientThread.start()
-                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):
@@ -67,7 +57,7 @@ class NetworkManager:
         __BufferSize:int = 1024
         __tcpSocket:socket
         __users:list
-        __eventHandler: list        
+        __eventHandler: TCPEventHandler        
         __TCPClientThread:threading.Thread
         
         def __init__(self, Addr:str, Port:str):
@@ -78,41 +68,62 @@ class NetworkManager:
             self.__eventHandler = {}
             self.__tcpSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             self.__tcpSocket.bind((self.__Addr, self.__Port))
+            self.__tcpSocket.listen(2)
                                     
             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()
+                try: 
-                print(f"Connected with {client_address}")
+                    client_tcp_socket, client_address = self.__tcpSocket.accept()
-                self.__users[client_address] = client_tcp_socket
+                    print(f"Connected with {client_address}")
-                self.__eventHandler[client_address] = TCPEventHandler(client_tcp_socket)
+                    self.__users[client_address] = client_tcp_socket
-                client_handler_thread = threading.Thread(target=self.receive, args=(client_tcp_socket, client_address))
+                    self.__eventHandler[client_address] = TCPEventHandler(client_tcp_socket)
-                client_handler_thread.start()
+                    client_handler_thread = threading.Thread(
+                        target=self.receive,
+                        args=(client_tcp_socket, client_address)
+                    )
+                    client_handler_thread.start()
+                except Exception as e:
+                    print(f"tcp socket failed to accept connection due to error: {e}")
+                    pass
 
-        # handles incomming udp data
+        def receive(self, client_socket, client_address):
-        def receive(self):
             while True:
-                data, address = self.__tcpSocket.recvfrom(self.__BufferSize)
+                try:
-                message = data.decode()
+                    data = client_socket.recv(self.__BufferSize)
-                messageJson = json.loads(message)
+                    if not data:
-                user = messageJson.get("user")
+                        print(f"Connection with {client_address} closed.")
+                        break  # Verbindung geschlossen, Schleife beenden
 
-                if user not in self.__users:
+                    message = data.decode()
-                    self.__users[user] = address  # Storing new user in dictionary
+                    messageJson = json.loads(message)
+                    user = messageJson.get("user")
 
-                # Process the message and handle accordingly
+                    if user not in self.__users:
-                self.__eventHandler.handleTCPEvents(messageJson)
+                        self.__users[user] = client_address
-                print(f"Received message from {address}: {message}")
+
+                    self.__eventHandler[client_address].handleTCPEvents(messageJson)
+                    print(f"Received message from {client_address}: {message}")
+
+                except socket.error as e:
+                    if e.errno == 10054:
+                        print(f"Connection with {client_address} forcibly closed by remote host.")
+                        break
+                    print(f"Socket error receiving data from {client_address}: {e}")
+                except json.JSONDecodeError as e:
+                    print(f"JSON decoding error receiving data from {client_address}: {e}")
+                except Exception as e:
+                    print(f"Error receiving data from {client_address}: {e}")
 
         def broadcast(self, payload:dict):
-            for user_address in self.__users.values():
+            for user_socket in self.__users.values():
-                self.__tcpSocket.sendto(json.dumps(payload).encode(), user_address)
+                user_socket.send(json.dumps(payload).encode())
 
         def send(self, payload:dict, user:str):
             if user in self.__users:
-                self.__tcpSocket.sendto(json.dumps(payload).encode(), self.__users[user])
+                self.__users[user].send(json.dumps(payload).encode())
             
     tcp: TCP
     udp: UDP

Game Server/index.py

@@ -1,15 +1,12 @@
 import os
-import dotenv
 
 from Classes.System.Server import Server
 
-def main(self):
+def main():
-    dotenv.load_dotenv()
-
     # retrieves host data from environment
-    HOST = os.getenv("HOST")
+    HOST = "127.0.0.1"
-    TCPPORT = os.getenv("TCPPORT")
+    TCPPORT = "54322"
-    UDPPORT = os.getenv("UDPPORT")
+    UDPPORT = "54323"
 
     Server(HOST, TCPPORT, UDPPORT)