removed server added client code
This commit is contained in:
141
Classes/System/App.py
Normal file
141
Classes/System/App.py
Normal file
@ -0,0 +1,141 @@
|
||||
import pygame
|
||||
from pygame.locals import *
|
||||
|
||||
from Classes.Game.Cards.MonsterCard import MonsterCard
|
||||
from Classes.System.Components.Window import Window
|
||||
from Classes.System.Components.InputHandler import InputHandler
|
||||
from Classes.Game.World import World
|
||||
from Classes.System.Network.TCPClient import TCPClient
|
||||
from Classes.Game.Events.Login import Login
|
||||
from Classes.Game.Events.PlaceCard import PlaceCard
|
||||
from Classes.Game.Player import Player
|
||||
from Classes.Game.Cards.Card import Card
|
||||
from Classes.System.Utils.Path import PathUtil
|
||||
|
||||
class App:
|
||||
|
||||
__window:Window
|
||||
__running:bool = True
|
||||
__FPS = 60
|
||||
__clock = pygame.time.Clock()
|
||||
__myFont:pygame.font
|
||||
__world:World
|
||||
__inputHandler: InputHandler
|
||||
__tcpClient: TCPClient
|
||||
|
||||
def __init__(self, width:int=1920, height:int=1080, title:str="default title"):
|
||||
pygame.font.init()
|
||||
self.__myFont = pygame.font.SysFont('Comic Sans MS', 30)
|
||||
self.__window = Window(width=width, height=height, title=title)
|
||||
self.__inputHandler = InputHandler()
|
||||
self.selectedCard = None
|
||||
|
||||
# game word
|
||||
self.__world = World(self.__window.getScreen())
|
||||
|
||||
try:
|
||||
self.__tcpClient = TCPClient("127.0.0.1", "54322", self.__world, self.__inputHandler)
|
||||
Login(self.__tcpClient) # will login to the server
|
||||
except Exception as e:
|
||||
print(f"failed to login due to error {e}")
|
||||
print("server connection failed or got refused")
|
||||
pass
|
||||
|
||||
self.startGameLoop()
|
||||
self.onCleanup()
|
||||
|
||||
def startGameLoop(self):
|
||||
|
||||
# create sprite groups
|
||||
# todo: remove these and let server handle card creation instead
|
||||
# blocker: server - client communication [WIP]
|
||||
# self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(500, 1050), self.__inputHandler, Player(1000, 0, "test"))
|
||||
# self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(600, 1050), self.__inputHandler, Player(1000, 0, "test"))
|
||||
# self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(700, 1050), self.__inputHandler, Player(1000, 0, "test"))
|
||||
# self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(800, 1050), self.__inputHandler, Player(1000, 0, "test"))
|
||||
# self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(900, 1050), self.__inputHandler, Player(1000, 0, "test"))
|
||||
# self.__world.spawnCard(PathUtil.getAbsolutePathTo("Assets/Cards/1/"), pygame.Vector2(1000, 1050), self.__inputHandler, Player(1000, 0, "test"))
|
||||
|
||||
while self.__running:
|
||||
self.__clock.tick(self.__FPS)
|
||||
|
||||
self.__window.getScreen().fill((0,0,0))
|
||||
|
||||
# render world
|
||||
self.__window.drawWorld(self.__world)
|
||||
|
||||
# updates all cards inside the cards Spritegroup at each step the gameloops does
|
||||
self.__world.getCards().update()
|
||||
self.__world.getHandCards().update()
|
||||
|
||||
# draw groups
|
||||
self.__window.drawSpriteGroup(self.__world.getCards())
|
||||
self.__window.drawSpriteGroup(self.__world.getHandCards())
|
||||
|
||||
# event handler
|
||||
self.handleEvent(pygame.event.get())
|
||||
|
||||
# emits update to the game
|
||||
pygame.display.update()
|
||||
|
||||
# handles incoming event queue
|
||||
def handleEvent(self, events):
|
||||
# TODO: fix bug that stacks cards when dragging them around
|
||||
try:
|
||||
for event in events:
|
||||
if event.type == pygame.QUIT:
|
||||
self.onCleanup()
|
||||
elif self.__inputHandler.getMousePressed()[0]:
|
||||
for card in self.__world.getCards():
|
||||
if card.getDragable() == True:
|
||||
if card.rect.collidepoint(self.__inputHandler.getMousePos()):
|
||||
#self.__logger.info(f"dragging card {card}")
|
||||
self.selectedCard = card
|
||||
|
||||
# failsafe to prevent NoneType errors
|
||||
if self.selectedCard != None:
|
||||
#self.__logger.info(f"working with card: {self.selectedCard}")
|
||||
self.selectedCard.setDragging(True)
|
||||
elif event.type == pygame.MOUSEBUTTONUP:
|
||||
print("left mousebutton")
|
||||
if event.button == 1:
|
||||
if self.selectedCard != None:
|
||||
self.selectedCard.setDragging(False)
|
||||
print(self.selectedCard)
|
||||
for field in self.__world.getBoardFields():
|
||||
print(f"checking field {field} is field mathinc? {field.getRect().collidepoint(self.__inputHandler.getMousePos())}")
|
||||
if field.getRect().collidepoint(self.__inputHandler.getMousePos()):
|
||||
print(f"is position valid? {field.getSide() == 'Player' and field.getType() == self.selectedCard.getType()} ")
|
||||
print(f"side {field.getSide()} fieldtype {field.getType()} card type {self.selectedCard.getType()}")
|
||||
|
||||
if field.getSide() == "Player" and field.getType() == self.selectedCard.getType():
|
||||
print(f"found field {field}")
|
||||
try:
|
||||
print(f"placing card {self.selectedCard} in field {field}")
|
||||
# snap card into the correct field
|
||||
self.selectedCard.rect.center = field.rect.center
|
||||
self.selectedCard.setDragging(False)
|
||||
|
||||
print(self.selectedCard)
|
||||
# TODO: adapt this into the new game engine version
|
||||
PlaceCard(self.__tcpClient, self.selectedCard, self.__world.getPlayer()) # tells te server that the player placed this card
|
||||
self.selectedCard = None
|
||||
except Exception as e:
|
||||
print(f"failed to place card on server due to error: {e}")
|
||||
|
||||
if self.selectedCard != None:
|
||||
self.selectedCard = None
|
||||
else:
|
||||
raise ValueError("selected card in event handler was found empty this should never happen!")
|
||||
pass
|
||||
except:
|
||||
pass
|
||||
|
||||
# sets the running state for the gameloop
|
||||
def setRunning(self, running:bool):
|
||||
self.__running = running
|
||||
|
||||
# ensures the gameloop stops running and the pygame instance is stopped properly
|
||||
def onCleanup(self):
|
||||
self.__running = False
|
||||
pygame.quit()
|
||||
53
Classes/System/Components/InputHandler.py
Normal file
53
Classes/System/Components/InputHandler.py
Normal file
@ -0,0 +1,53 @@
|
||||
import pygame
|
||||
|
||||
from Classes.Game.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
|
||||
47
Classes/System/Components/Label.py
Normal file
47
Classes/System/Components/Label.py
Normal file
@ -0,0 +1,47 @@
|
||||
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))
|
||||
54
Classes/System/Components/Window.py
Normal file
54
Classes/System/Components/Window.py
Normal file
@ -0,0 +1,54 @@
|
||||
import pygame
|
||||
from pygame.locals import *
|
||||
|
||||
from Classes.Game.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()
|
||||
@ -1,153 +1,23 @@
|
||||
import json
|
||||
import socket
|
||||
import time
|
||||
from Classes.Game.Player import Player
|
||||
from Classes.Game.World import World
|
||||
|
||||
|
||||
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
|
||||
# =============================================================================
|
||||
player:Player
|
||||
enemy:Player
|
||||
world:World
|
||||
|
||||
# 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
|
||||
def __init__(self, world):
|
||||
self.world = world
|
||||
|
||||
# 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):
|
||||
self.__state = "running"
|
||||
def getPlayer(self) -> Player:
|
||||
return self.player
|
||||
|
||||
players = list(self.__players.values())
|
||||
def getEnemy(self) -> Player:
|
||||
return self.enemy
|
||||
|
||||
print("game starts")
|
||||
self.logger.info("game manager is starting the game")
|
||||
for userAddr, player_data in self.__players.items():
|
||||
try:
|
||||
user = self.__players[userAddr]["player"]
|
||||
user.addMana(1000)
|
||||
user.adjustHP(1000)
|
||||
user.shuffleDeck()
|
||||
cards = self.__players[userAddr]["deck"]
|
||||
user.setHand(cards[:5])
|
||||
def setPlayer(self, player:Player):
|
||||
self.player = player
|
||||
|
||||
# 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}")
|
||||
pass
|
||||
# handles notifying all players that the game starts
|
||||
pass
|
||||
|
||||
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 setEnemy(self, enemy:Player):
|
||||
self.enemy = enemy
|
||||
@ -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)
|
||||
@ -1,32 +1,41 @@
|
||||
import socket
|
||||
|
||||
import pygame
|
||||
|
||||
from Classes.Game.Events.PlaceCard import CardPlaced
|
||||
from Classes.System.Components.InputHandler import InputHandler
|
||||
from Classes.Game.World import World
|
||||
from Classes.Game.Events.GameStart import GameStart
|
||||
from Classes.Game.Player import Player
|
||||
from Classes.System.GameManager import GameManager
|
||||
|
||||
from Classes.System.World import World
|
||||
|
||||
from Classes.Game.Events.Login import LoginResponse
|
||||
|
||||
class TCPEventHandler:
|
||||
__tcpSocket:socket
|
||||
|
||||
def __init__(self, socket:socket):
|
||||
self.__tcpSocket = socket
|
||||
self.tcp_socket = 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.spawnCard(event["card"], event["user"], event["x"], event["y"])
|
||||
def handleEvents(self, message, inputHandler:InputHandler, world:World):
|
||||
print(message)
|
||||
if message["event"] == "loginresponse":
|
||||
LoginResponse(message, world)
|
||||
pass
|
||||
elif event["event"] == "MoveCard":
|
||||
elif message["event"] == "startgame":
|
||||
print(world.player)
|
||||
# world.player.setMana(message["player"]["mana"])
|
||||
# world.player.setHp(message["player"]["hp"])
|
||||
GameStart(world, message["player"]["hand"], inputHandler, world.getPlayer(), Player(message["enemy"]["hp"],0,message["enemy"]["name"], message["enemy"]["id"]))
|
||||
pass
|
||||
elif event["event"] == "RemoveCard":
|
||||
elif message["event"] == "placecard":
|
||||
CardPlaced(world, message["card"], message["type"], message["owner"], pygame.Vector2(int(message["x"]), int(message["y"]), inputHandler))
|
||||
pass
|
||||
elif message["event"] == "MoveCard":
|
||||
pass
|
||||
elif event["event"] == "AttackCard":
|
||||
elif message["event"] == "RemoveCard":
|
||||
pass
|
||||
elif event["event"] == "AttackPlayer":
|
||||
elif message["event"] == "AttackCard":
|
||||
pass
|
||||
elif event["event"] == "ActivateEffectCard":
|
||||
elif message["event"] == "AttackPlayer":
|
||||
pass
|
||||
elif event["event"] == "ActivateMonsterCard":
|
||||
elif message["event"] == "ActivateEffectCard":
|
||||
pass
|
||||
pass
|
||||
elif message["event"] == "ActivateMonsterCard":
|
||||
pass
|
||||
@ -1,137 +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.__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.")
|
||||
self.__gameManager.getPlayers()[client_address] = None
|
||||
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)
|
||||
69
Classes/System/Network/TCPClient.py
Normal file
69
Classes/System/Network/TCPClient.py
Normal file
@ -0,0 +1,69 @@
|
||||
import json
|
||||
import socket
|
||||
import threading
|
||||
|
||||
import pygame
|
||||
|
||||
from Classes.Game.World import World
|
||||
from Classes.System.Components.InputHandler import InputHandler
|
||||
from Classes.Game.Events.GameStart import GameStart
|
||||
from Classes.Game.Events.Login import LoginResponse
|
||||
from Classes.Game.Events.PlaceCard import CardPlaced
|
||||
from Classes.Game.Player import Player
|
||||
|
||||
class TCPClient:
|
||||
def __init__(self, addr: str, port: str, world:World, inputHandler:InputHandler):
|
||||
self.addr = addr
|
||||
self.port = int(port)
|
||||
self.tcpSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
self.world = world
|
||||
self.inputHandler = inputHandler
|
||||
|
||||
try:
|
||||
self.tcpSocket.connect((self.addr, self.port))
|
||||
except Exception as e:
|
||||
print(f"Error connecting TCP socket: {e}")
|
||||
|
||||
# Starten des Listener-Threads
|
||||
self.listen()
|
||||
|
||||
def send(self, message: dict):
|
||||
try:
|
||||
self.tcpSocket.sendall(json.dumps(message).encode())
|
||||
except Exception as e:
|
||||
print(f"Error sending TCP data: {e}")
|
||||
|
||||
def receive(self):
|
||||
while True:
|
||||
try:
|
||||
data = self.tcpSocket.recv(1024)
|
||||
if data:
|
||||
decoded_data = json.loads(data.decode())
|
||||
self.handleEvents(decoded_data)
|
||||
except Exception as e:
|
||||
print(f"Error receiving TCP data: {e}")
|
||||
break
|
||||
|
||||
def handleEvents(self, message):
|
||||
print(message)
|
||||
if message["event"] == "loginresponse":
|
||||
if message["status"] != "success":
|
||||
print("login failed")
|
||||
else:
|
||||
print("receiving login confirmation from server")
|
||||
self.world.setPlayer(Player(0,0,message["name"], message["id"]))
|
||||
elif message["event"] == "startgame":
|
||||
print(self.world.player)
|
||||
# world.player.setMana(message["player"]["mana"])
|
||||
# world.player.setHp(message["player"]["hp"])
|
||||
self.world.setEnemy(Player(message["enemy"]["hp"],0,message["enemy"]["name"], message["enemy"]["id"]))
|
||||
GameStart(self.world, message["player"]["hand"], self.inputHandler, self.world.getPlayer())
|
||||
pass
|
||||
elif message["event"] == "PlacedCard":
|
||||
CardPlaced(self.world, message["card"], message["owner"], pygame.Vector2(message["x"], message["y"]), self.inputHandler)
|
||||
pass
|
||||
|
||||
def listen(self):
|
||||
tcpThread = threading.Thread(target=self.receive)
|
||||
tcpThread.daemon = True
|
||||
tcpThread.start()
|
||||
@ -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
|
||||
@ -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
|
||||
@ -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
|
||||
@ -3,4 +3,4 @@ import os
|
||||
|
||||
class PathUtil:
|
||||
def getAbsolutePathTo(notAbsolutPath:str) -> str:
|
||||
return os.path.abspath("OLD_Server/" + notAbsolutPath)
|
||||
return os.path.abspath("Client/" + notAbsolutPath)
|
||||
@ -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
|
||||
Reference in New Issue
Block a user