refactor: 🔥 removed server from repository

Client/Classes/Game/World.py

@@ -36,7 +36,6 @@ class World():
 
     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
@@ -56,17 +55,10 @@ class World():
         pManaPos = pygame.Vector2(20, pRow2Height + 255)
 
         # labeling
-<<<<<<< HEAD:Game_Client/Classes/Game/World.py
-        self.__labels.append(Label("PlayerHP", self.__screen, "0 / 0", pHPPos))
-        self.__labels.append(Label("PlayerName", self.__screen, "Not Connected", pNamePos))
-        self.__labels.append(Label("PlayerMana", self.__screen, "0", pManaPos))
-        self.__labels.append(Label("EnemyHP", self.__screen, "0 / 0", eHPPos))
-=======
         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))
->>>>>>> 18dcd6cc42f1f23e221702147a36f650f6aae6ac:Client/Classes/Game/World.py
         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"))

Client/Classes/System/Network/EventHandler.py

@@ -13,15 +13,9 @@ class TCPEventHandler:
     def __init__(self, socket:socket):
         self.tcp_socket = socket
 
-<<<<<<< HEAD:Game_Client/Classes/System/Network/EventHandler.py
-    def handleEvents(self, message:dict, inputHandler:InputHandler, world:World):
-        if message["event"] == "loginresponse":
-            # todo: handle login response here
-=======
     def handleEvents(self, message, inputHandler:InputHandler, world:World):
         print(message)
         if message["event"] == "loginresponse":
->>>>>>> 18dcd6cc42f1f23e221702147a36f650f6aae6ac:Client/Classes/System/Network/EventHandler.py
             LoginResponse(message, world)
             pass
         elif message["event"] == "startgame":
@@ -34,17 +28,6 @@ class TCPEventHandler:
             CardPlaced(world, message["card"], message["type"], message["owner"], pygame.Vector2(int(message["x"]), int(message["y"]), inputHandler))
             pass    
         elif message["event"] == "MoveCard":
-<<<<<<< HEAD:Game_Client/Classes/System/Network/EventHandler.py
-            # CardMoved(
-            #    world, 
-            #    message["card"], 
-            #    message["type"], 
-            #    message["owner"], 
-            #    pygame.Vector2(int(message["old_x"]), int(message["old_y"])), 
-            #    pygame.Vector2(int(message["new_x"]), int(message["new_y"])), 
-            #    inputHandler, world)
-=======
->>>>>>> 18dcd6cc42f1f23e221702147a36f650f6aae6ac:Client/Classes/System/Network/EventHandler.py
             pass
         elif message["event"] == "RemoveCard":
             pass

New_Client/App.py

@@ -1,76 +0,0 @@
-import pygame
-from Classes.Engine.EventHandler import EngineEventHandler
-from Classes.Engine.InputHandler import InputHandler
-from Classes.Engine.Logger import Logger
-from Classes.Engine.TCPClient import TCPClient
-
-from Classes.Engine.Window import Window
-from Classes.Game.World import World
-from Classes.Game.NetworkEvents.Login import Login
-
-
-class App:
-    
-    __running:bool
-    __FPS:int = 60
-    __clock:pygame.time.Clock()
-    __myFont:pygame.font
-    __window:Window
-    __world:World
-    __inputHandler: InputHandler
-    __tcpClient: TCPClient
-    __eventHandler: EngineEventHandler
-    logger:Logger
-    
-    def __init__(self, logger:Logger, width:int=1280, height:int=720, title:str="default title"):
-        self.logger = logger
-        
-        self.logger.info("initializing dependencies")
-        pygame.init()
-        pygame.font.init()
-        self.__myFont = pygame.font.SysFont('Comic Sans MS', 30)
-        self.__window = Window(width=width, height=height, title=title)
-        self.__world = World(self.logger, self.__window.getScreen())
-        self.__inputHandler = InputHandler()
-        
-        # attempt to connect to server
-        try:
-            self.logger.info("logging into server")
-            self.__tcpClient = TCPClient("127.0.0.1", "54322", self.__world, self.__inputHandler)
-            Login(self.__tcpClient) # will login to the server
-        except Exception as e:
-            print(f"failed to login due to error {e}")
-            print("server connection failed or got refused")
-            pass
-    
-    def startGameLoop(self):
-        self.__running = True
-        
-        while self.__running:
-            
-            self.__clock.tick(self.__FPS)
-
-            self.__window.getScreen().fill((0,0,0))
-
-            # render world
-            self.__window.drawWorld(self.__world)
-            
-            # updates all cards inside the cards Spritegroup at each step the gameloops does
-            self.__world.getCards().update()
-            self.__world.getHandCards().update()
-
-            # draw groups
-            self.__window.drawSpriteGroup(self.__world.getCards())
-            self.__window.drawSpriteGroup(self.__world.getHandCards())
-            
-            self.__eventHandler.handleEvent(pygame.event.get())
-            
-            # emits update to the game
-            pygame.display.update()
-        
-        self.__running = False
-        
-    # ensures the gameloop stops running and the pygame instance is stopped properly
-    def onCleanup(self):
-        self.__running = False
-        pygame.quit()

