def main(args=None): for aa, kk in product(asw, ksw): print(aa, kk) rates['addition'] = aa rates['coagulation'] = aa rates['subtraction'] = 10.0**-3 rates['fragmentation'] = 10.0**-3 ext = "_aa_{}_bb_{}_kk_{}.strup".format(aa, 10**-3, kk) # ext2="_aa_{}_kk_{}.up".format(aa,kk) fn = runs_name + ext # fn2=runs_name+ext2 rates['nucleation'] = kk params['rates'] = rates params['simulation']['runs'] = runs_num # params['simulation'][] os.makedirs(runs_dir + fn + "/", exist_ok=True) os.makedirs(runs_dir + fn + "/averaged/", exist_ok=True) with open(utils_dir + 'input.data', 'wb') as f: pll.dump(params, f) with open(runs_dir + fn + "/input.data", 'wb') as f: pll.dump(params, f) for i in range(1, runs_num + 1): ## IF EVERYTHING BREAKS # sim.simulation(runs_dir + fn + "/" + fn + "_" + str(i) + ".json") if i < 9: sim.simulation(runs_dir + fn + "/" + fn + "_0" + str(i) + ".json") else: sim.simulation(runs_dir + fn + "/" + fn + "_" + str(i) + ".json")
def move_utility(board, block, start_regionid, end_regionid, is_stay, turn): """ returns between 0 and 1 probability that it will choose again """ start_region = search.region_id_to_object(board, start_regionid) end_region = search.region_id_to_object(board, end_regionid) move_utility = 0 if regroup.noble_home_to_object(board, start_regionid): if is_stay: move_utility += .4 simulation_dict = simulations.simulation([block], end_region.blocks_present, list(), list()) move_utility += retreat.retreat(board, end_regionid, [], simulation_dict, True, turn)['Staying value'] / 150 if move_utility >= 1: move_utility = 0.8 elif move_utility == 0: move_utility = 0.2 return move_utility
def main(): blocks1 = initialize_blocks.initialize_blocks() print( simulations.simulation([ blocks.Block( attack_number=2, attack_letter='A', initial_attack_strength=4) ], [ blocks.Block( attack_number=2, attack_letter='A', initial_attack_strength=4) ], 1000))
def __init__(self, param_dict): self.age = param_dict['age'] self.retirement_age = param_dict['retirement_age'] self.terminal_age = param_dict['terminal_age'] self.non_taxable_balance = param_dict['non_taxable_balance'] self.taxable_balance = param_dict['taxable_balance'] self.effective_tax_rate = param_dict['eff_tax_rate'] self.returns_tax_rate = param_dict['returns_tax_rate'] self.non_taxable_contribution = param_dict['non_taxable_contribution'] self.taxable_contribution = param_dict['taxable_contribution'] self.monthly_retirement_expenses = param_dict['monthly_retirement_expenses'] self.years = self.terminal_age - self.age + 1 self.now = datetime.datetime.now().year self.retirement_age = param_dict['retirement_age'] self.expected_rate_of_return = param_dict['expected_rate_of_return'] self.asset_volatility = param_dict['asset_volatility'] self.inflation_rate = param_dict['inflation_rate'] #self.simdata = simData(self.expected_rate_of_return, self.asset_volatility, self.years) #self.plan_dict = self.run_all_sims() self.sim = simulation(self.years, self.expected_rate_of_return, self.asset_volatility) self.path_dict = self.run_calc() self.end_balance = self.get_final_balance()
rates['fragmentation'] = rates['subtraction'] #rates['fragmentation']=10**-5 app1 = "aa_{}".format(aa) app2 = "kk_{}".format(kk) app3 = "bb_{}".format(bb) folder = app1 + "/" + app2 + "/" + app3 + "/" fn_ext = "_" + app1 + "_" + app2 + "_" + app3 + ".strup" #ext2="_aa_{}_kk_{}.up".format(aa,kk) fn = folder + runs_name + "_" + fn_ext #fn2=runs_name+ext2 rates['nucleation'] = kk params['rates'] = rates params['simulation']['runs'] = runs_num # params['simulation'][] os.makedirs(runs_dir + fn + "/", exist_ok=True) os.makedirs(runs_dir + fn + "/averaged/", exist_ok=True) with open(utils_dir + 'input.data', 'wb') as f: pll.dump(params, f) with open(runs_dir + fn + "/input.data", 'wb') as f: pll.dump(params, f) for i in range(1, runs_num + 1): sim.simulation(runs_dir + fn + "/" + fn + "_" + str(i) + ".json") os.makedirs(runs_dir + folder, exist_ok=True) os.makedirs(runs_dir + folder + "binned/", exist_ok=True) with open(utils_dir + 'input.data', 'wb') as f: pll.dump(params, f) with open(runs_dir + folder + "input.data", 'wb') as f: pll.dump(params, f) for i in range(1, runs_num + 1): sim.simulation(runs_dir + fn + "_" + str(i) + ".json")
def good_move(board, num_moves, role, turn, truce, blocks_moved): """ board is a copy of the board going to make a move with copies of the board goes and makes the move role is scotland or england turn is 1 2 3 4 or 5 finds some utility and throws into random number generator to see if move chosen or not READ ME READ ME READ ME READ ME READ ME READ ME MAKES A COPY OF THE BOARD DOES THE MOVE EVALUATES THE MOVE IF BAD MOVE AGAIN AND CONTINUE LOOPING UNTIL FINDS GOOD MOVE AND THEN IT EXECUTES IT ON THE ACTUAL BOARD """ board_copy = copy.deepcopy(board) utility = 0 #count how man value of location of homes owned before: value_loc_before = 0 for region in board_copy.regions: value_loc_before += retreat.value_of_location(board_copy, region.regionID, role) computer_block = None #does movement while computer_block in blocks_moved or computer_block == None: computer_path, computer_block = other_movement.movement_execution( board_copy, 'comp', role, num_moves, truce=truce) #debugging why things aren't in combat dictionary #for region in board.regions: #if region.is_contested(): #for block in region.blocks_present: #if block not in #checks utilitiy of the battles using the retreat elliot's thing noble_home_after = 0 for i, region in enumerate(board_copy.regions): if region.is_contested(): board_copy.regions[i] = clean_up_dict(region) #board_copy.regions[contested_regions[i].regionID] = contested_regions[i] board_copy = clean_up_board(board_copy) for region in board_copy.regions: if region.is_contested(): ''' print("***ATTACKING***") print(region.combat_dict['Attacking']) print("******") print("***DEFENDING***") print(region.combat_dict['Defending']) print("******") print('attack reinforcements') print(region.combat_dict['Attacking Reinforcements']) print('defense reinforcements') print(region.combat_dict['Defending Reinforcements']) ''' combat_dict = copy.deepcopy(region.combat_dict) #print('IN COMPUTER:',combat_dict) #print('REGION IS: ', region) #print('ENTERERS:', region.enterers) #print(region.is_contested()) set_up_combat_dict(board_copy, region) #print('AFTER:',board_copy.regions[region.regionID].combat_dict) simulation_dict = simulations.simulation(region.combat_dict['Attacking'], region.combat_dict['Defending'], 1000, \ region.combat_dict['Attacking Reinforcements'], region.combat_dict['Defending Reinforcements']) ''' print("***ATTACKING***") print(region.combat_dict['Attacking']) print("******") print("***DEFENDING***") print(region.combat_dict['Defending']) print("******") #for key in region.combat_dict: #print(region.combat_dict[key]) ''' if len(combat_dict['Attacking']) > 0: if role == combat_dict['Attacking'][0].allegiance: is_attacking = True else: is_attacking = False utility += retreat.retreat(board_copy, region.regionID, [], simulation_dict, is_attacking, turn, combat_dict)['Staying value '] * 4 #account for difference in locations owned values value_loc_after = 0 for region in board_copy.regions: value_loc_after += retreat.value_of_location(board_copy, region.regionID, role) utility += (value_loc_after - value_loc_before) * 2 #throw in the random number generator with some base bad_move_utility #'move' is a substitute for whatever the move will be stored in later bad_move_utility = 3.5 if utility <= 0: utility = .01 utility_dict = {'move': utility, 'not move': bad_move_utility} if weighted_prob.weighted_prob(utility_dict) == 'move': #if utility > bad_move_utility: #total_string = '' #pause input_toggle.toggle_input('movement') print(computer_block.allegiance, 'ready to make a move') #input() if computer_path[0] != computer_path[ -1] and computer_block in board.regions[ computer_path[0]].blocks_present: board.move_block(computer_block, computer_path[0], end=computer_path[-1], position='comp', is_truce=truce, path=computer_path) else: print('Computer passes a movement point') other_movement.reset_total_string() print(computer_block.allegiance, 'done with move\n') #input_toggle.toggle_input('movement') #input() return board else: return good_move(board, num_moves, role, turn, truce, blocks_moved)
def should_retreat(board, attacking = None, defending = None, attacking_reinforcement = list(), defending_reinforcement = list(), is_attacking = None,\ combat_letter = 'A', combat_round = 0, turn = 'defender', retreat_constant = 0.3, attacking_block = None): ''' This function takes in all the group that are involved in a battle and a boolean about whether the computer is attacking or not. The should_retreat function will return either False, meaning the computer should not retreat, or a location in which the computer should retreat its blocks to. ''' attacking_copy = copy.deepcopy(attacking) defending_copy = copy.deepcopy(defending) attacking_rein_copy = copy.deepcopy(attacking_reinforcement) defending_rein_copy = copy.deepcopy(defending_reinforcement) simulation_dict = simulations.simulation(attacking_copy, defending_copy, 1000, attacking_rein_copy, defending_rein_copy, combat_letter, combat_round, turn) win_percentage = 0 #Calculate the win percentage based on if you are attacking or defending in the simulation if is_attacking: win_percentage = simulation_dict['attacker wins'] else: win_percentage = simulation_dict['defender wins'] + simulation_dict[ 'attacker retreats'] #Insert code to check to see if it should retreat possible_locations = [] if is_attacking: possible_locations = list( retreat_locations(board, [attacking_block], [], is_attacking)) else: possible_locations = list( retreat_locations(board, [], [attacking_block], is_attacking)) if len(possible_locations) == 0: return False if len(attacking) > 0 and attacking[0].current_strength > 0: found_location = find_location(board, attacking[0]) if found_location: current_location = found_location.regionID else: current_location = None elif len(attacking_reinforcement) > 0: current_location = find_location(board, attacking_reinforcement[0]).regionID else: current_location = find_location(board, defending[0]).regionID possible_locations_id = list() for location in possible_locations: possible_locations_id.append(location.regionID) #print('CURRENT LOCATION: ', current_location) choice_dictionary = retreat.retreat(board, current_location, possible_locations_id, simulation_dict, is_attacking, board.turn) choice = weighted_prob.weighted_prob(choice_dictionary) if choice == 'Staying value ': return False else: choice = board.regions[int(choice)] return choice
def good_move(board, num_moves, role, turn, truce, original_board): """ board is a copy of the board going to make a move with copies of the board goes and makes the move role is scotland or england turn is 1 2 3 4 or 5 finds some utility and throws into random number generator to see if move chosen or not READ ME READ ME READ ME READ ME READ ME READ ME MAKES A COPY OF THE BOARD DOES THE MOVE EVALUATES THE MOVE IF BAD MOVE AGAIN AND CONTINUE LOOPING UNTIL FINDS GOOD MOVE AND THEN IT EXECUTES IT ON THE ACTUAL BOARD """ global total_string utility = 0 #count how man value of location of homes owned before: value_loc_before = 0 for region in board.regions: value_loc_before += retreat.value_of_location(board, region.regionID, role) #does movement board_copy = copy.deepcopy(board) movement_execution(board_copy, 'comp', role, num_moves, truce=truce) #checks utilitiy of the battles using the retreat elliot's thing noble_home_after = 0 for region in board_copy.regions: if region.is_contested(): set_up_combat_dict(board_copy,region) simulation_dict = simulations.simulation(region.combat_dict['Attacking'], region.combat_dict['Defending'], 1000, \ region.combat_dict['Attacking Reinforcements'], region.combat_dict['Defending Reinforcements']) for key in region.combat_dict: print(region.combat_dict[key]) if role == region.combat_dict['Attacking'][0].allegiance: is_attacking = True else: is_attacking = False utility += retreat.retreat(board_copy, region.regionID, [], simulation_dict, is_attacking, turn)['Staying value '] * 4 #account for difference in locations owned values value_loc_after = 0 for region in board_copy.regions: value_loc_after += retreat.value_of_location(board_copy, region.regionID, role) utility += (value_loc_after - value_loc_before) * 2 #throw in the random number generator with some base bad_move_utility #'move' is a substitute for whatever the move will be stored in later bad_move_utility = .1 * num_moves if utility <= 0: utility = .01 utility_dict = {'move': utility, 'not move': bad_move_utility} if weighted_prob.weighted_prob(utility_dict) == 'move': total_string = '' #pause print('computer ready to make a move') input() movement_execution(board, 'comp', role, num_moves, truce=truce) original_board = board_copy print(total_string) total_string = '' print('computer done with move') input() else: total_string = '' good_move(original_board, num_moves, role, turn, truce, original_board)
def main(): finished = False first_time = True possible_answers = {'y', 'n'} attack_or_defense = ['attack', 'defense'] index = 0 attack = list() defense = list() ''' while not finished: if not first_time: bad_input = True while bad_input: input1 = input('do you want to add more blocks (y) or (n): ') if input1 not in possible_answers: print('Type y or n') else: bad_input = False if input1 == 'n': finished = True if not finished: bad = True while bad: print('What strength block do you want to add to', attack_or_defense[index]) strength = input('>') if strength.isdigit(): bad = False bad = True while bad: print('What letter block you want to add to', attack_or_defense[index]) letter = input('>') if letter.isalpha() and len(letter) == 1: bad = False bad = True while bad: print('What attack number do you want to add to', attack_or_defense[index]) attack_number1 = input('>') if attack_number1.isdigit(): bad = False new_block = blocks.Block(initial_attack_strength = int(strength), attack_letter = letter, attack_number = int(attack_number1)) if index == 1: defense.append(new_block) else: attack.append(new_block) index = 1 - index if not first_time and not finished: bad_input = True while bad_input: input1 = input('do you want to add more blocks (y) or (n): ') bad_input = False if input1 not in possible_answers: print('Type y or n') else: if input1 == 'n': finished = True if not finished: bad = True while bad: print('What strength block do you want to add to', attack_or_defense[index]) strength = input('>') if strength.isdigit(): bad = False bad = True while bad: print('What letter block you want to add to', attack_or_defense[index]) letter = input('>') if letter.isalpha() and len(letter) == 1: bad = False bad = True while bad: print('What attack number do you want to add to', attack_or_defense[index]) attack_number1 = input('>') if attack_number1.isdigit(): bad = False new_block = blocks.Block(initial_attack_strength = int(strength), attack_letter = letter, attack_number = int(attack_number1)) if index == 1: defense.append(new_block) else: attack.append(new_block) index = 1 - index first_time = False ''' attack = [ blocks.Block(attack_number=3, attack_letter='A', initial_attack_strength=4) ] defense = [ blocks.Block(attack_number=4, attack_letter='B', initial_attack_strength=4) ] bad_input = True while bad_input: try: num_times = int(input('How many times do you want to run this: ')) bad_input = False except ValueError: print('type number') print('SIMULATION RUNNING') print(simulations.simulation(attack, defense, num_times))
def main(): sim = simulation(sim_data_1) boids_xy = np.array([np.complex(x, y) for (x, y) in sim['boids_xy']]) boids_dxy = np.array([np.complex(0, 0) for _ in sim['boids_xy']]) boids_towards = boids_xy[..., np.newaxis] - boids_xy MA = np.tile(boids_xy[:, np.newaxis], boids_xy.size) boids_dist = abs(MA - MA.T) obstacles_xy = np.array([complex(x, y) for (x, y) in sim['obstacles_xy']]) obstacles_towards = np.array(boids_xy[..., np.newaxis] - obstacles_xy) obstacles_dist = abs(obstacles_towards) checkpoint_xy = np.array([ complex(*b.checkpoint) for b in itertools.chain( sim['boids'][Sheep]['objects'], sim['boids'][Dog]['objects'], sim['boids'][Wolf]['objects'], ) ]) checkpoint_towards = boids_xy - checkpoint_xy wall_dist = np.array( [[xy.real, xy.imag, consts.WIDTH - xy.real, consts.HEIGHT - xy.imag] for xy in boids_xy]) wall_towards = np.array( [[complex(-1, 0), complex(0, -1), complex(1, 0), complex(0, 1)] for _ in boids_xy]) global state state = { 'objects': [ b for b in itertools.chain( sim['boids'][Sheep]['objects'], sim['boids'][Dog]['objects'], sim['boids'][Wolf]['objects'], ) ], 'boids_xy': boids_xy, 'boids_dxy': boids_dxy, 'boids_towards': boids_towards, 'boids_dist': boids_dist, 'obstacles': sim['obstacles'], 'obstacles_xy': obstacles_xy, 'obstacles_towards': obstacles_towards, 'obstacles_dist': obstacles_dist, 'checkpoint_xy': checkpoint_xy, 'checkpoint_towards': checkpoint_towards, 'wall_dist': wall_dist, 'wall_towards': wall_towards, 'max_dist': defaultdict( lambda: np.array([[0] * len(boids_xy)]), **{ consts.WALLS: np.array([consts.WALL_DISTANCE for _ in range(len(boids_xy))]), consts.OBSTACLES: np.array( [consts.OBSTACLE_DISTANCE for _ in range(len(boids_xy))]), consts.SEPARATION: np.array([[ x for x in itertools.chain( [Sheep(100, []).SEPARATION_DISTANCES.get(Sheep, 0)] * len(sim['boids'][Sheep]['objects']), [Sheep(100, []).SEPARATION_DISTANCES.get(Dog, 0)] * len(sim['boids'][Dog]['objects']), [Sheep(100, []).SEPARATION_DISTANCES.get(Wolf, 0)] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Sheep]['objects']) + [[ x for x in itertools.chain( [Dog(100, []).SEPARATION_DISTANCES.get(Sheep, 0)] * len(sim['boids'][Sheep]['objects']), [Dog(100, []).SEPARATION_DISTANCES.get(Dog, 0)] * len(sim['boids'][Dog]['objects']), [Dog(100, []).SEPARATION_DISTANCES.get(Wolf, 0)] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Dog]['objects']) + [[ x for x in itertools.chain( [Wolf(100, []).SEPARATION_DISTANCES.get(Sheep, 0)] * len(sim['boids'][Sheep]['objects']), [Wolf(100, []).SEPARATION_DISTANCES.get(Dog, 0)] * len(sim['boids'][Dog]['objects']), [Wolf(100, []).SEPARATION_DISTANCES.get(Wolf, 0)] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Wolf]['objects'])), consts.ALIGNMENT: np.array([[ x for x in itertools.chain( [64] * len(sim['boids'][Sheep]['objects']), [0] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Sheep]['objects']) + [[ x for x in itertools.chain( [0] * len(sim['boids'][Sheep]['objects']), [0] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Dog]['objects']) + [[ x for x in itertools.chain( [0] * len(sim['boids'][Sheep]['objects']), [0] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Wolf]['objects'])), consts.COHESION: np.array([[ x for x in itertools.chain( [64] * len(sim['boids'][Sheep]['objects']), [64] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Sheep]['objects']) + [[ x for x in itertools.chain( [64] * len(sim['boids'][Sheep]['objects']), [64] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Dog]['objects']) + [[ x for x in itertools.chain( [0] * len(sim['boids'][Sheep]['objects']), [0] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Wolf]['objects'])), consts.HUNT: np.array([[ x for x in itertools.chain( [0] * len(sim['boids'][Sheep]['objects']), [0] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Sheep]['objects']) + [[ x for x in itertools.chain( [0] * len(sim['boids'][Sheep]['objects']), [0] * len(sim['boids'][Dog]['objects']), [160] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Dog]['objects']) + [[ x for x in itertools.chain( [160] * len(sim['boids'][Sheep]['objects']), [0] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Wolf]['objects'])), }), 'weights': { consts.ALIGNMENT: np.array([[ x for x in itertools.chain( [sim['boids'][Sheep]['rules'][Sheep][consts.ALIGNMENT]] * len(sim['boids'][Sheep]['objects']), [0] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Sheep]['objects']) + [[0] * len(sim['boids_xy'])] * (len(sim['boids'][Dog]['objects']) + len(sim['boids'][Wolf]['objects']))), consts.COHESION: np.array([[ x for x in itertools.chain( [sim['boids'][Sheep]['rules'][Sheep][consts.COHESION]] * len(sim['boids'][Sheep]['objects']), [sim['boids'][Sheep]['rules'][Dog][consts.COHESION]] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Sheep]['objects']) + [[ x for x in itertools.chain( [sim['boids'][Dog]['rules'][Sheep][consts.COHESION]] * len(sim['boids'][Sheep]['objects']), [0] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Dog]['objects']) + [[0] * len(sim['boids_xy'])] * len(sim['boids'][Wolf]['objects'])), consts.SEPARATION: np.array([[ x for x in itertools.chain( [sim['boids'][Sheep]['rules'][Sheep][consts.SEPARATION]] * len(sim['boids'][Sheep]['objects']), [sim['boids'][Sheep]['rules'][Dog][consts.SEPARATION]] * len(sim['boids'][Dog]['objects']), [sim['boids'][Sheep]['rules'][Wolf][consts.SEPARATION]] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Sheep]['objects']) + [[ x for x in itertools.chain( [sim['boids'][Dog]['rules'][Sheep][consts.SEPARATION]] * len(sim['boids'][Sheep]['objects']), [sim['boids'][Dog]['rules'][Dog][consts.SEPARATION]] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Dog]['objects']) + [[ x for x in itertools.chain( [0] * len(sim['boids'][Sheep]['objects']), [sim['boids'][Wolf]['rules'][Dog][consts.SEPARATION]] * len(sim['boids'][Dog]['objects']), [sim['boids'][Wolf]['rules'][Wolf][consts.SEPARATION]] * len(sim['boids'][Wolf]['objects']), ) ]] * len(sim['boids'][Wolf]['objects'])), consts.WALLS: np.identity(boids_xy.shape[0]) * np.array([ x for x in itertools.chain( [sim['boids'][Sheep]['rules'][Sheep][consts.WALLS]] * len(sim['boids'][Sheep]['objects']), [sim['boids'][Dog]['rules'][Dog][consts.WALLS]] * len(sim['boids'][Dog]['objects']), [sim['boids'][Wolf]['rules'][Wolf][consts.WALLS]] * len(sim['boids'][Wolf]['objects']), ) ]), consts.OBSTACLES: np.identity(boids_xy.shape[0]) * np.array([ x for x in itertools.chain( [sim['boids'][Sheep]['rules'][Sheep][consts.OBSTACLES]] * len(sim['boids'][Sheep]['objects']), [sim['boids'][Dog]['rules'][Dog][consts.OBSTACLES]] * len(sim['boids'][Dog]['objects']), [sim['boids'][Wolf]['rules'][Wolf][consts.OBSTACLES]] * len(sim['boids'][Wolf]['objects']), ) ]), consts.CHECKPOINT: np.identity(boids_xy.shape[0]) * np.array([ x for x in itertools.chain( [sim['boids'][Sheep]['rules'][Sheep][consts.CHECKPOINT]] * len(sim['boids'][Sheep]['objects']), [sim['boids'][Dog]['rules'][Dog][consts.CHECKPOINT]] * len(sim['boids'][Dog]['objects']), [0] * len(sim['boids'][Wolf]['objects']), ) ]), consts.HUNT: np.identity(boids_xy.shape[0]) * np.array([ x for x in itertools.chain( [0] * len(sim['boids'][Sheep]['objects']), [sim['boids'][Dog]['rules'][Wolf][consts.HUNT]] * len(sim['boids'][Dog]['objects']), [sim['boids'][Wolf]['rules'][Sheep][consts.HUNT]] * len(sim['boids'][Wolf]['objects']), ) ]), consts.MAINTENANCE: np.identity(boids_xy.shape[0]) * np.array([ x for x in itertools.chain( [sim['boids'][Sheep]['rules'][Sheep][consts.MAINTENANCE]] * len(sim['boids'][Sheep]['objects']), [sim['boids'][Dog]['rules'][Dog][consts.MAINTENANCE]] * len(sim['boids'][Dog]['objects']), [sim['boids'][Wolf]['rules'][Wolf][consts.MAINTENANCE]] * len(sim['boids'][Wolf]['objects']), ) ]), consts.KILL: np.zeros(boids_xy.shape[0]), }, 'speed': np.array([ x for x in itertools.chain( [Sheep.MAX_SPEED] * len(sim['boids'][Sheep]['objects']), [Dog.MAX_SPEED] * len(sim['boids'][Dog]['objects']), [Wolf.MAX_SPEED] * len(sim['boids'][Wolf]['objects']), ) ]) } state['kill_dist'] = np.array([[a.kill_dist(b) for b in state['objects']] for a in state['objects']]) # Open up our window arcade.open_window(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE) arcade.set_background_color(arcade.color.GREEN) # Tell the computer to call the draw command at the specified interval. arcade.schedule(draw, 1 / 60) # Run the program arcade.run()