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_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('')