New_Client/Assets/Cards/1/card.json

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

New_Client/Assets/Cards/2/testspellcard.json

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

New_Client/Assets/Cards/3/testtrapcard.json

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

New_Client/Classes/Engine/Components/BoardField.py

@@ -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("could not find image Location.")
-        else:
-            # Wenn der Pfad gültig ist, versuchen Sie, das Bild zu laden
-            self.image = pygame.image.load(imagePath).convert_alpha()
-            self.rect = self.image.get_rect()
-            self.rect.center = self.__pos
-
-    def getName(self) -> str:
-        return self.__name
-
-    def getSide(self) -> str:
-        return self.__side
-
-    def getType(self) -> str:
-        return self.__type
-
-    def getPos(self) -> pygame.Vector2:
-        return self.__pos
-
-    def getSize(self) -> tuple:
-        return self.__size
-
-    def getColor(self) -> tuple:
-        return self.__color
-
-    def getRect(self) -> pygame.Rect:
-        return self.rect
-
-    def getImage(self) -> pygame.image:
-        return self.image
-    
-    def getHoldingCard(self):
-        return self.__holdsCard
-
-    def setName(self, name:str) -> str:
-        self.__name = name
-        return self.__name
-
-    def setType(self,type:str) -> str:
-        self.__type = type
-        return self.__type
-
-    def setPos(self, pos:pygame.Vector2) -> pygame.Vector2:
-        self.pos = pos
-        return self.__pos
-
-    def setSize(self, size:tuple) -> tuple:
-        self.__size = size
-        return self.__size
-
-    def setColor(self, color:tuple) -> tuple:
-        self.__color = color
-        return self.__color
-    
-    def setCardHolding(self, card):
-        self.__holdsCard = card
-
-    def getFieldID(self) -> str:
-        return self.__fieldID

New_Client/Classes/Engine/Components/Label.py

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

New_Client/Classes/Engine/EventHandler.py

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

New_Client/Classes/Engine/InputHandler.py

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

New_Client/Classes/Engine/Logger.py

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

New_Client/Classes/Engine/TCPClient.py

