.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/Online_TCG.iml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+  <component name="TemplatesService">
+    <option name="TEMPLATE_FOLDERS">
+      <list>
+        <option value="$MODULE_DIR$/card files/Templates" />
+      </list>
+    </option>
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.11 (Online_TCG)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.11 (Online_TCG)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Online_TCG.iml" filepath="$PROJECT_DIR$/.idea/Online_TCG.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

.vscode/launch.json

@@ -1,27 +1,14 @@
 {
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
         {
-            "name": "Old Shadowcrest Engine Server",
+            "name": "Python:app",
             "type": "python",
             "request": "launch",
-            "program": "OLD_Server/index.py",
+            "program": "main.py",
-            "console": "integratedTerminal",
-            "justMyCode": true
-        },
-        {
-            "name": "Shadowcrest Engine Server",
-            "type": "python",
-            "request": "launch",
-            "program": "OLD_Server/index.py",
-            "console": "integratedTerminal",
-            "justMyCode": true
-        },
-        {
-            "name": "ShadowCrest Python GameEngine Client",
-            "type": "python",
-            "request": "launch",
-            "program": "Client/main.py",
             "console": "integratedTerminal",
             "justMyCode": true
         }

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "cSpell.ignoreWords": [
+        "posx"
+    ]
+}

Client/Classes/Game/Cards/Card.py

@@ -1,110 +0,0 @@
-import json
-import pygame
-
-from Classes.System.Components.InputHandler import InputHandler
-from Classes.Game.Player import Player
-
-class Card(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
-    __state:str
-    __dragable:bool = True
-    image:pygame.image
-    rect:pygame.rect
-
-    def __init__(self, pos: pygame.Vector2, assetDir: str, inputHandler: InputHandler, owner: Player, dragable:bool=True):
-        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.__type = "Monster"
-
-        self.__attacks = []
-        for attack in data.get("attacks", []):
-            self.__attacks.append(attack)
-
-    def update(self):
-        if self.__dragging:
-            if self.__dragable:
-                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 getDragable(self):
-        return self.__dragable
-
-    def getOffset(self):
-        return self.__offset
-
-    def getPos(self) -> pygame.Vector2:
-        return self.__pos
-
-    def getX(self) -> int:
-        return self.__pos.x
-
-    def getY(self) -> int:
-        return self.__pos.y
-
-    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

Client/Classes/Game/Events/GameStart.py

@@ -1,17 +0,0 @@
-import pygame
-from Classes.Game.World import World
-from Classes.Game.Cards.Card import Card
-from Classes.Game.Player import Player
-from Classes.System.Components.InputHandler import InputHandler
-from Classes.System.Utils.Path import PathUtil
-
-
-# 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):
-    index:int = 0
-
-    for card in handCards:
-        #world.AddToPlayerHand(Card(pygame.Vector2(500 + (index * 100), 1050), PathUtil.getAbsolutePathTo(f"Assets/Cards/{card}/"), inputHandler, Player(1000, 0, "test"), dragable=True))
-        world.spawnCard(PathUtil.getAbsolutePathTo(f"Assets/Cards/{card}"), pygame.Vector2(500 + (index * 100), 1050), inputHandler, world.getPlayer())
-        index=index+1

Client/Classes/Game/Events/Login.py

@@ -1,25 +0,0 @@
-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, world:World):
-    print("LoginResponse called")
-    # checks if the response on the login request is successfull
-    if message["status"] != "success":
-        print("login failed")
-    else:
-        print("receiving login confirmation from server")
-        world.setPlayer(Player(0,0,message["name"], message["id"]))

Client/Classes/Game/Events/PlaceCard.py

@@ -1,32 +0,0 @@
-import pygame
-from Classes.Game.World import World
-from Classes.System.Components.InputHandler import InputHandler
-from Classes.Game.Cards.Card import Card
-from Classes.System.Utils.Path import PathUtil
-
-# the event the client sends to the server when it places a card
-def PlaceCard(tcpClient, card:Card, player):
-    # 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(),
-        "user": player.getID(),
-        "x": card.getX(),
-        "y": card.getY(),
-    }
-
-    tcpClient.send(payload)
-
-# the event send from the server to display a card on the field
-def CardPlaced(world:World, card:int, owner:str, pos:pygame.Vector2, inputHandler:InputHandler):
-    # todo: make this work with all cardtypes
-    print("placing enemy card")
-    world.spawnEnemyCard(PathUtil.getAbsolutePathTo(f"Assets/Cards/{card}"), pos, inputHandler, owner)
-
-def MovedCard(world:World, card:int, type:str, owner:str, oldPos:pygame.Vector2, newPos:pygame.Vector2, inputHandler:InputHandler):
-    pass

