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

Game_Client/Classes/System/App.py

@@ -5,10 +5,11 @@ from Classes.Game.Cards.MonsterCard import MonsterCard
 from Classes.System.Components.Window import Window
 from Classes.System.Components.InputHandler import InputHandler
 from Classes.Game.World import World
-from Classes.System.Network.NetworkManager import NetworkManager
+from Classes.System.Network.TCPClient import TCPClient
 from Classes.Game.Events.Login import Login
 from Classes.Game.Events.PlaceCard import PlaceCard
 from Classes.Game.Player import Player
+from Classes.Game.Cards.Card import Card
 
 class App:
 
@@ -19,7 +20,7 @@ class App:
     __myFont:pygame.font
     __world:World
     __inputHandler: InputHandler
-    __networkManager: NetworkManager
+    __tcpClient: TCPClient
 
     def __init__(self, width:int=1920, height:int=1080, title:str="default title"):
         pygame.font.init() 
@@ -27,17 +28,17 @@ class App:
         self.__window = Window(width=width, height=height, title=title)
         self.__inputHandler = InputHandler()
 
+        # game word
+        self.__world = World(self.__window.getScreen())
+        
         try:
-            self.__networkManager = NetworkManager("127.0.0.1", "54322", "54323")
-            Login(self.__networkManager) # will login to the server
+            self.__tcpClient = TCPClient("127.0.0.1", "54322", self.__world, self.__inputHandler)
+            Login(self.__tcpClient) # will login to the server
         except Exception as e:
             print(f"failed to login due to error {e}")
             print("server connection failed or got refused")
             pass
 
-        # game word
-        self.__world = World(self.__window.getScreen())
-
         self.startGameLoop()
         self.onCleanup()
 
@@ -46,12 +47,12 @@ class App:
         # create sprite groups
         # todo: remove these and let server handle card creation instead
         # blocker: server - client communication [WIP]
-        self.__world.spawnMonsterCard("Assets/Cards/1/", pygame.Vector2(500, 1050), self.__inputHandler, Player(1000, 0, "test"))
-        self.__world.spawnMonsterCard("Assets/Cards/1/", pygame.Vector2(600, 1050), self.__inputHandler, Player(1000, 0, "test"))
-        self.__world.spawnMonsterCard("Assets/Cards/1/", pygame.Vector2(700, 1050), self.__inputHandler, Player(1000, 0, "test"))
-        self.__world.spawnMonsterCard("Assets/Cards/1/", pygame.Vector2(800, 1050), self.__inputHandler, Player(1000, 0, "test"))
-        self.__world.spawnMonsterCard("Assets/Cards/1/", pygame.Vector2(900, 1050), self.__inputHandler, Player(1000, 0, "test"))
-        self.__world.spawnMonsterCard("Assets/Cards/1/", pygame.Vector2(1000, 1050), self.__inputHandler, Player(1000, 0, "test"))
+        self.__world.spawnCard("Assets/Cards/1/", pygame.Vector2(500, 1050), self.__inputHandler, Player(1000, 0, "test"))
+        self.__world.spawnCard("Assets/Cards/1/", pygame.Vector2(600, 1050), self.__inputHandler, Player(1000, 0, "test"))
+        self.__world.spawnCard("Assets/Cards/1/", pygame.Vector2(700, 1050), self.__inputHandler, Player(1000, 0, "test"))
+        self.__world.spawnCard("Assets/Cards/1/", pygame.Vector2(800, 1050), self.__inputHandler, Player(1000, 0, "test"))
+        self.__world.spawnCard("Assets/Cards/1/", pygame.Vector2(900, 1050), self.__inputHandler, Player(1000, 0, "test"))
+        self.__world.spawnCard("Assets/Cards/1/", pygame.Vector2(1000, 1050), self.__inputHandler, Player(1000, 0, "test"))
 
         while self.__running:
             self.__clock.tick(self.__FPS)
@@ -63,6 +64,7 @@ class App:
 
             # updates all cards inside the cards Spritegroup at each step the gameloops does
             self.__world.getCards().update()
+            self.__world.getHandCards().update()
 
             # draw groups
             self.__window.drawSpriteGroup(self.__world.getCards())
@@ -88,22 +90,24 @@ class App:
 
                     for card in self.__world.getCards():
                         if card.rect.collidepoint(mouse_pos) and selectedCard == None:
-                            card.setDragging(True)
-                            selectedCard = card
+                            if card.getState() == "onHand":
+                                card.setDragging(True)
+                                selectedCard = card
+                                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.rect.center = field.rect.center
+                                                field.image = card.image.copy()
+                                                card.setDragging(False)
+                                            elif field.getType() == "EffectField" and card.getType() == "EffectCard" or field.getType() == "EffectField" and card.getType() == "EffectCard":
+                                                # todo: resize card so that it fits into the card field
+                                                card.rect.center = field.rect.center
+                                                field.image = card.image.copy()
+                                                card.setDragging(False)
+
 
-                            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.rect.center = field.rect.center
-                                            field.image = card.image.copy()
-                                            card.setDragging(False)
-                                        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.rect.center = field.rect.center
-                                            field.image = card.image.copy()
-                                            card.setDragging(False)
             elif self.__inputHandler.getPressed()[pygame.K_SPACE]:
                 print("card spawned")
                 self.__world.spawnMonsterCard("Assets/Cards/MonsterCards/testmonstercard/", self.__inputHandler.getMousePos(), self.__inputHandler)
