added first event functions documented server behaviour for some events

Game_Client/Classes/Game/BoardField.py

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

Game_Client/Classes/Game/Cards/Card.py

@@ -0,0 +1,14 @@
+import json
+import pygame
+
+
+class Card(pygame.sprite.Sprite):
+
+
+    def __init__(self, pos:tuple, assetDir:str):
+
+        if assetDir == "":
+            return ValueError.add_note("Card: imagePath cannot be empty")
+
+
+

Game_Client/Classes/Game/Cards/MonsterCard.py

@@ -0,0 +1,79 @@
+import json
+from typing import Any
+
+import pygame
+
+from Classes.System.Components.InputHandler import InputHandler
+
+class MonsterCard(pygame.sprite.Sprite):
+    __attacks = []
+    __name:str
+    __description:str
+    __pos:pygame.Vector2
+    __dragging:bool = False
+    __offset:pygame.Vector2 = pygame.Vector2(0,0)
+    __inputHandler: InputHandler
+    __type:str = "MonsterCard"
+    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
+
+        for attack in data["attacks"]:
+            self.__attacks.append(attack)
+
+    def update(self):
+        if self.getDragging():
+            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 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.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 = "SpellCard"
+    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.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 = "TrapCard"
+    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/Events/Login.py

@@ -0,0 +1,20 @@
+import pygame
+from Classes.System.Network.NetworkManager import NetworkManager
+from Classes.Game.World import World
+
+
+# event the client sends to let the server know it logged in
+def Login(networkManager:NetworkManager):
+    payload = {
+        "event":"login",
+        "username": "player"
+    }
+    
+    networkManager.tcp.send(payload)
+
+# server response for login event
+def LoginResponse(networkManager:NetworkManager, gameWorld: World):
+    # todo: get labels from world
+    # todo: get name for enemy
+    # todo: adjust enemy name label
+    pass

Game_Client/Classes/Game/Events/PlaceCard.py

@@ -0,0 +1,17 @@
+from Classes.Game.Cards.Card import Card
+from Classes.Game.World import World
+from Classes.System.Network.NetworkManager import NetworkManager
+
+
+# the event the client sends to the server when it places a card
+def PlaceCard(networkManager: NetworkManager, card: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)
+    pass
+
+# the event send from the server to display a card on the field
+def CardPlaced(world:World):
+    pass

Game_Client/Classes/Game/Player.py

@@ -0,0 +1,37 @@
+import pygame
+
+class Player:
+    __id:int
+    __hp:int
+    __name:str
+    __handCards:pygame.Sprite.Group
+    
+    def __init__(self, hp:int, name:str):
+        self.__hp = hp
+        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 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,89 @@
+import pygame
+from Classes.Game.BoardField import BoardField
+from Classes.System.Components.Label import Label
+from Classes.Game.Cards.MonsterCard import MonsterCard
+from Classes.System.Components.InputHandler import InputHandler
+
+class World():
+    __boardFields:list
+    __labels:list
+    __cards: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 = []
+        self.__screen = screen
+        self.__cardWidth = cardWidth
+        self.__cardHeight = cardHeight
+        self.__cardOffset = cardOffset
+        self.buildGameWorld()
+
+    def buildGameWorld(self):
+        # construct elements arround the playerfield
+        # Todo add lifepoint label for player and enemy and make them scriptable move to player class
+
+        # 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)
+
+        # labeling
+        self.__labels.append(Label("PlayerHP", self.__screen, "1000 / 1000", pHPPos))
+        self.__labels.append(Label("PlayerName", self.__screen, "Player", pNamePos))
+        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/Arena/field.png"))
+        self.__boardFields.append(BoardField("EnemyGraveyard", "Enemy", "Grave", eGravePos, "Assets/Cards/Arena/field.png"))
+        self.__boardFields.append(BoardField("PlayerDeck", "Player", "Deck", pDeckPos, "Assets/Cards/Arena/field.png"))
+        self.__boardFields.append(BoardField("PlayerGraveyard", "Player", "Grave", pGravePos, "Assets/Cards/Arena/field.png"))
+
+        # 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", "MonsterField", pMonsterPos, "Assets/Cards/Arena/field.png", "pm"+str(id)))
+            self.__boardFields.append(BoardField("PlayerEffectField-"+str(i), "Player", "EffectField", pEffectPos, "Assets/Cards/Arena/field.png", "pe"+str(id)))
+            self.__boardFields.append(BoardField("EnemyMonsterField-"+str(i), "Enemy", "MonsterField", eMonsterPos, "Assets/Cards/Arena/field.png", "em"+str(id)))
+            self.__boardFields.append(BoardField("EnemySpellTrapField-"+str(i), "Enemy", "EffectField", eEffectPos, "Assets/Cards/Arena/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 spawnCard(self, asset:str, pos:pygame.Vector2, inputHandler:InputHandler) -> MonsterCard:
+        self.__cards.add(MonsterCard(pos, asset, inputHandler))
+
+    def spawnCards(self, cards:pygame.sprite.Group):
+        for card in cards:
+            self.__cards.append(card)