Client/Classes/Game/Player.py

@@ -1,46 +0,0 @@
-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, id:int=0):
-        self.__hp = hp
-        self.__mana = mana
-        self.__name = name
-        self.__id = id
-
-    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
-    
-    def setMana(self, mana:int):
-        self.__mana = mana

Client/Classes/System/App.py

@@ -1,141 +0,0 @@
-import pygame 
-from pygame.locals import *
-
-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.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
-from Classes.System.Utils.Path import PathUtil
-
-class App:
-
-    __window:Window
-    __running:bool = True
-    __FPS = 60
-    __clock = pygame.time.Clock()
-    __myFont:pygame.font
-    __world:World
-    __inputHandler: InputHandler
-    __tcpClient: TCPClient
-
-    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.selectedCard = None
-
-        # game word
-        self.__world = World(self.__window.getScreen())
-        
-        try:
-            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
-
-        self.startGameLoop()
-        self.onCleanup()
-
-    def startGameLoop(self):
-
-        # create sprite groups
-        # todo: remove these and let server handle card creation instead
-        # blocker: server - client communication [WIP]
-        # self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(500, 1050), self.__inputHandler, Player(1000, 0, "test"))
-        # self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(600, 1050), self.__inputHandler, Player(1000, 0, "test"))
-        # self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(700, 1050), self.__inputHandler, Player(1000, 0, "test"))
-        # self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(800, 1050), self.__inputHandler, Player(1000, 0, "test"))
-        # self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(900, 1050), self.__inputHandler, Player(1000, 0, "test"))
-        # self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(1000, 1050), self.__inputHandler, Player(1000, 0, "test"))
-
-        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())
-
-            # event handler
-            self.handleEvent(pygame.event.get())
-
-            # emits update to the game
-            pygame.display.update()
-
-    # handles incoming event queue
-    def handleEvent(self, events):
-        # TODO: fix bug that stacks cards when dragging them around
-        try:
-            for event in events:
-                if event.type == pygame.QUIT:
-                    self.onCleanup()
-                elif self.__inputHandler.getMousePressed()[0]:  
-                    for card in self.__world.getCards():
-                        if card.getDragable() == True:
-                            if card.rect.collidepoint(self.__inputHandler.getMousePos()):
-                                #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:
-                    print("left mousebutton")
-                    if event.button == 1:
-                        if self.selectedCard != None:
-                            self.selectedCard.setDragging(False)
-                            print(self.selectedCard)
-                            for field in self.__world.getBoardFields():
-                                print(f"checking field {field} is field mathinc? {field.getRect().collidepoint(self.__inputHandler.getMousePos())}")
-                                if field.getRect().collidepoint(self.__inputHandler.getMousePos()):
-                                    print(f"is position valid? {field.getSide() == 'Player' and field.getType() == self.selectedCard.getType()} ")
-                                    print(f"side {field.getSide()} fieldtype {field.getType()} card type {self.selectedCard.getType()}")
-                                    
-                                    if field.getSide() == "Player" and field.getType() == self.selectedCard.getType():
-                                        print(f"found field {field}")
-                                        try:
-                                            print(f"placing card {self.selectedCard} in field {field}")
-                                            # snap card into the correct field
-                                            self.selectedCard.rect.center = field.rect.center
-                                            self.selectedCard.setDragging(False) 
-                                            
-                                            print(self.selectedCard)
-                                            # TODO: adapt this into the new game engine version
-                                            PlaceCard(self.__tcpClient, self.selectedCard, self.__world.getPlayer()) # 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
-        except:
-            pass
-
-    # sets the running state for the gameloop
-    def setRunning(self, running:bool):
-        self.__running = running
-
-    # ensures the gameloop stops running and the pygame instance is stopped properly
-    def onCleanup(self):
-        self.__running = False
-        pygame.quit()

Client/Classes/System/GameManager.py

