added old code, fixed it (mostly), merged some new code to the old code, made it mostly runnable

New_Client/App.py

@@ -0,0 +1,76 @@
+import pygame
+from Classes.Engine.EventHandler import EngineEventHandler
+from Classes.Engine.InputHandler import InputHandler
+from Classes.Engine.Logger import Logger
+from Classes.Engine.TCPClient import TCPClient
+
+from Classes.Engine.Window import Window
+from Classes.Game.World import World
+from Classes.Game.NetworkEvents.Login import Login
+
+
+class App:
+    
+    __running:bool
+    __FPS:int = 60
+    __clock:pygame.time.Clock()
+    __myFont:pygame.font
+    __window:Window
+    __world:World
+    __inputHandler: InputHandler
+    __tcpClient: TCPClient
+    __eventHandler: EngineEventHandler
+    logger:Logger
+    
+    def __init__(self, logger:Logger, width:int=1280, height:int=720, title:str="default title"):
+        self.logger = logger
+        
+        self.logger.info("initializing dependencies")
+        pygame.init()
+        pygame.font.init()
+        self.__myFont = pygame.font.SysFont('Comic Sans MS', 30)
+        self.__window = Window(width=width, height=height, title=title)
+        self.__world = World(self.logger, self.__window.getScreen())
+        self.__inputHandler = InputHandler()
+        
+        # attempt to connect to server
+        try:
+            self.logger.info("logging into 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
+    
+    def startGameLoop(self):
+        self.__running = True
+        
+        while self.__running:
+            
+            self.__clock.tick(self.__FPS)
+
+            self.__window.getScreen().fill((0,0,0))
+
+            # render world
+            self.__window.drawWorld(self.__world)
+            
+            # 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())
+            self.__window.drawSpriteGroup(self.__world.getHandCards())
+            
+            self.__eventHandler.handleEvent(pygame.event.get())
+            
+            # emits update to the game
+            pygame.display.update()
+        
+        self.__running = False
+        
+    # ensures the gameloop stops running and the pygame instance is stopped properly
+    def onCleanup(self):
+        self.__running = False
+        pygame.quit()

New_Client/Assets/Cards/1/card.json

@@ -0,0 +1,23 @@
+{
+    "id": 1,
+    "type":"MonsterCard",
+    "name": "Test Monster",
+    "image": "Assets/Cards/1/cards.png",
+    "description": "can attack other monsters",
+    "costs": 30,
+    "defense": 40,
+    "attacks":[
+        {
+            "id": 1,
+            "name":"test attack",
+            "description": "can attack another Monster",
+            "damage": 80
+        },
+        {
+            "id": 2,
+            "name":"test attack",
+            "description": "can attack another Monster",
+            "damage": 80
+        }
+    ]
+}

New_Client/Assets/Cards/2/testspellcard.json

@@ -0,0 +1,9 @@
+{
+    "name": "testspell",
+    "type":"EffectCard",
+    "image":"Assets/Cards/2/artwork.png",
+    "costs": 30,
+    "defense": 0,
+    "description":"this is a test spell card",
+    "attacks": []
+}

New_Client/Assets/Cards/3/testtrapcard.json

@@ -0,0 +1,9 @@
+{
+    "name": "testtrap",
+    "type":"EffectCard",
+    "image":"Assets/Cards/3/artwork.png",
+    "costs": 30,
+    "defense": 0,
+    "description":"this is a test trap card",
+    "attacks": []
+}

New_Client/Classes/Engine/Components/BoardField.py

@@ -0,0 +1,85 @@
+import os
+import pygame
+
+class BoardField(pygame.sprite.Sprite):
+    __fieldID:str
+    __name:str
+    __side:str
+    __type:str
+    __pos:pygame.Vector2
+    __size:tuple
+    __color:tuple = (255,255,255)
+    __holdsCard = None
+    image:pygame.image
+    rect:pygame.rect
+
+    def __init__(self, name:str, side:str, type:str, pos:pygame.Vector2, imagePath:str, fid:str):
+        pygame.sprite.Sprite.__init__(self)
+        self.__name = name
+        self.__side = side
+        self.__type = type
+        self.__pos = pos
+        self.__holdsCard = None
+        self.__fieldID = fid
+
+        # Überprüfen des Dateipfads
+        if not os.path.exists(imagePath):
+            print("could not find image Location.")
+        else:
+            # Wenn der Pfad gültig ist, versuchen Sie, das Bild zu laden
+            self.image = pygame.image.load(imagePath).convert_alpha()
+            self.rect = self.image.get_rect()
+            self.rect.center = self.__pos
+
+    def getName(self) -> str:
+        return self.__name
+
+    def getSide(self) -> str:
+        return self.__side
+
+    def getType(self) -> str:
+        return self.__type
+
+    def getPos(self) -> pygame.Vector2:
+        return self.__pos
+
+    def getSize(self) -> tuple:
+        return self.__size
+
+    def getColor(self) -> tuple:
+        return self.__color
+
+    def getRect(self) -> pygame.Rect:
+        return self.rect
+
+    def getImage(self) -> pygame.image:
+        return self.image
+    
+    def getHoldingCard(self):
+        return self.__holdsCard
+
+    def setName(self, name:str) -> str:
+        self.__name = name
+        return self.__name
+
+    def setType(self,type:str) -> str:
+        self.__type = type
+        return self.__type
+
+    def setPos(self, pos:pygame.Vector2) -> pygame.Vector2:
+        self.pos = pos
+        return self.__pos
+
+    def setSize(self, size:tuple) -> tuple:
+        self.__size = size
+        return self.__size
+
+    def setColor(self, color:tuple) -> tuple:
+        self.__color = color
+        return self.__color
+    
+    def setCardHolding(self, card):
+        self.__holdsCard = card
+
+    def getFieldID(self) -> str:
+        return self.__fieldID

New_Client/Classes/Engine/Components/Label.py

@@ -0,0 +1,46 @@
+import pygame
+
+class Label:
+    rect:pygame.rect
+    image:pygame.image
+    __screen:pygame.surface
+    __text:str
+    __pos:pygame.Vector2
+    __font:pygame.font
+    font:pygame.font
+    __name:str
+
+    def __init__(self, name:str, screen:pygame.surface, text:str, pos:pygame.Vector2, size:float=20, color:str="white"):
+        self.__font = pygame.font.SysFont("Arial", size)
+        self.font = pygame.font.SysFont("Arial", size)
+        self.image = self.font.render(text, 1, color)
+        _, _, w, h = self.image.get_rect()
+        self.__pos = pos
+        self.rect = pygame.Rect(self.__pos.x, self.__pos.y, w, h)
+        self.__screen = screen
+        self.__text = text
+
+    def getText(self) -> str:
+        return self.__text
+
+    def getFont(self) -> pygame.font:
+        return self.__font
+
+    def getPos(self) -> pygame.Vector2:
+        return self.__pos
+
+    def getName(self) -> str:
+        return self.__name
+
+    def setText(self, newtext:str, color:str="white"):
+        self.image = self.font.render(newtext, 1, color)
+
+    def setFont(self, font:pygame.font, size:float, color:str="white"):
+        self.__font = pygame.font.SysFont(font, size)
+        self.change_text(self.text, color)
+
+    def setPos(self, pos:pygame.Vector2):
+        self.__pos = pos
+
+    def draw(self):
+        self.__screen.blit(self.image, (self.rect))

New_Client/Classes/Engine/EventHandler.py

@@ -0,0 +1,117 @@
+import socket
+
+import pygame
+from Classes.Engine.Logger import Logger
+
+from Classes.Game.NetworkEvents.PlaceCard import CardPlaced
+from Classes.Game.NetworkEvents.GameStart import GameStart
+from Classes.Game.NetworkEvents.PlaceCard import PlaceCard
+from Classes.Engine.InputHandler import InputHandler
+from Classes.Game.World import World
+from Classes.Game.Player import Player
+from Classes.Game.NetworkEvents.Login import LoginResponse
+
+# network event handler this only handles events coming from the server
+class TCPEventHandler:
+    def __init__(self, socket:socket, inputHandler:InputHandler, world:World):
+        self.tcp_socket = socket
+        self.__world = world
+        self.__inputHandler = inputHandler
+
+    def handleEvents(self, message:dict):
+        if message["event"] == "loginresponse":
+            LoginResponse(message)
+            pass
+        elif message["event"] == "startgame":
+            print("gamestart")
+            GameStart(self.__world, message["hand"], self.__inputHandler, self.__world.getPlayer())
+            pass
+        elif message["event"] == "PlaceCard":
+            CardPlaced(self.__world, message["card"], message["type"], message["owner"], pygame.Vector2(int(message["x"]), int(message["y"]), self.__inputHandler))
+            pass    
+        elif message["event"] == "MoveCard":
+            CardMoved(
+                self.__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"])), 
+                self.__inputHandler)
+            pass
+        elif message["event"] == "RemoveCard":
+            pass
+        elif message["event"] == "AttackCard":
+            pass
+        elif message["event"] == "AttackPlayer":
+            pass
+        elif message["event"] == "ActivateEffectCard":
+            pass
+        elif message["event"] == "ActivateMonsterCard":
+            pass
+    
+# handles engine events this is separate from the network event handler
+class EngineEventHandler:
+    
+    __inputHandler:InputHandler
+    __world:World
+    __logger:Logger
+    
+    def __init__(self, inputHandler:InputHandler, world:World, logger:Logger, tcpClient):
+        self.__logger = logger
+        self.__logger.info("initializing engine Event Handler")
+        if inputHandler == None:
+            raise ValueError("InputHandler was found to be None")
+        
+        if world == None:
+            raise ValueError("world was found to be None")
+
+        if world == tcpClient:
+            raise ValueError("tcpCLient was found to be None")
+                
+        self.__inputHandler = inputHandler
+        self.__world = world
+        self.__tcpClient = tcpClient
+                
+    # handles the incoming event queue
+    def handleEvent(self, events):
+        # TODO: fix bug that stacks cards when dragging them around
+        self.selectedCard = None
+        self.mousePos = self.__inputHandler.getMousePos()
+        
+        for event in events:
+            if event.type == pygame.QUIT:
+                self.onCleanup()
+            elif self.__inputHandler.getMousePos()[0]:  
+                for card in self.__world.getCards():
+                    if card.rect.collidepoint(self.mousePos):
+                        self.__logger.info(f"dragging card {card}")
+                        self.selectedCard = card
+
+                        # failsafe to prevent NoneType errors
+                        if self.selectedCard != None:
+                            self.__logger.info(f"working with card: {self.selectedCard}")
+                            self.selectedCard.setDragging(True)
+            elif event.type == pygame.MOUSEBUTTONUP:
+                if event.button == 1:
+                    if self.selectedCard != None:
+                        for field in self.__world.getBoardFields():
+                            if field.getRect().collidepoint(self.mousePos):
+                                if field.getSide() == "Player" and field.getType() == self.selectedCard.getType():
+                                    try:
+                                        # snap card into the correct field
+                                        self.selectedCard.rect.center = field.rect.center
+                                        self.selectedCard.setDragging(False) 
+                                        print(self.selectedCard)
+                                        if self.selectedCard == card:
+                                            # TODO: adapt this into the new game engine version
+                                            PlaceCard(self.__tcpClient, self.selectedCard) # tells te server that the player placed this card
+                                            self.selectedCard = None
+                                    except Exception as e:
+                                        print(f"failed to place card on server due to error: {e}")             
+                                        
+                                    if self.selectedCard != None:
+                                        self.selectedCard = None
+                    else:
+                        raise ValueError("selected card in event handler was found empty this should never happen!")
+                    pass

New_Client/Classes/Engine/InputHandler.py

@@ -0,0 +1,53 @@
+import pygame
+
+from Classes.Engine.Components.BoardField import BoardField
+
+class InputHandler:
+    # returns pressed key
+    @staticmethod
+    def getPressed():
+        return pygame.key.get_pressed()
+    
+        # returns pressed key
+    @staticmethod
+    def getMousePressed():
+        return pygame.mouse.get_pressed()
+        
+    # takes in movement inputs and maps them to x and y axis
+    @staticmethod
+    def getInputAxis() -> tuple:
+        xvel = 0    
+        yvel = 0
+
+        # construct x and y velocity input axis
+        if InputHandler.getPressed()[pygame.K_a] or InputHandler.getPressed()[pygame.K_LEFT]:
+            xvel = -1
+        if InputHandler.getPressed()[pygame.K_d] or InputHandler.getPressed()[pygame.K_RIGHT]:
+            xvel = 1
+        if InputHandler.getPressed()[pygame.K_w] or InputHandler.getPressed()[pygame.K_UP]:
+            yvel = -1
+        if InputHandler.getPressed()[pygame.K_s] or InputHandler.getPressed()[pygame.K_DOWN]:
+            yvel = 1
+        
+        return tuple((xvel, yvel))
+    
+    @staticmethod
+    def getMousePos() -> pygame.Vector2:
+        return pygame.Vector2(pygame.mouse.get_pos())
+
+    # get field under mousbutton
+    @staticmethod
+    def getMouseHover(mouse_pos: pygame.Vector2, world_card_width: int, world_card_height: int, board_fields: list) -> BoardField:
+        x_pos = mouse_pos.x / world_card_width
+        y_pos = mouse_pos.y / world_card_height
+
+        for field in board_fields:
+            field_x = field.getPos().x
+            field_y = field.getPos().y
+            field_width = world_card_width  # Annahme: Jedes Feld hat eine Breite von 1 Einheit
+            field_height = world_card_height  # Annahme: Jedes Feld hat eine Höhe von 1 Einheit
+
+            if field_x <= x_pos < field_x + field_width and field_y <= y_pos < field_y + field_height:
+                return field
+
+        return None

New_Client/Classes/Engine/Logger.py

@@ -0,0 +1,18 @@
+import logging
+
+
+class Logger:
+    def __init__(self, filename):
+        logging.basicConfig(filename=filename,
+                filemode='a',
+                format='%(asctime)s,%(msecs)d %(name)s %(levelname)s %(message)s',
+                datefmt='%H:%M:%S',
+                level=logging.DEBUG)
+
+    def info(self, message):
+        print(message)
+        logging.info(message)
+
+    def error(self, message):
+        print(message)
+        logging.error(message)

New_Client/Classes/Engine/TCPClient.py

@@ -0,0 +1,52 @@
+import json
+import socket
+import threading
+
+from Classes.Engine.EventHandler import TCPEventHandler
+from Classes.Game.World import World
+from Classes.Engine.InputHandler import InputHandler
+
+class TCPClient:
+    
+    __running:bool
+    
+    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.world = world
+        self.inputHandler = inputHandler
+        self.eventHandler = TCPEventHandler(self.tcpSocket, self.inputHandler, self.world)
+                
+        try:
+            self.tcpSocket.connect((self.addr, self.port))
+            self.__running = True
+            
+        except Exception as e:
+            print(f"Error connecting TCP socket: {e}")
+            self.__running = False
+
+        # 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):
+        self.tcpThread = threading.Thread(target=self.receive)
+        self.tcpThread.daemon = True
+        self.tcpThread.start()

New_Client/Classes/Engine/Utils/Path.py

@@ -0,0 +1,6 @@
+import os
+
+
+class PathUtil:
+    def getAbsolutePathTo(notAbsolutPath:str) -> str:
+        return os.path.abspath("Client/" + notAbsolutPath)

New_Client/Classes/Engine/Utils/StringUtils.py

@@ -0,0 +1,11 @@
+import random
+import string
+
+
+class StringUtils:
+    def get_random_string(length) -> str:
+        # choose from all lowercase letter
+        letters = string.ascii_lowercase
+        result_str = ''.join(random.choice(letters) for i in range(length))
+        print("Random string of length", length, "is:", result_str)
+        return result_str

New_Client/Classes/Engine/Window.py

@@ -0,0 +1,54 @@
+import pygame
+from pygame.locals import *
+
+from Classes.Engine.Components.BoardField import BoardField
+from Classes.Game.World import World
+
+class Window:
+    __width:int = 800
+    __height:int = 600 # takes 80% of width which tranlates to 640
+    __title:str = "python game engine"
+    __screen:pygame.Surface
+    __clock:pygame.time.Clock
+
+    def __init__(self, width:int=800, height:int=600, title:str="python game engine"):
+        self.__width = width
+        self.__height = height
+        self.__title = title
+
+        pygame.init()
+
+        self.__screen = pygame.display.set_mode((self.__width, self.__height))
+        self.__screen.fill((236, 240, 241))  # Hier liegt der Fehler, es muss eine Tuple übergeben werden
+        pygame.display.set_caption(self.__title)
+
+        self.__clock = pygame.time.Clock()
+        self.__framerate = 60  # Framerate auf 60 FPS festlegen
+
+        # set framerate (where the fuck is it?)
+    def Render(self):
+        # dear future me figure out what past me did!
+        pass
+
+    def setWidth(self, width:int):
+        self.__width = width
+
+    def setHeight(self, height:int):
+        self.__height = height
+
+    def setTitle(self, title:str):
+        self.__title = title
+
+    def getScreen(self) -> pygame.surface:
+        return self.__screen
+    
+    # draws a passed sprite group to the screen
+    def drawSpriteGroup(self, group:pygame.sprite.Group):
+        group.draw(self.__screen)
+
+    # draws a given group of rectangles onto the screen
+    def drawWorld(self, world:World):
+        for field in world.getBoardFields():
+            pygame.draw.rect(self.__screen, field.getColor(), field.getRect())
+        for label in world.getLabels():
+            label.draw()

New_Client/Classes/Game/Cards/Card.py

@@ -0,0 +1,98 @@
+import json
+import pygame
+
+from Classes.Engine.InputHandler import InputHandler
+from Classes.Game.Player import Player
+
+class Card(pygame.sprite.Sprite):
+    __name:str
+    __id:int
+    __description:str
+    __attacks = []
+    __type:str = "MonsterCard"
+    __pos:pygame.Vector2
+    __dragging:bool = False
+    __offset:pygame.Vector2 = pygame.Vector2(0,0)
+    __inputHandler: InputHandler
+    __owner:Player
+    __state:str
+    image:pygame.image
+    rect:pygame.rect
+
+    def __init__(self, pos: pygame.Vector2, assetDir: str, inputHandler: InputHandler, owner: Player):
+        if assetDir == "":
+            raise ValueError("Card: imagePath cannot be empty")
+
+        pygame.sprite.Sprite.__init__(self)
+
+        with open(assetDir + "/card.json", 'r') as file:
+            data = json.load(file)
+
+        self.__owner = owner
+        self.__id = int(data["id"])
+        self.__pos = pos
+        self.__name = data["name"]
+        self.__type = data.get("type")
+        self.image = pygame.image.load(assetDir + "/card.png").convert_alpha()
+        self.rect = self.image.get_rect()
+        self.__inputHandler = inputHandler
+        self.rect.center = self.__pos
+        self.__description = data["description"]
+        self.original_size = self.image.get_size()
+        self.original_position = self.rect.center
+        self.__state = "onHand"
+
+        self.__attacks = []
+        for attack in data.get("attacks", []):
+            self.__attacks.append(attack)
+
+    def update(self):
+        if self.__dragging:
+            mouse_pos = self.__inputHandler.getMousePos()
+            self.__pos = mouse_pos
+            self.rect.center = self.__pos
+
+    def attacks(self):
+        return self.__attacks
+    
+    def getName(self) -> str:
+        return self.__name
+
+    def getCardSprite(self) -> pygame.image:
+        return self.__cardSprite
+    
+    def getDescription(self):
+        return self.__description
+
+    def getDragging(self):
+        return self.__dragging
+
+    def getOffset(self):
+        return self.__offset
+
+    def getPos(self):
+        return self.__pos
+
+    def getType(self):
+        return self.__type
+
+    def getID(self) -> int:
+        return self.__id
+
+    def getOwner(self) -> Player:
+        return self.__owner
+
+    def getState(self) -> str:
+        return self.__state 
+    
+    def setDragging(self, dragging:bool):
+        self.__dragging = dragging
+
+    def setOffset(self, offset:pygame.Vector2):
+        self.__offset = offset
+
+    def setPos(self, pos:pygame.Vector2):
+        self.__pos = pos
+
+    def setState(self, state:str):
+        self.__state = state

New_Client/Classes/Game/Cards/MonsterCard.py

@@ -0,0 +1,88 @@
+import json
+import pygame
+
+from Classes.Engine.InputHandler import InputHandler
+from Classes.Game.Player import Player
+
+class MonsterCard(pygame.sprite.Sprite):
+    __name:str
+    __id:int
+    __description:str
+    __attacks = []
+    __type:str = "Monster"
+    __pos:pygame.Vector2
+    __dragging:bool = False
+    __offset:pygame.Vector2 = pygame.Vector2(0,0)
+    __inputHandler: InputHandler
+    __owner:Player
+    image:pygame.image
+    rect:pygame.rect
+
+    def __init__(self, pos:pygame.Vector2, assetDir:str, inputHandler:InputHandler, owner:Player):
+        if assetDir == "":
+            return ValueError.add_note("Card: imagePath cannot be empty")
+        
+        pygame.sprite.Sprite.__init__(self)
+
+        data = json.load(open(assetDir + "/card.json"))
+        self.__owner = owner
+        self.__id = int(data["id"])
+        self.__pos = pos
+        self.__name = data["name"]
+        self.image = pygame.image.load(assetDir + "/card.png").convert_alpha()
+        self.rect = self.image.get_rect()
+        self.dragging = False
+        self.offset = pygame.Vector2(0, 0)  # Offset zwischen der Karte und der Mausposition
+        self.__inputHandler = inputHandler
+        self.rect.center = self.__pos
+        self.__description = data["description"]
+        self.original_size = self.image.get_size()
+        self.original_position = self.rect.center
+
+        for attack in data["attacks"]:
+            self.__attacks.append(attack)
+
+    def update(self):
+        if self.__dragging:
+            mouse_pos = self.__inputHandler.getMousePos()
+            self.__pos = mouse_pos
+            self.rect.center = self.__pos
+
+    def attacks(self):
+        return self.__attacks
+    
+    def getName(self) -> str:
+        return self.__name
+
+    def getCardSprite(self) -> pygame.image:
+        return self.__cardSprite
+    
+    def getDescription(self):
+        return self.__description
+
+    def getDragging(self):
+        return self.__dragging
+
+    def getOffset(self):
+        return self.__offset
+
+    def getPos(self):
+        return self.__pos
+
+    def getType(self):
+        return self.__type
+
+    def getID(self) -> int:
+        return self.__id
+
+    def getOwner(self) -> Player:
+        return self.__owner
+
+    def setDragging(self, dragging:bool):
+        self.__dragging = dragging
+
+    def setOffset(self, offset:pygame.Vector2):
+        self.__offset = offset
+
+    def setPos(self, pos:pygame.Vector2):
+        self.__pos = pos

New_Client/Classes/Game/Cards/SpellCard.py

@@ -0,0 +1,72 @@
+import json
+from typing import Any
+
+import pygame
+
+from Classes.Engine.InputHandler import InputHandler
+
+class SpellCard(pygame.sprite.Sprite):
+    __name:str
+    __description:str
+    __pos:pygame.Vector2
+    __dragging:bool = False
+    __offset:pygame.Vector2 = pygame.Vector2(0,0)
+    __inputHandler: InputHandler
+    __type:str = "Effect"
+    image:pygame.image
+    rect:pygame.rect
+
+    def __init__(self, pos:pygame.Vector2, assetDir:str, inputHandler:InputHandler):
+        if assetDir == "":
+            return ValueError.add_note("Card: imagePath cannot be empty")
+        
+        pygame.sprite.Sprite.__init__(self)
+
+        data = json.load(open(assetDir + "/card.json"))
+        self.__pos = pos
+        self.__name = data["name"]
+        self.image = pygame.image.load(assetDir + "/card.png").convert_alpha()
+        self.rect = self.image.get_rect()
+        self.dragging = False
+        self.offset = pygame.Vector2(0, 0)  # Offset zwischen der Karte und der Mausposition
+        self.__inputHandler = inputHandler
+        self.rect.center = self.__pos
+        self.__description = data["description"]
+        self.original_size = self.image.get_size()
+        self.original_position = self.rect.center
+
+    def update(self):
+        if self.getDragging():
+            mouse_pos = self.__inputHandler.getMousePos()
+            self.__pos = mouse_pos
+            self.rect.center = self.__pos
+
+    def getName(self) -> str:
+        return self.__name
+
+    def getCardSprite(self) -> pygame.image:
+        return self.__cardSprite
+    
+    def getDescription(self):
+        return self.__description
+
+    def getDragging(self):
+        return self.__dragging
+
+    def getOffset(self):
+        return self.__offset
+
+    def getPos(self):
+        return self.__pos
+
+    def getType(self):
+        return self.__type
+
+    def setDragging(self, dragging:bool):
+        self.__dragging = dragging
+
+    def setOffset(self, offset:pygame.Vector2):
+        self.__offset = offset
+
+    def setPos(self, pos:pygame.Vector2):
+        self.__pos = pos

New_Client/Classes/Game/Cards/TrapCard.py

@@ -0,0 +1,72 @@
+import json
+from typing import Any
+
+import pygame
+
+from Classes.Engine.InputHandler import InputHandler
+
+class TrapCard(pygame.sprite.Sprite):
+    __name:str
+    __description:str
+    __pos:pygame.Vector2
+    __dragging:bool = False
+    __offset:pygame.Vector2 = pygame.Vector2(0,0)
+    __inputHandler: InputHandler
+    __type:str = "Effect"
+    image:pygame.image
+    rect:pygame.rect
+
+    def __init__(self, pos:pygame.Vector2, assetDir:str, inputHandler:InputHandler):
+        if assetDir == "":
+            return ValueError.add_note("Card: imagePath cannot be empty")
+        
+        pygame.sprite.Sprite.__init__(self)
+
+        data = json.load(open(assetDir + "/card.json"))
+        self.__pos = pos
+        self.__name = data["name"]
+        self.__inputHandler = inputHandler
+        self.__description = data["description"]
+        self.original_size = self.image.get_size()
+        self.original_position = self.rect.center
+        self.offset = pygame.Vector2(0, 0)  # Offset zwischen der Karte und der Mausposition
+        self.rect = self.image.get_rect()
+        self.rect.center = self.__pos
+        self.image = pygame.image.load(assetDir + "/card.png").convert_alpha()
+        self.__dragging = False
+
+    def update(self):
+        if self.getDragging():
+            mouse_pos = self.__inputHandler.getMousePos()
+            self.__pos = mouse_pos
+            self.rect.center = self.__pos
+
+    def getName(self) -> str:
+        return self.__name
+
+    def getCardSprite(self) -> pygame.image:
+        return self.__cardSprite
+    
+    def getDescription(self):
+        return self.__description
+
+    def getDragging(self):
+        return self.__dragging
+
+    def getOffset(self):
+        return self.__offset
+
+    def getPos(self):
+        return self.__pos
+
+    def getType(self):
+        return self.__type
+
+    def setDragging(self, dragging:bool):
+        self.__dragging = dragging
+
+    def setOffset(self, offset:pygame.Vector2):
+        self.__offset = offset
+
+    def setPos(self, pos:pygame.Vector2):
+        self.__pos = pos

New_Client/Classes/Game/NetworkEvents/GameStart.py

@@ -0,0 +1,16 @@
+import pygame
+from Classes.Game.World import World
+from Classes.Game.Cards.Card import Card
+from Classes.Game.Player import Player
+from Classes.Engine.InputHandler import InputHandler
+
+
+# send from the server to tell the player the game starts
+# gives the client its and the opponents stats (not cards!!)
+def GameStart(world: World, handCards:list, inputHandler:InputHandler, owner:Player, opponent:Player):
+    index:int = 0
+    world.setEnemy(opponent)
+
+    for card in handCards:
+        world.AddToPlayerHand(Card(pygame.Vector2(500 + (index + 100), 1050), f"Assets/Cards/{card}/", inputHandler, owner))
+    

New_Client/Classes/Game/NetworkEvents/Login.py

@@ -0,0 +1,22 @@
+import json
+import pygame
+from Classes.Game.World import World
+from Classes.Game.Player import Player
+
+
+# event the client sends to let the server know it logged in
+def Login(tcpClient):
+    payload = {
+        "event":"login",
+        "username": "player",
+        "deck": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
+    }
+    
+    tcpClient.send(payload)
+
+# server response for login event
+def LoginResponse(message:dict):
+    # checks if the response on the login request is successfull
+    if message["status"] != "success":
+        print("login failed")
+    pass

New_Client/Classes/Game/NetworkEvents/PlaceCard.py

@@ -0,0 +1,36 @@
+import pygame
+from Classes.Game.World import World
+from Classes.Engine.InputHandler import InputHandler
+
+# the event the client sends to the server when it places a card
+def PlaceCard(tcpClient, card):
+    # todo: send card information to the server
+    # todo: required info is:
+    #   - position
+    #   - field type (used for validating what field the card is played in will be compared on server side)
+    #   - card id (server will do the rest to fetch card info)
+    payload = {
+        "event":"placecard",
+        "card": card.getID(),
+        "type": card.getType(),
+        "x": card.getPos().x,
+        "y": card.getPos().y,
+    }
+
+    tcpClient.send(payload)
+
+# the event send from the server to display a card on the field
+def CardPlaced(world:World, card:int, type:str, owner:str, pos:pygame.Vector2, inputHandler:InputHandler):
+    if type == "MonsterCard":
+        world.spawnMonsterCard(f"Assets/Cards/{card}/", pos, inputHandler, owner)
+        pass
+    elif type == "SpellCard":
+        world.spawnSpellCard(f"Assets/Cards/{card}/", pos, inputHandler, owner)
+        pass
+    elif type == "TrapCard":
+        world.spawnTrapCard(f"Assets/Cards/{card}/", pos, inputHandler, owner)
+        pass
+    pass
+
+def MovedCard(world:World, card:int, type:str, owner:str, oldPos:pygame.Vector2, newPos:pygame.Vector2, inputHandler:InputHandler):
+    pass

New_Client/Classes/Game/Player.py

@@ -0,0 +1,43 @@
+import pygame
+
+class Player:
+    __id:int
+    __hp:int
+    __mana:int
+    __name:str
+    __handCards:pygame.sprite.Group
+    
+    def __init__(self, hp:int, mana:int, name:str):
+        self.__hp = hp
+        self.__mana = mana
+        self.__name = name
+
+    def setID(self, id:int):
+        self.__id = id
+
+    def getID(self) -> int:
+        return self.__id
+
+    def getName(self) -> str:
+        return self.__name
+    
+    def getHP(self) -> int:
+        return self.__hp
+
+    def getMana(self) -> int:
+        return self.__mana
+
+    def adjustHP(self, hp:int) -> int:
+        self.__hp = self.__hp + hp
+
+    def getHand(self) -> pygame.sprite.Group:
+        return self.__handCards
+    
+    def AddToHand(self, card) -> pygame.sprite.Group:
+        self.__handCards.add(card)
+        return self.__handCards
+
+    def removeFromHand(self, pos:int) -> pygame.sprite.Group:
+        self.__handCards.remove(pos)
+        return self.__handCards
+    

New_Client/Classes/Game/World.py

@@ -0,0 +1,116 @@
+import pygame
+from Classes.Engine.Logger import Logger
+from Classes.Engine.Components.BoardField import BoardField
+from Classes.Engine.Components.Label import Label
+from Classes.Game.Cards.MonsterCard import MonsterCard
+from Classes.Game.Cards.SpellCard import SpellCard
+from Classes.Game.Cards.TrapCard import TrapCard
+from Classes.Engine.InputHandler import InputHandler
+from Classes.Game.Player import Player
+from Classes.Game.Cards.Card import Card
+from Classes.Engine.Utils.Path import PathUtil
+
+class World():
+    __boardFields:list
+    __player:Player
+    __enemy:Player
+    __labels:list
+    __cards:pygame.sprite.Group()
+    __PlayerHandCards:pygame.sprite.Group()
+    __screen:pygame.surface
+    __cardWidth:int = 150
+    __cardHeight:int = 200
+    __cardOffset:int = 400
+    __logger:Logger
+
+    def __init__(self, logger:Logger, screen:pygame.surface, cardWidth:int=200, cardHeight:int=250, cardOffset:int=400):
+        self.__logger = logger
+        
+        self.__logger.info("initializing world")
+        self.__boardFields = []
+        self.__labels = []
+        self.__cards = pygame.sprite.Group()
+        self.__PlayerHandCards = pygame.sprite.Group()
+        self.__screen = screen
+        self.__cardWidth = cardWidth
+        self.__cardHeight = cardHeight
+        self.__cardOffset = cardOffset
+        self.__player = None
+        self.__enemy = None
+        self.buildGameWorld()
+
+    def buildGameWorld(self):
+        # construct elements around the player field
+        self.__logger.info("building game world")
+
+        # presets the y position later passed down to the vector2
+        eRow1Height = 85
+        eRow2Height = (self.__cardHeight + 45)
+        pRow1Height = ((2 * self.__cardHeight) + 75)
+        pRow2Height = ((2 * self.__cardHeight) + self.__cardHeight + 30)
+        
+        self.__labels.append(Label("EnemyHP", self.__screen, "1000 / 1000", pygame.Vector2(15, 75)))
+        self.__labels.append(Label("EnemyName", self.__screen, "Enemy", pygame.Vector2(15, 45)))
+        self.__boardFields.append(BoardField("EnemyDeck", "Enemy", "Deck", pygame.Vector2((self.__cardOffset + ((self.__cardWidth + 10) * 0)), eRow1Height), PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "e-deck"))
+        self.__boardFields.append(BoardField("EnemyGraveyard", "Enemy", "Grave", pygame.Vector2((self.__cardOffset + ((self.__cardWidth + 10) * 0)), eRow2Height), PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "e-grave"))
+                
+        self.__labels.append(Label("PlayerHP", self.__screen, "1000 / 1000", pygame.Vector2(20, pRow2Height + 225)))
+        self.__labels.append(Label("PlayerName", self.__screen, "Player", pygame.Vector2(20, pRow2Height + 195)))
+        self.__labels.append(Label("Player Mana", self.__screen, "0", pygame.Vector2(20, pRow2Height + 255)))
+        self.__boardFields.append(BoardField("PlayerDeck", "Player", "Deck", pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30 ) * 5)), pRow2Height), PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "P-deck"))
+        self.__boardFields.append(BoardField("PlayerGraveyard", "Player", "Grave", pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30 ) * 5)), pRow1Height), PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "p-grave"))
+
+        # handle field creation
+        for i in range(5):           
+            self.__boardFields.append(BoardField("PlayerMonsterField-"+str(i), "Player", "Monster", pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30) * i)), pRow1Height), PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "pm"+str(id)))
+            self.__boardFields.append(BoardField("PlayerEffectField-"+str(i), "Player", "Effect", pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30) * i)), pRow2Height), PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "pe"+str(id)))            
+            self.__boardFields.append(BoardField("EnemyMonsterField-"+str(i), "Enemy", "Monster", pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30) * (i+1)), eRow1Height)), PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "em"+str(id)))
+            self.__boardFields.append(BoardField("EnemySpellTrapField-"+str(i), "Enemy", "Effect", pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30) * (i+1))), eRow2Height), PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "ee"+str(id)))
+            
+    def getBoardFields(self) -> list:
+        return self.__boardFields
+    
+    def getLabels(self) -> list:
+        return self.__labels
+
+    def getCardWidth(self) -> int:
+        return self.__cardWidth
+    
+    def getCardHeight(self) -> int:
+        return self.__cardHeight
+    
+    def getCards(self) -> pygame.sprite.Group:
+        return self.__cards
+    
+    def getHandCards(self) -> pygame.sprite.Group:
+        return self.__PlayerHandCards
+
+    def getPlayer(self) -> Player:
+        return self.__player
+
+    def getEnemy(self) -> Player:
+        return self.__enemy
+
+    def setPlayer(self, player:Player):
+        for label in self.__labels:
+            if label.getName() == "PlayerName":
+                label.setText(player.getName())
+        self.__player = player
+
+    def setEnemy(self, player:Player):
+        for label in self.__labels:
+            if label.getName() == "EnemyName":
+                label.setText(player.getName())
+        self.__enemy = player
+
+    def spawnCard(self, asset:str, pos:pygame.Vector2, inputHandler:InputHandler, owner:Player) -> Card:
+        card = Card(pos, asset, inputHandler, owner)
+        self.__cards.add(card)
+        return card
+
+    def spawnCards(self, cards:pygame.sprite.Group):
+        for card in cards:
+            self.__cards.add(card)
+
+    def AddToPlayerHand(self, Card:Card):
+        self.__PlayerHandCards.add(Card)

