def updateLocation(gID,
uID,
value,
card=False): #moves a player to new position
#value can be value of a roll, or a special card e.g. jail, go, free parking
player = r.getPlayers(gID)[uID]
board = r.getBoard(gID)
prevPos = player['public']['position']
GO = False
if value == "GTJ":
newPos = 10
player['public']['jail']['boolean'] = True
alert = {}
alert['boolean'] = True
alert['alert'] = "IN JAIL"
board[prevPos]['playersOn'].remove(player["public"]['number'])
board[newPos]['playersOn'].append(player["public"]['number'])
r.setBoard(gID, board)
player['public']['position'] = newPos
r.setPlayer(gID, uID, player)
return alert
if card:
newPos = int(value)
if newPos > 39:
game = r.getGame(gID)
amount = game['GO']
incrementMoney(gID, uID, amount)
newPos = newPos - 40
GO = True
else:
newPos = prevPos + value
if newPos > 39:
game = r.getGame(gID)
amount = game['GO']
incrementMoney(gID, uID, amount)
newPos = newPos - 40
GO = True
board[prevPos]['playersOn'].remove(player['public']['number'])
board[newPos]['playersOn'].append(player['public']['number'])
r.setBoard(gID, board)
player['public']['position'] = newPos
r.setPlayer(gID, uID, player)
alert = analysePosition(gID, uID, board, newPos) #checking position
if GO:
alert["GO"] = GO
return alert
def giveGOOJF(gID, uID, deckType):
player = r.getPlayers(gID)[uID]
game = r.getGame(gID)
game['takenGOOJF'][deckType] = True
player['public']['GOOJF'][deckType] = True
r.setPlayer(gID, uID, player)
r.setGame(gID, game)
def initTrade(gID, uID, playerNumber, jOffer, jFor):
alert = {}
alert["boolean"] = False
game = r.getGame(gID)
players = r.getPlayers(gID)
trader = players[uID]
receiver = None
_uID = None
for ID in players:
if players[ID]['public']['number'] == playerNumber:
receiver = players[ID]
_uID = ID
alert = mCannotTrade(gID, trader, receiver, jOffer, jFor)["boolean"]
if not alert["boolean"]:
alert = pCannotTrade(gID, jOffer, jFor)
if not alert["boolean"]:
tID = helpers.genID()
offer = {}
offer["from"] = {}
offer["to"] = {}
offer["from"]["number"] = trader['public']['number']
offer["from"]["name"] = trader['public']['name']
offer["to"]["number"] = receiver['public']['number']
offer["to"]["name"] = receiver['public']['name']
offer['offered'] = jOffer
offer['for'] = jFor
game['trade'][tID] = offer
trader["trade"]["sent"][tID] = {"pending": receiver["public"]["name"]}
receiver["trade"]["recieved"] += tID
r.setPlayer(gID, _uID, receiver)
r.setPlayer(gID, uID, trader)
r.setGame(gID, game)
return alert
def rentCalculator(gID, property):
# calculates rent for a specific property <deed>
playerProp = None
players = r.getPlayers(gID)
for _uID in players:
if players[_uID]['public']['number'] == property['owner']:
playerProp = players[_uID]['public']['properties']
break
if property["group"] == "transport":
rentFactor = 2**(len(playerProp[property["group"]]["owned"]) - 1)
rent = property["rent"] * rentFactor
elif property["group"] == "services":
game = r.getGame(gID)
rollValue = game["lastRoll"]["value"]
if len(playerProp[property["group"]]["owned"]) == 1:
rent = rollValue * 4
else:
rent = rollValue * 10
elif property['buildings'] > 0:
if property["buildings"] == 5:
rent = property["hotel"]
else:
rent = property["house" + str(property['buildings'])]
else:
rent = property['rent']
if len(playerProp[property['group']]['owned']) == playerProp[
property['group']]['size']:
rent = rent * 2
return rent
def killPlayer(gID, uID):
game = r.getGame(gID)
players = r.getPlayers(gID)
players[uID]["options"] = []
players[uID]["state"] = "spect"
game["spect"].append(players[uID]["public"]["number"])
r.setGame(gID, game)
r.setPlayers(gID, players)
def canStart(gID, uID): #checks to see if starting is a viable option
game = r.getGame(gID)
players = r.getPlayers(gID)
if players[uID]['public']['number'] == 1:
if game['playersNo'] > 1:
if game['playersNo'] == 8 - len(game['figurines']):
return True
return False
def roll(json):
# rolling a dice
gID = json['gID']
uID = json['uID']
roll = double_roll()
game = r.getGame(gID)
game['lastRoll'] = roll
r.setGame(gID, game)
if inJail(gID, uID) and not roll['double']:
player = r.getPlayers(gID)[uID]
if player["public"]["jail"]["turn"] == 4:
alert = payToGOOJ(gID, uID, player)
if alert["boolean"]:
#kill player
pass
else:
getOutOfJail(gID, uID)
if player["public"]["jail"]["turn"] == 3:
alert = payToGOOJ(gID, uID, player)
if alert["boolean"]:
ret = helpers.getReturnData(gID, uID, ["ROLLED"], ['ROLL'],
alert['alert'])
return ret
else:
getOutOfJail(gID, uID)
if inJail(gID, uID):
player['public']['jail']['turn'] += 1
incrementTurn(gID)
r.setPlayer(gID, uID, player)
ret = helpers.getReturnData(gID, uID, [], ['ROLL'])
return ret
elif inJail(gID, uID) and roll['double']:
getOutOfJail(gID, uID)
alert = updateLocation(gID, uID, roll['value'])
if "card" in alert:
card = alert["card"]
else:
card = False
if alert['boolean']:
ret = helpers.getReturnData(gID, uID, [], ['ROLL'], alert['alert'],
card)
if alert["alert"] == "IN JAIL":
incrementTurn(gID)
return ret
else:
return ret
elif "activity" in alert:
if alert['activity'] == "rent":
ret = helpers.getReturnData(gID, uID, [], ['ROLL'],
alert['activity'], card)
incrementTurn(gID)
return ret
elif card == False:
ret = helpers.getReturnData(gID, uID, ["ROLLED"], ['ROLL'])
return ret
def checkTurn(gID, uID):
#checks to see if it's the player's turn
game = r.getGame(gID)
player = r.getPlayers(gID)[uID]
if (player['public']['number'] == game['turn']):
if player['state'] == 'spect':
incrementTurn(gID)
checkTurn(gID, uID)
return True
else:
return False
def incrementTurn(gID):
# goes to next turn (also accounts for double rolls)
game = r.getGame(gID)
if not game['lastRoll']['double']:
turn = game['turn'] + 1
if turn > game['playersNo']:
turn = turn - game['playersNo']
game['turn'] = turn
r.setGame(gID, game)
return True
else:
return False
def declineTrade(gID, uID, tID):
game = r.getGame(gID)
players = r.getPlayers(gID)
player = r.getPlayers(gID)[uID]
sender = game["trade"][tID]["from"]["number"]
game["trade"].pop(tID, None)
r.setGame(gID, game)
_uID = None
for ID in players:
if players[ID]['public']["number"] == sender:
sender = players[ID]
_uID = ID
sender["trade"]["sent"][tID] = {"declined": player["public"]["name"]}
r.setPlayer(gID, _uID, sender)
def acceptTrade(gID, uID, tID):
alert = {}
alert["boolean"] = False
game = r.getGame(gID)
trade = game['trade'][tID]
players = r.getPlayers(gID)
player = players[uID]
_uID = None
sendingPlayer = trade[tID]["from"]["number"]
for ID in players:
if players[ID]['public']["number"] == sendingPlayer:
sendingPlayer = players[ID]
_uID = ID
break
alert = mCannotTrade(gID, sendingPlayer, player, trade["offered"],
trade["for"])
if not alert["boolean"]:
sTotal = alert["sTotal"]
rTotal = alert["rTotal"]
decrementMoney(gID, uID, alert["rMortgage"])
decrementMoney(gID, _uID, alert["sMortgage"])
if sTotal > rTotal:
alert = pay(gID, _uID, sendingPlayer["public"]["number"],
sTotal - rTotal)
elif rTotal > sTotal:
alert = pay(gID, uID, player["public"]["number"], rTotal - sTotal)
if "property" in trade["offered"]:
for pID in trade["offered"]["property"]:
tradeProp(gID, uID, _uID, pID, player, sendingPlayer)
if "property" in trade["for"]:
for pID in trade["for"]["property"]:
tradeProp(gID, _uID, uID, pID, sendingPlayer, player)
if "GOOJF" in trade["offered"]:
sendingPlayer["public"]["GOOJF"][trade["offered"]["GOOJF"]] = False
giveGOOJF(gID, uID, trade["offered"]["GOOJF"])
if "GOOJF" in trade["for"]:
player["public"]["GOOJF"][trade["for"]["GOOJF"]] = False
giveGOOJF(gID, _uID, trade["for"]["GOOJF"])
if not alert["boolean"]:
sendingPlayer["trade"]["sent"][tID] = {
"accepted": player["public"]["name"]
}
r.setPlayer(gID, _uID, sendingPlayer)
return alert
def join(json, gID=None):
#sets a player
ret = {}
if gID == None:
if "gID" in json:
gID = json['gID']
else:
gID = helpers.getfirstPublicGame()
try:
game = r.getGame(gID)
if game['playersNo'] == 8:
ret['error'] = 'Game is full. Try again.'
else:
game['playersNo'] += 1
uID = helpers.genID()
player = {}
player['uID'] = uID
player["state"] = "active"
player['money'] = getInitJson()['startMoney']
player['options'] = []
player["trade"] = {}
player["trade"]["sent"] = {}
player["trade"]["recieved"] = []
player['public'] = {}
player['public']['name'] = json['name']
player['public']['number'] = game['playersNo']
player['public']['properties'] = getPlayerPropertiesDict()
player['public']['GOOJF'] = {
"CommunityChest": False,
"Chance": False,
}
player['public']['position'] = 0
player['public']['figurine'] = None
player['public']['jail'] = {}
player['public']['jail']['boolean'] = False
player['public']['jail']['turn'] = 0
player["canBuy"] = None
r.setPlayer(gID, uID, player)
r.setGame(gID, game)
ret = helpers.getReturnData(gID, uID, ["FIGURINE"])
except:
ret['error'] = 'join'
return ret
def game(json):
ret = {'error': 'game'}
isTurn = checkTurn(json['gID'], json['uID'])
if r.validateUID(json['gID'], json['uID']):
if json['request'] == "PING":
ret = ping(json, isTurn)
if json['request'] == "CHAT":
ret = chat(json)
elif isTurn and json['request'] in r.getPlayers(
json['gID'])[json['uID']]['options']:
if "ROLLED" not in r.getPlayers(json['gID'])[
json['uID']]['options'] and json['request'] == "ROLL":
ret = roll(json)
elif json['request'] == 'BUY':
ret = buy(json)
elif json['request'] == 'AUCTION':
ret = auction(json)
elif json['request'] == 'MORTGAGE':
ret = mortgage(json)
elif json['request'] == "BUILD":
ret = build(json)
elif json['request'] == 'SELL':
ret = build(json, True)
elif json['request'] == 'TRADE':
ret = trade(json)
elif json['request'] == 'GOOJF':
ret = getOutOfJail(json['gID'], json['uID'], True)
elif json['request'] == 'PAYMORT':
ret = payMort(json)
elif json["request"] == "PGOOJ":
ret = payGetOutOfJail(json['gID'], json['uID'])
if gameOver(json['gID']):
game = r.getGame(json['gID'])
game['state'] = "FINISHED"
r.setGame(json["gID"], game)
return ret
def start(json):
#initialises the board and starts the game
gID = json['gID']
uID = json['uID']
if canStart(gID, uID):
game = r.getGame(gID)
game['state'] = "PLAYING"
r.setGame(gID, game)
_start(gID)
players = r.getPlayers(
gID) #add the default options for the PLAYING state to all players
for _uID in players:
players[_uID]["options"].append("TRADE")
players[_uID]["options"].append("MORTGAGE")
r.setPlayers(gID, players)
ret = helpers.getReturnData(gID, uID, ["ROLL"], ["START"])
else:
ret = {}
ret['error'] = "START"
return ret
def auction(json):
# moves the game state into an auction for 30 seconds
gID = json['gID']
uID = json['uID']
players = r.getPlayers(gID)
player = players[uID]
pID = json["pID"]
if player["canBuy"] == pID:
deed = r.getDeeds(gID)[pID]
for _uID in players:
players[_uID]['options'] += ["BID"]
r.setPlayer(gID, _uID, players[_uID])
game = r.getGame(gID)
game['auction'] = {}
game['auction']['pID'] = pID
game['auction']['highest'] = {0: deed['price'] / 2}
game['auction']['out'] = []
game['lastActivity'] = helpers.getTime()
game['state'] = "AUCTION"
r.setGame(gID, game)
ret = helpers.getReturnData(gID, uID, [], ["AUCTION", "BUY"])
return ret
def drawCard(gID, uID):
alert = {}
alert['boolean'] = False
game = r.getGame(gID)
board = r.getBoard(gID)
player = r.getPlayers(gID)[uID]
pos = player['public']['position']
cardType = board[pos]['name']
cardNumber = drawFromDeck()
takenGOOJF = game['takenGOOJF'][cardType]
if takenGOOJF and cardNumber == 0:
cardNumber += 1
if cardType == "CommunityChest":
deck = getCommChestJson()
else:
deck = getChanceJson()
deck = helpers.keyStringtoInt(deck)
card = deck[cardNumber - 1]
alert = processCard(gID, uID, card, cardType)
alert['card'] = card
return alert
def getOutOfJail(gID, uID, card=False):
ret = None
if card:
player = r.getPlayers(gID)[uID]
if inJail(gID, uID) and (player['public']['GOOJF']['CommunityChest']
or player['public']['GOOJF']['Chance']):
deck = None
if player['public']['GOOJF']['CommunityChest']:
deck = "CommunityChest"
elif player['public']['GOOJF']['Chance']:
deck = "Chance"
player['public']['GOOJF'][deck] = False
game = r.getGame(gID)
game['takenGOOJF'][deck] = False
r.setGame(gID, game)
ret = helpers.getReturnData(gID, uID)
else:
ret = helpers.getReturnData(gID, uID, [], [], "INVALID USE")
player = r.getPlayers(gID)[uID]
player['public']['jail']['boolean'] = False
player['public']['jail']['turn'] = 0
r.setPlayer(gID, uID, player)
if card:
return ret
def getGameState(gID):
return r.getGame(gID)['state']
def getReturnData(gID,
uID,
optionsToAdd=[],
optionsToRemove=[],
alert={},
card=False):
ret = {}
game = r.getGame(gID)
players = r.getPlayers(gID)
player = players[uID]
ret['players'] = {}
for _uID in players:
ret['players'][players[_uID]['public']
['name']] = players[_uID]['public']
if game['state'] != "LOBBY":
ret['board'] = r.getBoard(gID)
ret['deeds'] = r.getDeeds(gID)
ret["chat"] = r.getChat(gID)
ret["trade"] = {}
if len(player["trade"]["recieved"]) > 0:
ret["trade"]["recieved"] = player["trade"]["recieved"][0]
if len(player["trade"]["sent"]) > 0:
for tID in player["trade"]["sent"]:
if player["trade"]["sent"][tID] == "declined":
game["trade"].pop(tID, None)
ret["trade"]["sent"] = player["trade"]["sent"][tID][
"declined"] + "declined your trade offer"
player["trade"]["sent"].pop(tID, None)
r.setPlayer(gID, uID, player)
r.setGame(gID, game)
break
if player["trade"]["sent"][tID] == "accepted":
game["trade"].pop(tID, None)
ret["trade"]["sent"] = player["trade"]["sent"][tID][
"accepted"] + "accepted your trade offer"
player["trade"]["sent"].pop(tID, None)
r.setPlayer(gID, uID, player)
r.setGame(gID, game)
break
if len(optionsToAdd) + len(optionsToRemove) > 0:
for option in optionsToAdd:
if option not in player['options']:
player['options'] += [option]
for option in optionsToRemove:
try:
if option == "BUY":
player["canBuy"] = None
player['options'].remove(option)
except:
pass
r.setPlayer(gID, uID, player)
ret['options'] = player['options']
if len(alert) != 0:
ret['alert'] = alert
if card:
ret['card'] = card
ret['game'] = game
ret['player'] = player
# if game['state'] != "LOBBY" and (game["turn"] == player["public"]["number"]):
# print ("Return Data")
# print("name: " + player["public"]["name"])
# print("turn: " + str(game["turn"]))
# print("options: " + str(ret['options']))
# if "card" in ret:
# print (card['type'])
# if 'alert' in ret:
# print (alert)
# print("")
return ret
def gameOver(gID):
return len(r.getGame(gID)["spect"]) == r.getGame(gID)["playersNo"] - 1
def bid(json):
gID = json['gID']
uID = json['uID']
if r.validateUID(json['gID'], json['uID']):
game = r.getGame(gID)
players = r.getPlayers(gID)
player = players[uID]
hBidder = None
for key in game['auction']['highest']:
hBidder = key
hBidAmount = game['auction']['highest'][hBidder]
def close():
if hBidder == None or int(hBidder) == 0:
for _uID in players:
players[_uID]['options'].remove("BID")
if "AUCTION" in players[_uID]["options"]:
players[_uID]['options'].remove("AUCTION")
if "BUY" in players[_uID]["options"]:
players[_uID]['options'].remove("BUY")
players[_uID]["canBuy"] = None
r.setPlayers(gID, players)
game['state'] = "PLAYING"
r.setGame(gID, game)
incrementTurn(gID)
return helpers.getReturnData(gID, uID)
if int(hBidder) != 0:
payUID = None
for _uID in players:
if players[_uID]["public"]["number"] == int(hBidder):
payUID = _uID
break
alert = pay(gID, payUID, 0, hBidAmount)
if not alert['boolean']:
deed = r.getDeeds(gID)[game['auction']['pID']]
giveProperty(gID, payUID, deed)
for _uID in players:
players[_uID]['options'].remove("BID")
if "AUCTION" in players[_uID]["options"]:
players[_uID]['options'].remove("AUCTION")
if "BUY" in players[_uID]["options"]:
players[_uID]['options'].remove("BUY")
players[_uID]["canBuy"] = None
r.setPlayers(gID, players)
game['state'] = "PLAYING"
r.setGame(gID, game)
incrementTurn(gID)
return helpers.getReturnData(gID, uID)
else:
return helpers.getReturnData(gID, uID, [], [],
alert['alert'])
if not helpers.checkTime(game['lastActivity'], 30, True):
return close()
elif json['request'] == "PING":
pass
elif json['request'] == "BID" and player['public'][
'number'] not in game['auction']['out']:
if (json['amount'] > hBidAmount) and (json['amount'] <=
player['money']):
newBid = {player['public']['number']: json['amount']}
game['auction']['highest'] = newBid
r.setGame(json['gID'], game)
else:
return helpers.getReturnData(gID, uID, [], [],
"INSUFFICIENT FUNDS")
elif json['request'] == "OUT":
if hBidder != player['public']['number']:
game['auction']['out'].append(player['public']['number'])
r.setGame(json['gID'], game)
if len(game['auction']['out']) >= game['playersNo'] - 1 - len(
game['spect']):
return close()
return helpers.getReturnData(gID, uID)
def housingShortage(gID):
# returns true if there are no houses to be bought
return r.getGame(gID)['buildings'] != 0