@@ -1,52 +0,0 @@
-import json
-import socket
-import threading
-
-from Classes.Engine.EventHandler import TCPEventHandler
-from Classes.Game.World import World
-from Classes.Engine.InputHandler import InputHandler
-
-class TCPClient:
-    
-    __running:bool
-    
-    def __init__(self, addr: str, port: str, world:World, inputHandler:InputHandler):
-        self.addr = addr
-        self.port = int(port)
-        self.tcpSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.world = world
-        self.inputHandler = inputHandler
-        self.eventHandler = TCPEventHandler(self.tcpSocket, self.inputHandler, self.world)
-                
-        try:
-            self.tcpSocket.connect((self.addr, self.port))
-            self.__running = True
-            
-        except Exception as e:
-            print(f"Error connecting TCP socket: {e}")
-            self.__running = False
-
-        # Starten des Listener-Threads
-        self.listen()
-
-    def send(self, message: dict):
-        try:
-            self.tcpSocket.sendall(json.dumps(message).encode())
-        except Exception as e:
-            print(f"Error sending TCP data: {e}")
-
-    def receive(self):
-        while True:
-            try:
-                data = self.tcpSocket.recv(1024)
-                if data:
-                    decoded_data = json.loads(data.decode())
-                    self.eventHandler.handleEvents(decoded_data)
-            except Exception as e:
-                print(f"Error receiving TCP data: {e}")
-                break
-
-    def listen(self):
-        self.tcpThread = threading.Thread(target=self.receive)
-        self.tcpThread.daemon = True
-        self.tcpThread.start()

New_Client/Classes/Engine/Utils/Path.py

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

New_Client/Classes/Engine/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

New_Client/Classes/Engine/Window.py

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

New_Client/Classes/Game/Cards/Card.py

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

New_Client/Classes/Game/Cards/MonsterCard.py

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

New_Client/Classes/Game/Cards/SpellCard.py

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

New_Client/Classes/Game/Cards/TrapCard.py

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

New_Client/Classes/Game/NetworkEvents/GameStart.py

@@ -1,16 +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.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, 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, world.getPlayer()))
-    

New_Client/Classes/Game/NetworkEvents/Login.py

@@ -1,23 +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):
-    # checks if the response on the login request is successfull
-    if message["status"] != "success":
-        print("login failed")
-    else:
-        world.setPlayer(Player(0,0, message["username"], message["id"]))

New_Client/Classes/Game/NetworkEvents/PlaceCard.py

@@ -1,37 +0,0 @@
-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, id):
-    # 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": id,
-        "x": card.getPos().x,
-        "y": card.getPos().y,
-    }
-
-    tcpClient.send(payload)
-
-# the event send from the server to display a card on the field
-def CardPlaced(world:World, card:int, type:str, owner:str, pos:pygame.Vector2, inputHandler:InputHandler):
-    if type == "MonsterCard":
-        world.spawnMonsterCard(f"Assets/Cards/{card}/", pos, inputHandler, owner)
-        pass
-    elif type == "SpellCard":
-        world.spawnSpellCard(f"Assets/Cards/{card}/", pos, inputHandler, owner)
-        pass
-    elif type == "TrapCard":
-        world.spawnTrapCard(f"Assets/Cards/{card}/", pos, inputHandler, owner)
-        pass
-    pass
-
-def MovedCard(world:World, card:int, type:str, owner:str, oldPos:pygame.Vector2, newPos:pygame.Vector2, inputHandler:InputHandler):
-    pass

New_Client/Classes/Game/Player.py

@@ -1,44 +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):
-        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
-    

New_Client/Classes/Game/World.py

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

New_Client/log/aruudvef.log

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

New_Client/log/azkihdia.log

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

New_Client/log/cssmtaso.log

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

New_Client/log/dypjnvwx.log

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

New_Client/log/ecnwzwpv.log

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

New_Client/log/ezuxqfek.log

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

New_Client/log/hpyfylsj.log

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

New_Client/log/jqqeltiy.log

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

New_Client/log/mhtlvsqm.log

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

New_Client/log/pbwegfvw.log

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

New_Client/log/qqebhbex.log

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

New_Client/log/rnwforll.log

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

New_Client/log/rrffvbhc.log

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

New_Client/log/snqncicq.log

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

New_Client/log/sstwdlli.log

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

New_Client/log/vzybrxrc.log

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

New_Client/log/wqfhotaq.log

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

New_Client/log/xqetosuq.log

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

New_Client/log/xwrmortx.log

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

New_Client/log/xxfpqmla.log

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

New_Client/log/ysnrngup.log

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

New_Client/log/zlnfjkpf.log

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

New_Client/log/zoukqhzj.log

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

New_Client/log/zpvgppfk.log

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

New_Client/main.py

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