New_Client/log/aruudvef.log

@@ -0,0 +1,6 @@
+18:31:53,299 root INFO starting game engine
+18:31:53,300 root INFO initializing dependencies
+18:31:53,543 root INFO initializing world
+18:31:53,545 root INFO building game world
+18:31:53,562 root INFO initializing engine Event Handler
+18:31:53,562 root INFO attempting to login to server

New_Client/log/azkihdia.log

@@ -0,0 +1,6 @@
+18:35:17,398 root INFO starting game engine
+18:35:17,399 root INFO initializing dependencies
+18:35:17,647 root INFO initializing world
+18:35:17,647 root INFO building game world
+18:35:17,664 root INFO initializing engine Event Handler
+18:35:17,664 root INFO attempting to login to server

New_Client/log/cssmtaso.log

@@ -0,0 +1,6 @@
+18:28:36,740 root INFO starting game engine
+18:28:36,740 root INFO initializing dependencies
+18:28:36,976 root INFO initializing world
+18:28:36,976 root INFO building game world
+18:28:36,995 root INFO initializing engine Event Handler
+18:28:36,995 root INFO attempting to login to server

New_Client/log/dypjnvwx.log

@@ -0,0 +1,6 @@
+18:24:39,228 root INFO starting game engine
+18:24:39,229 root INFO initializing dependencies
+18:24:39,473 root INFO initializing world
+18:24:39,473 root INFO building game world
+18:24:39,489 root INFO initializing engine Event Handler
+18:24:39,490 root INFO attempting to login to server

