def cron_one_tourney(tourney_id):
tourney_id = int(tourney_id)
logging.info( 'in cron_one_tourney(' +str(tourney_id)+' )' )
checkInProgressGames(tourney_id)
setResultsOfAllFinishedGames(tourney_id)
if (not main.isTourneyInPlay(tourney_id)) and main.seeIfTourneyCanStart(tourney_id):
main.startTourney(tourney_id)
logging.info('******STARTED TOURNEY ' +str(tourney_id)+ '*****')
logging.info(main.getTourneyType(tourney_id))
logging.info('main.isTourneyInPlay() ' +str(main.isTourneyInPlay(tourney_id)))
if main.isTourneyInPlay(tourney_id):
main.createGames(tourney_id)
clot.setRanks(tourney_id)
logging.info( 'cron_one_tourney(' +str(tourney_id)+' ) done' )
def seeIfTourneyCanStart_Swiss(tourney_id, tourney_clotconfig):
"""this is the special swiss version of the function"""
ppp = players.Player.all().filter("tourney_id =", tourney_id)#.run(batch_size=1000)
count = 0
for p in ppp:
if p.isParticipating:
count += 1
if count >= main.getMinimumNumberOfPlayers(tourney_id, tourney_clotconfig):
if (not main.isTourneyInPlay(tourney_id, tourney_clotconfig)) and (not main.hasTourneyFinished(tourney_id, tourney_clotconfig)):
if main.areWePastStarttime(tourney_id, tourney_clotconfig):
main.startTourney(tourney_id, tourney_clotconfig)
logging.info('tourney starting')
return True
else:
logging.info('tourney doesnt yet have enough players to start. num active players = '+str(count)+' num needed players = '+str(main.getMinimumNumberOfPlayers(tourney_id, tourney_clotconfig)))
return False
def seeIfTourneyCanStart(tourney_id):
"""this is the default function, if no special one is specified for the tourney type chosen"""
ppp = players.Player.all().filter("tourney_id =", tourney_id)
count = 0
for p in ppp:
if p.isParticipating:
count += 1
if count >= main.getMinimumNumberOfPlayers(tourney_id):
if (not main.isTourneyInPlay(tourney_id)) and (not main.hasTourneyFinished(tourney_id)):
if main.areWePastStarttime(tourney_id):
main.startTourney(tourney_id)
logging.info('tourney starting')
return True
else:
logging.info('tourney doesnt yet have enough players to start. num active players = '+str(count)+' num needed players = '+str(main.getMinimumNumberOfPlayers(tourney_id)))
return False
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)
})