reworked client netcode

Game_Client/Classes/System/App.py

@@ -5,6 +5,7 @@ from Classes.Objects.Cards.MonsterCard import MonsterCard
 from Classes.System.Components.Window import Window
 from Classes.System.Components.InputHandler import InputHandler
 from Classes.Objects.World import World
+from Classes.System.Network.NetworkManager import NetworkManager
 
 class App:
 
@@ -15,12 +16,14 @@ class App:
     __myFont:pygame.font
     __world:World
     __inputHandler: InputHandler
+    __networkManager: NetworkManager
 
     def __init__(self, width:int=1920, height:int=1080, title:str="default title"):
         pygame.font.init() 
         self.__myFont = pygame.font.SysFont('Comic Sans MS', 30)
         self.__window = Window(width=width, height=height, title=title)
         self.__inputHandler = InputHandler()
+        self.__networkManager("127.0.0.1", "54322", "54323")
         
         # game word
         self.__world = World(self.__window.getScreen())
@@ -32,7 +35,7 @@ class App:
 
         # create sprite groups
         # todo: remove these and let server handle card creation instead
-        # blocker: server - client communication
+        # blocker: server - client communication [WIP]
         self.__world.spawnCard("Assets/Cards/MonsterCards/testmonstercard/", (pygame.Vector2(500, 1050), self.__inputHandler))
         self.__world.spawnCard("Assets/Cards/MonsterCards/testmonstercard/", (pygame.Vector2(600, 1050), self.__inputHandler))
         self.__world.spawnCard("Assets/Cards/MonsterCards/testmonstercard/", (pygame.Vector2(700, 1050), self.__inputHandler))
@@ -64,34 +67,33 @@ class App:
     def handleEvent(self, events):
         # TODO: fix bug that stacks cards when dragging them around
         selectedCard = None
+        
         for event in events:
             if event.type == pygame.QUIT:
                 self.onCleanup()
             elif pygame.mouse.get_pressed()[0]:  # Wenn linke Maustaste gedrückt wird
                     mouse_x, mouse_y = pygame.mouse.get_pos()
                     mouse_pos = pygame.Vector2(mouse_x, mouse_y)
+
                     for card in self.__world.getCards():
                         if card.rect.collidepoint(mouse_pos) and selectedCard == None:
                             card.setDragging(True)
                             selectedCard = card
-                            # card.setOffset(mouse_pos - card.getPos())
+
                             for field in self.__world.getBoardFields():
                                 if field.getRect().collidepoint(mouse_pos):
                                     if field.getSide() == "Player":
                                         if field.getType() == "MonsterField" and card.getType() == "MonsterCard":
                                             # todo: resize card so that it fits into the card field
-                                            # card.image = pygame.transform.scale(card.image, (field.getSize()[0] - 10, field.getSize()[1] - 10))
                                             card.rect.center = field.rect.center
                                             field.image = card.image.copy()
                                             card.setDragging(False)
-                                            # card.kill()
                                         elif field.getType() == "EffectField" and card.getType() == "SpellCard" or field.getType() == "EffectField" and card.getType() == "TrapCard":
                                             # todo: resize card so that it fits into the card field
-                                            # card.image = pygame.transform.scale(card.image, (field.getSize()[0] - 10, field.getSize()[1] - 10))
                                             card.rect.center = field.rect.center
                                             field.image = card.image.copy()
                                             card.setDragging(False)
-                                            # card.kill()
+
             elif event.type == pygame.MOUSEBUTTONUP:
                 mouse_x, mouse_y = pygame.mouse.get_pos()
                 mouse_pos = pygame.Vector2(mouse_x, mouse_y)

Game_Client/Classes/System/Network/Handler/EventHandler.py

@@ -0,0 +1,29 @@
+import socket
+
+
+class TCPEventHandler:
+    def __init__(self, socket:socket):
+        self.tcp_socket = socket
+
+    def handleEvents(self, event):
+        pass
+
+class UDPEventHandler:
+    def __init__(self, socket:socket):
+        self.udp_socket = socket
+
+    def handleEvents(self, event):
+        if event["event"] == "PlaceCard":
+            pass
+        elif event["event"] == "MoveCard":
+            pass
+        elif event["event"] == "RemoveCard":
+            pass
+        elif event["event"] == "AttackCard":
+            pass
+        elif event["event"] == "AttackPlayer":
+            pass
+        elif event["event"] == "ActivateEffectCard":
+            pass
+        elif event["event"] == "ActivateMonsterCard":
+            pass