New_Client/log/ecnwzwpv.log

@@ -0,0 +1,6 @@
+18:24:07,392 root INFO starting game engine
+18:24:07,392 root INFO initializing dependencies
+18:24:07,636 root INFO initializing world
+18:24:07,636 root INFO building game world
+18:24:07,653 root INFO initializing engine Event Handler
+18:24:07,653 root INFO attempting to login to server

New_Client/log/ezuxqfek.log

@@ -0,0 +1,6 @@
+18:34:47,406 root INFO starting game engine
+18:34:47,406 root INFO initializing dependencies
+18:34:47,651 root INFO initializing world
+18:34:47,651 root INFO building game world
+18:34:47,668 root INFO initializing engine Event Handler
+18:34:47,669 root INFO attempting to login to server

New_Client/log/hpyfylsj.log

@@ -0,0 +1,6 @@
+18:15:16,227 root INFO starting game engine
+18:15:16,227 root INFO initializing dependencies
+18:15:16,469 root INFO initializing world
+18:15:16,469 root INFO building game world
+18:15:16,486 root INFO initializing engine Event Handler
+18:15:16,487 root INFO attempting to login to server

New_Client/log/jqqeltiy.log

@@ -0,0 +1,6 @@
+18:26:41,981 root INFO starting game engine
+18:26:41,982 root INFO initializing dependencies
+18:26:42,202 root INFO initializing world
+18:26:42,202 root INFO building game world
+18:26:44,431 root INFO initializing engine Event Handler
+18:26:44,431 root INFO attempting to login to server

