def checkInProgressGames(tourney_id): """This is called periodically to look for games that are finished. If we find a finished game, we record the winner""" #Find all games that we think aren't finished activeGames = games.Game.all().filter("winner =", None).filter("tourney_id =", tourney_id) for g in activeGames: #call WarLight's GameFeed API so that it can tell us if it's finished or not apiret = main.hitapi('/API/GameFeed?GameID=' + str(g.wlnetGameID), {}) data = json.loads(apiret) state = data.get('state', 'err') if state == 'err': raise Exception("GameFeed API failed. Message = " + data.get('error', apiret)) if state == 'Finished': #It's finished. Record the winner and save it back. winner = findWinner(data,tourney_id) logging.info('Identified the winner of game ' + str(g.wlnetGameID) + ' is ' + str(winner)) loser = findLoser(data,tourney_id) logging.info('Identified the loser of game ' + str(g.wlnetGameID) + ' is ' + str(loser)) g.winner = winner.key().id() g.loser = loser.key().id() #g.winningTeamName = 'bob' #winner.key().name() g.dateEnded = datetime.datetime.now() g.save() else: #It's still going. #terminate games that have not started for a long time. if state == 'WaitingForPlayers': latest_joining_time = g.dateCreated +datetime.timedelta(0,60*main.getHowLongYouHaveToJoinGames(tourney_id)) if datetime.datetime.now() > latest_joining_time: logging.info('game ' + str(g.wlnetGameID) + ' has taken too long to start') #game has taken too long to start. game_id = g.key().id() logging.info('game_id='+str(game_id)) for gp in games.GamePlayer.all().filter("tourney_id =", tourney_id): logging.info(gp) game_players = games.GamePlayer.all().filter("gameID =", game_id).filter("tourney_id =", tourney_id) players_ids = [p.playerID for p in game_players] logging.info(players_ids) random.shuffle(players_ids) g.winner = players_ids[0] g.loser = players_ids[1] g.legitimateGame = False g.dateEnded = datetime.datetime.now() g.save() logging.info('Game ' + str(g.wlnetGameID) + ' is not finished, state=' + state + ', numTurns=' + data['numberOfTurns']+' ----------------------------------------------------------------------------')
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) })
def checkInProgressGames(tourney_id, tourney_clotconfig): """This is called periodically to look for games that are finished. If we find a finished game, we record the winner""" #Find all games that we think aren't finished activeGames = games.Game.all().filter("winner =", None).filter("tourney_id =", tourney_id)#.run(batch_size=1000) for g in activeGames: #call WarLight's GameFeed API so that it can tell us if it's finished or not apiret = main.hitapi('/API/GameFeed?GameID=' + str(g.wlnetGameID), {}) data = json.loads(apiret) state = data.get('state', 'err') #logging.info('+++++++++++++++++++++++++++++++++++++++++++') #logging.info('data: ' + str(data) + ' ') #logging.info('+++++++++++++++++++++++++++++++++++++++++++') player_data = data.get('players') #logging.info('player_data: ' + str(player_data) + ' ') #logging.info('+++++++++++++++++++++++++++++++++++++++++++') if state == 'err': raise Exception("GameFeed API failed. Message = " + data.get('error', apiret)) if state == 'Finished': #It's finished. Record the winner and save it back. winner = findWinner(data,tourney_id) logging.info('Identified the winner of game ' + str(g.wlnetGameID) + ' is ' + str(winner)) loser = findLoser(data,tourney_id) logging.info('Identified the loser of game ' + str(g.wlnetGameID) + ' is ' + str(loser)) g.winner = winner.key().id() g.loser = loser.key().id() g.dateEnded = datetime.datetime.now() g.save() else: #It's still going. logging.info('Game ' + str(g.wlnetGameID) + ' is not finished, state=' + state + ', numTurns=' + data['numberOfTurns']+' ----------------------------------------------------------------------------') #terminate games that have not started for a long time. if state == 'WaitingForPlayers': latest_joining_time = g.dateCreated +datetime.timedelta(0,60*main.getHowLongYouHaveToJoinGames(tourney_id, tourney_clotconfig)) if datetime.datetime.now() > latest_joining_time: logging.info('game ' + str(g.wlnetGameID) + ' has taken too long to start') logging.info('data: ' + str(data) + ' ') #find who Joined and who did not. good_player_wlids = [] bad_player_wlids = [] logging.info('') logging.info('players are:') for p in player_data: logging.info(p) if p['state']=='Playing': #only 'Playing' is the acceptable status - anything else means you did not join (ie ignored, or declined). good_player_wlids.append(int(p['id'])) else: bad_player_wlids.append(int(p['id'])) #shuffle randomly in case we need to select winner at random random.shuffle(good_player_wlids) random.shuffle(bad_player_wlids) #set the winner and loser if len(good_player_wlids)==1 and len(bad_player_wlids)==1: logging.info('1 player Joined, the other did not ') g.winner = findPlayerID_FromWarlightID(good_player_wlids[0],tourney_id) g.loser = findPlayerID_FromWarlightID(bad_player_wlids[0],tourney_id) elif len(bad_player_wlids)==2: logging.info('neither player Joined, winner/loser will be selected randomly') g.winner = findPlayerID_FromWarlightID(bad_player_wlids[0],tourney_id) g.loser = findPlayerID_FromWarlightID(bad_player_wlids[1],tourney_id) else: assert False #must not occur g.dateEnded = datetime.datetime.now() logging.info('player ' + str(g.winner) + ' won') logging.info('player ' + str(g.loser) + ' lost') g.save()