@@ -1,23 +0,0 @@
-from Classes.Game.Player import Player
-from Classes.Game.World import World
-
-
-class GameManager:
-    player:Player
-    enemy:Player
-    world:World
-    
-    def __init__(self, world):
-        self.world = world
-
-    def getPlayer(self) -> Player:
-        return self.player
-
-    def getEnemy(self) -> Player:
-        return self.enemy
-
-    def setPlayer(self, player:Player):
-        self.player = player
-
-    def setEnemy(self, enemy:Player):
-        self.enemy = enemy

Client/Classes/System/Network/TCPClient.py

@@ -1,69 +0,0 @@
-import json
-import socket
-import threading
-
-import pygame
-
-from Classes.Game.World import World
-from Classes.System.Components.InputHandler import InputHandler
-from Classes.Game.Events.GameStart import GameStart
-from Classes.Game.Events.Login import LoginResponse
-from Classes.Game.Events.PlaceCard import CardPlaced
-from Classes.Game.Player import Player
-
-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.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.handleEvents(decoded_data)
-            except Exception as e:
-                print(f"Error receiving TCP data: {e}")
-                break
-
-    def handleEvents(self, message):
-        print(message)
-        if message["event"] == "loginresponse":
-            if message["status"] != "success":
-                print("login failed")
-            else:
-                print("receiving login confirmation from server")
-                self.world.setPlayer(Player(0,0,message["name"], message["id"]))
-        elif message["event"] == "startgame":
-            print(self.world.player)
-            # world.player.setMana(message["player"]["mana"])
-            # world.player.setHp(message["player"]["hp"])
-            self.world.setEnemy(Player(message["enemy"]["hp"],0,message["enemy"]["name"], message["enemy"]["id"]))
-            GameStart(self.world, message["player"]["hand"], self.inputHandler, self.world.getPlayer())
-            pass
-        elif message["event"] == "PlacedCard":
-            CardPlaced(self.world, message["card"], message["owner"], pygame.Vector2(message["x"], message["y"]), self.inputHandler)
-            pass    
-
-    def listen(self):
-        tcpThread = threading.Thread(target=self.receive)
-        tcpThread.daemon = True
-        tcpThread.start()

Client/Classes/System/Utils/Path.py

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

Client/Classes/System/Utils/StringUtils.py

@@ -1,11 +0,0 @@
-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

Game Server/Classes/Game/Player.py

@@ -10,7 +10,6 @@ class Player:
 
     def __init__(self, name:str, deck:list, hp:int=1000, mana:int=0):
         self.__hp = hp
-        self.__mana = mana
         self.__name = name
         self.__handCards = []
         self.__deck = deck

Game Server/Classes/System/GameManager.py

@@ -1,6 +1,5 @@
 import json
 import socket
-import time
 from Classes.Game.Player import Player
 
 
@@ -9,7 +8,6 @@ class GameManager:
     __playingPlayer:Player
     __state:str
     __round:str
-    __cards:list
 
     def __init__(self, logger):
         self.__players = {}
@@ -17,34 +15,11 @@ class GameManager:
         self.__state = "waiting"
         self.__round = "none"
         self.logger = logger
-        self.__cards = []
         pass
 
     def getLogger(self):
         return self.logger
 
-    # card management
-    def spawnCard(self, card, owner, x, y):
-        # self.logger.info("spawning card")
-        
-        self.__cards.append(card)
-        
-        payload = {
-            "event":"PlacedCard",
-            "owner": owner,
-            "card": card,
-            "x": x,
-            "y": y,
-        }
-
-        for userAddr in self.__players.keys():
-            try:
-                self.logger.info(f"send to client {self.__players[userAddr]['player'].getID() != owner}")
-                if self.__players[userAddr]["player"].getID() != owner:
-                    self.__players[userAddr]["socket"].send(json.dumps(payload).encode())
-            except:
-                pass
-
     # game round management
     # this section manages the flow of rounds this should inherit itself
     # =============================================================================
@@ -81,7 +56,7 @@ class GameManager:
                 user.addMana(1000)
                 user.adjustHP(1000)
                 user.shuffleDeck()
-                cards = self.__players[userAddr]["deck"]
+                cards = user.getDeck()
                 user.setHand(cards[:5])
 
                 # iterates until the enemy player is not anymore equal to current player
@@ -101,8 +76,7 @@ class GameManager:
                     },
                 }
 
-                print(f"user {player_data["socket"]}")
+                tcpSocket.send(json.dumps(payload).encode())
-                player_data["socket"].send(json.dumps(payload).encode())
             except Exception as e:
                 self.logger.error(f"failed to start game due to error: {e}")
                 break