OLD_Server/.env

@@ -1,4 +0,0 @@
-HOST="127.0.0.1"
-TCPPORT=54322
-UDPPORT=54323
-ENV="DEV"

OLD_Server/.vscode/settings.json

@@ -1,14 +0,0 @@
-{
-    "cSpell.words": [
-        "DGRAM"
-    ],
-    "cSpell.ignoreWords": [
-        "activateeffectcard",
-        "activatemonstereffect",
-        "attackcard",
-        "attackplayer",
-        "movecard",
-        "placecard",
-        "removecard"
-    ]
-}

OLD_Server/Assets/Cards/MonsterCards/testmonstercard/card.json

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

OLD_Server/Assets/Cards/SpeelCards/testspellcard/testspellcard.json

@@ -1,6 +0,0 @@
-{
-    "name": "testspell",
-    "image":"Assets/Cards/testspelltcard/artwork.png",
-    "costs": 30,
-    "description":"this is a test spell card"
-}

OLD_Server/Assets/Cards/TrapCards/testtrapcard/testtrapcard.json

@@ -1,6 +0,0 @@
-{
-    "name": "testtrap",
-    "image":"Assets/Cards/testtrapcard/artwork.png",
-    "costs": 30,
-    "description":"this is a test tryp card"
-}

OLD_Server/Classes/Game/Player.py

@@ -1,57 +0,0 @@
-import random
-
-class Player:
-    __id:int
-    __hp:int
-    __mana:int
-    __name:str
-    __handCards:list
-    __deck:list
-
-    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
-        self.__id = random.randint(3, 99999)
-        self.__mana = mana
-
-    def shuffleDeck(self):
-        self.__deck = random.shuffle(self.__deck)
-
-    def getDeck(self) -> list:
-        return self.__deck
-
-    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 getID(self) -> int:
-        return self.__id
-
-    def getHand(self) -> list:
-        return self.__handCards
-    
-    def getMana(self) -> int:
-        return self.__mana
-    
-    def addMana(self, amount) -> int:
-        self.__mana + amount
-        return self.__mana
-
-    def AddToHand(self, card) -> list:
-        self.__handCards.append(card)
-        return self.__handCards
-
-    def setHand(self, hand:list):
-        self.__handCards = hand
-
-    def removeFromHand(self, pos:int) -> list:
-        self.__handCards.remove(pos)
-        return self.__handCards

OLD_Server/Classes/System/GameManager.py

@@ -1,155 +0,0 @@
-import json
-import socket
-import time
-from Classes.Game.Player import Player
-
-
-class GameManager:
-    __players:dict
-    __playingPlayer:Player
-    __state:str
-    __round:str
-    __cards:list
-
-    def __init__(self, logger):
-        self.__players = {}
-        self.__playingPlayer = None
-        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
-    # =============================================================================
-    
-    # this function iterates all 
-    def progressRound(self):
-        # phases
-        # - playerPrep => playing player switches, gets a mana point and gets verified
-        if self.__playingPlayer != None:
-            for player in self.__players:
-                if self.__playingPlayer != player:
-                    self.__playingPlayer = player
-        else:
-            self.__playingPlayer = next(iter(self.__players))
-        # - playerDraw => player draws a card
-        # - playerPlay => player can place cards and active effects
-        # - playerEnd => player ends his turn and the code reiterates with the remaining player
-        pass
-
-    # game state management
-    # this section mostly only used by the networking and event handling classes
-    # other parts should never need to interface with this unless really required
-    # =============================================================================
-    def startGame(self, tcpSocket: socket):
-        self.__state = "running"
-
-        players = list(self.__players.values())
-
-        print("game starts")
-        self.logger.info("game manager is starting the game")
-        for userAddr, player_data in self.__players.items():
-            try:
-                user = player_data["player"]
-                user.addMana(1000)
-                user.adjustHP(1000)
-                user.shuffleDeck()
-                cards = self.__players[userAddr]["deck"]
-                user.setHand(cards[:5])
-
-                # iterates until the enemy player is not anymore equal to current player
-                enemy = next(player_data["player"] for player_data in players if player_data["player"] != user)
-
-                payload = {
-                    "event": "startgame",
-                    "player": {
-                        "mana": user.getMana(),
-                        "hp": user.getHP(),
-                        "hand": user.getHand()
-                    },
-                    "enemy": {
-                        "id": enemy.getID(),
-                        "name": enemy.getName(),
-                        "hp": enemy.getHP(),
-                    },
-                }
-
-                print(f"user {player_data["socket"]}")
-                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
-
-    def stopGame(self):
-        # handles notifying all players that the game stops
-        # handles stoping the game itself and notifies server to stop itself
-        pass
-
-    # player management
-    # the network manager will create a player instance
-    # =============================================================
-
-    # gets all player known to the game manager and returns them
-    def getPlayers(self) -> dict:
-        return self.__players
-
-    # 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:
-        
-        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:
-            time.sleep(1)
-            self.logger.info("2 players have join game starts")
-            self.startGame()
-
-        return self.__players
-    
-    def removePlayers(self, clientAddr):
-        self.logger.info(f"removing player with address '{clientAddr}' from players database")
-        del self.__players[clientAddr]

