def main(games_in_a_set=1000): game0 = monopoly.Game(cutoff=1000, trading_enabled=True, image_exporting=0) for n in [6]: for thresh in range(1, 250, 25): trade_count = [] winners = [0, 0, 0] for i in range(games_in_a_set): # Play game. player1 = monopoly.Player( 1, buying_threshold=thresh, dynamic_ordering=True, n=n, ) player2 = monopoly.Player( 2, dynamic_ordering=True, buying_threshold=randint(1, 500), n=randint(1, 18), ) game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 trade_count.append(results['trade count']) print(winners, n, thresh, sum(trade_count) / games_in_a_set)
def optimize(games_in_a_set=10000): game0 = monopoly.Game(cutoff=1000, trading_enabled=True, image_exporting=0) for c in range(-1000, 1, 100): trade_count = [] winners = [0, 0, 0] for i in range(games_in_a_set): # Play game. player1 = monopoly.Player( 1, dynamic_ordering=True, # group_ordering=random_ordering(), c=c, n=6, ) player2 = monopoly.Player(2, group_ordering=best_ordering(), step_threshold=True, buying_threshold=1000) game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 trade_count.append(results['trade count']) print(winners, c, sum(trade_count) / games_in_a_set)
def main(games_in_a_set=10000): game0 = monopoly.Game( cutoff=1000, trading_enabled=True, image_exporting=0, ) trade_count = [] winners = [0, 0, 0] for i in range(games_in_a_set): # Play game. player1 = monopoly.Player( 1, buying_threshold=500, group_ordering=random_ordering(), #step_threshold=True, ) player2 = monopoly.Player(2, dynamic_ordering=True, n=6, buying_threshold=500, jail_time=0) game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 trade_count.append(results['trade count']) print(winners, sum(trade_count) / games_in_a_set)
def main(): rule_sets = generate_rules() base_games = 100 desired_radius = 1 for rule_set in rule_sets: game0 = monopoly.Game( cutoff=1000, trading_enabled=rule_set[5], free_parking_pool=rule_set[0], double_on_go=rule_set[1], no_rent_in_jail=rule_set[2], trip_to_start=rule_set[3], snake_eyes_bonus=rule_set[4], ) counter = 0 lengths_sum = 0 lengths = [] interval_size = desired_radius + 100 stalemates = 0 while (counter < base_games) or interval_size > desired_radius: # Play game. player1 = monopoly.Player( 1, buying_threshold=1500, group_ordering=random_ordering(), step_threshold=True, ) player2 = monopoly.Player(2, buying_threshold=1500, group_ordering=random_ordering(), step_threshold=True) game0.new_players([player1, player2]) results = game0.play() # Store length. length = results['length'] if length == 1000: stalemates += 1 else: counter += 1 lengths.append(length) lengths_sum += length interval_size = 1.960 * (numpy.std(lengths) / math.sqrt(counter)) # print(counter, lengths_sum / counter, interval_size) print(lengths_sum / counter, stalemates / counter, numpy.std(lengths), counter, rule_set)
def main(games_in_a_set=100000): matrix = numpy.zeros((10, 10)) game_counter = 0 game0 = monopoly.Game(cutoff=1000, trading_enabled=False) while game_counter < games_in_a_set: print(game_counter) # Play game. player1 = monopoly.Player(1, buying_threshold=500, group_ordering=random_ordering(), step_threshold=True) player2 = monopoly.Player(2, buying_threshold=500, group_ordering=random_ordering(), step_threshold=True) game0.new_players([player1, player2]) results = game0.play() if results['winner'] != 0: game_counter += 1 winner = game0.active_players[0] loser = game0.inactive_players[0] winner.add_railroads_and_utilities() loser.add_railroads_and_utilities() for winning_group in winner.monopolies: for losing_group in loser.monopolies: matrix[group_index(winning_group)][group_index(losing_group)] += 1 matrix = normalize_columns(matrix) graph_matrix = [] group_names = ["Brown", "Light Blue", "Pink", "Orange", "Red", "Yellow", "Green", "Dark Blue", "Utility", "Railroad"] graph_matrix.append([""] + group_names) for i in range(len(matrix)): row = [group_names[i]] for j in matrix[i]: row.append(float(j)) graph_matrix.append(row) # Save matrix with open("PageRankEndGroupsMatrix.csv", 'w', newline='') as csvfile: output_file = csv.writer(csvfile, quotechar=',') for row in graph_matrix: output_file.writerow(row) eigenvalues, eigenvectors = numpy.linalg.eig(matrix) print(eigenvalues[0]) for element in normalize_data(eigenvectors[:, 0]): print(element)
def main(): game0 = monopoly.Game(cutoff=1000, trading_enabled=True, image_exporting=0) base_games = 1000 counter = 0 winners = [0, 0, 0] interval_size = 10 trade_count = [] while (counter < base_games) or interval_size > 0.01: counter += 1 # Play game. player1 = monopoly.Player( 1, buying_threshold=1500, group_ordering=[ 'Railroad', 'Dark Blue', 'Utility', 'Green', 'Red', 'Yellow', 'Orange', 'Light Blue', 'Pink', 'Brown' ], #('Railroad', 'Utility', 'Dark Blue', 'Green', 'Red', 'Yellow', 'Orange', 'Pink','Light Blue', 'Brown'), #group_ordering=random_ordering(), step_threshold=True, ) # player1 = monopoly.Player(1, # buying_threshold=100, # dynamic_ordering=True, # n=6, #) player2 = monopoly.Player( 2, buying_threshold=1500, group_ordering=random_ordering(), step_threshold=True, ) game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 p = winners[1] / counter interval_size = 1.960 * math.sqrt((p * (1 - p)) / counter) trade_count.append(results['trade count']) # print(counter, p, interval_size) print(winners[0] / counter, winners[1] / counter, winners[2] / counter, counter) print(sum(trade_count) / counter)
def go_record(games_in_a_set=1000): game0 = monopoly.Game(cutoff=1000, trading_enabled=False) go_record = [] for i in range(games_in_a_set): # Play game. player1 = monopoly.Player(1, buying_threshold=100) player2 = monopoly.Player(2, buying_threshold=100) game0.new_players([player1, player2]) results = game0.play() # Store length. go_record.extend(player1.go_record) print(sum(go_record) / len(go_record))
def main(): game0 = monopoly.Game(cutoff=1000, trading_enabled=True, image_exporting=0) for n in [6]: # range(1, 37): for threshold in [100]: # range(100, 1001, 100): base_games = 1000 counter = 0 winners = [0, 0, 0] interval_size = 10 trade_count = [] while (counter < base_games) or interval_size > 0.01: counter += 1 # Play game. player1 = monopoly.Player( 1, buying_threshold=threshold, dynamic_ordering=True, n=n, ) # player2 = monopoly.Player(2, buying_threshold=randint(1, 1000), # dynamic_ordering=True, # n=randint(1, 36) #) player2 = monopoly.Player(2, buying_threshold=1500, group_ordering=random_ordering(), step_threshold=True) game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 p = winners[1] / counter interval_size = 1.960 * math.sqrt((p * (1 - p)) / counter) trade_count.append(results['trade count']) # print(counter, p, interval_size) print(winners[0] / counter, winners[1] / counter, winners[2] / counter, counter, n, threshold) print(sum(trade_count) / counter)
def test(games_in_a_set=1): game0 = monopoly.Game(cutoff=1000, trading_enabled=True, image_exporting=0) for i in range(games_in_a_set): # Play game. player1 = monopoly.Player( 1, dynamic_ordering=True, n=18, c=0, ) player2 = monopoly.Player( 2, dynamic_ordering=True, n=6, c=0, ) game0.new_players([player1, player2]) results = game0.play()
def main3(games_in_a_set=1000): for m1 in range(1, 21): for m2 in range(1, 21): game0 = monopoly.Game(cutoff=1000, trading_enabled=True, image_exporting=0, matrix1=m1, matrix2=m2) trade_count = [] winners = [0, 0, 0] for i in range(games_in_a_set): # Play game. player1 = monopoly.Player( 1, buying_threshold=100, # group_ordering=random_ordering(), dynamic_ordering=True, static_threshold=False) player2 = monopoly.Player( 2, buying_threshold=100, group_ordering=[ "Railroad", "Light Blue", "Orange", "Pink", "Red", "Yellow", "Green", "Dark Blue", "Utility", "Brown" ], # group_ordering=random_ordering(), static_threshold=True) game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 trade_count.append(results['trade count']) print(winners, m1, m2) '''print("**") print("trades:",results['trade count']) for trade_pair in game0.trades: print(trade_pair[0].name, "--", trade_pair[1].name)''' '''print("avg. trades", sum(trade_count) / games_in_a_set)
def main(): game0 = monopoly.Game(cutoff=1000, trading_enabled=True, image_exporting=0) base_games = 1000 counter = 0 winners = [0, 0, 0] interval_size = 10 trade_count = [] while (counter < base_games) or interval_size > 0.01: counter += 1 # Play game. player1 = monopoly.Player( 1, buying_threshold=1500, group_ordering=best_ordering(), step_threshold=True, ) player2 = monopoly.Player( 2, buying_threshold=1500, group_ordering=random_ordering(), step_threshold=True, ) game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 p = winners[1] / counter interval_size = 1.960 * math.sqrt((p * (1 - p)) / counter) trade_count.append(results['trade count']) # print(counter, p, interval_size) print(winners[0] / counter, winners[1] / counter, winners[2] / counter, counter) print(sum(trade_count) / counter)
def main(games_in_a_set=5000): game0 = monopoly.Game(cutoff=1000, trading_enabled=True) for j in range(40): thresh = j / 200 winners = [0, 0, 0] for i in range(games_in_a_set): # Play game. player1 = monopoly.Player(1, buying_threshold=thresh, group_ordering=random_ordering()) player2 = monopoly.Player(2, buying_threshold=uniform(0, 1), group_ordering=random_ordering()) game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 print(winners, thresh)
def main(games_in_a_set=100000): for shuffle in [True, False]: game0 = monopoly.Game(cutoff=1000, trading_enabled=False, image_exporting=0, shuffle=shuffle, trip_to_start=True) trade_count = [] winners = [0, 0, 0] wins1 = [] wins2 = [] for i in range(games_in_a_set): # Play game. player1 = monopoly.Player(1, buying_threshold=500, group_ordering=random_ordering(), ) player2 = monopoly.Player(2, buying_threshold=500, group_ordering=random_ordering(), ) game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 if results['winner'] == 1: wins1.append(1) wins2.append(0) elif results['winner'] == 2: wins1.append(0) wins2.append(1) else: wins1.append(0) wins2.append(0) trade_count.append(results['trade count']) print(mean_confidence_interval(wins1)) print(mean_confidence_interval(wins2)) print(winners, shuffle, sum(trade_count) / games_in_a_set)
def main(): game0 = monopoly.Game(cutoff=1000, trading_enabled=True, image_exporting=0) base_games = 1000 counter = 0 wins = [] interval_size = 10 while (counter < base_games) or interval_size > 0.01: counter += 1 # Play game. player1 = monopoly.Player( 1, buying_threshold=1000, group_ordering=best_ordering(), step_threshold=True, ) player2 = monopoly.Player( 2, buying_threshold=500, group_ordering=random_ordering(), step_threshold=False, ) game0.new_players([player1, player2]) results = game0.play() # Store length. if results['winner'] == 1: wins.append(1) else: wins.append(0) p = sum(wins) / counter interval_size = 1.960 * math.sqrt((p * (1 - p)) / counter) print(counter, p, interval_size)
def main2(games_in_a_set=100): game0 = monopoly.Game(cutoff=1000, trading_enabled=True) winners = [0, 0, 0] for i in range(games_in_a_set): # Play game. player1 = monopoly.Player(1, buying_threshold=500, group_ordering=random_ordering(), static_threshold=True) # player2 = monopoly.Player(2, buying_threshold=randint(1, 500), group_ordering=random_ordering(),static_threshold=True) player2 = monopoly.Player(2, buying_threshold=500, group_ordering=random_ordering(), static_threshold=True) game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 print(winners)
def main(): game0 = monopoly.Game(cutoff=1000, trading_enabled=True, image_exporting=0) for t in range(20, 40, 1): base_games = 1000 counter = 0 winners = [0, 0, 0] interval_size = 10 while (counter < base_games) or interval_size > 0.01: counter += 1 # Play game. player1 = monopoly.Player(1, n=6, buying_threshold=1500, group_ordering=best_ordering(), t=t, hybrid_trading=True, step_threshold=True) player2 = monopoly.Player(2, buying_threshold=1500, group_ordering=random_ordering(), step_threshold=True) game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 p = winners[1] / counter interval_size = 1.960 * math.sqrt((p * (1 - p)) / counter) # print(counter, p, interval_size) print(winners[0] / counter, winners[1] / counter, winners[2] / counter, counter, t)
def main(desired_radius=0.01): matrix = numpy.zeros((40, 40)) game0 = monopoly.Game(cutoff=1000, trading_enabled=True) props = [] for board_space in game0.board: if board_space.is_property: props.append(board_space.id) main_counter = 0 for prop1 in props: for prop2 in props[props.index(prop1) + 1:]: winners = [0, 0, 0] base_games = 10 game_counter = 0 current_radius = 10 while (game_counter < base_games) or current_radius > desired_radius: # Play game. player1 = monopoly.Player(1, buying_threshold=1500, step_threshold=True, group_ordering=random_ordering(), initial_properties=[prop1]) player2 = monopoly.Player(2, buying_threshold=1500, step_threshold=True, group_ordering=random_ordering(), initial_properties=[prop2]) game0.new_players([player1, player2]) results = game0.play() winners[results['winner']] += 1 game_counter += 1 p = winners[1] / game_counter current_radius = 1.960 * math.sqrt( (p * (1 - p)) / game_counter) #print(game_counter, p, current_radius) main_counter += 1 print(main_counter) matrix[prop1][prop2] += winners[1] / game_counter matrix[prop2][prop1] += winners[2] / game_counter matrix = normalize_columns(matrix) # Save matrix with open("PageRankStart_Matrix.csv", 'w', newline='') as csvfile: output_file = csv.writer(csvfile, quotechar=',') for row in matrix: output_file.writerow(row) eigenvalues, eigenvectors = numpy.linalg.eig(matrix) for i in range(len(eigenvalues)): print("*************************") print(eigenvalues[i]) normalized_vector = normalize_data(eigenvectors[:, i]) for element in normalized_vector: print(element)
def main(games_in_a_set=10000): matrix = numpy.zeros((28, 28)) game_counter = 0 game0 = monopoly.Game(cutoff=1000, trading_enabled=True) while game_counter < games_in_a_set: print(game_counter) # Play game. player1 = monopoly.Player( 1, # dynamic_ordering=True, # c=1, n=randint(1, 13)) buying_threshold=500, group_ordering=random_ordering(), step_threshold=True) player2 = monopoly.Player( 2, # dynamic_ordering=True, # c=1, n=randint(1, 13)) buying_threshold=500, group_ordering=random_ordering(), step_threshold=True) game0.new_players([player1, player2]) results = game0.play() if results['winner'] != 0: game_counter += 1 winner = game0.active_players[0] loser = game0.inactive_players[0] for winning_prop in winner.inventory: for losing_prop in loser.inventory: matrix[winning_prop.prop_id][losing_prop.prop_id] += 1 matrix = normalize_columns(matrix) graph_matrix = [] prop_names = [] for prop in game0.board: if prop.is_property: prop_names.append(safe_name(prop.name)) graph_matrix.append([""] + prop_names) for i in range(len(matrix)): row = [prop_names[i]] for j in matrix[i]: row.append(float(j)) graph_matrix.append(row) # Save matrix with open("PageRankEndMatrix.csv", 'w', newline='') as csvfile: output_file = csv.writer(csvfile, quotechar=',') for row in graph_matrix: output_file.writerow(row) eigenvalues, eigenvectors = numpy.linalg.eig(matrix) for i in range(len(eigenvalues)): print("*************************") print(eigenvalues[i]) for element in eigenvectors[:, i]: if element.real != 0: print(element.real)
def main(): with open('pageRank_DynamicGraph.csv', 'w', newline='') as csvfile: output_file = csv.writer(csvfile, quotechar=',') game0 = monopoly.Game(cutoff=1000, trading_enabled=True, image_exporting=0) groups = [ "Brown", "Light Blue", "Pink", "Orange", "Red", "Yellow", "Green", "Dark Blue", "Utility", "Railroad" ] counter = 0 matrix = numpy.zeros((10, 10)) for i in range(100000): counter += 1 # Play game. player1 = monopoly.Player( 1, buying_threshold=100, n=6, dynamic_ordering=True, ) player2 = monopoly.Player( 2, buying_threshold=1500, group_ordering=random_ordering(), step_threshold=True, ) game0.new_players([player1, player2]) results = game0.play() for trade in game0.trades: # print(trade[1].group, trade[0].group) g1to2 = groups.index(trade[0].group) g2to1 = groups.index(trade[1].group) matrix[g2to1][g1to2] += 1 if counter % 1000 == 0: print(matrix) print(counter) new_matrix = normalize_columns(copy.deepcopy(matrix)) eigenvalues, eigenvectors = numpy.linalg.eig(new_matrix) big_vector = eigenvectors[:, 0] # Grab e-vector. small_vector = [x for x in big_vector if x != 0] # Remove 0s # Write to file. ranking = normalize_data(small_vector) for i in range(10): print(ranking[i], groups[i]) output_file.writerow([counter] + ranking) numpy.savetxt("tradeMatrix.csv", matrix, delimiter=",") new_matrix = normalize_columns(copy.deepcopy(matrix)) graph_matrix = [] group_names = [ "Brown", "Light Blue", "Pink", "Orange", "Red", "Yellow", "Green", "Dark Blue", "Utility", "Railroad" ] graph_matrix.append([""] + group_names) for i in range(len(new_matrix)): row = [group_names[i]] for j in new_matrix[i]: row.append(float(j)) graph_matrix.append(row) # Save matrix with open("adjTradeMatrix.csv", 'w', newline='') as csvfile: output_file = csv.writer(csvfile, quotechar=',') for row in graph_matrix: output_file.writerow(row)
def main(): game0 = monopoly.Game(cutoff=1000, trading_enabled=False, record_predicted_winners=True) base_games = 100 counter = 0 winners = [0, 0, 0] interval_size = 10 matching_counter = 0 monopolies_formed_counter = 0 formation_times = [] prediction = [0] * 100 turn_prediction = [0] * 1000 turn_counter_list = [0] * 1000 while (counter < base_games) or interval_size > 0.01: counter += 1 # Play game. player1 = monopoly.Player(1, buying_threshold=100) # group_ordering=random_ordering()) player2 = monopoly.Player(2, buying_threshold=100) # group_ordering=random_ordering()) game0.new_players([player1, player2]) results = game0.play() winners[results['winner']] += 1 p = winners[1] / counter interval_size = 1.960 * math.sqrt((p * (1 - p)) / counter) # It was not a tie. if results['winner'] != 0: for percent in range(1, 101): index = round((percent / 100) * results['length']) if game0.predicted_winners[index - 1] == results['winner']: prediction[percent - 1] += 1 for turn in range(results['length']): turn_counter_list[turn] += 1 if game0.predicted_winners[turn] == results['winner']: turn_prediction[turn] += 1 # If monopolies formed see if the winner got the first one. if game0.first_monopoly: monopolies_formed_counter += 1 if game0.first_monopoly == results['winner']: matching_counter += 1 # if results['winning_player'].monopoly_tags: # proportion = results['winning_player'].monopoly_tags[0] / results['length'] # formation_times.append(proportion) print("*" * 10) # finite_games = winners[1] + winners[2] # for element in prediction: # print(element / finite_games) print("*" * 10) for i in range(1000): if turn_counter_list[i] > 0: print(turn_prediction[i] / turn_counter_list[i]) else: print(0) print("*" * 10) print("games played:", counter) print("win %s:", winners[0] / counter, winners[1] / counter, winners[2] / counter) print("winner had first monopoly:", matching_counter / monopolies_formed_counter, "of", monopolies_formed_counter, "games")
def main(games_in_a_set=100000): with open('pageRank_GroupGraph3.csv', 'w', newline='') as csvfile: output_file = csv.writer(csvfile, quotechar=',') matrix = numpy.zeros((10, 10)) game_counter = 0 game0 = monopoly.Game(cutoff=1000, trading_enabled=True) while game_counter < games_in_a_set: # Play game. player1 = monopoly.Player(1, buying_threshold=100, group_ordering=random_ordering()) player2 = monopoly.Player(2, buying_threshold=100, group_ordering=random_ordering()) game0.new_players([player1, player2]) results = game0.play() if results['winner'] != 0: game_counter += 1 winner = game0.active_players[0] loser = game0.inactive_players[0] winner.add_railroads_and_utilities() loser.add_railroads_and_utilities() #print(winner.monopolies, loser.monopolies) for winning_group in winner.monopolies: for losing_group in loser.monopolies: matrix[group_index(winning_group)][group_index( losing_group)] += 1 if game_counter % 100 == 0: print(game_counter) new_matrix = normalize_columns(copy.deepcopy(matrix)) eigenvalues, eigenvectors = numpy.linalg.eig(new_matrix) big_vector = eigenvectors[:, 0] # Grab e-vector. small_vector = [x for x in big_vector if x != 0] # Remove 0s # Write to file. output_file.writerow([game_counter] + normalize_data(small_vector)) new_matrix = normalize_columns(copy.deepcopy(matrix)) graph_matrix = [] group_names = [ "Brown", "Light Blue", "Pink", "Orange", "Red", "Yellow", "Green", "Dark Blue", "Utility", "Railroad" ] graph_matrix.append([""] + group_names) for i in range(len(new_matrix)): row = [group_names[i]] for j in new_matrix[i]: row.append(float(j)) graph_matrix.append(row) # Save matrix with open("PageRankEndGroupsMatrix.csv", 'w', newline='') as csvfile: output_file = csv.writer(csvfile, quotechar=',') for row in graph_matrix: output_file.writerow(row)
def main(): game0 = monopoly.Game(cutoff=1000, trading_enabled=True, image_exporting=0) for thresh in [1]: # range(150,1501,150): base_games = 1000 counter = 0 winners = [0, 0, 0] interval_size = 10 while (counter < base_games) or interval_size > 0.01: counter += 1 # Play game. player1 = monopoly.Player( 1, # Newbie buying_threshold=1500, group_ordering=[ "Dark Blue", "Green", "Yellow", "Red", "Orange", "Railroad", "Utility", "Pink", "Light Blue", "Brown" ], step_threshold=True, ) '''player1 = monopoly.Player(1, buying_threshold=thresh, group_ordering=random_ordering(), step_threshold=False, )''' '''player2 = monopoly.Player(2, buying_threshold=1500, group_ordering=random_ordering(), step_threshold=True, )''' player2 = monopoly.Player( 2, buying_threshold=1500, group_ordering=best_ordering(), step_threshold=True, ) '''player2 = monopoly.Player(2, buying_threshold=100, n=6, dynamic_ordering=True, )''' '''player2 = monopoly.Player(2, buying_threshold=1500, n=6, t=10, hybrid_trading=True, group_ordering=best_ordering(), step_threshold=True )''' game0.new_players([player1, player2]) results = game0.play() # Store length. winners[results['winner']] += 1 p = winners[1] / counter interval_size = 1.960 * math.sqrt((p * (1 - p)) / counter) # print(counter, p, interval_size) print(winners[0] / counter, winners[1] / counter, winners[2] / counter, counter, thresh)
def main(games_in_a_set=100000): with open('pageRankEnd_Graph.csv', 'w', newline='') as csvfile: output_file = csv.writer(csvfile, quotechar=',') matrix = numpy.zeros((28, 28)) game_counter = 0 game0 = monopoly.Game(cutoff=1000, trading_enabled=True) keep_going = True while keep_going: # Play game. player1 = monopoly.Player(1, buying_threshold=1500, group_ordering=random_ordering(), step_threshold=True) player2 = monopoly.Player(2, buying_threshold=1500, group_ordering=random_ordering(), step_threshold=True) game0.new_players([player1, player2]) results = game0.play() if results['winner'] != 0: game_counter += 1 winner = game0.active_players[0] loser = game0.inactive_players[0] for winning_prop in winner.inventory: for losing_prop in loser.inventory: matrix[winning_prop.prop_id][losing_prop.prop_id] += 1 if game_counter % 100 == 0: print(game_counter) new_matrix = normalize_columns(copy.deepcopy(matrix)) eigenvalues, eigenvectors = numpy.linalg.eig(new_matrix) e_vector = eigenvectors[:, 0] # Grab e-vector. # Write to file. output_file.writerow([game_counter] + normalize_data(e_vector)) if game_counter == games_in_a_set: for element in normalize_data(e_vector): print(element) keep_going = False for i in range(28): for j in range(28): p = matrix[i][j] / game_counter radius = 1.960 * math.sqrt( (p * (1 - p)) / game_counter) if radius > 0.01: keep_going = True graph_matrix = [] prop_names = [] for prop in game0.board: if prop.is_property: prop_names.append(safe_name(prop.name)) graph_matrix.append([""] + prop_names) for i in range(len(matrix)): row = [prop_names[i]] for j in matrix[i]: row.append(float(j)) graph_matrix.append(row) # Save matrix with open("PageRankEnd_Matrix.csv", 'w', newline='') as csvfile: output_file = csv.writer(csvfile, quotechar=',') for row in graph_matrix: output_file.writerow(row)