New_Client/log/mhtlvsqm.log

@@ -0,0 +1,6 @@
+18:03:55,272 root INFO starting game engine
+18:03:55,273 root INFO initializing dependencies
+18:03:55,522 root INFO initializing world
+18:03:55,524 root INFO building game world
+18:03:55,541 root INFO initializing engine Event Handler
+18:03:55,541 root INFO attempting to login to server

New_Client/log/pbwegfvw.log

@@ -0,0 +1,4 @@
+18:28:05,511 root INFO starting game engine
+18:28:05,512 root INFO initializing dependencies
+18:28:05,733 root INFO initializing world
+18:28:05,735 root INFO building game world

New_Client/log/qqebhbex.log

@@ -0,0 +1,6 @@
+18:12:06,302 root INFO starting game engine
+18:12:06,302 root INFO initializing dependencies
+18:12:06,552 root INFO initializing world
+18:12:06,553 root INFO building game world
+18:12:06,570 root INFO initializing engine Event Handler
+18:12:06,571 root INFO attempting to login to server

New_Client/log/rnwforll.log

@@ -0,0 +1,6 @@
+18:26:02,924 root INFO starting game engine
+18:26:02,925 root INFO initializing dependencies
+18:26:03,152 root INFO initializing world
+18:26:03,153 root INFO building game world
+18:26:15,219 root INFO initializing engine Event Handler
+18:26:15,219 root INFO attempting to login to server

