def check_radius_squares_factories(gc, location): location_coords = (location.x, location.y) nearby_locs = explore.coord_neighbors(location_coords) for nearby_loc_coords in nearby_locs: nearby_loc = bc.MapLocation(variables.curr_planet, nearby_loc_coords[0], nearby_loc_coords[1]) if gc.can_sense_location(nearby_loc) and gc.has_unit_at_location(nearby_loc) and gc.sense_unit_at_location(nearby_loc).unit_type == bc.UnitType.Factory: return True return False
def optimal_unload(gc, unit, directions, building_assignments, battle_locs): """ Tries to find unload direction towards a battle location, otherwise finds another optimal direction with previous logic. Returns direction or None. """ unit_loc = unit.location.map_location() #build_sites = list(map(lambda site: site.map_location,list(building_assignments.values()))) ## Find list of best unload towards battle_locs and use best dir that doesn't interfere with building if len(battle_locs) > 0: weakest = random.choice(list(battle_locs.keys())) target_loc = battle_locs[weakest][0] shape = [target_loc.x - unit_loc.x, target_loc.y - unit_loc.y] unload_dirs = sense_util.get_best_option( shape) ## never returns None or empty list for d in unload_dirs: if gc.can_unload(unit.id, d): #and unit_loc.add(d) not in build_sites return d ## Use previous optimal location best = None best_val = -float('inf') map_loc = unit.location.map_location() map_loc_coords = (map_loc.x, map_loc.y) for d in directions: if gc.can_unload( unit.id, d ): # and unit.location.map_location().add(d) not in build_sites locs = explore.coord_neighbors(map_loc_coords, diff=explore.diffs_10) locs_good = [] for loc in locs: loc_map_vers = bc.MapLocation(variables.curr_planet, loc[0], loc[1]) if gc.can_sense_location( loc_map_vers) and gc.has_unit_at_location( loc_map_vers): locs_good.append(loc) num_good = len(locs_good) if num_good > best_val: best_val = num_good best = d return best
def get_neighboring_quadrants(self): quadrant = (int(self.bottom_left[0] / self.quadrant_size), int(self.bottom_left[1] / self.quadrant_size)) return explore.coord_neighbors(quadrant)
def timestep(unit): building_assignments = variables.building_assignment directions = variables.directions gc = variables.gc composition = variables.info producing = variables.producing battle_locs = variables.last_turn_battle_locs mining_rate = 3 * len(variables.current_worker_roles["miner"]) total_units = [composition[0]+producing[0], composition[1]+producing[1], composition[2]+producing[2], composition[3]+producing[3], composition[4]+producing[4]] num_attacking_units = sum(total_units[1:3]) num_non_workers = num_attacking_units + total_units[4] curr_round = gc.round() # should alter based on curr_round. this is a temporary idea. # last check to make sure the right unit type is running this if unit.unit_type != bc.UnitType.Factory: # prob should return some kind of error return unit_locations = variables.unit_locations quadrant_battles = variables.quadrant_battle_locs if variables.curr_planet == bc.Planet.Earth: quadrant_size = variables.earth_quadrant_size else: quadrant_size = variables.mars_quadrant_size ## Add new ones to unit_locations, else just get the location if unit.id not in unit_locations: loc = unit.location.map_location() unit_locations[unit.id] = (loc.x,loc.y) f_f_quad = (int(loc.x / quadrant_size), int(loc.y / quadrant_size)) quadrant_battles[f_f_quad].add_ally(unit.id, "factory") garrison = unit.structure_garrison() # units inside of factory if len(garrison)>0: # try to unload a unit if there exists one in the garrison optimal_unload_dir = optimal_unload(gc, unit, directions, building_assignments, battle_locs) if optimal_unload_dir is not None: gc.unload(unit.id, optimal_unload_dir) # rockets_need_filling = (len(variables.rocket_locs) >0) and (len(variables.ranger_roles["go_to_mars"])<10) if variables.knight_rush: if gc.round()>250 or variables.died_without_attacking > 0.7 or variables.ranged_enemies >= 5: variables.knight_rush = False variables.switch_to_rangers = True """ """ if variables.knight_rush: if not variables.stockpile_until_75 and gc.can_produce_robot(unit.id, bc.UnitType.Knight): #and should_produce_robot(gc, mining_rate, current_production, karbonite_lower_limit): # otherwise produce a unit, based on most_off_optimal if total_units[0]<2: if gc.can_produce_robot(unit.id, bc.UnitType.Worker): gc.produce_robot(unit.id, bc.UnitType.Worker) variables.producing[0] += 1 elif total_units[1] < 0.75* num_non_workers or total_units[2]<7: gc.produce_robot(unit.id, bc.UnitType.Knight) variables.producing[1] += 1 else: gc.produce_robot(unit.id, bc.UnitType.Healer) variables.producing[4] += 1 else: produce_some_knights = False my_location = unit.location.map_location() my_location_coords = (my_location.x, my_location.y) if gc.round() < 250: for neighbor in explore.coord_neighbors(my_location_coords, diff=explore.diffs_20): neighbor_loc = bc.MapLocation(variables.curr_planet, neighbor[0], neighbor[1]) if gc.can_sense_location(neighbor_loc) and gc.has_unit_at_location(neighbor_loc): nearby_unit = gc.sense_unit_at_location(neighbor_loc) if nearby_unit.unit_type == variables.unit_types["factory"] and nearby_unit.team !=variables.my_team: produce_some_knights = True break if produce_some_knights and gc.can_produce_robot(unit.id, bc.UnitType.Knight): gc.produce_robot(unit.id, bc.UnitType.Knight) variables.producing[1] += 1 elif not variables.stockpile_until_75 and (total_units[0]<2 or gc.round()<680 or len(variables.rocket_locs)>0) and gc.can_produce_robot(unit.id, bc.UnitType.Ranger) \ and (total_units[0]<2 or gc.round() < 150 or num_attacking_units < 60 or num_attacking_units < 2*variables.num_enemies): #and should_produce_robot(gc, mining_rate, current_production, karbonite_lower_limit): # otherwise produce a unit, based on most_off_optimal if total_units[0]<2: if gc.can_produce_robot(unit.id, bc.UnitType.Worker): gc.produce_robot(unit.id, bc.UnitType.Worker) variables.producing[0]+=1 #elif total_units[1]<5 and gc.round() < 70: # gc.produce_robot(unit.id, bc.UnitType.Knight) elif total_units[2] < 0.63 * num_non_workers or total_units[2]<3: gc.produce_robot(unit.id, bc.UnitType.Ranger) variables.producing[2] += 1 else: gc.produce_robot(unit.id, bc.UnitType.Healer) variables.producing[4] += 1
if x == -1 or y == -1 or x == earth_map.width or y == earth_map.height: passable_locations_earth[coords] = False elif earth_map.is_passable_terrain_at(bc.MapLocation(earth, x, y)): passable_locations_earth[coords] = True else: passable_locations_earth[coords] = False number_of_cells = earth_width * earth_height start_time = time.time() S = dok_matrix((number_of_cells, number_of_cells), dtype=int) for x in range(earth_width): for y in range(earth_height): curr = (x, y) if passable_locations_earth[curr]: val = y * earth_width + x for coord in explore.coord_neighbors(curr): if passable_locations_earth[coord]: val2 = coord[1] * earth_width + coord[0] S[val, val2] = 1 S[val2, val] = 1 bfs_array = csgraph.shortest_path(S, method='D', unweighted=True) #bfs_dict = {} # stores the distances found by BFS so far #precomputed_bfs = explore.precompute_earth(passable_locations_earth, coord_to_direction, wavepoints) #start_time = time.time() #precomputed_bfs_dist = explore.precompute_earth_dist(passable_locations_earth, coord_to_direction, wavepoints) #print(time.time()-start_time) dist_to_enemies = [] dists = [] for our_init_loc in our_init_locs: for their_init_loc in init_enemy_locs: