def createGames_Swiss(tourney_id, tourney_clotconfig):
"""This is called periodically to check if a round has finished. If so, new games are created.
the 'swiss' part is that we match players based on ranking - we match players with similar
rankings who have not yet played each other. if there are an odd number of players,
then someone randomly misses a game (and we prefer players who have not yet missed a game) """
logging.info('')
logging.info('in createGames_Swiss()')
if main.hasTourneyFinished(tourney_id, tourney_clotconfig):
logging.info('swiss tourney has finished')
return
#Retrieve all games that are ongoing
activeGames = list(games.Game.all().filter("winner =", None).filter("tourney_id =", tourney_id)) ###.run(batch_size=1000))
activeGameIDs = dict([[g.key().id(), g] for g in activeGames])
logging.info("Active games: " + str(activeGameIDs))
if activeGames:
logging.info('games still in progress. cannot start next round until these games finish.')
else:
logging.info('no games in progress. so we move on to the next round.')
if main.getRoundNumber(tourney_id, tourney_clotconfig) == main.getNumRounds(tourney_id, tourney_clotconfig):
main.endTourney(tourney_id, tourney_clotconfig)
logging.info('')
logging.info('all rounds have been played, so TOURNAMENT IS OVER !!!!!!!!!!!!!!')
logging.info('')
return
players_ids_matched_list = getMatchedList_Swiss(tourney_id)
if not players_ids_matched_list:
main.endTourney(tourney_id, tourney_clotconfig)
logging.info('')
logging.info('seems everyone has played everyone else, so TOURNAMENT IS OVER !!!!!!!!!!!!!!')
logging.info('')
return
players_ids_names_dict = dict([[gp.player_id, gp] for gp in players.Player.all().filter("tourney_id =", tourney_id)]) ###.run(batch_size=1000)])
logging.info('players_ids_names_dict')
logging.info(players_ids_names_dict)
players_names_matched_list = [players_ids_names_dict[i] for i in players_ids_matched_list]
#The template ID defines the settings used when the game is created. You can create your own template on warlight.net and enter its ID here
templateID = main.getTemplateID(tourney_id, tourney_clotconfig)
#Create a game for everyone not in a game.
gamesCreated = [games.createGame(pair, templateID, tourney_id) for pair in clot.pairs(players_names_matched_list)]
logging.info("Created games " + str(gamesCreated))
main.incrementRoundNumber(tourney_id, tourney_clotconfig)
logging.info("\n ------------------------------------ \n swiss tourney round " + str(main.getRoundNumber(tourney_id, tourney_clotconfig))+ " starting. \n ---------------------------")
logging.info('')
def createGames_RandomMatchup(tourney_id):
"""This is called periodically to check for new games that need to be created.
You should replace this with your own logic for how games are to be created.
Right now, this function just randomly pairs up players who aren't in a game."""
#Retrieve all games that are ongoing
activeGames = list(games.Game.all().filter("winner =", None).filter("tourney_id =", tourney_id))
activeGameIDs = dict([[g.key().id(), g] for g in activeGames])
logging.info("Active games: " + str(activeGameIDs))
#Throw all of the player IDs that are in these ongoing games into a dictionary
playerIDsInGames = dict([[gp.playerID, gp] for gp in games.GamePlayer.all().filter("tourney_id =", tourney_id) if gp.gameID in activeGameIDs])
#Find all players who aren't in the dictionary (and therefore aren't in any games) and also have not left the CLOT (isParticipating is true)
allPlayers = players.Player.all().filter("tourney_id =", tourney_id)
all_players_vec = [p for p in allPlayers]
logging.info("all_players_vec: ")
logging.info(all_players_vec)
all_players_keys_ids_vec = [p.key().id() for p in allPlayers]
logging.info("all_players_keys_ids_vec: " + str(all_players_keys_ids_vec))
player_ids_in_games_vec = [p for p in playerIDsInGames]
logging.info("player_ids_in_games_vec: " + str(player_ids_in_games_vec))
playersNotInGames = [p for p in allPlayers if p.isParticipating and p.key().id() not in playerIDsInGames]
logging.info("Players not in games: ")
logging.info(playersNotInGames)
#Randomize the order
random.shuffle(playersNotInGames)
#debug
random.shuffle(playersNotInGames)
logging.info("new player order is: ")
logging.info(playersNotInGames)
for pair in clot.pairs(playersNotInGames):
logging.info(pair)
random.shuffle(playersNotInGames)
logging.info("new player order is: ")
logging.info(playersNotInGames)
for pair in clot.pairs(playersNotInGames):
logging.info(pair)
#end of debug
#The template ID defines the settings used when the game is created. You can create your own template on warlight.net and enter its ID here
templateID = main.getTemplateID(tourney_id)
#Create a game for everyone not in a game.
gamesCreated = [games.createGame(pair, templateID, tourney_id) for pair in clot.pairs(playersNotInGames)]
logging.info("Created games " + str(gamesCreated))
def createGames_RoundRobin(tourney_id):
"""This is called periodically to check for new games that need to be created.
the roundrobin part is that we want everyone to play everyone else.
so the players not currently in games are just paired up with each other,
so long as they have not yet played each other.
"""
logging.info('')
logging.info('in createGames_RoundRobin()')
if main.hasTourneyFinished(tourney_id):
logging.info('round robin tourney has finished')
return
#Retrieve all games that are ongoing
activeGames = list(games.Game.all().filter("winner =", None).filter("tourney_id =", tourney_id))
activeGameIDs = dict([[g.key().id(), g] for g in activeGames])
logging.info("Active games: " + str(activeGameIDs))
#Throw all of the player IDs that are in these ongoing games into a dictionary
playerIDsInGames = dict([[gp.playerID, gp] for gp in games.GamePlayer.all().filter("tourney_id =", tourney_id) if gp.gameID in activeGameIDs])
#Find all players who aren't in the dictionary (and therefore aren't in any games) and also have not left the CLOT (isParticipating is true)
allPlayers = players.Player.all().filter("tourney_id =", tourney_id)
all_players_vec = [p for p in allPlayers]
logging.info("all_players_vec: ")
logging.info(all_players_vec)
all_players_keys_ids_vec = [p.key().id() for p in allPlayers]
logging.info("all_players_keys_ids_vec: " + str(all_players_keys_ids_vec))
player_ids_in_games_vec = [p for p in playerIDsInGames]
logging.info("player_ids_in_games_vec: " + str(player_ids_in_games_vec))
playersNotInGames = [p for p in allPlayers if p.isParticipating and p.key().id() not in playerIDsInGames]
logging.info("Players not in games: ")
logging.info(playersNotInGames)
#------------------------
#now pair up players who are not in games. IF they have not played each otehr yet.
#get the head-to-head matrix, so we can see who has played who
head_to_head_biggermat, head_to_head_2d = new_utility_functions.getHeadToHeadTable(tourney_id)
##logging.info('head_to_head_2d:')
##logging.info(head_to_head_2d)
#
the_ids = deepcopy(head_to_head_biggermat[0][1:])
logging.info('the_ids:')
logging.info(the_ids)
#Randomize the order
random.shuffle(playersNotInGames)
#loop over all possible pairs, and pair IF they have not played each other yet
paired_yet = [False]*len(playersNotInGames)
list_for_pairing = []
for i in range(0,len(playersNotInGames)-1):
if not paired_yet[i]:
pi = playersNotInGames[i]
pi_id = int(pi.player_id)
pi_index = the_ids.index(pi_id) #find where in the head-to-head matrix this player is.
logging.info('pi:')
logging.info(pi)
logging.info(pi_id)
logging.info(pi_index)
for j in range(i+1,len(playersNotInGames)):
if (not paired_yet[j]) and (not paired_yet[i]):
pj = playersNotInGames[j]
pj_id = int(pj.player_id)
pj_index = the_ids.index(pj_id) #find where in the head-to-head matrix this player is.
logging.info('pj:')
logging.info(pj)
logging.info(pj_id)
logging.info(pj_index)
if (head_to_head_2d[pi_index][pj_index][0]==0) and (head_to_head_2d[pj_index][pi_index][0]==0):
#they have not played each other.
#so match them.
paired_yet[i] = True
paired_yet[j] = True
list_for_pairing.append(pi)
list_for_pairing.append(pj)
logging.info('paired '+str(pi)+' '+str(pj))
##debug
logging.info("new player order is: ")
logging.info(list_for_pairing)
for pair in clot.pairs(list_for_pairing):
logging.info(pair)
##end of debug
#The template ID defines the settings used when the game is created. You can create your own template on warlight.net and enter its ID here
templateID = main.getTemplateID(tourney_id)
#Create a game for everyone not in a game.
gamesCreated = [games.createGame(pair, templateID, tourney_id) for pair in clot.pairs(list_for_pairing)]
logging.info("Created games " + str(gamesCreated))
if (len(activeGames)==0) and (len(list_for_pairing)==0):
if main.isTourneyInPlay(tourney_id):
#tourney is in play, but no games are going on, and we found no games we could create.
#so the tourney is over
main.endTourney(tourney_id)
logging.info('')
logging.info('all games have been played, so TOURNAMENT IS OVER !!!!!!!!!!!!!!')
logging.info('')
def index_new(request,tourney_id):
"""Request / """
logging.info('in index_new(' +str(tourney_id)+ ')')
tourney_id = int(tourney_id)
logging.info('tourney_id = '+str(tourney_id))
tourney_clotconfig = main.getClotConfig(tourney_id)
if not main.doesTourneyExist(tourney_id, tourney_clotconfig):
logging.info('tourney does not exist, redirecting user to tourneys info instead')
return shortcuts.render_to_response('tourney_does_not_exist.html' )
#arrange players by rank
the_players = players.Player.all().filter("tourney_id =", tourney_id)#.run(batch_size=1000)
the_players = sorted(the_players, key=lambda z: z.currentRank)
gamePlayers = main.group(games.GamePlayer.all().filter("tourney_id =", tourney_id), lambda z: z.gameID) #.run(batch_size=1000)
#arrange games by reverse of created date
the_games = games.Game.all().filter("tourney_id =", tourney_id)#.run(batch_size=1000)
the_games = sorted(the_games, key=lambda z: z.dateCreated, reverse=True)
#for game in the_games:
# logging.info('game: '+str(game))
# logging.info('game.winningTeamName = '+str(game.winningTeamName))
#do the head-to-head table
biggermat, head_to_head_2d = new_utility_functions.getHeadToHeadTable(tourney_id)
biggermat_str = deepcopy(biggermat)
for i in range(1,len(biggermat_str)):
for j in range(1,len(biggermat_str[i])):
if i==j:
biggermat_str[i][j] = "---"
else:
biggermat_str[i][j] = str(biggermat_str[i][j][0]) + "-" + str(biggermat_str[i][j][1])
#see if players are gated
players_gated_string = "players may join or leave"
if main.arePlayersGated(tourney_id, tourney_clotconfig):
players_gated_string = "players may NOT join or leave"
#get tourney_status_string
tourney_status_string = 'Tourney Not Yet Started'
if main.isTourneyInPlay(tourney_id, tourney_clotconfig):
if str(main.getTourneyType(tourney_id, tourney_clotconfig)) == 'swiss':
tourney_status_string = 'Tourney In Progress. Round '+str(main.getRoundNumber(tourney_id, tourney_clotconfig))+' of '+str(main.getNumRounds(tourney_id, tourney_clotconfig))
else:
tourney_status_string = 'Tourney In Progress.'
elif main.hasTourneyFinished(tourney_id, tourney_clotconfig):
winner = the_players[0]
winner_name = winner.name
tourney_status_string = 'Tourney has finished. Congratulations to '+str(winner_name)+'!'
minNumPlayersString= 'minNumPlayers: '+str(main.getMinimumNumberOfPlayers(tourney_id, tourney_clotconfig))
maxNumPlayersString= 'maxNumPlayers: '+str(main.getMaximumNumberOfPlayers(tourney_id, tourney_clotconfig))
starttimeString = 'starttime will be: '+str(main.getStarttime(tourney_id, tourney_clotconfig))+' provided we have minimum number of players.'
currentTimeString = 'current time = '+str(main.getCurrentTime())
tourney_type_string = str(main.getTourneyType(tourney_id, tourney_clotconfig)) + ' tourney'
how_long_you_have_to_join_games_string = 'You have '+str(main.getHowLongYouHaveToJoinGames(tourney_id, tourney_clotconfig))+' minutes to join your auto-created games. After that you may lose that game!!'
template_id = main.getTemplateID(tourney_id, tourney_clotconfig)
#things for specific tourney types
if main.getTourneyType(tourney_id, tourney_clotconfig)=='swiss':
swiss_games_info_table = tournament_swiss.getTourneyRoundsAndGameInfo(tourney_id)
else:
swiss_games_info_table = 0
#end of things for specific tourney types
return shortcuts.render_to_response('tourney_home.html',{'players': the_players, 'config': tourney_clotconfig, 'games': the_games,
'biggermat':biggermat_str,
'players_gated_string':players_gated_string,
'minNumPlayersString':minNumPlayersString,
'maxNumPlayersString':maxNumPlayersString,
'tourney_status_string':tourney_status_string,
'starttimeString':starttimeString,
'currentTimeString':currentTimeString,
'tourney_type_string':tourney_type_string,
'how_long_you_have_to_join_games_string':how_long_you_have_to_join_games_string,
'template_title_string':'Game Template',
'template_id':template_id,
'swiss_games_info_table':swiss_games_info_table,
'join_url':'/tourneys/'+str(tourney_id)+'/join',
'leave_url':'/tourneys/'+str(tourney_id)+'/leave',
'tourney_id':str(tourney_id)
})