def startGame(self, req):
jsonResponse = {'response': 'startGame'}
try:
playerName = req['playerName']
playerTeam = req['playerTeam']
opponentTeam = req['opponentTeam']
self.players = GameServer.createPlayers(playerName, playerTeam, opponentTeam)
self.cardGame = CardGame(self.players)
self.scores = ScoreKeeper(self.players)
jsonResponse['resultCode'] = 'SUCCESS'
#self.cardGame.decideOrder()
# override to set humanplayer as first
self.cardGame.startingPlayerIndex = 0
self.cardGame.setPlayingOrder()
playersList = []
i = 0
for player in self.cardGame.getPlayers():
playersList.append({'index': i, 'name': player.name,
'id': player.id, 'team': player.team,
'isHuman': isinstance(player,
HumanPlayer)})
i = i + 1
jsonResponse['players'] = playersList
jsonResponse['playingOrder'] = self.cardGame.getOrder()
jsonResponse['gameId'] = str(self.cardGame.id)
except Exception as ex:
self.writer.sendError(ex)
raise
self.writer.sendMessage(jsonResponse)
def startGame(self, handler, req):
nr = len(self.players)
if nr == 4:
message = {"response": "roomFull"}
logging.debug("Room is full")
handler.sendMessage(message)
else:
if nr % 2 == 0:
teamName = "Team A"
else:
teamName = "Team B"
# player = Player(nr, req['playerName'], teamName)
# FIXME: uncomment the previous line, just debugging
player = HumanPlayer(nr, nr, teamName)
self.players.append(player)
self.handlerQueue.append(handler)
if len(self.players) == 4:
logging.debug("Game started")
self.cardGame = CardGame(self.players)
self.scores = ScoreKeeper(self.players)
self.cardGame.startingPlayerIndex = 0
self.cardGame.setPlayingOrder()
self.gameStarted = True
self.cardGame.dealCards()
self.cardGame.initCall()
message = {"response": "joinedGame", "id": nr, "name": req["playerName"], "team": teamName}
logging.debug("%s added to room", req["playerName"])
handler.sendMessage(message)
def testPickBestSuit(self):
cards = []
cards.append(Card('D',1))
cards.append(Card('D',2))
cards.append(Card('D',3))
cards.append(Card('S',1))
cards.append(Card('C',13))
trump = CardGame.pickBestSuit(cards)
print(trump)
self.assertEqual(trump, 'D', "trump is not D")
def testPickBestSuit(self):
cards = []
cards.append(Card('D', 1))
cards.append(Card('D', 2))
cards.append(Card('D', 3))
cards.append(Card('S', 1))
cards.append(Card('C', 13))
trump = CardGame.pickBestSuit(cards)
print(trump)
self.assertEqual(trump, 'D', "trump is not D")
def startGame(self, req):
jsonResponse = {'response': 'startGame'}
try:
playerName = req['playerName']
playerTeam = req['playerTeam']
opponentTeam = req['opponentTeam']
self.players = GameServer.createPlayers(playerName, playerTeam,
opponentTeam)
self.cardGame = CardGame(self.players)
self.scores = ScoreKeeper(self.players)
jsonResponse['resultCode'] = 'SUCCESS'
#self.cardGame.decideOrder()
# override to set humanplayer as first
self.setHumanPlayerFirst()
#self.cardGame.startingPlayerIndex = 0
#self.cardGame.setPlayingOrder()
playersList = []
i = 0
for player in self.cardGame.getPlayers():
playersList.append({
'index': i,
'name': player.name,
'id': player.id,
'team': player.team,
'isHuman': isinstance(player, HumanPlayer)
})
i = i + 1
jsonResponse['players'] = playersList
jsonResponse['playingOrder'] = self.cardGame.getOrder()
jsonResponse['gameId'] = str(self.cardGame.id)
except Exception as ex:
self.writer.sendError(ex)
raise
self.writer.sendMessage(jsonResponse)
player1_defeat = loser1 * 100 / (loser0 + loser1) if loser0 + loser1 > 0 else 0
player2_defeat = loser0 * 100 / (loser0 + loser1) if loser0 + loser1 > 0 else 0
print("Average moves:", avg_moves,
", Player1 lost", player1_defeat,
"%, Player 0 lost", player2_defeat, "%")
def run_rounds(game):
set_logging(False)
stats = []
for i in range(0, 1000):
stats.append(game.round())
print_stats(stats)
def debug_round(game):
set_logging(True)
stats = []
for i in range(0, 1):
stats.append(game.round())
print_stats(stats)
set_logging(False)
player1 = SimplePlayer("Player 1")
player2 = SimplePlayer("Player2")
g = CardGame([player1, player2])
# run_rounds(g)
debug_round(g)
class GameServer:
def __init__(self):
self.players = []
self.writer = None
self.cardGame = None
self.scores = None
self.hand = None
def setWriter(self, writer):
self.writer = writer
@staticmethod
def createPlayers(playerName="John Doe", team1Name="Team Suriname", team2Name="Team Nederland"):
p1 = HumanPlayer(1, playerName, team1Name)
p2 = Player(2, "Bob Marley", team1Name)
p3 = Player(3, "Tupac Shakur", team2Name)
p4 = Player(4, "Jimi Hendrix", team2Name)
return [p1, p3, p2, p4]
def setHumanPlayerFirst(self):
self.cardGame.startingPlayerIndex = 0
self.cardGame.setPlayingOrder()
def isHumanPlayerFirst(self):
return self.cardGame.startingPlayerIndex == 0
def startGame(self, req):
jsonResponse = {'response': 'startGame'}
try:
playerName = req['playerName']
playerTeam = req['playerTeam']
opponentTeam = req['opponentTeam']
self.players = GameServer.createPlayers(playerName, playerTeam, opponentTeam)
self.cardGame = CardGame(self.players)
self.scores = ScoreKeeper(self.players)
jsonResponse['resultCode'] = 'SUCCESS'
#self.cardGame.decideOrder()
# override to set humanplayer as first
self.setHumanPlayerFirst()
#self.cardGame.startingPlayerIndex = 0
#self.cardGame.setPlayingOrder()
playersList = []
i = 0
for player in self.cardGame.getPlayers():
playersList.append({'index': i, 'name': player.name,
'id': player.id, 'team': player.team,
'isHuman': isinstance(player,
HumanPlayer)})
i = i + 1
jsonResponse['players'] = playersList
jsonResponse['playingOrder'] = self.cardGame.getOrder()
jsonResponse['gameId'] = str(self.cardGame.id)
except Exception as ex:
self.writer.sendError(ex)
raise
self.writer.sendMessage(jsonResponse)
def nextGame(self, req):
jsonResponse = {'response': 'nextGame'}
try:
jsonResponse['playingOrder'] = self.cardGame.getOrder()
jsonResponse['resultCode'] = 'SUCCESS'
self.cardGame.clearGame()
self.scores.clearTeamScores()
except Exception as ex:
self.writer.sendError(ex)
raise
self.writer.sendMessage(jsonResponse)
def dealFirstCards(self, request):
response = {'response': 'dealFirstCards'}
try:
self.cardGame.dealFirstCards()
player = self.cardGame.getPlayerById(request['playerId'])
firstCards = player.getCards()
logging.debug("Total nr of cards: %s", len(firstCards))
response['cards'] = [{'rank': card.rank, 'suit': card.suit}
for card in firstCards]
if not self.isHumanPlayerFirst():
logging.debug("Deciding trump for first player")
trumpSuit = self.cardGame.decideTrump()
self.cardGame.chooseTrump(trumpSuit)
else:
logging.debug("Human player first, no need to decide trump")
except Exception as ex:
self.writer.sendError(ex)
raise
self.writer.sendMessage(response)
def chooseTrump(self, request):
response = {'response': 'allCards'}
try:
trumpSuit = None
if 'suit' in request:
trumpSuit = request['suit']
self.cardGame.chooseTrump(trumpSuit)
else:
trumpSuit = self.cardGame.getTrumpSuit()
self.cardGame.dealCards()
player = self.cardGame.getPlayerById(request['playerId'])
allCards = player.getCards()
logging.debug("Total nr of cards: %s", len(allCards))
response['cards'] = [{'rank': card.rank, 'suit': card.suit}
for card in allCards]
response['trumpSuit'] = trumpSuit
self.writer.sendMessage(response)
except Exception as ex:
self.writer.sendError(ex)
raise
def askPlayers(self):
jsonResponse = {'response': 'handPlayed'}
trumpSuit = self.cardGame.trumpSuit
while not self.hand.isComplete():
player = self.cardGame.getNextPlayer(self.hand.getStep())
logging.debug("Asking player %s for move", player.name)
# asynchronous via websocket
if isinstance(player, HumanPlayer):
message = {}
message['response'] = 'askMove'
message['hand'] = self.hand
self.writer.sendMessage(message)
break
else:
card = player.getNextMove(self.hand, trumpSuit)
self.hand.addPlayerMove(PlayerMove(player, card))
logging.debug("%s played %s", player.name, card)
if self.hand.isComplete():
winningMove = self.hand.decideWinner(trumpSuit)
winningPlayer = winningMove.getPlayer()
logging.debug("Winner is %s\n", winningPlayer)
self.scores.registerWin(winningPlayer)
scores = self.scores.getScores()
self.cardGame.changePlayingOrder(winningPlayer)
jsonResponse['hand'] = self.hand
jsonResponse['winningCard'] = winningMove.card
jsonResponse['winningPlayerId'] = winningPlayer.id
jsonResponse['scores'] = scores
self.writer.sendMessage(jsonResponse)
def makeMove(self, req):
try:
player = self.cardGame.getPlayerById(req['playerId'])
playedCard = Card(req['suit'], req['rank'])
playerMove = PlayerMove(player, playedCard)
validMove = self.hand.validatePlayerMove(playerMove, self.cardGame.trumpSuit)
if not validMove:
response = {'response': 'invalidMove', 'playerId': req['playerId']}
self.writer.sendMessage(response)
else:
self.hand.addPlayerMove(playerMove)
player.removeCard(playedCard)
self.askPlayers()
except Exception as ex:
self.writer.sendError(ex)
raise
def isReady(self, req):
try:
if self.scores.isGameDecided():
scores = self.scores.getScores()
winningTeam = self.scores.getWinningTeam()
self.cardGame.processWin(winningTeam)
response = {'response': 'gameDecided', 'scores': scores,
'winningTeam': winningTeam}
self.writer.sendMessage(response)
else:
self.hand = HandInfo()
self.askPlayers()
except Exception as ex:
self.writer.sendError(ex)
raise
class GameServer:
def __init__(self):
self.players = []
self.writer = None
self.cardGame = None
self.scores = None
self.hand = None
self.handlerQueue = []
self.readyQueue = []
self.gameStarted = False
@staticmethod
def getSuitForNumber(num):
suits = ["CLUBS", "DIAMONDS", "HEARTS", "SPADES", "NOTRUMP"]
return suits[num]
def addWriter(self, writer):
self.writers.append(writer)
def startGame(self, handler, req):
nr = len(self.players)
if nr == 4:
message = {"response": "roomFull"}
logging.debug("Room is full")
handler.sendMessage(message)
else:
if nr % 2 == 0:
teamName = "Team A"
else:
teamName = "Team B"
# player = Player(nr, req['playerName'], teamName)
# FIXME: uncomment the previous line, just debugging
player = HumanPlayer(nr, nr, teamName)
self.players.append(player)
self.handlerQueue.append(handler)
if len(self.players) == 4:
logging.debug("Game started")
self.cardGame = CardGame(self.players)
self.scores = ScoreKeeper(self.players)
self.cardGame.startingPlayerIndex = 0
self.cardGame.setPlayingOrder()
self.gameStarted = True
self.cardGame.dealCards()
self.cardGame.initCall()
message = {"response": "joinedGame", "id": nr, "name": req["playerName"], "team": teamName}
logging.debug("%s added to room", req["playerName"])
handler.sendMessage(message)
def getGameInfo(self, handler, req):
if self.gameStarted:
message = {"response": "gameInfo"}
playersList = []
i = 0
for player in self.cardGame.getPlayers():
playersList.append({"index": i, "name": player.name, "id": player.id, "team": player.team})
i = i + 1
message["players"] = playersList
message["playingOrder"] = self.cardGame.getOrder()
message["gameId"] = str(self.cardGame.id)
self.broadcast(message)
def dealCards(self, handler, request):
response = {"response": "dealCards"}
try:
player = self.cardGame.getPlayerById(request["playerId"])
cards = player.getCards()
logging.debug("Total nr of cards: %s", len(cards))
response["cards"] = [{"rank": card.rank, "suit": card.suit} for card in cards]
handler.sendMessage(response)
except Exception as ex:
# self.writer.sendError(ex)
raise
def readyForCall(self, handler, request):
if self.cardGame.callWon:
response = {"response": "callWon"}
response["callNumber"] = self.cardGame.highestCall[0]
response["callSuit"] = self.cardGame.highestCall[1]
response["playerId"] = self.cardGame.highestCaller.id
partner = self.cardGame.getPlayerById((self.cardGame.highestCaller.id + 2) % 4)
response["partnerPlayerId"] = partner.id
response["partnerCards"] = partner.getCards()
handler.sendMessage(response)
else:
player = self.cardGame.getPlayerById(self.cardGame.callTurn)
response = {
"playerId": player.id,
"response": "askCall",
"minCallNumber": self.cardGame.minCall[0],
"minCallSuit": self.cardGame.minCall[1],
}
if self.cardGame.redouble:
response["canDouble"] = "false"
response["canRedouble"] = "false"
elif self.cardGame.double:
response["canDouble"] = "false"
response["canRedouble"] = "true"
elif self.cardGame.highestCall == [0, 0]:
response["canDouble"] = "false"
response["canRedouble"] = "false"
else:
response["canDouble"] = "true"
response["canRedouble"] = "false"
handler.sendMessage(response)
def makeCall(self, handler, request):
response = {"response": "callMade"}
player = self.cardGame.getPlayerById(request["playerId"])
if player == self.cardGame.players[self.cardGame.callTurn]:
response["id"] = player.id
callNumber = int(request["callNumber"])
callSuit = int(request["callSuit"])
# if passed
if callNumber == 8:
self.cardGame.numberOfPasses += 1
response["callNumber"] = "pass"
response["callSuit"] = 0
if self.cardGame.numberOfPasses == 3:
self.cardGame.callWon = True
trumpSuit = self.getSuitForNumber(self.cardGame.highestCall[1])
self.cardGame.chooseTrump(trumpSuit)
self.hand = HandInfo()
playerToStart = self.cardGame.getPlayerById((self.cardGame.highestCaller.id + 1) % 4)
self.cardGame.changePlayingOrder(playerToStart)
self.cardGame.callTurn = (self.cardGame.callTurn + 1) % 4
# if double
elif callNumber == 9:
if self.cardGame.highestCall != [0, 0] and self.cardGame.double == False:
self.cardGame.numberOfPasses = 0
response["callNumber"] = "double"
response["callSuit"] = 0
self.cardGame.double = True
self.cardGame.doubleCaller = player
self.cardGame.callTurn = (self.cardGame.callTurn + 1) % 4
else:
return
# if re-double
elif callNumber == 10:
if self.cardGame.double:
self.cardGame.numberOfPasses = 0
response["callNumber"] = "redouble"
response["callSuit"] = 0
self.cardGame.double = False
self.cardGame.redouble = True
self.cardGame.doubleCaller = player
self.cardGame.callTurn = (self.cardGame.callTurn + 1) % 4
else:
return
# if not passed
elif callNumber > self.cardGame.highestCall[0] or (
callNumber == self.cardGame.highestCall[0] and callSuit >= self.cardGame.highestCall[1]
):
if callNumber < 8 and callSuit < 5:
self.cardGame.numberOfPasses = 0
self.cardGame.double = False
self.cardGame.redouble = False
response["callNumber"] = request["callNumber"]
response["callSuit"] = request["callSuit"]
self.cardGame.highestCall = [callNumber, callSuit]
self.cardGame.highestCaller = player
if callSuit == 4:
self.cardGame.minCall[0] = callNumber + 1
self.cardGame.minCall[1] = 0
else:
self.cardGame.minCall[0] = callNumber
self.cardGame.minCall[1] = callSuit + 1
self.cardGame.callTurn = (self.cardGame.callTurn + 1) % 4
else:
return
else:
return
self.broadcast(response)
def nextGame(self, req):
jsonResponse = {"response": "nextGame"}
try:
jsonResponse["resultCode"] = "SUCCESS"
self.cardGame.clearGame()
self.scores.clearTeamScores()
except Exception as ex:
self.writer.sendError(ex)
raise
self.writer.sendMessage(jsonResponse)
def chooseTrump(self, handler, request):
response = {"response": "trumpChosen"}
if self.cardGame.getPlayerById(request["playerId"]) != self.cardGame.highestCaller:
return
try:
trumpSuit = request["suit"]
self.cardGame.chooseTrump(trumpSuit)
self.cardGame.dealCards()
self.hand = HandInfo()
self.broadcast(response)
except Exception as ex:
raise
def askPlayers(self, handler):
jsonResponse = {"response": "handPlayed"}
trumpSuit = self.cardGame.trumpSuit
while not self.hand.isComplete():
player = self.cardGame.getNextPlayer(self.hand.getStep())
logging.debug("Asking player %s for move", player.name)
# asynchronous via websocket
if isinstance(player, HumanPlayer):
message = {}
message["response"] = "askMove"
message["hand"] = self.hand
handler.sendMessage(message)
break
else:
card = player.getNextMove(self.hand, trumpSuit)
self.hand.addPlayerMove(PlayerMove(player, card))
logging.debug("%s played %s", player.name, card)
if self.hand.isComplete():
winningMove = self.hand.decideWinner(trumpSuit)
pointsWon = self.hand.getHandPoints()
winningPlayer = winningMove.getPlayer()
self.readyQueue = []
logging.debug("Winner is %s\n", winningPlayer)
self.scores.registerWin(winningPlayer, pointsWon)
scores = self.scores.getScores()
self.cardGame.changePlayingOrder(winningPlayer)
jsonResponse["hand"] = self.hand
jsonResponse["winningCard"] = winningMove.card
jsonResponse["winningPlayerId"] = winningPlayer.id
jsonResponse["scores"] = scores
self.writer.sendMessage(jsonResponse)
def isReady(self, handler, request):
if self.hand.isComplete() == False:
player = self.cardGame.getNextPlayer(self.hand.getStep())
if player.id == request["playerId"]:
message = {}
message["response"] = "askMove"
handler.sendMessage(message)
else:
winningMove = self.hand.decideWinner(self.cardGame.trumpSuit)
# pointsWon = self.hand.getHandPoints()
winningPlayer = winningMove.getPlayer()
self.hand = HandInfo()
logging.debug("Winner is %s\n", winningPlayer)
self.scores.registerWin(winningPlayer, 1)
scores = self.scores.getScores()
self.cardGame.changePlayingOrder(winningPlayer)
message = {"response": "handPlayed"}
message["winningCard"] = winningMove.card
message["winningPlayerId"] = winningPlayer.id
message["scores"] = scores
self.broadcast(message)
def makeMove(self, handler, req):
try:
player = self.cardGame.getPlayerById(req["playerId"])
playedCard = Card(req["suit"], req["rank"])
playerMove = PlayerMove(player, playedCard)
validMove = self.hand.validatePlayerMove(playerMove, self.cardGame.trumpSuit)
if not validMove:
response = {"response": "invalidMove", "playerId": req["playerId"]}
handler.sendMessage(response)
else:
self.hand.addPlayerMove(playerMove)
player.removeCard(playedCard)
message = {}
message["response"] = "moveMade"
message["hand"] = self.hand
message["id"] = player.id
self.broadcast(message)
except Exception as ex:
self.writer.sendError(ex)
raise
def broadcast(self, message):
for handler in self.handlerQueue:
handler.sendMessage(message)
class GameServer:
def __init__(self):
self.players = []
self.writer = None
self.cardGame = None
self.scores = None
self.hand = None
def setWriter(self, writer):
self.writer = writer
@staticmethod
def createPlayers(playerName="John Doe",
team1Name="Team Suriname",
team2Name="Team Nederland"):
p1 = HumanPlayer(1, playerName, team1Name)
p2 = Player(2, "Bob Marley", team1Name)
p3 = Player(3, "Tupac Shakur", team2Name)
p4 = Player(4, "Jimi Hendrix", team2Name)
return [p1, p3, p2, p4]
def setHumanPlayerFirst(self):
self.cardGame.startingPlayerIndex = 0
self.cardGame.setPlayingOrder()
def isHumanPlayerFirst(self):
return self.cardGame.startingPlayerIndex == 0
def startGame(self, req):
jsonResponse = {'response': 'startGame'}
try:
playerName = req['playerName']
playerTeam = req['playerTeam']
opponentTeam = req['opponentTeam']
self.players = GameServer.createPlayers(playerName, playerTeam,
opponentTeam)
self.cardGame = CardGame(self.players)
self.scores = ScoreKeeper(self.players)
jsonResponse['resultCode'] = 'SUCCESS'
#self.cardGame.decideOrder()
# override to set humanplayer as first
self.setHumanPlayerFirst()
#self.cardGame.startingPlayerIndex = 0
#self.cardGame.setPlayingOrder()
playersList = []
i = 0
for player in self.cardGame.getPlayers():
playersList.append({
'index': i,
'name': player.name,
'id': player.id,
'team': player.team,
'isHuman': isinstance(player, HumanPlayer)
})
i = i + 1
jsonResponse['players'] = playersList
jsonResponse['playingOrder'] = self.cardGame.getOrder()
jsonResponse['gameId'] = str(self.cardGame.id)
except Exception as ex:
self.writer.sendError(ex)
raise
self.writer.sendMessage(jsonResponse)
def nextGame(self, req):
jsonResponse = {'response': 'nextGame'}
try:
jsonResponse['playingOrder'] = self.cardGame.getOrder()
jsonResponse['resultCode'] = 'SUCCESS'
self.cardGame.clearGame()
self.scores.clearTeamScores()
except Exception as ex:
self.writer.sendError(ex)
raise
self.writer.sendMessage(jsonResponse)
def dealFirstCards(self, request):
response = {'response': 'dealFirstCards'}
try:
self.cardGame.dealFirstCards()
player = self.cardGame.getPlayerById(request['playerId'])
firstCards = player.getCards()
logging.debug("Total nr of cards: %s", len(firstCards))
response['cards'] = [{
'rank': card.rank,
'suit': card.suit
} for card in firstCards]
if not self.isHumanPlayerFirst():
logging.debug("Deciding trump for first player")
trumpSuit = self.cardGame.decideTrump()
self.cardGame.chooseTrump(trumpSuit)
else:
logging.debug("Human player first, no need to decide trump")
except Exception as ex:
self.writer.sendError(ex)
raise
self.writer.sendMessage(response)
def chooseTrump(self, request):
response = {'response': 'allCards'}
try:
trumpSuit = None
if 'suit' in request:
trumpSuit = request['suit']
self.cardGame.chooseTrump(trumpSuit)
else:
trumpSuit = self.cardGame.getTrumpSuit()
self.cardGame.dealCards()
player = self.cardGame.getPlayerById(request['playerId'])
allCards = player.getCards()
logging.debug("Total nr of cards: %s", len(allCards))
response['cards'] = [{
'rank': card.rank,
'suit': card.suit
} for card in allCards]
response['trumpSuit'] = trumpSuit
self.writer.sendMessage(response)
except Exception as ex:
self.writer.sendError(ex)
raise
def askPlayers(self):
jsonResponse = {'response': 'handPlayed'}
trumpSuit = self.cardGame.trumpSuit
while not self.hand.isComplete():
player = self.cardGame.getNextPlayer(self.hand.getStep())
logging.debug("Asking player %s for move", player.name)
# asynchronous via websocket
if isinstance(player, HumanPlayer):
message = {}
message['response'] = 'askMove'
message['hand'] = self.hand
self.writer.sendMessage(message)
break
else:
card = player.getNextMove(self.hand, trumpSuit)
self.hand.addPlayerMove(PlayerMove(player, card))
logging.debug("%s played %s", player.name, card)
if self.hand.isComplete():
winningMove = self.hand.decideWinner(trumpSuit)
winningPlayer = winningMove.getPlayer()
logging.debug("Winner is %s\n", winningPlayer)
self.scores.registerWin(winningPlayer)
scores = self.scores.getScores()
self.cardGame.changePlayingOrder(winningPlayer)
jsonResponse['hand'] = self.hand
jsonResponse['winningCard'] = winningMove.card
jsonResponse['winningPlayerId'] = winningPlayer.id
jsonResponse['scores'] = scores
self.writer.sendMessage(jsonResponse)
def makeMove(self, req):
try:
player = self.cardGame.getPlayerById(req['playerId'])
playedCard = Card(req['suit'], req['rank'])
playerMove = PlayerMove(player, playedCard)
validMove = self.hand.validatePlayerMove(playerMove,
self.cardGame.trumpSuit)
if not validMove:
response = {
'response': 'invalidMove',
'playerId': req['playerId']
}
self.writer.sendMessage(response)
else:
self.hand.addPlayerMove(playerMove)
player.removeCard(playedCard)
self.askPlayers()
except Exception as ex:
self.writer.sendError(ex)
raise
def isReady(self, req):
try:
if self.scores.isGameDecided():
scores = self.scores.getScores()
winningTeam = self.scores.getWinningTeam()
self.cardGame.processWin(winningTeam)
response = {
'response': 'gameDecided',
'scores': scores,
'winningTeam': winningTeam
}
self.writer.sendMessage(response)
else:
self.hand = HandInfo()
self.askPlayers()
except Exception as ex:
self.writer.sendError(ex)
raise
class GameServer:
def __init__(self):
self.players = []
self.writer = None
self.cardGame = None
self.scores = None
self.hand = None
self.handlerQueue = []
self.readyQueue = []
self.gameStarted = False
def addWriter(self, writer):
self.writers.append(writer)
def startGame(self, handler, req):
nr = len(self.players)
if nr == 4:
message = {'response': 'roomFull'}
logging.debug("Room is full")
handler.sendMessage(message)
else:
if nr % 2 == 0:
teamName = "Team A"
else:
teamName = "Team B"
#player = Player(nr, req['playerName'], teamName)
#FIXME: uncomment the previous line, just debugging
player = HumanPlayer(nr, nr, teamName)
self.players.append(player)
self.handlerQueue.append(handler)
if len(self.players) == 4:
self.cardGame = CardGame(self.players)
self.scores = ScoreKeeper(self.players)
self.cardGame.startingPlayerIndex = 0
self.cardGame.setPlayingOrder()
self.gameStarted = True
self.cardGame.dealFirstCards()
self.cardGame.initCall()
message = {'response': 'joinedGame', 'id': nr, 'name' : req['playerName'], 'team': teamName}
logging.debug("%s added to room", req['playerName'])
handler.sendMessage(message)
def getGameInfo(self, handler, req):
if self.gameStarted:
message = {'response': 'gameInfo'}
playersList = []
i = 0
for player in self.cardGame.getPlayers():
playersList.append({'index': i, 'name': player.name,
'id': player.id, 'team': player.team})
i = i + 1
message['players'] = playersList
message['playingOrder'] = self.cardGame.getOrder()
message['gameId'] = str(self.cardGame.id)
self.broadcast(message)
def dealFirstCards(self, handler, request):
response = {'response': 'dealFirstCards'}
try:
player = self.cardGame.getPlayerById(request['playerId'])
firstCards = player.getCards()
logging.debug("Total nr of cards: %s", len(firstCards))
response['cards'] = [{'rank': card.rank, 'suit': card.suit}
for card in firstCards]
except Exception as ex:
self.writer.sendError(ex)
raise
handler.sendMessage(response)
def readyForCall(self, handler, request):
if self.cardGame.callWon:
response = {'response': 'callWon'}
response['call'] = self.cardGame.highestCall
response['playerId'] = self.cardGame.highestCaller.id
handler.sendMessage(response)
else:
player = self.cardGame.getPlayerById(request['playerId'])
if player == self.cardGame.players[self.cardGame.callTurn]:
response = {'response': 'askCall', 'minCall': self.cardGame.minCall}
handler.sendMessage(response)
def makeCall(self, handler, request):
response = {'response': 'callMade'}
player = self.cardGame.getPlayerById(request['playerId'])
if player == self.cardGame.players[self.cardGame.callTurn]:
response['id'] = player.id
callValue = int(request['call'])
# if passed
if callValue == 0:
self.cardGame.numberOfPasses += 1
response['call'] = 'pass'
if self.cardGame.firstCall == True:
self.cardGame.callTurn = (self.cardGame.stayTurn + 1) % 4
self.cardGame.stayTurn = self.cardGame.callTurn
else:
if self.cardGame.callStatus == 'stay':
self.cardGame.callTurn = (self.cardGame.stayTurn + 1) % 4
self.cardGame.minCall += 1
self.cardGame.callStatus = 'challenge'
elif self.cardGame.callStatus == 'challenge':
self.cardGame.callTurn = (self.cardGame.callTurn + 1) % 4
# if not passed
elif callValue >= self.cardGame.minCall:
response['call'] = request['call']
self.cardGame.highestCall = callValue
self.cardGame.highestCaller = player
# first call
if self.cardGame.firstCall == True:
self.cardGame.minCall = callValue + 1
self.cardGame.stayTurn = self.cardGame.callTurn
self.cardGame.callTurn = (self.cardGame.callTurn + 1) % 4
self.cardGame.firstCall = False
self.cardGame.callStatus = 'challenge'
else:
if self.cardGame.callStatus == 'stay':
self.cardGame.minCall = callValue + 1
self.cardGame.callTurn, self.cardGame.stayTurn = self.cardGame.stayTurn, self.cardGame.callTurn
self.cardGame.callStatus = 'challenge'
elif self.cardGame.callStatus == 'challenge':
self.cardGame.minCall = callValue
self.cardGame.callTurn, self.cardGame.stayTurn = self.cardGame.stayTurn, self.cardGame.callTurn
self.cardGame.callStatus = 'stay'
if self.cardGame.callTurn == 0 and self.cardGame.callStatus == 'challenge':
self.cardGame.callWon = True
self.broadcast(response)
def nextGame(self, req):
jsonResponse = {'response': 'nextGame'}
try:
jsonResponse['resultCode'] = 'SUCCESS'
self.cardGame.clearGame()
self.scores.clearTeamScores()
except Exception as ex:
self.writer.sendError(ex)
raise
self.writer.sendMessage(jsonResponse)
def chooseTrump(self, handler, request):
response = {'response': 'trumpChosen'}
if self.cardGame.getPlayerById(request['playerId']) != self.cardGame.highestCaller:
return
try:
trumpSuit = request['suit']
self.cardGame.chooseTrump(trumpSuit)
self.cardGame.dealCards()
self.hand = HandInfo()
self.broadcast(response)
except Exception as ex:
raise
def dealAllCards(self, handler, request):
response = {'response': 'allCards'}
player = self.cardGame.getPlayerById(request['playerId'])
allCards = player.getCards()
logging.debug("Total nr of cards: %s", len(allCards))
response['cards'] = [{'rank': card.rank, 'suit': card.suit}
for card in allCards]
handler.sendMessage(response)
def askPlayers(self, handler):
jsonResponse = {'response': 'handPlayed'}
trumpSuit = self.cardGame.trumpSuit
while not self.hand.isComplete():
player = self.cardGame.getNextPlayer(self.hand.getStep())
logging.debug("Asking player %s for move", player.name)
# asynchronous via websocket
if isinstance(player, HumanPlayer):
message = {}
message['response'] = 'askMove'
message['hand'] = self.hand
handler.sendMessage(message)
break
else:
card = player.getNextMove(self.hand, trumpSuit)
self.hand.addPlayerMove(PlayerMove(player, card))
logging.debug("%s played %s", player.name, card)
if self.hand.isComplete():
winningMove = self.hand.decideWinner(trumpSuit)
pointsWon = self.hand.getHandPoints()
winningPlayer = winningMove.getPlayer()
self.readyQueue = []
logging.debug("Winner is %s\n", winningPlayer)
self.scores.registerWin(winningPlayer, pointsWon)
scores = self.scores.getScores()
self.cardGame.changePlayingOrder(winningPlayer)
jsonResponse['hand'] = self.hand
jsonResponse['winningCard'] = winningMove.card
jsonResponse['winningPlayerId'] = winningPlayer.id
jsonResponse['scores'] = scores
self.writer.sendMessage(jsonResponse)
def isReady(self, handler, request):
if self.hand.isComplete() == False:
player = self.cardGame.getNextPlayer(self.hand.getStep())
if player.id == request['playerId']:
message = {}
message['response'] = 'askMove'
handler.sendMessage(message)
else:
winningMove = self.hand.decideWinner(self.cardGame.trumpSuit)
pointsWon = self.hand.getHandPoints()
winningPlayer = winningMove.getPlayer()
self.hand = HandInfo()
logging.debug("Winner is %s\n", winningPlayer)
self.scores.registerWin(winningPlayer, pointsWon)
scores = self.scores.getScores()
self.cardGame.changePlayingOrder(winningPlayer)
message = {'response' : 'handPlayed'}
message['winningCard'] = winningMove.card
message['winningPlayerId'] = winningPlayer.id
message['scores'] = scores
self.broadcast(message)
def makeMove(self, handler, req):
try:
player = self.cardGame.getPlayerById(req['playerId'])
playedCard = Card(req['suit'], req['rank'])
playerMove = PlayerMove(player, playedCard)
validMove = self.hand.validatePlayerMove(playerMove, self.cardGame.trumpSuit)
if not validMove:
response = {'response': 'invalidMove', 'playerId': req['playerId']}
handler.sendMessage(response)
else:
self.hand.addPlayerMove(playerMove)
player.removeCard(playedCard)
message = {}
message['response'] = 'moveMade'
message['hand'] = self.hand
message['id'] = player.id
self.broadcast(message)
except Exception as ex:
self.writer.sendError(ex)
raise
def isReady_old(self, handler, req):
self.readyQueue.append(handler)
if len(self.readyQueue) >= 4:
self.isReady_all()
def broadcast(self, message):
for handler in self.handlerQueue:
handler.sendMessage(message)
def isReady_all(self):
try:
if self.scores.isGameDecided():
scores = self.scores.getScores()
winningTeam = self.scores.getWinningTeam()
self.cardGame.processWin(winningTeam)
response = {'response': 'gameDecided', 'scores': scores,
'winningTeam': winningTeam}
self.broadcast(response)
else:
self.hand = HandInfo()
except Exception as ex:
#self.writer.sendError(ex)
raise
import numpy as np
#import xrange
from game import CardGame, Deck, Player
from mc import MonteCarloLearning
CARDS_IN_DECK = {0.25: 16, 0.50: 28, 0.75: 16}
NUM_PLAYERS = 2
HAND_SIZE = 5
ACTIONS = ['small_spoil', 'median', 'large_max']
NUM_GAMES_TO_PLAY = 2000000
deck = Deck(CARDS_IN_DECK)
card_game = CardGame(deck, NUM_PLAYERS, ACTIONS, HAND_SIZE)
def play_action(card_showing, player):
if card_showing == 0: # player goes first
if player.next_action == ACTIONS.index('small_spoil'):
card_value = player.play_card(0)
elif player.next_action == ACTIONS.index('large_max'):
card_value = player.play_card(-1)
else:
card_value = player.play_card(card_game.hand_size // 2)
else: # opponent went first, player's turn
if player.next_action == ACTIONS.index('small_spoil'):
for c, card in enumerate(player.hand):
if card + card_showing > 1.0: # can spoil, play this card
card_value = player.play_card(c)