New_Client/log/rrffvbhc.log

@@ -0,0 +1,6 @@
+18:31:12,770 root INFO starting game engine
+18:31:12,771 root INFO initializing dependencies
+18:31:13,6 root INFO initializing world
+18:31:13,6 root INFO building game world
+18:31:13,23 root INFO initializing engine Event Handler
+18:31:13,23 root INFO attempting to login to server

New_Client/log/snqncicq.log

@@ -0,0 +1,6 @@
+18:32:14,21 root INFO starting game engine
+18:32:14,22 root INFO initializing dependencies
+18:32:14,268 root INFO initializing world
+18:32:14,268 root INFO building game world
+18:32:14,285 root INFO initializing engine Event Handler
+18:32:14,285 root INFO attempting to login to server

New_Client/log/sstwdlli.log

@@ -0,0 +1,6 @@
+18:17:42,689 root INFO starting game engine
+18:17:42,689 root INFO initializing dependencies
+18:17:42,927 root INFO initializing world
+18:17:42,928 root INFO building game world
+18:17:42,946 root INFO initializing engine Event Handler
+18:17:42,946 root INFO attempting to login to server

New_Client/log/vzybrxrc.log

@@ -0,0 +1,6 @@
+18:25:06,487 root INFO starting game engine
+18:25:06,487 root INFO initializing dependencies
+18:25:06,730 root INFO initializing world
+18:25:06,730 root INFO building game world
+18:25:06,748 root INFO initializing engine Event Handler
+18:25:06,748 root INFO attempting to login to server