OLD_Server/Classes/System/Logger.py

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

OLD_Server/Classes/System/Network/EventHandler.py

@@ -1,45 +0,0 @@
-import socket
-from Classes.Game.Player import Player
-from Classes.System.GameManager import GameManager
-
-from Classes.System.World import World
-
-
-class TCPEventHandler:
-    __tcpSocket:socket
-
-    def __init__(self, socket:socket):
-        self.__tcpSocket = socket
-
-    # handles passing of event data to the right functions
-    def handleTCPEvents(self, event, gameManager:GameManager, address):
-        gameManager.getLogger().info(f"incommingevent {event}")
-        if event["event"] == "PlaceCard":
-            gameManager.getLogger().info(f"player {event['user']} attempted to place card {event['card']}")
-            for playerKey in gameManager.getPlayers().keys():
-                player = gameManager.getPlayers()[playerKey]
-                if int(event["user"]) != player["player"].getID():
-                    payload = {
-                        "event":"cardPlaced",
-                        "card": {
-                            "card":event["card"],
-                            "owner": event["user"],
-                            "x": event["x"],
-                            "y": event["y"]
-                        }
-                    }
-                    player["socket"].send(payload)
-            pass
-        elif event["event"] == "MoveCard":
-            pass
-        elif event["event"] == "RemoveCard":
-            pass
-        elif event["event"] == "AttackCard":
-            pass
-        elif event["event"] == "AttackPlayer":
-            pass
-        elif event["event"] == "ActivateEffectCard":
-            pass
-        elif event["event"] == "ActivateMonsterCard":
-            pass
-        pass

OLD_Server/Classes/System/Network/NetworkManger.py

