def add(player):
flag = PlayerDao.addPlayer(player)
if flag == 1:
player_id = PlayerDao.queryIdByEmail(getattr(player, '__player_email'))
GameDao.addPerformance(player_id)
print "Add player successfully !!!"
else:
print "Add player failure !!!"
pass
def play1v1Game(self, bronze1v1PlayerInfo, silver1v1PlayerInfo, gold1v1PlayerInfo,
platinum1v1PlayerInfo, diamond1v1PlayerInfo,
master1v1PlayerInfo, grandmaster1v1PlayerInfo, curTime):
# bronze
if len(bronze1v1PlayerInfo) != 0:
for i in range(len(bronze1v1PlayerInfo)):
tempBronzePlayerInfo = bronze1v1PlayerInfo[i]
GameDao.showInfoAfterGame(tempBronzePlayerInfo)
playerGroup = GameDao.gameMatch1v1(tempBronzePlayerInfo)
GameDao.showGroup1v1(playerGroup)
self.printPlayerInfoByLeague(tempBronzePlayerInfo, self.BronzeLeague, curTime)
self.startGame(playerGroup, curTime)
# silver
if len(silver1v1PlayerInfo) != 0:
for i in range(len(silver1v1PlayerInfo)):
tempSilverPlayerInfo = silver1v1PlayerInfo[i]
GameDao.showInfoAfterGame(tempSilverPlayerInfo)
playerGroup = GameDao.gameMatch1v1(tempSilverPlayerInfo)
GameDao.showGroup1v1(playerGroup)
self.printPlayerInfoByLeague(tempSilverPlayerInfo, self.SilverLeague, curTime)
self.startGame(playerGroup, curTime)
# gold
if len(gold1v1PlayerInfo) != 0:
for i in range(len(gold1v1PlayerInfo)):
tempGoldPlayerInfo = gold1v1PlayerInfo[i]
GameDao.showInfoAfterGame(tempGoldPlayerInfo)
playerGroup = GameDao.gameMatch1v1(tempGoldPlayerInfo)
GameDao.showGroup1v1(playerGroup)
self.printPlayerInfoByLeague(tempGoldPlayerInfo, self.GoldLeague, curTime)
self.startGame(playerGroup, curTime)
# platinum
if len(platinum1v1PlayerInfo) != 0:
for i in range(len(platinum1v1PlayerInfo)):
tempPlatinumPlayerInfo = platinum1v1PlayerInfo[i]
GameDao.showInfoAfterGame(tempPlatinumPlayerInfo)
playerGroup = GameDao.gameMatch1v1(tempPlatinumPlayerInfo)
GameDao.showGroup1v1(playerGroup)
self.printPlayerInfoByLeague(tempPlatinumPlayerInfo, self.PlatinumLeague, curTime)
self.startGame(playerGroup, curTime)
# diamond
if len(diamond1v1PlayerInfo) != 0:
for i in range(len(diamond1v1PlayerInfo)):
tempDiamondPlayerInfo = diamond1v1PlayerInfo[i]
GameDao.showInfoAfterGame(tempDiamondPlayerInfo)
playerGroup = GameDao.gameMatch1v1(tempDiamondPlayerInfo)
GameDao.showGroup1v1(playerGroup)
self.printPlayerInfoByLeague(tempDiamondPlayerInfo, self.DiamondLeague, curTime)
self.startGame(playerGroup, curTime)
# master
if len(master1v1PlayerInfo) != 0:
for i in range(len(master1v1PlayerInfo)):
tempMasterPlayerInfo = master1v1PlayerInfo[i]
GameDao.showInfoAfterGame(tempMasterPlayerInfo)
playerGroup = GameDao.gameMatch1v1(tempMasterPlayerInfo)
GameDao.showGroup1v1(playerGroup)
self.printPlayerInfoByLeague(tempMasterPlayerInfo, self.MasterLeague, curTime)
self.startGame(playerGroup, curTime)
# grandmaster
if len(grandmaster1v1PlayerInfo) != 0:
for i in range(len(grandmaster1v1PlayerInfo)):
tempGrandMasterPlayerInfo = grandmaster1v1PlayerInfo[i]
GameDao.showInfoAfterGame(tempGrandMasterPlayerInfo)
playerGroup = GameDao.gameMatch1v1(tempGrandMasterPlayerInfo)
GameDao.showGroup1v1(playerGroup)
self.printPlayerInfoByLeague(tempGrandMasterPlayerInfo, self.GrandMasterLeague, curTime)
self.startGame(playerGroup, curTime)
# end the game for each round
gameResults = self.endGame(curTime)
if len(gameResults) > 0:
GameDao.show1v1GameRes(gameResults)
GameDao.upDatePerformance(gameResults)
def dynamicGroup2v2(self, playerIdList, curTime):
print "isInGame:" + str(self.gamingPool2v2) + " at curTime = " + str(curTime)
# query the league using player_id, the output = [[player_id, score, league],..]
res = GameDao.queryScoreAndLeague(playerIdList)
print res
# put the current [player_id, score] into the corresponding deque according to his league
bronze2v2PlayerInfo = []
silver2v2PlayerInfo = []
gold2v2PlayerInfo = []
platinum2v2PlayerInfo = []
diamond2v2PlayerInfo = []
master2v2PlayerInfo = []
grandmaster2v2PlayerInfo = []
# at the beginning of each round, we need to copy the players id from high league deque to
# the low league deque according to their waiting time.
# GrandMaster => Master
self.copyPlayerId(self.GrandMaster2v2WaitTime, self.isIn2v2GrandMasterdeque,
self.GrandMaster2v2Deque, self.isIn2v2Masterdeque, self.Master2v2Deque,
self.MasterLeague, curTime, 1)
# Master => Diamond
self.copyPlayerId(self.Master2v2WaitTime, self.isIn2v2Masterdeque,
self.Master2v2Deque, self.isIn2v2Diamonddeque, self.Diamond2v2Deque,
self.DiamondLeague, curTime, 1)
# Diamond => Platinum
self.copyPlayerId(self.Diamond2v2WaitTime, self.isIn2v2Diamonddeque,
self.Diamond2v2Deque, self.isIn2v2Platinumdeque, self.Platinum2v2Deque,
self.PlatinumLeague, curTime, 1)
# Platinum => Gold
self.copyPlayerId(self.Platinum2v2WaitTime, self.isIn2v2Platinumdeque,
self.Platinum2v2Deque, self.isIn2v2Golddeque, self.Gold2v2Deque,
self.GoldLeague, curTime, 1)
# Gold => Silver
self.copyPlayerId(self.Gold2v2WaitTime, self.isIn2v2Golddeque,
self.Gold2v2Deque, self.isIn2v2Silverdeque, self.Silver2v2Deque,
self.SilverLeague, curTime, 1)
# Silver => Bronze
self.copyPlayerId(self.Silver2v2WaitTime, self.isIn2v2Silverdeque,
self.Silver2v2Deque, self.isIn2v2Bronzedeque, self.Bronze2v2Deque,
self.BronzeLeague, curTime, 1)
# add all the current players in their corresponding deque
for i in range(len(res)):
player = res[i]
player_id = player[0]
player_league = player[2]
# GrandMaster
if player_league == self.GrandMasterLeague:
self.isIn2v2GrandMasterdeque[player_id] = curTime
self.GrandMaster2v2Deque.append(player)
# Master
elif player_league == self.MasterLeague:
self.isIn2v2Masterdeque[player_id] = curTime
self.Master2v2Deque.append(player)
# Diamond
elif player_league == self.DiamondLeague:
self.isIn2v2Diamonddeque[player_id] = curTime
self.Diamond2v2Deque.append(player)
# Platinum
elif player_league == self.PlatinumLeague:
self.isIn2v2Platinumdeque[player_id] = curTime
self.Platinum2v2Deque.append(player)
# Gold
elif player_league == self.GoldLeague:
self.isIn2v2Golddeque[player_id] = curTime
self.Gold2v2Deque.append(player)
# Silver
elif player_league == self.SilverLeague:
self.isIn2v2Silverdeque[player_id] = curTime
self.Silver2v2Deque.append(player)
# Bronze
elif player_league == self.BronzeLeague:
self.isIn2v2Bronzedeque[player_id] = curTime
self.Bronze2v2Deque.append(player)
# group the current players for each league deque
# GrandMaster
curGrandMasterLength = len(self.GrandMaster2v2Deque)
while curGrandMasterLength >= self.GrandMaster2v2DequeSize:
curPath = []
for i in range(self.GrandMaster2v2DequeSize):
# current league: GrandMaster
top = self.GrandMaster2v2Deque.popleft()
top_id = top[0]
self.isIn2v2GrandMasterdeque.pop(top_id, None)
# lower league
if top_id in self.isIn2v2Masterdeque:
self.Master2v2Deque.remove(top)
self.isIn2v2Masterdeque.pop(top_id, None)
curPath.append([top[0], top[1]])
grandmaster2v2PlayerInfo.append(curPath)
curGrandMasterLength -= self.GrandMaster2v2DequeSize
# Master
curMasterLength = len(self.Master2v2Deque)
while curMasterLength >= self.Master2v2DequeSize:
curPath = []
for i in range(self.Master2v2DequeSize):
# current league: Master
top = self.Master2v2Deque.popleft()
top_id = top[0]
self.isIn2v2Masterdeque.pop(top_id, None)
# lower league: Diamond
if top_id in self.isIn2v2Diamonddeque:
self.Diamond2v2Deque.remove(top)
self.isIn2v2Diamonddeque.pop(top_id, None)
# upper league: GrandMaster
if top_id in self.isIn2v2GrandMasterdeque:
self.GrandMaster2v2Deque.remove(top)
self.isIn2v2GrandMasterdeque.pop(top_id, None)
curPath.append([top[0], top[1]])
master2v2PlayerInfo.append(curPath)
curMasterLength -= self.Master2v2DequeSize
# Diamond
curDiamondLength = len(self.Diamond2v2Deque)
while curDiamondLength >= self.Diamond2v2DequeSize:
curPath = []
for i in range(self.Diamond2v2DequeSize):
# current league: Diamond
top = self.Diamond2v2Deque.popleft()
top_id = top[0]
self.isIn2v2Diamonddeque.pop(top_id, None)
# lower level: Platinum
if top_id in self.isIn2v2Platinumdeque:
self.Platinum2v2Deque.remove(top)
self.isIn2v2Platinumdeque.pop(top_id, None)
# upper level: Master
if top_id in self.isIn2v2Masterdeque:
self.Master2v2Deque.remove(top)
self.isIn2v2Masterdeque.pop(top_id, None)
curPath.append([top[0], top[1]])
diamond2v2PlayerInfo.append(curPath)
curDiamondLength -= self.Diamond2v2DequeSize
# Platinum
curPlatinumLength = len(self.Platinum2v2Deque)
while curPlatinumLength >= self.Platinum2v2DequeSize:
curPath = []
for i in range(self.Platinum2v2DequeSize):
# current league: Platinum
top = self.Platinum2v2Deque.popleft()
top_id = top[0]
self.isIn2v2Platinumdeque.pop(top_id, None)
# lower league: Gold
if top_id in self.isIn2v2Golddeque:
self.Gold2v2Deque.remove(top)
self.isIn2v2Golddeque.pop(top_id, None)
# upper league: Diamond
if top_id in self.isIn2v2Diamonddeque:
self.Diamond2v2Deque.remove(top)
self.isIn2v2Diamonddeque.pop(top_id, None)
curPath.append([top[0], top[1]])
platinum2v2PlayerInfo.append(curPath)
curPlatinumLength -= self.Platinum2v2DequeSize
# Gold
curGoldLength = len(self.Gold2v2Deque)
while curGoldLength >= self.Gold2v2DequeSize:
curPath = []
for i in range(self.Gold2v2DequeSize):
# current league: Gold
top = self.Gold2v2Deque.popleft()
top_id = top[0]
self.isIn2v2Golddeque.pop(top_id, None)
# lower league: Silver
if top_id in self.isIn2v2Silverdeque:
self.Silver2v2Deque.remove(top)
self.isIn2v2Silverdeque.pop(top_id, None)
# upper league: Platinum
if top_id in self.isIn2v2Platinumdeque:
self.Platinum2v2Deque.remove(top)
self.isIn2v2Platinumdeque.pop(top_id, None)
curPath.append([top[0], top[1]])
gold2v2PlayerInfo.append(curPath)
curGoldLength -= self.Gold2v2DequeSize
# Silver
curSilverLength = len(self.Silver2v2Deque)
while curSilverLength >= self.Silver2v2DequeSize:
curPath = []
for i in range(self.Silver2v2DequeSize):
# current league: Silver
top = self.Silver2v2Deque.popleft()
top_id = top[0]
self.isIn2v2Silverdeque.pop(top_id, None)
# lower league: Bronze
if top_id in self.isIn2v2Bronzedeque:
self.Bronze2v2Deque.remove(top)
self.isIn2v2Bronzedeque.pop(top_id, None)
# upper league: Gold
if top_id in self.isIn2v2Golddeque:
self.Gold2v2Deque.remove(top)
self.isIn2v2Golddeque.pop(top_id, None)
curPath.append([top[0], top[1]])
silver2v2PlayerInfo.append(curPath)
curSilverLength -= self.Silver2v2DequeSize
# Bronze
curBronzeLength = len(self.Bronze2v2Deque)
while curBronzeLength >= self.Bronze2v2DequeSize:
curPath = []
for i in range(self.Bronze2v2DequeSize):
# current league: Bronze
top = self.Bronze2v2Deque.popleft()
top_id = top[0]
self.isIn2v2Bronzedeque.pop(top_id, None)
# upper league: Silver
if top_id in self.isIn2v2Silverdeque:
self.Silver2v2Deque.remove(top)
self.isIn2v2Silverdeque.pop(top_id, None)
curPath.append([top[0], top[1]])
bronze2v2PlayerInfo.append(curPath)
curBronzeLength -= self.Bronze2v2DequeSize
# print the results of each deque
# print "bronzeDeque: " + str(self.Bronze1v1Deque)
# print "silverDeque: " + str(self.Silver1v1Deque)
# print "goldDeque: " + str(self.Gold1v1Deque)
# print "platinumDeque: " + str(self.Platinum1v1Deque)
# print "diamondDeque: " + str(self.Diamond1v1Deque)
# print "masterDeque: " + str(self.Master1v1Deque)
# print "grandmasterDeque: " + str(self.GrandMaster1v1Deque)
# return the results
return bronze2v2PlayerInfo, silver2v2PlayerInfo, gold2v2PlayerInfo, \
platinum2v2PlayerInfo, diamond2v2PlayerInfo, \
master2v2PlayerInfo, grandmaster2v2PlayerInfo
def start4v4Game(num_player):
playerInfo = GameDao.selectPlayers(num_player)
print "================================================================"
print " The following players are going to play the 4v4 game: "
GameDao.showInfoAfterGame(playerInfo)
playerGroup = GameDao.gameMatch4v4(playerInfo)
GameDao.showGroup4v4(playerGroup)
gameResults, groupRes = GameDao.genGame2v2Results(playerGroup)
GameDao.show4v4GameRes(groupRes, playerGroup)
GameDao.upDatePerformance(gameResults)
print "================================================================"
print " The Info of the players after the game: "
GameDao.showInfoAfterGame(playerInfo)
pass
def start1v1Game(num_player):
playerInfo = GameDao.selectPlayers(num_player)
print "================================================================"
print " The following players are going to play the 1v1 game: "
GameDao.showInfoAfterGame(playerInfo)
playerGroup = GameDao.gameMatch1v1(playerInfo)
GameDao.showGroup1v1(playerGroup)
gameResults = GameDao.genGame1v1Results(playerGroup)
GameDao.show1v1GameRes(gameResults)
GameDao.upDatePerformance(gameResults)
print "================================================================"
print " The Info of the players after the game: "
GameDao.showInfoAfterGame(playerInfo)
pass
def startGame(num_player):
playerInfo = GameDao.selectPlayers(num_player)
# print playerInfo
# playerInfo = [[4, 200], [8, 1200], [10, 400], [16, 1400]]
print "================================================================"
print " The following players are going to play the game: "
GameDao.showInfoAfterGame(playerInfo)
resList = GameDao.showPlayerInfo(playerInfo)
playerGroup = GameDao.gameMatching(playerInfo)
GameDao.showGroupedPlayerInfo(playerGroup, resList)
gameResults, groupRes = GameDao.genGameResults(playerGroup)
GameDao.showGroupRes(groupRes)
GameDao.upDatePerformance(gameResults)
print "================================================================"
print " The Info of the players after the game: "
GameDao.showInfoAfterGame(playerInfo)
def queryComplete():
res = GameDao.queryCompleteInfo()
return res
pass