New_Client/log/wqfhotaq.log

@@ -0,0 +1,6 @@
+18:35:28,383 root INFO starting game engine
+18:35:28,383 root INFO initializing dependencies
+18:35:28,619 root INFO initializing world
+18:35:28,620 root INFO building game world
+18:35:28,637 root INFO initializing engine Event Handler
+18:35:28,638 root INFO attempting to login to server

New_Client/log/xqetosuq.log

@@ -0,0 +1,6 @@
+18:28:22,876 root INFO starting game engine
+18:28:22,876 root INFO initializing dependencies
+18:28:23,117 root INFO initializing world
+18:28:23,117 root INFO building game world
+18:28:23,134 root INFO initializing engine Event Handler
+18:28:23,135 root INFO attempting to login to server

New_Client/log/xwrmortx.log

@@ -0,0 +1,6 @@
+18:14:40,491 root INFO starting game engine
+18:14:40,492 root INFO initializing dependencies
+18:14:40,714 root INFO initializing world
+18:14:40,715 root INFO building game world
+18:14:41,59 root INFO initializing engine Event Handler
+18:14:41,168 root INFO attempting to login to server

New_Client/log/xxfpqmla.log

@@ -0,0 +1,6 @@
+18:17:28,90 root INFO starting game engine
+18:17:28,90 root INFO initializing dependencies
+18:17:28,335 root INFO initializing world
+18:17:28,336 root INFO building game world
+18:17:28,352 root INFO initializing engine Event Handler
+18:17:28,352 root INFO attempting to login to server