@@ -1,145 +0,0 @@
-import json
-import signal
-import socket
-import sys
-import threading
-from Classes.Game.Player import Player
-from Classes.System.GameManager import GameManager
-
-from Classes.System.Network.EventHandler import TCPEventHandler
-from Classes.System.World import World
-
-class NetworkManager:
-    class TCP:
-        __Addr:str
-        __Port:str
-        __BufferSize:int = 1024
-        __tcpSocket:socket
-        __eventHandler: dict   
-        __users: dict     
-        __TCPClientThread:threading.Thread
-        __gameManager:GameManager
-        
-        def __init__(self, Addr:str, Port:str, gameManager:GameManager):
-            gameManager.getLogger().info("starting up network manager")
-            
-            self.running = True
-            self.__Addr = Addr
-            self.__Port = int(Port)
-            self.__gameManager = gameManager
-            self.__eventHandler = {}
-
-            gameManager.getLogger().info("starting up tcp server")
-            self.__tcpSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            self.__tcpSocket.bind((self.__Addr, self.__Port))
-            self.__tcpSocket.listen()
-                                    
-            gameManager.getLogger().info("starting up thread for client socket accepting")
-            self.__TCPClientThread = threading.Thread(target=self.accept_connections)
-            self.__TCPClientThread.daemon = True
-            self.__TCPClientThread.start()
-
-        def accept_connections(self):
-            while self.running:
-                try: 
-                    client_tcp_socket, client_address = self.__tcpSocket.accept()
-                    self.__gameManager.getLogger().info(f"Connected with {client_address}")
-                    self.__gameManager.getPlayers()[client_address] = client_tcp_socket
-                    self.__eventHandler[client_address] = TCPEventHandler(client_tcp_socket)
-                    
-                    client_handler_thread = threading.Thread(
-                        target=self.receive,
-                        args=(client_tcp_socket, client_address)
-                    )
-                    
-                    self.__gameManager.getLogger().info(f"starting client handler thread for client at address {client_address}")
-                    client_handler_thread.daemon = True
-                    client_handler_thread.start()
-                
-                except Exception as e:
-                    self.__gameManager.getLogger().error(f"tcp socket failed to accept connection due to error: {e}")
-                    pass
-            client_handler_thread.join()
-
-        def receive(self, client_socket, client_address):
-            while self.running:
-                try:
-                    data = client_socket.recv(self.__BufferSize)
-                    if not data:
-                        self.__gameManager.getLogger().info(f"Connection with {client_address} closed.")
-                        break 
-
-                    try:
-                
-                        message = data.decode()
-                        messageJson = json.loads(message)
-                        self.__gameManager.getLogger().info(f"decoded message {messageJson}")
-                        user = messageJson.get("user")
-                        self.__gameManager.getLogger().info(f"user in message {user}")
-                
-                    except Exception as ex:
-                        self.__gameManager.getLogger().info(f"decoding incoming packet failed due to exception: {ex}")
-
-                    # creates a user and counts how many currently are connected to  the server
-                    # if enough users for a round are connected the server has to start the game
-                    if user not in self.__gameManager.getPlayers():
-                        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"]) 
-                            self.__gameManager.getLogger().info(f"connected users {len(self.__gameManager.getPlayers())}")
-                            
-                            self.__gameManager.getLogger().info(f"confirming login for user")
-                            self.send({
-                                "event": "loginresponse",
-                                "status": "success",
-                                "username": user[client_address]["player"].getName(),
-                                "id": user[client_address]["player"].getID(),
-                            }, client_address)
-
-                    self.__eventHandler[client_address].handleTCPEvents(messageJson, self.__gameManager, client_address)
-                    self.__gameManager.getLogger().info(f"Received message from {client_address}: {message}")
-
-                except socket.error as e:
-                
-                    if e.errno == 10054:
-                        self.__gameManager.getLogger().error(f"Connection with {client_address} forcibly closed by remote host.")
-                        players = self.__gameManager.getPlayers()
-                        self.__gameManager.removePlayers(client_address)
-                        self.__gameManager.getLogger().info(f"new player length {len(players)}")
-                        break
-                
-                    self.__gameManager.getLogger().error(f"Socket error receiving data from {client_address}: {e}")
-                
-                except json.JSONDecodeError as e:
-                    self.__gameManager.getLogger().error(f"JSON decoding error receiving data from {client_address}: {e}")
-                
-                # except Exception as e:
-                #    self.__gameManager.getLogger().error(f"UknownError receiving data from {client_address} due to error: {e}")
-
-        def broadcast(self, payload:dict):
-            for user in self.__gameManager.getPlayers().values():
-                user["socket"].send(json.dumps(payload).encode())
-
-        def send(self, payload: dict, user: str):
-            players = self.__gameManager.getPlayers()
-
-            if user in players and "socket" in players[user]:
-                players[user]["socket"].send(json.dumps(payload).encode())
-            else:
-                self.__gameManager.getLogger().error(f"user '{user}' or socket was not found 'socket' failed to send data.")
-
-        def stop(self):
-            self.__TCPClientThread.join()  # Wait for the thread to finish before exiting
-
-    tcp: TCP
-    # udp: UDP
-
-    def __init__(self, Addr:str, TCPPort:str, UDPPort:str, gameManager:GameManager):
-        self.tcp = self.TCP(Addr, TCPPort, gameManager)
-        signal.signal(signal.SIGINT, self.handle_interrupt)  # Register the signal handler
-
-    def handle_interrupt(self, signum, frame):
-        self.__gameManager.getLogger().info("Received keyboard interrupt. Stopping the server.")
-        self.tcp().stop()
-        sys.exit(0)

