initial commit for rework

Game Client/Classes/Game/Cards/Card.py

@@ -0,0 +1,98 @@
+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 = "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

Game 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

Game 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

Game 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

Game 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))
+    

Game Client/Classes/Game/NetworkEvents/Login.py

@@ -0,0 +1,22 @@
+import json
+import pygame
+from Classes.Engine.TCPClient import TCPClient
+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: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:json):
+    # checks if the response on the login request is successfull
+    if message["status"] != "success":
+        print("login failed")

Game 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

Game 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
+    

Game Client/Classes/Game/World.py

@@ -0,0 +1,129 @@
+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
+
+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 arround the playerfield
+        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)
+        
+        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)
+        self.__labels.append(Label("EnemyHP", self.__screen, "1000 / 1000", eHPPos))
+        self.__labels.append(Label("EnemyName", self.__screen, "Enemy", eNamePos))
+        self.__boardFields.append(BoardField("EnemyDeck", "Enemy", "Deck", eDeckPos, "Assets/Cards/0/field.png", "e-deck"))
+        self.__boardFields.append(BoardField("EnemyGraveyard", "Enemy", "Grave", eGravePos, "Assets/Cards/0/field.png", "e-grave"))
+        
+        pNamePos = pygame.Vector2(20, pRow2Height + 195)
+        pHPPos = pygame.Vector2(20, pRow2Height + 225)
+        pManaPos = pygame.Vector2(20, pRow2Height + 255)
+        self.__labels.append(Label("PlayerHP", self.__screen, "1000 / 1000", pHPPos))
+        self.__labels.append(Label("PlayerName", self.__screen, "Player", pNamePos))
+        self.__labels.append(Label("PlayerName", self.__screen, "0", pManaPos))
+        self.__boardFields.append(BoardField("PlayerDeck", "Player", "Deck", pDeckPos, "Assets/Cards/0/field.png", "P-deck"))
+        self.__boardFields.append(BoardField("PlayerGraveyard", "Player", "Grave", pGravePos, "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)
+            self.__boardFields.append(BoardField("PlayerMonsterField-"+str(i), "Player", "Monster", pMonsterPos, "Assets/Cards/0/field.png", "pm"+str(id)))
+            self.__boardFields.append(BoardField("PlayerEffectField-"+str(i), "Player", "Effect", pEffectPos, "Assets/Cards/0/field.png", "pe"+str(id)))
+            
+            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("EnemyMonsterField-"+str(i), "Enemy", "Monster", eMonsterPos, "Assets/Cards/0/field.png", "em"+str(id)))
+            self.__boardFields.append(BoardField("EnemySpellTrapField-"+str(i), "Enemy", "Effect", eEffectPos, "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)