New_Client/log/ysnrngup.log

@@ -0,0 +1,4 @@
+18:30:56,421 root INFO starting game engine
+18:30:56,421 root INFO initializing dependencies
+18:30:56,654 root INFO initializing world
+18:30:56,654 root INFO building game world

New_Client/log/zlnfjkpf.log

@@ -0,0 +1,6 @@
+18:14:31,193 root INFO starting game engine
+18:14:31,193 root INFO initializing dependencies
+18:14:31,416 root INFO initializing world
+18:14:31,416 root INFO building game world
+18:14:36,438 root INFO initializing engine Event Handler
+18:14:36,864 root INFO attempting to login to server

New_Client/log/zoukqhzj.log

@@ -0,0 +1,6 @@
+18:34:33,865 root INFO starting game engine
+18:34:33,865 root INFO initializing dependencies
+18:34:34,103 root INFO initializing world
+18:34:34,104 root INFO building game world
+18:34:34,121 root INFO initializing engine Event Handler
+18:34:34,121 root INFO attempting to login to server

New_Client/log/zpvgppfk.log

@@ -0,0 +1,5 @@
+18:37:44,978 root INFO starting game engine
+18:37:44,978 root INFO initializing dependencies
+18:37:45,225 root INFO initializing world
+18:37:45,225 root INFO building game world
+18:37:45,242 root INFO logging into server

New_Client/main.py

@@ -0,0 +1,11 @@
+from App import App
+from Classes.Engine.Logger import Logger
+from Classes.Engine.Utils.StringUtils import StringUtils
+from Classes.Engine.Utils.Path import PathUtil
+
+if __name__ == "__main__":
+    
+    logger = Logger(PathUtil.getAbsolutePathTo("log/"+StringUtils.get_random_string(8)+".log"))
+    
+    logger.info("starting game engine")
+    game = App(logger)