OLD_Server/Classes/System/PlayerManager.py

@@ -1,23 +0,0 @@
-import json
-class Player:
-        
-    def createUser(self, user:json):
-        self.__users.append(user)
-
-    def createUser(self, user:json):
-        if self.getUser(user["username"]) == None:
-            self.__users.append(Player(user["username"]))
-
-    def removeUser(self, user:int):
-        self.__users.remove(user)
-
-    def removeUser(self, user:str):
-        self.__users.remove(user)
-
-    def getUsers(self) -> list:
-        return self.__users
-
-    def getUser(self, user:int):
-        for user in self.__users:
-            if int(user["id"]) == user:
-                return user

OLD_Server/Classes/System/QueueManager.py

@@ -1,34 +0,0 @@
-
-
-from Classes.Game.Player import Player
-
-
-class QueueManager:
-    __queue:list
-
-    def __init__(self):
-        self.__queue = []
-
-    def getQueue(self) -> list:
-        return self.__queue
-
-    def addToQueue(self, user) -> list:
-        if self.isInQueue(user["id"]):
-            self.__queue.append(user)
-            return self.__queue
-
-    def removeFromQueue(self, player:Player) -> list:
-        self.__queue.remove(player)
-        return self.__queue
-
-    def isInQueue(self, user:int) -> bool:
-        for user in self.__queue:
-            if int(user["id"]) == user:
-                return True
-        return False
-            
-    def isInQueue(self, user:str) -> bool:
-        for user in self.__queue:
-            if user["username"] == user:
-                return True
-        return False

OLD_Server/Classes/System/Server.py

@@ -1,40 +0,0 @@
-import json
-import socket
-import threading
-from Classes.System.GameManager import GameManager
-
-from Classes.System.Network.NetworkManger import NetworkManager
-from Classes.System.PlayerManager import Player
-from Classes.System.World import World
-from Classes.System.Logger import Logger
-
-class Server:
-
-    __address:str
-    __tcpPort:str
-    __udpPort:str
-    __world:World
-    __gameManager:GameManager
-
-    networkManager:NetworkManager
-
-    def __init__(self, address:str, tcpPort:str, udpPort:str, logger:Logger):
-        self.__address = address
-        self.__tcpPort = tcpPort
-        self.__udpPort = udpPort
-        self.__world = World()
-        self.logger = logger
-
-        self.logger.info("starting up game manager")
-        self.__gameManager = GameManager(logger)
-
-        self.logger.info("preparing to start server")
-        self.startServer(self.__gameManager)
-
-    # handles starting the server and assigning socket values to the local reference
-    def startServer(self, gameManager:GameManager):
-        self.logger.info("starting up network manager")
-        self.__networkManager = NetworkManager(self.__address, self.__tcpPort, self.__udpPort, gameManager)
-
-    def getNetworkManager(self) -> NetworkManager:
-        return self.__networkManager

OLD_Server/Classes/System/Utils/Path.py

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

OLD_Server/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

OLD_Server/Classes/System/World.py

@@ -1,20 +0,0 @@
-import socket
-from Classes.Game.Player import Player
-
-
-class World:
-    __players:dict
-
-    def __init__(self):
-        self.__players = {}
-
-    def getPlayers(self) -> list:
-        return self.__players
-    
-    def addPlayers(self, player:Player, socket:socket, clientAddr) -> list:
-        self.__players[clientAddr] = {
-            player: player,
-            socket:socket
-        }
-
-        return self.__players