def main(self): command_helper = InputHelper(["play", "exit"]) player_type_helper = InputHelper( ["player", "historian", "mostcommon", "random", "sequential"] ) try: next_command = command_helper.get_legal_input("Please enter a command: \n") if next_command == "play": players = [] for player_num in range(1, 3): player_name = input(f"Please enter player {player_num}'s NAME: ") player_type = player_type_helper.get_legal_input( f"Please enter player {player_num}'s TYPE: " ) players.append(self.__create_player(player_name, player_type)) number_of_games = int(input("Please enter number of rounds: ")) tournament = Tournament(players[0], players[1], number_of_games) tournament.arrange_tournament() else: sys.exit(0) except KeyboardInterrupt: return self.main()
def test_new_round(self): players = [0, 1, 2, 3] t = Tournament(players) games = t.new_round() self.assertEqual(1, len(games)) self.assertEqual(0, games[0].gameid) self.assertEqual([0, 1, 2, 3], games[0].playerids)
def play(cls, para): if not checkPara(para, ['uid', 'machine_id']): return Error.INVALID_PARAM uid = para['uid'] mid = para['machine_id'] bonus = cls(uid, mid) ret = bonus.doPlay() if ret is False: return Error.BONUS_NOT_EXIST (bet, rate, total_win, left) = ret user = User(uid) if total_win > 0: user.coin += total_win Tournament.compete(uid, mid, total_win) User(uid).addWinRec(total_win / bet) data = {'coin': user.coin, 'bet': bet, 'rate': rate, 'total_win': total_win, 'left': left} return data
def play(cls, para): if not checkPara(para, ["uid", "machine_id", "idx"]): return Error.INVALID_PARAM uid = para["uid"] mid = para["machine_id"] idx = para["idx"] bonus = cls(uid, mid) ret = bonus.doPlay(idx) if ret is False: return Error.BONUS_NOT_EXIST (bet, rate, total_win, left) = ret user = User(uid) if total_win > 0: user.coin += total_win Tournament.compete(uid, mid, total_win) User(uid).addWinRec(total_win / bet) data = {"coin": user.coin, "bet": bet, "rate": rate, "total_win": total_win, "left": left} return data
def run_tournament(): num_games = 20 player_1 = NumWinsAgent(Agent.RED_PLAYER) player_2 = SmartRandomAgent(Agent.BLACK_PLAYER) tournament = Tournament(player_1, player_2, num_games) tournament.play_tournament() wins = tournament.get_player_wins() for win in wins: print(win)
def process_results(self, my_strategy, other_strategy): self.my_points += Tournament.score(Tournament, my_strategy, other_strategy)[0] self.other_points += Tournament.score(Tournament, my_strategy, other_strategy)[1] if self.my_points >= self.other_points: self.strat = False else: self.strat = True
def parse_directory(dirname, mode='json', reuse_html=False): tour = Tournament() tour.create_tournament_from_directory(dirname, reuse_html=reuse_html) tour_json_file = os.path.join(dirname, '{0} {1}.json'.format(tour.year, tour.tour_name)) if mode == 'json': if tour.is_valid(): json.dump(tour.to_dict(), open(tour_json_file, 'w'), indent=4)
def train(self): for i in range(1, self.config.num_iters + 1): log.info(f'Iteration #{i} ...') iteration_train_samples = deque([], maxlen=self.config.queue_max_len) # Start self-play to generate training samples for i in tqdm(range(self.config.num_self_play_games), desc="Self Play"): self.mcts = MCTS(self.game, self.nnet, self.config) iteration_train_samples += self.start_game() # save the iteration examples to the history self.train_examples_history.append(iteration_train_samples) if len(self.train_examples_history ) > self.config.num_iters_for_train_examples_history: self.train_examples_history.pop(0) train_examples = [] for train_example in self.train_examples_history: train_examples.extend(train_example) self.nnet.save_checkpoint(folder=self.config.checkpoint, filename='temp_model.tar') self.pnet.load_checkpoint(folder=self.config.checkpoint, filename='temp_model.tar') p_mcts = MCTS(self.game, self.pnet, self.config) # shuffle examples before training shuffle(train_examples) self.nnet.train(train_examples) n_mcts = MCTS(self.game, self.nnet, self.config) log.info('Playing tournament against last iteration network') tournament = Tournament(p_mcts.get_action_with_high_prob, n_mcts.get_action_with_high_prob, self.game) p_wins, n_wins, draws = tournament.play_games( self.config.num_tournament_games) self.monitor_metrics(i, n_wins, p_wins, draws) # If all games are draw or if n_wins doesn't exceed threshold, if (p_wins + n_wins == 0) or (n_wins / float(p_wins + n_wins) < self.config.model_accept_threshold): log.info('Model not accepted') self.nnet.load_checkpoint(folder=self.config.checkpoint, filename='temp_model.tar') else: log.info('Model accepted') self.nnet.save_checkpoint(folder=self.config.checkpoint, filename='best_model.tar')
def new_tournament(): jsonData = simplejson.loads(request.body.read()) if request.body else {} tournament = False if jsonData: from Tournament import Tournament TournamentObj = Tournament(db) tournament = TournamentObj.create_new_tournament(jsonData) if tournament: return api_response(tournament=tournament) else: return api_error(message="Something went wrong, we'll figure it out")
def test_init(self): players = [0, 1, 2, 3] t = Tournament(players) self.assertNotEqual(None, t) table = t.get_table() self.assertEqual(4, len(table)) self.assertEqual(1, table[1].playerid) self.assertEqual(0, table[1].games) self.assertEqual(0, table[1].points) self.assertEqual(0, table[1].goaldifference) self.assertEqual(0, len(t.get_games()))
def get_tournaments(): from Tournament import Tournament TournamentObj = Tournament(db) tournaments = TournamentObj.get_tournaments() from Location import Location LocationObj = Location(db) locations = LocationObj.get_locations() if auth.has_membership('Admin'): types = TournamentObj.get_tournament_types() return api_response(tournaments=tournaments, types=types, locations=locations) else: return api_response(tournaments=tournaments, locations=locations)
def main(): tournament = Tournament() actual = LoadBracket("brackets/actual.bracket", tournament, 2) player = LoadBracket("brackets/rob.bracket", tournament) start, end = tournament.getRoundRange(3) for i in range(start, 63): print(player.getStrGame(i)) # start, end = tournament.getRoundRange(1) # for i in range(start, end): # print(player.getStrGame(i)) print(actual.getPoints(player))
def run_interface(self): """ Main interface that a user interacts with """ print("--------------------------Rock-Paper-Scissors--------------------------") self.get_player_types() self.declare_player_types() number_of_games = int(input("Number of games to be played: ")) player_one = self.__players__[0] player_two = self.__players__[1] tournament = Tournament(player_one, player_two, number_of_games) tournament.arrange_tournament() print("-----------------------------------------------------------------------")
def startGame(self): fistPlayer = self.playerOne.text() secondPlayer = self.playerTwo.text() thridPlayer = self.playerThree.text() fourthPlayer = self.playerFour.text() self.frame = Tournament(fistPlayer, secondPlayer, thridPlayer, fourthPlayer, 1) self.close()
def main(): tournament = Tournament() startingPoint = LoadBracket('brackets/actual.bracket', tournament, 2) player = LoadBracket("brackets/ferd.bracket", tournament) for i in range(50): # for i in range(2**(BITS - 5)): gen = GeneratedBracket(i, startingPoint, tournament) print(i, gen.probability, gen.getPoints(player))
def main(): tournament = Tournament() startingPoint = LoadBracket('brackets/actual.bracket', tournament, 2) PlayerHandler("__^__^_//*v*//", "brackets/blake.bracket", tournament) PlayerHandler("Little Dribble", "brackets/adam.bracket", tournament) PlayerHandler("winner_ganadora", "brackets/an.bracket", tournament) PlayerHandler("At Least No Duke", "brackets/duke.bracket", tournament) PlayerHandler("The 'Eyes Have It", "brackets/eyes.bracket", tournament) PlayerHandler("Thundering Ferd", "brackets/ferd.bracket", tournament) PlayerHandler("JakeSickAFBracket", "brackets/jake.bracket", tournament) PlayerHandler("Wackabrack", "brackets/spence.bracket", tournament) PlayerHandler("Steven Kerr", "brackets/steve.bracket", tournament) PlayerHandler("TLaw and Order", "brackets/tlaw.bracket", tournament) PlayerHandler("Animal Fries", "brackets/rob.bracket", tournament) totalProbabilty = 0.0 # for i in range(50): # for i in range(2**(BITS - 5)): for i in range(NUM_IDS): gen = GeneratedBracket(i, startingPoint, tournament) curMax = 0 for player in PlayerHandler.ALL: playerValue = gen.getPoints(player.bracket) if playerValue > curMax: maxList = [player] curMax = playerValue elif playerValue == curMax: maxList.append(player) if len(maxList) == 1: maxList[0].winProbablity += gen.probability else: for player in maxList: player.tieProbablity += gen.probability totalProbabilty += gen.probability #print to screen # print(f"{i},{gen.probability}", end="") # for player in PlayerHandler.ALL: # print(f",{gen.getPoints(player.bracket)}", end="") # print() print(totalProbabilty) for player in sorted(PlayerHandler.ALL, key=lambda player: -player.winProbablity): print(player)
def main(): display_separator("=") display_intro() display_separator("=") while True: try: noOfPlayers = int(input("Number of players: ")) if (noOfPlayers < 2): print("Not enough players. Please try again.") else: break except ValueError: print("Invalid input. Please Try again.") tournament = Tournament() playersList = players(noOfPlayers, tournament) display_separator("-") main_menu(playersList, tournament)
def geneticAlgorithm(): ratio_initial_max_mutation_numbers = 0.4 ratio_initial_max_mutation_stars = 0.5 ratio_max_mutation_numbers = ratio_initial_max_mutation_numbers ratio_max_mutation_stars = ratio_initial_max_mutation_stars total_fathers = 500 total_generations = 100 tournament_size = 5 file = readFile("premios2012.txt") winning_combinations = fileToCombination(file) fathers = createFirstGeneration(total_fathers) count_generations = 0 tournament = Tournament() while count_generations<total_generations: print("Generacion: " , count_generations) if count_generations%10==0: tournament_size+=1 ratio_max_mutation_numbers -= 0.015 ratio_max_mutation_stars -= 0.019 count_generations+=1 fathers = tournament.valueAll(fathers, winning_combinations) fathers = tournament.fightTournament(fathers, winning_combinations, total_fathers, tournament_size) sons = reproduceCombinations(fathers) sons = tournament.valueAll(sons, winning_combinations) sons = mutateCombinations(sons, ratio_max_mutation_numbers, ratio_max_mutation_stars) sons = tournament.valueAll(sons, winning_combinations) sons.sort(key=lambda combination: combination.value, reverse=False) fathers = sons best_combination = sons[len(sons)-1] best_combination.printInfo()
def spin(cls, para): if not checkPara(para, ['uid', 'machine_id', 'lines', 'bet', 'is_free']): return Error.INVALID_PARAM uid = para['uid'] game_id = para['machine_id'] lines = para['lines'] bet = para['bet'] is_free = para['is_free'] fake_flag = 0 if 'fakeflag' in para: fake_flag = int(para['fakeflag']) lv = User(uid).level #check if not ConfMgr.isMachineLocked(game_id, lv): return Error.MACHINE_LOCKED if not ConfMgr.isLineValid(game_id, lines): return Error.LINE_EXCEEDED if not ConfMgr.isBetValid(lv, bet): return Error.BET_EXCEEDED pay_in = 0 user = User(uid) cur_coin = user.coin # may change wild_tune for this user user.addSpin() if not is_free: user.clearWinRec() if not is_free: pay_in = lines * bet if cur_coin < pay_in: Log.error('no enough coin to spin') return Error.NO_COIN else: # pick saved bet and lines for free spin free_spin = FreeSpin(uid, game_id) ret = free_spin.consume() if ret is False: return Error.NO_FREE_SPIN # override (lines, bet) = ret machine = cls(game_id) # ignore bonus if skip playing it game_type = BonusGameType.getBonusGameType(game_id) bonus_game = game_type(uid, game_id) bonus_game.remove() (response, win, bonus_num, spin_num) = machine.doSpin(game_id, lv, lines, bet, is_free, fake_flag) if bonus_num > 0: game_type.create(uid, game_id, bonus_num, bet) Log.debug('created bonus games: bonus_num=%s'%bonus_num) if spin_num > 0: free_spin = FreeSpin(uid, game_id) free_spin.add(spin_num, lines, bet) response['is_new_freespin'] = True Log.debug('added free spin=%s'%spin_num) # save for big/mega win user.addWinRec(win / bet) # Tournament update Tournament.compete(uid, game_id, win) # compose reponse now_coin = cur_coin - pay_in + win user.coin = now_coin response['coin'] = now_coin (now_exp, lv_up) = user.addExp(lines*bet) response['exp'] = now_exp response['level'] = user.level free_spin = FreeSpin(uid, game_id).getAll() if free_spin: response['free_spin'] = free_spin win_info = user.checkWinRec() if win_info: response.update(win_info) rank_info = Tournament.getRank({'uid': uid, 'machine_id': game_id}) if rank_info != Error.TOUR_NOT_OPEN: response['rank_info'] = rank_info # share gift flag share = UserShareGift(uid) if '5combo' in response: share.setFlag(UserShareGift.TYPE_COMBO) # bonus may also trigger it if 'is_mega' in response: share.setFlag(UserShareGift.TYPE_MEGA) if lv_up: share.setFlag(UserShareGift.TYPE_LEVELUP) #only for stat data = {'bet': pay_in, 'win': win, 'spin': 1, 'trigger_freespin': 1 if spin_num > 0 else 0, 'trigger_bonus': 1 if bonus_num > 0 else 0, 'free_spin': 1 if is_free else 0, } Stat().incr(data) return response
import multiprocessing def start_game(cellular_a): cellular_a.play() def start_chat(cellular_a): cellular_a.read_chat() if __name__ == "__main__": ## start with tournament tournament = "SmartCUP" pltournament1 = Tournament(name="ai9_pl1", tournament=tournament) pltournament2 = Tournament(name="ai9_pl2", tournament=tournament) pltournament3 = Tournament(name="ai9_pl3", tournament=tournament) input( 'Finished to join in tournament correctly! Press any key to continue..' ) ##start with game manager = multiprocessing.Manager() for i in range(1, 13): value = tournament + "-" + str(i) + "-1" print("Start game on: " + value) input('wait') SAME_NAME = value NAME_GAME = SAME_NAME #+datetime.datetime.now().strftime("%Y%m%d_%H%M%S") NAME_CHAT = SAME_NAME debug = False
# to report the average RMSD sum_of_RMSDs_all = 0 # keep a seperate running sum of RMSDs for the # top 4 teams (by input rank) for each tournament sum_of_RMSDs_top_4 = 0 sum_of_ceiling_hits = 0 # declare eventual Tournament object outside for loop so the last tournament's values can be accessed test_tournament = -1 for i in range(0, tournaments): #first_line = first_line + ',T' + str(i + 1) test_tournament = Tournament(teams, matches_per_team) while not test_tournament.create_match_schedule(): continue test_tournament.run_tournament() # if needed, assign random TBP if (random_TBP): for t in test_tournament.teams: t.tp = int(random.random() * 1000) test_tournament.rank() sum_of_squared_residuals_all = 0 sum_of_squared_residuals_top_4 = 0
from Tournament import Tournament, elo_ranks from random import gauss, randint players = ["Alice","Bob","Carol","David","Eve","Frank"] skill = [2.1, 2, 2.2, 3.5, 2, 1.7] T = Tournament(players) for i in range(500): p1 = randint(0,5) p2 = randint(0,5) sc1 = abs(gauss(skill[p1],.2)) sc2 = abs(gauss(skill[p2],.2)) T.update(players[p1],players[p2],sc1,sc2) elo_ranks(T) print(T.predict("Frank","David"))
combinations = [(a, b, c, d) for a in range(5) for b in range(5) for c in range(5) for d in range(2)] for combination in combinations: second.VALUABLE_STARTING_MIN_REPEATABILITY = combination[0] second.VALUABLE_RESPONDING_MIN_REPEATABILITY = combination[1] second.MIN_STACK_VALUE_TO_REPEAT = combination[2] second.IGNORE_WINNING_WHEN_REPEATING = combination[3] == 1 # total statistics n_first_won_tournaments = 0 n_first_won_games = 0 # play as many tournaments as needed for TOURNAMENT in range(N_TOTAL_TOURNAMENTS): tournament = Tournament(first, second, N_GAMES_IN_TOURNAMENT) tournament.playTournament() if tournament.getAbsoluteWinner() == first: n_first_won_tournaments += 1 n_first_won_games += tournament.player1_stats['games_won'] percentage = 100 * ( (n_first_won_games / N_TOTAL_TOURNAMENTS) / N_GAMES_IN_TOURNAMENT) # statistics: (combination) : average percentage of games won in the tournament print("Combination {} : {}".format(combination, percentage)) output.write('{};{};{};{};{}\n'.format(combination[0], combination[1], combination[2], combination[3],
""" test.py -- A simple script for testing the Tournament module by simulating a short 32-player tournament and outputting the results. """ from Player import Player from Tournament import Tournament from random import randint from console import list_tables, list_standings if __name__ == '__main__': EVENT = Tournament('Test Event') for x in open('player_names.txt').readlines(): x = x.strip('\n') first, last = x.split(' ') EVENT.add_player(Player(first, last)) for x in xrange(5): EVENT.start_round() print 'Round: ', EVENT.round list_tables(EVENT, showall=True) for match in EVENT.tables[EVENT.round]: y = randint(1, 100) if y < 25: match.report_match(2, 1) if y >= 25 and y < 50: match.report_match(2, 0) if y >= 50 and y < 75: match.report_match(1, 2) if y >= 75 and y <= 100:
def main(): print(django.get_version()) # Create Players p1 = Player(uuid.uuid4(), 'Drew', 'Casner') p2 = Player(uuid.uuid4(), 'RJ', 'Morley') p3 = Player(uuid.uuid4(), 'Jesper', 'Stryen') p4 = Player(uuid.uuid4(), 'Austin', 'Smith') p5 = Player(uuid.uuid4(), 'Lucas', 'Sward') p6 = Player(uuid.uuid4(), 'Ben', 'Settlerquist') p7 = Player(uuid.uuid4(), 'Powell', 'Hinson') p8 = Player(uuid.uuid4(), 'Quinn', 'Mahone') p9 = Player(uuid.uuid4(), 'Colt', 'Wise') p10 = Player(uuid.uuid4(), 'Ryan', 'Becker') p11 = Player(uuid.uuid4(), 'Matt', 'Skogen') p12 = Player(uuid.uuid4(), 'Isaiah', 'Jones') p13 = Player(uuid.uuid4(), 'John', 'Gadbois') p14 = Player(uuid.uuid4(), 'Kian', 'Tanner') p15 = Player(uuid.uuid4(), 'Pete', 'Snowden') p16 = Player(uuid.uuid4(), 'Nick', 'Hearon') # Create Teams t1 = Team(uuid.uuid4(), 'The Killerz', 'Boulder', 'Colorado') t1.addPlayer(p1) t1.addPlayer(p2) t2 = Team(uuid.uuid4(), 'The Vikings', 'New York', 'New York') t2.addPlayer(p3) t2.addPlayer(p4) t3 = Team(uuid.uuid4(), 'The High Flyers', 'Austin', 'Texas') t3.addPlayer(p6) t3.addPlayer(p7) t4 = Team(uuid.uuid4(), 'The Ballers', 'Aurora', 'Colorado') t4.addPlayer(p5) t4.addPlayer(p8) t5 = Team(uuid.uuid4(), 'The Wurst', 'Boulder', 'Colorado') t5.addPlayer(p9) t5.addPlayer(p10) t6 = Team(uuid.uuid4(), 'Da N3rds', 'Seattle', 'Washington') t6.addPlayer(p11) t6.addPlayer(p12) t7 = Team(uuid.uuid4(), 'The Climbers', 'LA', 'Cali') t7.addPlayer(p13) t7.addPlayer(p14) t8 = Team(uuid.uuid4(), 'Rockstars', 'Summit County', 'Colorado') t8.addPlayer(p15) t8.addPlayer(p16) # Test Game g1 = Game(uuid.uuid4(), t1, t2) # Create Tournament turny1 = Tournament(uuid.uuid4(), 'Champions Club', 1, 8 * 60, 60) turny1.addTeam(t1, 0) turny1.addTeam(t2, 0) turny1.addTeam(t3, 0) turny1.addTeam(t4, 0) turny1.addTeam(t5, 0) #turny1.addTeam(t6, 0) #turny1.addTeam(t7, 0) #turny1.addTeam(t8, 0) turny1.start() # Update results #''' turny1.getGames()[2][0].setScoreHome(90) turny1.getGames()[2][0].setScoreAway(80) turny1.getGames()[2][0].gameComplete() print('') print(turny1.getGames()[2][0].getWinningTeam()) print('') turny1.update()
def loadGame(self): tempBoard = Board() tempTournament = Tournament() MAX_COL = 9 MAX_ROW = 8 rowLine = 0 strboard = [[]] gameboard = [[Die() for j in range(MAX_COL)] for i in range(MAX_ROW)] print("************************************") print("* ~~ Load Game ~~ *") print("************************************") print() fileName = str(input("Enter File Name: ")) fileName += ".txt" file = open(fileName, 'r') # Skip first line containing Board: file.readline() for line in file: line = line.split(' ') for i in line: if (i != ''): strboard[rowLine].append(i) rowLine += 1 if (rowLine == MAX_ROW): break strboard.append([]) # Skip Blank file.readline() # Read computer wins string computerstr = file.readline() computerstr = computerstr.split(' ') computerwin = int(computerstr[2]) # Skip Blank file.readline() humanstr = file.readline() humanstr = humanstr.split(' ') humanwin = int(humanstr[2]) # Skip Blank file.readline() # Read Next Player next = file.readline() next = next.split(' ') nextPlayer = next[2] # Create Board iter = 0 for row in range(7, -1, -1): for col in range(0, 9): tmp = strboard[row][col] if (tmp != "0" and tmp != "0\n"): player = tmp[0] topNum = int(tmp[1]) rightNum = int(tmp[2]) gameboard[iter][col] = self.board.dieSwitch( topNum, rightNum, player) iter += 1 # Set Objects tempBoard.setGameBoard(gameboard) tempTournament.setComputerWins(computerwin) tempTournament.setHumanWins(humanwin) self.setTournament(tempTournament) self.setBoard(tempBoard) self.startGame(nextPlayer, False)
from read_input import read_input if __name__ == "__main__": #Reads the name of the tournament from prompt if len(sys.argv) != 2: sys.exit('### ERROR: Choose a tournament') nfile = sys.argv[1] #Reads the tournament details, the groups and the teams from the input file [teams_and_groups, file_results, ppm] = read_input(nfile) allteams = [] allgroups = [] nallgroups = set([]) ngroup = 'NG' for i in teams_and_groups: if i[0:4] == '': ngroup = 'NG' elif i[0:4] == '### ': ngroup = i[4:] nallgroups.add(ngroup) else: allteams.append(Team(i)) allteams[-1].set_group(ngroup) pointspermatch = [2, 1, 0] for i in sorted(nallgroups): allgroups.append( Group(i, [team for team in allteams if team.group == i], ppm)) #Creates the tournament tournament = Tournament(allgroups, file_results) tournament.update_results() tournament.print_groups()
Player0 = 1613.0 Player1 = 1609.0 Player2 = 1477.0 Player3 = 1388.0 Player4 = 1586.0 Player5 = 1720.0 players = ["Player0", "Player1", "Player2", "Player3", "Player4", "Player5"] ratings = [Player0, Player1, Player2, Player3, Player4, Player5] results = [[0, 0.5, 1, 1, 0], [1, 1, 1, 1, 0], [0.5, 0, 1, 1, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [1, 1, 1, 1, 1]] record = [ "X L D W W L", "W X W W W L", "D L X W W L", "L L L X L L", "L L L W X L", "W W W W W X" ] # Initialise Swiss Tournament tournament = Tournament(ratings, results) performance_ratings = tournament.GetPerformanceRatings() old_ratings = ratings.copy() tournament.UpdateEloScores() # Print results print("Rating:\tprev\tnew\tperformance\trecord") for i in range(len(players)): print( players[i] + "\t{}\t{}\t{}".format(math.floor(old_ratings[i]), math.floor( ratings[i]), math.floor(performance_ratings[i])) + "\t\t" + record[i])
# for names of the form "Smith, John" rex = search("(\w+),( |)(\w+)", username) if rex is not None: firstname, lastname = rex.group(3), rex.group(1) # commit this stuff to the event if sanctioned == True: userpin = int(raw_input("pin -> ")) EVENT.add_player(Player(firstname, lastname, userpin)) elif sanctioned == False: EVENT.add_player(Player(firstname, lastname)) if __name__ == "__main__": INFO = get_event_info() EVENT = Tournament(INFO[0], INFO[1]) get_players() ROUNDS = number_rounds(len(EVENT.players)) # main event-reporting loop while EVENT.round < ROUNDS: EVENT.start_round() ACTIVE = len(EVENT.active_tables()) while ACTIVE > 0: CMD = raw_input("Round #%d (%d tables open) -> " % (EVENT.round, ACTIVE)) if search("lp", CMD) is not None: list_pairings(EVENT) continue if search("ls", CMD) is not None:
REVERSE_HANDS = [ "KA", "QK", "JQ", "TK", "TQ", "TJ", "KAs", "QKs", "JQs", "TKs", "TQs", "TJs" ] NOREVERSE_HANDS = [ "AK", "AKs", "KQ", "KQs", "QJ", "QJs", "JT", "JTs", "KT", "KTs", "QT", "QTs", "JT", "JTs" ] players = int(input("Enter the number of players for the tournament: ")) # name = input("Enter the tournament name: ") # buyin = float(input("Enter the tournament buyin: ")) # speed = input("Enter the tournament speed: ") Tourn = Tournament(players) Main = PositionStrategy(Tourn) def clean_cards(cards): cards = cards.upper() if 'S' in cards: cards = cards[:2] + cards[2:].lower() if cards in REVERSE_HANDS: if len(cards) == 2: cards = cards[1] + cards[0] else: cards = cards[1] + cards[0] + cards[2] elif cards in NOREVERSE_HANDS: cards = cards elif cards[0] < cards[1]:
from Tournament import Tournament from Ranking import Ranking from SimulatedAnnealing import SimulatedAnnealing tournament = Tournament(definition_file="1994_Formula_One.wmg") initial_ranking = Ranking(order=list(range(0, len(tournament.participants))), tournament=tournament) final_ranking = tournament.get_best_ranking(initial_ranking=initial_ranking, initial_temp=300, temp_length=45, cooling_ratio=0.999, num_non_improve=100000) print(final_ranking.get_kemeny_score(), final_ranking.get_participants())
def __init__(self): self.viewBoard = ViewBoard() self.board = Board() self.human = Human() self.computer = Computer() self.tournament = Tournament()
import sys import time sys.path.append("..") from Tournament import Tournament if __name__ == "__main__": print "now:", int(time.time()) Tournament.refresh()
def main(): Tournament().startTournament()
print("sqlite db created") except lite.Error as e: print("Could not open database file\n{}".format(e)) #============================================================================== # running the app #============================================================================== def run_App(): if __name__ == '__main__': Main() #main.showName() global base_path base_path = 'null' print("base_path : " + base_path) if not os.path.isfile(base_path): main = Main() base_path = main.db run_App() print(base_path) #db = SQL_Adapter(base_path) from Tournament import Tournament tournament = Tournament() tournament.insertTournament("Default Tournament 3")
elif RUNS[RUN] == "Tournament - different net structures using replay buffer": print("Mode: Tournament. Several players play against each other.") game = HexGame() replay_buffer = ReplayBuffer() net1 = Dense(hidden_layers=[(100, relu)], optimizer=Adam) net2 = Dense(hidden_layers=[(100, sigmoid)], optimizer=Adam) net3 = Dense(hidden_layers=[(100, relu)], optimizer=SGD) net4 = Dense(hidden_layers=[(100, sigmoid)], optimizer=SGD) player1 = NetBotFromTraining("Adam relu", net1, replay_buffer) player2 = NetBotFromTraining("Adam sig", net2, replay_buffer) player3 = NetBotFromTraining("SGD relu", net3, replay_buffer) player4 = NetBotFromTraining("SGD sig", net4, replay_buffer) players = [player1, player2, player3, player4] tournament = Tournament(game, players) wins = tournament.play_tournament() elif RUNS[RUN] == "Tournament - different training amounts from loading ": print( "Mode: Trained tournament. Already trained nets play against each other." ) game = HexGame() players = [NetBotFromLoading(name) for name in NETS_TOURNAMENT] tournament = Tournament(game, players) wins = tournament.play_tournament() elif RUNS[RUN] == "Train net on buffer and save it": print("Mode: Train net on buffer and save it") trainer = NetTrainer(train_net_on_init=True) trainer.net.save("Saved_net") else: print("Custom - nothing")
from Tournament import Tournament from Jesus import Jesus from Lucifer import Lucifer from TitForTat import TitForTat # Create tournament species = [Jesus, Lucifer, TitForTat] tournament = Tournament(species, 200, 5) # Run tournament print(tournament) while True: inp = input("Press Enter to start the next round") if inp.lower() == "done": break print("\n") tournament.round_robin() tournament.reproduce() tournament.repopulate() print("Results:") print(tournament)
def create_offspring(self): tournament = Tournament(np.random.choice(self.members, 4)) winner = tournament.conduct() return winner
from Inv_Judas import Inv_Judas from Judas import Judas from MasonPrisoner import MasonPrisoner from Random import Random from SchizophrenicRetribution import SchizophrenicRetribution from TitForTat_Avg import TitForTat_Avg from XmasTruce import XmasTruce import time # Create tournament species = [ Jesus, Lucifer, TitForTat, Telepath, BahHumbug, FelizNavidad, Inv_Judas, Judas, MasonPrisoner, Random, SchizophrenicRetribution, TitForTat_Avg, XmasTruce ] tournament = Tournament(species, 200, 10) # Time species valid = True for sp in species: print("") s1 = 0 s2 = 0 start = time.thread_time() for ii in range(1000): (score1, score2) = tournament.play_match(sp, sp, 1000) s1 += score1 s2 += score2 end = time.thread_time() print("Validating %s" % sp.__name__) print("Scores against self: %d, %d" % (s1, s2))