Game_Client/Classes/System/Network/NetworkManager.py

@@ -0,0 +1,73 @@
+import json
+import socket
+import threading
+
+from Classes.System.Network.Handler.EventHandler import TCPEventHandler, UDPEventHandler
+
+class NetworkManager:
+    class UDP:
+        def __init__(self, addr: str, port: str):
+            self.addr = addr
+            self.port = int(port)
+            self.udpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            self.eventHandler = UDPEventHandler(self.udpSocket)
+            
+            # start listener thread
+            self.listen()
+
+        def send(self, message: dict):
+            self.udpSocket.sendto(json.dumps(message).encode(), (self.addr, self.port))
+
+        # starts a listener thread for udp data
+        def listen(self):
+            udpThread = threading.Thread(target=self.receive)
+            udpThread.daemon = True
+            udpThread.start()
+
+        def receive(self):
+            while True:
+                try:
+                    data, addr = self.udpSocket.recvfrom(1024)
+                    if data:
+                        decoded_data = json.loads(data.decode())
+                        self.eventHandler.handleEvents(decoded_data)
+                except Exception as e:
+                    print(f"Error receiving UDP data: {e}")
+                    break
+
+    class TCP:
+        def __init__(self, addr: str, port: str):
+            self.addr = addr
+            self.port = int(port)
+            self.tcpSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.eventHandler = TCPEventHandler(self.tcpSocket)
+
+            # start listener thread
+            self.listen()
+
+        def connect(self):
+            self.tcpSocket.connect((self.addr, self.port))
+
+        def send(self, message: dict):
+            self.tcpSocket.sendall(json.dumps(message).encode())
+
+        # starts a listener thread for tcp data
+        def listen(self):
+            tcp_thread = threading.Thread(target=self.receive)
+            tcp_thread.daemon = True
+            tcp_thread.start()
+
+        def receive(self):
+            while True:
+                try:
+                    data = self.tcpSocket.recv(1024)
+                    if data:
+                        decoded_data = json.loads(data.decode())
+                        self.eventHandler.handleEvents(decoded_data)
+                except Exception as e:
+                    print(f"Error receiving TCP data: {e}")
+                    break
+
+    def __init__(self, addr: str, port: str):
+        self.tcp = self.TCP(addr, port)
+        self.udp = self.UDP(addr, port)

Game_Client/Classes/System/chatgpt server.py

@@ -0,0 +1,66 @@
+import selectors
+import socket
+import json
+
+sel = selectors.DefaultSelector()
+
+clients = {}  # Dictonary, um Clients zu speichern
+
+def accept_wrapper(sock):
+    conn, addr = sock.accept()
+    print(f"Verbunden mit {addr}")
+    conn.setblocking(False)
+    data = types.SimpleNamespace(addr=addr, inb=b"", outb=b"")
+    events = selectors.EVENT_READ | selectors.EVENT_WRITE
+    sel.register(conn, events, data=data)
+
+def service_connection(key, mask):
+    sock = key.fileobj
+    data = key.data
+
+    if mask & selectors.EVENT_READ:
+        recv_data = sock.recv(1024)
+        if recv_data:
+            data.outb += recv_data
+            try:
+                received_json = json.loads(recv_data.decode())
+                # Hier könnte man weitere Verarbeitungsschritte für die empfangenen Daten durchführen
+            except json.JSONDecodeError:
+                pass
+        else:
+            print("Verbindung geschlossen mit", data.addr)
+            sel.unregister(sock)
+            sock.close()
+            del clients[data.addr]
+
+    if mask & selectors.EVENT_WRITE:
+        if data.outb:
+            sent = sock.send(data.outb)
+            data.outb = data.outb[sent:]
+
+def start_server():
+    host = '127.0.0.1'
+    port_tcp = 65432
+    port_udp = 65433
+
+    server_tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    server_tcp.bind((host, port_tcp))
+    server_tcp.listen()
+    server_tcp.setblocking(False)
+    sel.register(server_tcp, selectors.EVENT_READ, data=None)
+
+    server_udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    server_udp.bind((host, port_udp))
+    server_udp.setblocking(False)
+    sel.register(server_udp, selectors.EVENT_READ, data=None)
+
+    while True:
+        events = sel.select(timeout=None)
+        for key, mask in events:
+            if key.data is None:
+                accept_wrapper(key.fileobj)
+            else:
+                service_connection(key, mask)
+
+if __name__ == "__main__":
+    start_server()