stripped game specific logic from engine started working on engine approach

Classes/Game/BoardField.py

@@ -1,85 +0,0 @@
-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("Der Dateipfad zur Bilddatei ist ungültig oder die Datei existiert nicht.")
-        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

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

Classes/Game/Cards/MonsterCard.py

@@ -1,88 +0,0 @@
-import json
-import pygame
-
-from Classes.System.Components.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

Classes/Game/Cards/SpellCard.py

@@ -1,72 +0,0 @@
-import json
-from typing import Any
-
-import pygame
-
-from Classes.System.Components.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

Classes/Game/Cards/TrapCard.py

@@ -1,72 +0,0 @@
-import json
-from typing import Any
-
-import pygame
-
-from Classes.System.Components.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

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

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"]))

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

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

Classes/Game/World.py

@@ -1,137 +0,0 @@
-import pygame
-from Classes.Game.BoardField import BoardField
-from Classes.System.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.System.Components.InputHandler import InputHandler
-from Classes.Game.Player import Player
-from Classes.Game.Cards.Card import Card
-from Classes.System.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
-
-    def __init__(self, screen:pygame.surface, cardWidth:int=200, cardHeight:int=250, cardOffset:int=400):
-        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 arround the playerfield
-
-        # 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)
-        
-        eDeckPos = pygame.Vector2((self.__cardOffset + ((self.__cardWidth + 10) * 0)), eRow1Height)
-        eGravePos = pygame.Vector2((self.__cardOffset + ((self.__cardWidth + 10) * 0)), eRow2Height)
-        eNamePos = pygame.Vector2(15, 45)
-        eHPPos = pygame.Vector2(15, 75)
-        
-        pGravePos = pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30 ) * 5)), pRow1Height)
-        pDeckPos = pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30 ) * 5)), pRow2Height)
-        pNamePos = pygame.Vector2(20, pRow2Height + 195)
-        pHPPos = pygame.Vector2(20, pRow2Height + 225)
-        pManaPos = pygame.Vector2(20, pRow2Height + 255)
-
-        # labeling
-        self.__labels.append(Label("PlayerHP", self.__screen, "1000 / 1000", pHPPos))
-        self.__labels.append(Label("PlayerName", self.__screen, "Not Connected", pNamePos))
-        self.__labels.append(Label("PlayerName", self.__screen, "0", pManaPos))
-        self.__labels.append(Label("EnemyHP", self.__screen, "1000 / 1000", eHPPos))
-        self.__labels.append(Label("EnemyName", self.__screen, "Not Connected", eNamePos))
-
-        self.__boardFields.append(BoardField("EnemyDeck", "Enemy", "Deck", eDeckPos, PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "e-deck"))
-        self.__boardFields.append(BoardField("EnemyGraveyard", "Enemy", "Grave", eGravePos, PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "e-grave"))
-        self.__boardFields.append(BoardField("PlayerDeck", "Player", "Deck", pDeckPos, PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "P-deck"))
-        self.__boardFields.append(BoardField("PlayerGraveyard", "Player", "Grave", pGravePos, PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "p-grave"))
-
-        # handle field creation
-        for i in range(5):
-            pMonsterPos = pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30) * i)), pRow1Height)
-            pEffectPos = pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30) * i)), pRow2Height)
-            eMonsterPos = pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30) * (i+1)), eRow1Height))
-            eEffectPos = pygame.Vector2((self.__cardOffset + (((self.__cardWidth + 10) - 30) * (i+1))), eRow2Height)
-
-            self.__boardFields.append(BoardField("PlayerMonsterField-"+str(i), "Player", "Monster", pMonsterPos, PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "pm"+str(id)))
-            self.__boardFields.append(BoardField("PlayerEffectField-"+str(i), "Player", "Effect", pEffectPos, PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "pe"+str(id)))
-            self.__boardFields.append(BoardField("EnemyMonsterField-"+str(i), "Enemy", "Monster", eMonsterPos, PathUtil.getAbsolutePathTo("Assets/Cards/0/field.png"), "em"+str(id)))
-            self.__boardFields.append(BoardField("EnemySpellTrapField-"+str(i), "Enemy", "Effect", eEffectPos, 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):
-        print(f"setting player {player}")
-        self.player = player
-        for label in self.__labels:
-            if label.getName() == "PlayerName":
-                label.setText(player.getName())
-
-    def setEnemy(self, player:Player):
-        self.enemy = player
-        for label in self.__labels:
-            if label.getName() == "EnemyName":
-                label.setText(player.getName())
-
-    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 spawnEnemyCard(self, asset:str, pos:pygame.Vector2, inputHandler:InputHandler, owner:str) -> Card:
-        pos.y = (self.__cardHeight + 45)
-
-        card = Card(pos, asset, inputHandler, self.enemy, dragable=False)
-        self.__cards.add(card)
-
-        print(f"new card collection {self.__cards}")
-        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)

Classes/System/App.py

@@ -1,15 +1,9 @@
 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:
@@ -19,7 +13,6 @@ class App:
     __FPS = 60
     __clock = pygame.time.Clock()
     __myFont:pygame.font
-    __world:World
     __inputHandler: InputHandler
     __tcpClient: TCPClient
 
@@ -30,32 +23,11 @@ class App:
         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)
 
@@ -64,14 +36,6 @@ class App:
             # 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())
 
@@ -85,49 +49,6 @@ class App:
             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
 

Classes/System/Network/EventHandler.py

@@ -2,40 +2,10 @@ 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
-from Classes.Game.Events.Login import LoginResponse
-
 class TCPEventHandler:
     def __init__(self, socket:socket):
         self.tcp_socket = socket
 
-    def handleEvents(self, message, inputHandler:InputHandler, world:World):
+    def handleEvents(self, message, inputHandler:InputHandler):
-        print(message)
+        pass
-        if message["event"] == "loginresponse":
-            LoginResponse(message, world)
-            pass
-        elif message["event"] == "startgame":
-            print(world.player)
-            # world.player.setMana(message["player"]["mana"])
-            # world.player.setHp(message["player"]["hp"])
-            GameStart(world, message["player"]["hand"], inputHandler, world.getPlayer(), Player(message["enemy"]["hp"],0,message["enemy"]["name"], message["enemy"]["id"]))
-            pass
-        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":
-            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