@@ -113,9 +117,14 @@ class App:
                 if event.button == 1:  # Wenn linke Maustaste losgelassen wird
                     for card in self.__world.getCards():
                         card.setDragging(False)
+                        card.setState("placed")
                         # TODO: send place card event to server
                         # resets the currently selected card in order to prevent it getting moved
-                        PlaceCard(self.__networkManager, card) # tells the server that the player placed this card
+                        try:
+                            PlaceCard(self.__tcpClient, card) # tells the server that the player placed this card
+                        except Exception as e:
+                            print(f"failed to place card on server due to error: {e}")
+
                         if not card == None:
                             card = None 
 

Game_Client/Classes/System/Network/EventHandler.py

@@ -1,27 +1,37 @@
 import socket
 
+import pygame
+
+from Classes.Game.Events.PlaceCard import CardPlaced
+from Classes.System.Components.InputHandler import InputHandler
+from Classes.Game.World import World
+from Classes.Game.Events.GameStart import GameStart
+from Classes.Game.Player import Player
 
 class TCPEventHandler:
     def __init__(self, socket:socket):
         self.tcp_socket = socket
 
-    def handleEvents(self, message):
+    def handleEvents(self, message, inputHandler:InputHandler, world:World):
         if message["event"] == "login":
             # todo: handle login response here
             pass
         elif message["event"] == "startgame":
-            # todo: handle starting the game here
-            print("game starts")
+            print("gamestart")
+            GameStart(world, message["hand"], inputHandler, world.getPlayer())
             pass
-
-class UDPEventHandler:
-    def __init__(self, socket:socket):
-        self.udp_socket = socket
-
-    def handleEvents(self, message):
-        if message["event"] == "PlaceCard":
+        elif message["event"] == "PlaceCard":
+            CardPlaced(world, message["card"], message["type"], message["owner"], pygame.Vector2(int(message["x"]), int(message["y"]), inputHandler))
             pass    
         elif message["event"] == "MoveCard":
+            CardMoved(
+                world, 
+                message["card"], 
+                message["type"], 
+                message["owner"], 
+                pygame.Vector2(int(message["old_x"]), int(message["old_y"])), 
+                pygame.Vector2(int(message["new_x"]), int(message["new_y"])), 
+                inputHandler)
             pass
         elif message["event"] == "RemoveCard":
             pass

Game_Client/Classes/System/Network/NetworkManager.py

@@ -1,85 +0,0 @@
-import json
-import socket
-import threading
-
-from Classes.System.Network.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)
-
-            try:
-                self.udpSocket.bind((self.addr, self.port))
-            except Exception as e:
-                print(f"Error binding UDP socket: {e}")
-            
-            # start listener thread
-            self.listen()
-
-        def send(self, message: dict):
-            try:
-                self.udpSocket.sendto(json.dumps(message).encode(), (self.addr, self.port))
-            except Exception as e:
-                print(f"Error sending UDP data: {e}")
-
-        # starts a listener thread for udp data
-        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
-
-        def listen(self):
-            udpThread = threading.Thread(target=self.receive)
-            udpThread.daemon = True
-            udpThread.start()
-
-    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)
-
-            try:
-                self.tcpSocket.connect((self.addr, self.port))
-            except Exception as e:
-                print(f"Error connecting TCP socket: {e}")
-
-            # Starten des Listener-Threads
-            self.listen()
-
-        def send(self, message: dict):
-            try:
-                self.tcpSocket.sendall(json.dumps(message).encode())
-            except Exception as e:
-                print(f"Error sending TCP data: {e}")
-
-        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 listen(self):
-            tcpThread = threading.Thread(target=self.receive)
-            tcpThread.daemon = True
-            tcpThread.start()
-
-    def __init__(self, addr: str, tcpport: str, udpport: str):
-        self.tcp = self.TCP(addr, tcpport)
-        self.udp = self.UDP(addr, udpport)

Game_Client/Classes/System/Network/TCPClient.py

@@ -0,0 +1,46 @@
+import json
+import socket
+import threading
+
+from Classes.System.Network.EventHandler import TCPEventHandler
+from Classes.Game.World import World
+from Classes.System.Components.InputHandler import InputHandler
+
+class TCPClient:
+    def __init__(self, addr: str, port: str, world:World, inputHandler:InputHandler):
+        self.addr = addr
+        self.port = int(port)
+        self.tcpSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.eventHandler = TCPEventHandler(self.tcpSocket)
+        self.world = world
+        self.inputHandler = inputHandler
+
+        try:
+            self.tcpSocket.connect((self.addr, self.port))
+        except Exception as e:
+            print(f"Error connecting TCP socket: {e}")
+
+        # Starten des Listener-Threads
+        self.listen()
+
+    def send(self, message: dict):
+        try:
+            self.tcpSocket.sendall(json.dumps(message).encode())
+        except Exception as e:
+            print(f"Error sending TCP data: {e}")
+
+    def receive(self):
+        while True:
+            try:
+                data = self.tcpSocket.recv(1024)
+                if data:
+                    decoded_data = json.loads(data.decode())
+                    self.eventHandler.handleEvents(decoded_data, self.inputHandler, self.world)
+            except Exception as e:
+                print(f"Error receiving TCP data: {e}")
+                break
+
+    def listen(self):
+        tcpThread = threading.Thread(target=self.receive)
+        tcpThread.daemon = True
+        tcpThread.start()