@@ -122,31 +96,19 @@ class GameManager:
 
     # creates a player and handles counting all players and if conditions met starting the game
     # returns the new dict in which the new player now is added
-    def addPlayers(self, player:Player, socket:socket, clientAddr, deck) -> dict:
+    def addPlayers(self, player:Player, socket:socket, clientAddr) -> dict:
         
         self.logger.info(f"creating user with id: {player.getID}")
         self.__players[clientAddr] = {
             "player": player,
-            "deck": deck,
             "socket":socket
         }
         self.logger.info(f"new length of user dictionary: {len(self.__players)}")
 
-        payload = {
-            "event":"loginresponse",
-            "status": "success",
-            "id": player.getID(),
-            "name": player.getName()
-        }
-
-        socket.send(json.dumps(payload).encode())
-
-
         # counts participating players and starts the game if enough have joined
-        if len(self.__players) >= 2:
+        if len(self.__players) == 2:
-            time.sleep(1)
             self.logger.info("2 players have join game starts")
-            self.startGame()
+            self.startGame(socket)
 
         return self.__players
     

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

@@ -86,7 +86,7 @@ class NetworkManager:
                         if messageJson["event"] == "login":
                             self.__gameManager.getLogger().info("user logging in")
                             self.__gameManager.getLogger().info("task passed off to gameManager")
-                            user = self.__gameManager.addPlayers(Player(messageJson["username"], messageJson["deck"]), client_socket, client_address, messageJson["deck"]) 
+                            user = self.__gameManager.addPlayers(Player(messageJson["username"], messageJson["deck"]), client_socket, client_address) 
                             self.__gameManager.getLogger().info(f"connected users {len(self.__gameManager.getPlayers())}")
                             
                             self.__gameManager.getLogger().info(f"confirming login for user")

Game Server/Classes/System/QueueManager.py

@@ -1,6 +1,4 @@
-
+from Classes.Objects.Player import Player
-
-from Classes.Game.Player import Player
 
 
 class QueueManager:

Game Server/index.py

@@ -6,7 +6,6 @@ import sys
 
 from Classes.System.Server import Server
 from Classes.System.Logger import Logger
-from Classes.System.Utils.Path import PathUtil
 
 def get_random_string(length) -> str:
     # choose from all lowercase letter
@@ -21,7 +20,7 @@ def main():
     TCPPORT = "54322"
     UDPPORT = "54323"
 
-    logger = Logger(PathUtil.getAbsolutePathTo("log/"+get_random_string(8)+".log"))
+    logger = Logger("log/"+get_random_string(8)+".log")
     logger.info("starting up server")
     server = Server(HOST, TCPPORT, UDPPORT, logging)
     server.getNetworkManager().tcp.stop()

Game_Client/Classes/Game/Cards/Card.py

@@ -1,7 +1,7 @@
 import json
 import pygame
 
-from Classes.Engine.InputHandler import InputHandler
+from Classes.System.Components.InputHandler import InputHandler
 from Classes.Game.Player import Player
 
 class Card(pygame.sprite.Sprite):

Game_Client/Classes/Game/Cards/MonsterCard.py

@@ -9,7 +9,7 @@ class MonsterCard(pygame.sprite.Sprite):
     __id:int
     __description:str
     __attacks = []
-    __type:str = "Monster"
+    __type:str = "MonsterCard"
     __pos:pygame.Vector2
     __dragging:bool = False
     __offset:pygame.Vector2 = pygame.Vector2(0,0)

Game_Client/Classes/Game/Cards/SpellCard.py

@@ -12,7 +12,7 @@ class SpellCard(pygame.sprite.Sprite):
     __dragging:bool = False
     __offset:pygame.Vector2 = pygame.Vector2(0,0)
     __inputHandler: InputHandler
-    __type:str = "Effect"
+    __type:str = "SpellCard"
     image:pygame.image
     rect:pygame.rect
 

Game_Client/Classes/Game/Cards/TrapCard.py

@@ -12,7 +12,7 @@ class TrapCard(pygame.sprite.Sprite):
     __dragging:bool = False
     __offset:pygame.Vector2 = pygame.Vector2(0,0)
     __inputHandler: InputHandler
-    __type:str = "Effect"
+    __type:str = "TrapCard"
     image:pygame.image
     rect:pygame.rect