def mine(gc, unit, karbonite_locations, current_roles, building_assignment): my_location = unit.location position = my_location.map_location() closest_deposit = get_closest_deposit(gc, unit, karbonite_locations) start_map = gc.starting_map(bc.Planet(0)) #check to see if there even are deposits if start_map.on_map(closest_deposit): direction_to_deposit = position.direction_to(closest_deposit) #print(unit.id, "is trying to mine at", direction_to_deposit) if position.is_adjacent_to( closest_deposit) or position == closest_deposit: # mine if adjacent to deposit if gc.can_harvest(unit.id, direction_to_deposit): gc.harvest(unit.id, direction_to_deposit) current_roles["miner"].remove(unit.id) #print(unit.id," just harvested!") else: # move toward deposit enemies = gc.sense_nearby_units_by_team(position, unit.vision_range, sense_util.enemy_team(gc)) if len(enemies) > 0: dir = sense_util.best_available_direction(gc, unit, enemies) movement.try_move(gc, unit, dir) #current_roles["miner"].remove(unit.id) #current_roles["builder"].append(unit.id) #building_assignment[unit.id] = pick_closest_building_assignment(gc, unit, building_assignment) else: movement.try_move(gc, unit, direction_to_deposit) else: current_roles["miner"].remove(unit.id)
def mage_sense(gc, unit, battle_locs, queued_paths): dir = None attack = None blink = None move_then_attack = False visible_enemies = False location = unit.location.map_location() enemies = gc.sense_nearby_units_by_team(location, unit.vision_range, sense_util.enemy_team(gc)) if len(enemies) > 0: if unit.id in queued_paths: del queued_paths[unit.id] visible_enemies = True sorted_enemies = sorted(enemies, key=lambda x: x.location.map_location(). distance_squared_to(location)) closest_enemy = ranger.closest_among_ungarrisoned(sorted_enemies) print('closest enemy:', closest_enemy) attack = ranger.get_attack(gc, unit, location) print(attack) if attack is not None: print('found it here') if closest_enemy is not None: if (ranger.exists_bad_enemy(enemies) and (closest_enemy.location.map_location().distance_squared_to( location))**(0.5) + 2 < unit.attack_range()** (0.5)) or not gc.can_attack(unit.id, attack.id): dir = sense_util.best_available_direction( gc, unit, enemies) else: if gc.is_move_ready(unit.id): if closest_enemy is not None: dir = ranger.optimal_direction_towards( gc, unit, location, closest_enemy.location.map_location()) next_turn_loc = location.add(dir) attack = ranger.get_attack(gc, unit, next_turn_loc) if attack is not None: move_then_attack = True else: dir = ranger.get_explore_dir(gc, unit) else: if unit.id in queued_paths: if location != queued_paths[unit.id]: dir = ranger.optimal_direction_towards(gc, unit, location, queued_paths[unit.id]) return dir, attack, blink, move_then_attack, visible_enemies else: del queued_paths[unit.id] if len(battle_locs) > 0: dir, target = ranger.go_to_battle(gc, unit, battle_locs) queued_paths[unit.id] = target else: dir = ranger.get_explore_dir(gc, unit) return dir, attack, blink, move_then_attack, visible_enemies
def move_away(gc, unit, battle_locs, map_loc): lst = [] for nearby_unit in gc.sense_nearby_units(map_loc, 10): if nearby_unit.location.is_on_map(): nearby_loc = nearby_unit.location.map_location() 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: lst.append(nearby_unit) return sense_util.best_available_direction(gc, unit, lst)
def timestep(gc, unit, info, karbonite_locations, locs_next_to_terrain, blueprinting_queue, building_assignment, current_roles): # last check to make sure the right unit type is running this if unit.unit_type != bc.UnitType.Worker: # prob should return some kind of error return my_team = gc.team() my_location = unit.location # make sure unit can actually perform actions ie. not in garrison if not my_location.is_on_map(): return print() print("ON UNIT #", unit.id, "position: ", unit.location.map_location()) role = get_role(gc, unit, blueprinting_queue, current_roles, karbonite_locations) print("KARBONITE: ", gc.karbonite()) if gc.team() == bc.Team(0): pass #print("current_roles",current_roles) #print("blueprinting_queue",blueprinting_queue) #print("building_assignment",building_assignment) current_num_workers = info[0] max_num_workers = get_replication_cap(gc, karbonite_locations) worker_spacing = 10 #print("REPLICATION CAP: ",max_num_workers) # replicates if unit is able to (cooldowns, available directions etc.) if current_num_workers < max_num_workers: replicate(gc, unit) return # runs this block every turn if unit is miner if role == "miner": mine(gc, unit, karbonite_locations, current_roles) # if unit is builder elif role == "builder": build(gc, unit, building_assignment, current_roles) # if unit is blueprinter elif role == "blueprinter": blueprint(gc, unit, blueprinting_queue, building_assignment, current_roles, locs_next_to_terrain) # if unit is idle elif role == "idle": nearby = gc.sense_nearby_units(my_location.map_location(), worker_spacing) away_from_units = sense_util.best_available_direction(gc, unit, nearby) print(unit.id, "at", unit.location.map_location(), "is trying to move to", away_from_units) movement.try_move(gc, unit, away_from_units)
def timestep(gc, unit, composition, knight_to_cluster, seen_knights_ids, KNIGHT_CLUSTER_MIN, constants): # last check to make sure the right unit type is running this if unit.unit_type != bc.UnitType.Knight: # prob should return some kind of error return my_team = gc.team() direction = None location = unit.location if location.is_on_map() and unit.id not in seen_knights_ids: ## Clustering: if has a goal location keep moving there if unit.id in knight_to_cluster: try: c = knight_to_cluster[unit.id] # print('cluster units: ', c.cluster_units()) valid_cluster = clusters.knight_cluster_sense(gc, unit, c) except: # print('KNIGHT clustering sense didnt run') pass try: if not valid_cluster: clusters.remove_cluster(c, knight_to_cluster) # print('removed cluster') else: seen_knights_ids.update(c.cluster_units()) except: # print('cannot remove cluster OR add units to seen') pass else: try: enemy = knight_sense(gc, unit, knight_to_cluster, KNIGHT_CLUSTER_MIN) except: # print('KNIGHT sense didnt run') pass ## Movement try: ## Knight movement away from allies if direction == None: nearby = gc.sense_nearby_units(unit.location.map_location(),8) direction = sense_util.best_available_direction(gc,unit,nearby) if gc.is_move_ready(unit.id) and gc.can_move(unit.id, direction): gc.move_robot(unit.id, direction) # print('moved no cluster') except: # print('KNIGHT movement didnt go through') pass
def timestep(gc, unit, composition, last_turn_battle_locs): # last check to make sure the right unit type is running this if unit.unit_type != bc.UnitType.Healer: return my_team = gc.team() direction = None location = unit.location if location.is_on_map(): unit_loc = location.map_location() print('HEALER LOC: ', unit_loc) directions, heal_target = healer_sense(gc, unit, last_turn_battle_locs) ## Movement try: if directions is not None: if len(directions) > 0 and gc.is_move_ready(unit.id): for d in directions: if gc.can_move(unit.id, d): gc.move_robot(unit.id, d) print('HEALER moved to battle loc!') break ## Healer movement away from allies else: nearby = gc.sense_nearby_units(unit.location.map_location(), 8) direction = sense_util.best_available_direction( gc, unit, nearby) if gc.is_move_ready(unit.id) and gc.can_move( unit.id, direction): gc.move_robot(unit.id, direction) print('HEALER moved away from allies!') except: print('HEALER movement didnt go through') ## Healing try: if heal_target is not None: if gc.is_heal_ready(unit.id) and gc.can_heal( unit.id, heal_target.id): gc.heal(unit.id, heal_target.id) # heal it, if possible print('healed ', heal_target.id) except: print('HEALER healing didnt go through')
def mine_mars(gc, unit): my_location = unit.location.map_location() all_locations = gc.all_locations_within(my_location, unit.vision_range) planet = bc.Planet.Mars start_map = gc.starting_map(planet) worker_spacing = 8 current_distance = float('inf') closest_deposit = bc.MapLocation(planet, -1, -1) for deposit_location in all_locations: if gc.karbonite_at(deposit_location) == 0: continue distance_to_deposit = my_location.distance_squared_to(deposit_location) #keep updating current closest deposit to unit if distance_to_deposit < current_distance: current_distance = distance_to_deposit closest_deposit = deposit_location #check to see if there even are deposits if start_map.on_map(closest_deposit): direction_to_deposit = my_location.direction_to(closest_deposit) #print(unit.id, "is trying to mine at", direction_to_deposit) if my_location.is_adjacent_to( closest_deposit) or my_location == closest_deposit: # mine if adjacent to deposit if gc.can_harvest(unit.id, direction_to_deposit): gc.harvest(unit.id, direction_to_deposit) #print(unit.id," just harvested on Mars!") else: # move toward deposit movement.try_move(gc, unit, direction_to_deposit) else: nearby = gc.sense_nearby_units_by_team(my_location.map_location(), worker_spacing, gc.team()) away_from_units = sense_util.best_available_direction(gc, unit, nearby) #print(unit.id, "at", unit.location.map_location(), "is trying to move to", away_from_units) movement.try_move(gc, unit, away_from_units)
def timestep(unit): # last check to make sure the right unit type is running this if unit.unit_type != bc.UnitType.Healer: return # print('HEALER ID: ', unit.id) gc = variables.gc composition = variables.info direction_to_coord = variables.direction_to_coord bfs_array = variables.bfs_array enemy_team = variables.enemy_team my_team = variables.my_team assigned_healers = variables.assigned_healers ## healer id: (cluster, best_healer_loc) assigned_overcharge = variables.assigned_overcharge overcharge_targets = variables.overcharge_targets 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 unit_locations = variables.unit_locations best_dir = None best_loc = None best_heal_target = None best_overcharge_target = None heal = False overcharge = False location = unit.location if location.is_on_map(): #print(location.map_location()) ## 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, "healer") unit_loc = unit_locations[unit.id] ## Assign role if unit.id not in assigned_overcharge and unit.id not in assigned_healers: overcharge_to_total = 1 total = len(assigned_healers) + len(assigned_overcharge) if total > 0: overcharge_to_total = len(assigned_overcharge) / total # Assign to overcharge if there are targets and ratio is good if variables.research.get_level( variables.unit_types["healer"] ) == 3 and overcharge_to_total < 0.2 and len( overcharge_targets) > 0: best_overcharge_target = gc.unit(overcharge_targets.pop()) assigned_overcharge[unit.id] = best_overcharge_target best_heal_target = get_best_target(gc, unit, unit_loc, my_team) if best_heal_target is not None: heal = True assigned, best_loc = assign_to_quadrant(gc, unit, unit_loc) # print('assigned? ', assigned) # print('assigned loc: ', best_loc) if not assigned: nearby = gc.sense_nearby_units_by_team( bc.MapLocation(variables.curr_planet, unit_loc[0], unit_loc[1]), 8, variables.my_team) best_dir = sense_util.best_available_direction( gc, unit, nearby) ## Overcharge if unit.id in assigned_overcharge: ally = assigned_overcharge[unit.id] if gc.can_overcharge(unit.id, ally.id): overcharge = True best_overcharge_target = ally if best_heal_target is None: best_heal_target = get_best_target(gc, unit, unit_loc, my_team) if best_heal_target is not None: heal = True ## Movement # If sees enemies close enough then tries to move away from them loc = bc.MapLocation(variables.curr_planet, unit_loc[0], unit_loc[1]) enemies = gc.sense_nearby_units_by_team(loc, unit.vision_range, enemy_team) if len(enemies) > 0: enemies = sorted(enemies, key=lambda x: x.location.map_location(). distance_squared_to(loc)) enemy_loc = enemies[0].location.map_location() best_dir = dir_away_from_enemy(gc, unit, loc, enemy_loc) elif variables.curr_round > 650: best_dir = Ranger.move_to_rocket(gc, unit, loc, variables.direction_to_coord, variables.bfs_array) # Otherwise, goes to locations in need of healers else: if unit.id in assigned_overcharge: ally = assigned_overcharge[unit.id] best_loc_map = ally.location.map_location() best_loc = (best_loc_map.x, best_loc_map.y) elif unit.id in assigned_healers: best_loc = assigned_healers[unit.id][1] ## Do shit #print(best_dir) #print(best_loc) if best_overcharge_target is not None: if overcharge and gc.is_overcharge_ready(unit.id): gc.overcharge(unit.id, best_overcharge_target.id) overcharged_unit = gc.unit(best_overcharge_target.id) if overcharged_unit.unit_type == variables.unit_types[ "ranger"]: Ranger.timestep(overcharged_unit) if best_heal_target is not None: if heal and gc.is_heal_ready(unit.id) and gc.can_heal( unit.id, best_heal_target.id): gc.heal(unit.id, best_heal_target.id) if best_dir is not None and gc.is_move_ready(unit.id) and gc.can_move( unit.id, best_dir): gc.move_robot(unit.id, best_dir) add_new_location(unit.id, unit_loc, best_dir) elif best_loc is not None and gc.is_move_ready( unit.id) and unit_loc != best_loc: try_move_smartly(unit, unit_loc, best_loc)
def ranger_sense(gc, unit, battle_locs, queued_paths, ranger_roles, location, constants, direction_to_coord, precomputed_bfs): if unit.id in ranger_roles["sniper"]: return snipe_sense(gc, unit, battle_locs, queued_paths, location, direction_to_coord, precomputed_bfs) signals = {} dir = None attack = None snipe = None closest_enemy = None move_then_attack = False visible_enemies = False enemies = gc.sense_nearby_units_by_team(location, unit.vision_range, sense_util.enemy_team(gc)) if len(enemies) > 0: if unit.id in queued_paths: del queued_paths[unit.id] visible_enemies = True sorted_enemies = sorted(enemies, key=lambda x: x.location.map_location(). distance_squared_to(location)) closest_enemy = closest_among_ungarrisoned(sorted_enemies) attack = get_attack(gc, unit, location) if attack is not None: if closest_enemy is not None: if check_radius_squares_factories(gc, unit): dir = optimal_direction_towards( gc, unit, location, closest_enemy.location.map_location(), constants.directions) elif (exists_bad_enemy(enemies)) or not gc.can_attack( unit.id, closest_enemy.id): dir = sense_util.best_available_direction( gc, unit, enemies) #and (closest_enemy.location.map_location().distance_squared_to(location)) ** ( #0.5) + 2 < unit.attack_range() ** (0.5)) or not gc.can_attack(unit.id, attack.id): else: if gc.is_move_ready(unit.id): if closest_enemy is not None: dir = optimal_direction_towards( gc, unit, location, closest_enemy.location.map_location(), constants.directions) next_turn_loc = location.add(dir) attack = get_attack(gc, unit, next_turn_loc) if attack is not None: move_then_attack = True else: dir = get_explore_dir(gc, unit, location, constants.directions) else: # if there are no enemies in sight, check if there is an ongoing battle. If so, go there. if len(battle_locs) > 0: dir, target = go_to_battle(gc, unit, battle_locs, constants.directions, location, direction_to_coord, precomputed_bfs) #queued_paths[unit.id] = target else: #dir = move_away(gc, unit, battle_locs) dir = get_explore_dir(gc, unit, location, constants.directions) """ elif unit.id in queued_paths: if location!=queued_paths[unit.id]: dir = optimal_direction_towards(gc, unit, location, queued_paths[unit.id]) return dir, attack, snipe, move_then_attack, visible_enemies, signals else: del queued_paths[unit.id] """ return dir, attack, snipe, move_then_attack, visible_enemies, closest_enemy, signals
def ranger_sense(gc, unit, battle_locs, ranger_roles, location, direction_to_coord, bfs_array, targeting_units, rocket_locs): enemies = gc.sense_nearby_units_by_team(location, unit.vision_range, variables.enemy_team) if unit.id in ranger_roles["sniper"]: return snipe_sense(gc, unit, battle_locs, location, enemies, direction_to_coord, bfs_array, targeting_units) elif unit.id in ranger_roles["go_to_mars"]: return go_to_mars_sense(gc, unit, battle_locs, location, enemies, direction_to_coord, bfs_array, targeting_units, rocket_locs) signals = {} dir = None attack = None snipe = None closest_enemy = None move_then_attack = False visible_enemies = False start_time = time.time() # if variables.print_count < 10: # print("Sensing nearby units:", time.time() - start_time) if len(enemies) > 0: visible_enemies = True start_time = time.time() closest_enemy = None closest_dist = float('inf') for enemy in enemies: loc = enemy.location if loc.is_on_map(): dist = sense_util.distance_squared_between_maplocs( loc.map_location(), location) if dist < closest_dist: closest_dist = dist closest_enemy = enemy # if variables.print_count < 10: # print("Getting closest enemy:", time.time() - start_time) # sorted_enemies = sorted(enemies, key=lambda x: x.location.map_location().distance_squared_to(location)) # closest_enemy = closest_among_ungarrisoned(sorted_enemies) start_time = time.time() attack = get_attack(gc, unit, location, targeting_units) # if variables.print_count < 10: # print("Getting attack:", time.time() - start_time) if attack is not None: if closest_enemy is not None: start_time = time.time() if check_radius_squares_factories(gc, location): dir = optimal_direction_towards( gc, unit, location, closest_enemy.location.map_location()) elif (exists_bad_enemy(closest_enemy)) or not gc.can_attack( unit.id, closest_enemy.id): # if variables.print_count < 10: # print("Checking if condition:", time.time() - start_time) start_time = time.time() dir = sense_util.best_available_direction( gc, unit, [closest_enemy]) # if variables.print_count < 10: # print("Getting best available direction:", time.time() - start_time) # and (closest_enemy.location.map_location().distance_squared_to(location)) ** ( # 0.5) + 2 < unit.attack_range() ** (0.5)) or not gc.can_attack(unit.id, attack.id): else: if gc.is_move_ready(unit.id): if closest_enemy is not None: dir = optimal_direction_towards( gc, unit, location, closest_enemy.location.map_location()) next_turn_loc = location.add(dir) attack = get_attack(gc, unit, next_turn_loc, targeting_units) if attack is not None: move_then_attack = True else: dir = run_towards_init_loc_new(gc, unit, location, direction_to_coord) # if variables.print_count < 10: # print("Getting direction:", time.time() - start_time) else: # if there are no enemies in sight, check if there is an ongoing battle. If so, go there. if len(rocket_locs) > 0 and gc.round( ) > 600 and variables.curr_planet == bc.Planet.Earth: dir = move_to_rocket(gc, unit, location, direction_to_coord, bfs_array) if dir is not None: return dir, attack, snipe, move_then_attack, visible_enemies, closest_enemy, signals if len(battle_locs) > 0: # print('IS GOING TO BATTLE') dir = go_to_battle_new(gc, unit, battle_locs, location, direction_to_coord) # queued_paths[unit.id] = target else: # dir = move_away(gc, unit, battle_locs) if variables.curr_planet == bc.Planet.Earth: # print('IS RUNNING TOWARDS INIT LOC') dir = run_towards_init_loc_new(gc, unit, location, direction_to_coord) else: # print('EXPLORING') dir = get_explore_dir(gc, unit, location) """ elif unit.id in queued_paths: if location!=queued_paths[unit.id]: dir = optimal_direction_towards(gc, unit, location, queued_paths[unit.id]) return dir, attack, snipe, move_then_attack, visible_enemies, signals else: del queued_paths[unit.id] """ # if variables.print_count < 10: # print("regular movement:", time.time() - start_time) return dir, attack, snipe, move_then_attack, visible_enemies, closest_enemy, signals """
def timestep(unit): # last check to make sure the right unit type is running this if unit.unit_type != bc.UnitType.Knight: # prob should return some kind of error return gc = variables.gc assigned_knights = variables.assigned_knights quadrant_battles = variables.quadrant_battle_locs unit_locations = variables.unit_locations info = variables.info my_team = variables.my_team enemy_team = variables.enemy_team directions = variables.directions best_loc = None ## (x,y) best_dir = None best_target = None location = unit.location if variables.curr_planet == bc.Planet.Earth: quadrant_size = variables.earth_quadrant_size else: quadrant_size = variables.mars_quadrant_size if location.is_on_map(): # unit_loc = location.map_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, "knight") unit_loc = unit_locations[unit.id] ## Attack best_target = get_best_target(gc, unit, unit_loc, knight_unit_priority) ## Movement # If new knight assign to location if unit.id not in assigned_knights: assigned, best_loc = assign_to_quadrant(gc, unit, unit_loc) if not assigned: nearby = gc.sense_nearby_units_by_team( bc.MapLocation(variables.curr_planet, unit_loc[0], unit_loc[1]), 8, variables.my_team) best_dir = sense_util.best_available_direction( gc, unit, nearby) else: best_loc = assigned_knights[unit.id] ## Do shit # Attack if best_target is not None and gc.can_attack( unit.id, best_target.id ): # checked if ready to attack in get best target gc.attack(unit.id, best_target.id) # Move if best_loc is not None and gc.is_move_ready( unit.id) and unit_loc != best_loc: try_move_smartly(unit, unit_loc, best_loc) elif best_dir is not None and gc.is_move_ready( unit.id) and gc.can_move(unit.id, best_dir): gc.move_robot(unit.id, best_dir) add_new_location(unit.id, unit_loc, best_dir)
def blueprint(gc, unit, blueprinting_queue, building_assignment, current_roles, locs_next_to_terrain): my_location = unit.location start_map = gc.starting_map(bc.Planet(0)) directions = list(bc.Direction) blueprint_spacing = 20 nearby = gc.sense_nearby_units(my_location.map_location(), blueprint_spacing) is_nearby_factories = False is_nearby_potential_factories = False # if it finds a nice location for factory cluster, put it in queue if len(blueprinting_queue) < get_cluster_limit(gc): for other in nearby: if other.unit_type == bc.UnitType.Factory: is_nearby_factories = True break for cluster in blueprinting_queue: for potential_factory in cluster: if my_location.map_location().distance_squared_to( potential_factory.map_location) < blueprint_spacing: is_nearby_potential_factories = True break if not (is_nearby_factories or is_nearby_potential_factories): future_factory_locations = generate_factory_locations( start_map, my_location.map_location(), locs_next_to_terrain) if len(future_factory_locations) > 0: new_cluster = [ BuildSite(building_location, bc.UnitType.Factory) for building_location in future_factory_locations ] blueprinting_queue.extend([new_cluster]) #print(unit.id," just added to building queue") # assign this unit to build a blueprint, if nothing to build just move away from other factories if unit.id not in building_assignment: if len(blueprinting_queue) > 0: closest_building_site = get_closest_site(gc, unit, blueprinting_queue) for cluster in blueprinting_queue: if closest_building_site in cluster: cluster.remove(closest_building_site) if len(cluster) == 0: blueprinting_queue.remove(cluster) break building_assignment[unit.id] = closest_building_site #print(unit.id, "has been assigned to this building ",closest_building_site) else: all_factories = [] for other in gc.my_units(): if other.unit_type == bc.UnitType.Factory: all_factories.append(other) away_from_factories = sense_util.best_available_direction( gc, unit, all_factories) # pick other direction if direction is center if away_from_factories == directions[8]: away_from_factories = directions[1] movement.try_move(gc, unit, away_from_factories) #print(unit.id, " is exploring the map for build sites") # build blueprint in assigned square if unit.id in building_assignment: assigned_site = building_assignment[unit.id] direction_to_site = my_location.map_location().direction_to( assigned_site.map_location) if my_location.map_location().is_adjacent_to( assigned_site.map_location): if can_blueprint_factory(gc) and gc.can_blueprint( unit.id, bc.UnitType.Factory, direction_to_site): gc.blueprint(unit.id, bc.UnitType.Factory, direction_to_site) current_roles["blueprinter"].remove(unit.id) current_roles["builder"].append(unit.id) print(unit.id, " just created a blueprint!") else: pass #print(unit.id, "can't build but is right next to assigned site") elif my_location.map_location() == assigned_site.map_location: # when unit is currently on top of the queued building site d = random.choice(list(bc.Direction)) movement.try_move(gc, unit, d) #print(unit.id, " is on top of its build site and is moving away") else: # move toward queued building site print(unit.id, "is moving toward building site: ", assigned_site) next_direction = my_location.map_location().direction_to( assigned_site.map_location) movement.try_move(gc, unit, next_direction) """
def ranger_sense(gc, unit, battle_locs, ranger_roles, location, direction_to_coord, bfs_array, targeting_units, rocket_locs): signals = {} dir = None attack = None snipe = None closest_enemy = None move_then_attack = False visible_enemies = False if not unit.ranger_is_sniping(): if unit.id in variables.is_sniping: del variables.is_sniping[unit.id] enemies = gc.sense_nearby_units_by_team(location, unit.vision_range, variables.enemy_team) if unit.id in ranger_roles["go_to_mars"]: return go_to_mars_sense(gc, unit, battle_locs, location, enemies, direction_to_coord, bfs_array, targeting_units, rocket_locs) # if variables.print_count < 10: # print("Sensing nearby units:", time.time() - start_time) if len(enemies) > 0: visible_enemies = True start_time = time.time() closest_enemy = None closest_dist = float('inf') for enemy in enemies: loc = enemy.location if loc.is_on_map(): dist = sense_util.distance_squared_between_maplocs( loc.map_location(), location) if dist < closest_dist: closest_dist = dist closest_enemy = enemy # if variables.print_count < 10: # print("Getting closest enemy:", time.time() - start_time) # sorted_enemies = sorted(enemies, key=lambda x: x.location.map_location().distance_squared_to(location)) # closest_enemy = closest_among_ungarrisoned(sorted_enemies) attack = get_attack(gc, unit, location, targeting_units) # if variables.print_count < 10: # print("Getting attack:", time.time() - start_time) if attack is not None: #visible_enemies = True if closest_enemy is not None: closest_enemy_loc = closest_enemy.location.map_location() if check_radius_squares_factories( gc, location ) and closest_enemy.unit_type != variables.unit_types[ "knight"]: dir = optimal_direction_towards( gc, unit, location, closest_enemy_loc) elif closest_enemy.unit_type == variables.unit_types[ "knight"] or not gc.can_attack( unit.id, closest_enemy.id): # if variables.print_count < 10: # print("Checking if condition:", time.time() - start_time) #start_time = time.time() dir = sense_util.best_available_direction( gc, unit, [closest_enemy]) # if variables.print_count < 10: # print("Getting best available direction:", time.time() - start_time) # and (closest_enemy.location.map_location().distance_squared_to(location)) ** ( # 0.5) + 2 < unit.attack_range() ** (0.5)) or not gc.can_attack(unit.id, attack.id): elif variables.num_enemies > 0.9 * variables.info[2]: #dir = None dir = sense_util.best_available_direction( gc, unit, [closest_enemy]) else: dir = None #dir = sense_util.best_available_direction(gc, unit, [closest_enemy]) #dir = try_orthogonal(gc, unit, location, closest_enemy_loc) else: num_sniping = len(variables.is_sniping) if gc.research_info().get_level( variables.unit_types["ranger"] ) == 3 and gc.is_begin_snipe_ready( unit.id) and num_sniping < 10: best_unit = None best_priority = -float("inf") for poss_enemy in variables.units: if poss_enemy.location.is_on_map( ) and poss_enemy.team != gc.team() and snipe_priority( poss_enemy) > best_priority: best_unit = poss_enemy best_priority = snipe_priority(poss_enemy) # temporary always target factories if best_priority == 5: break snipe = best_unit elif gc.is_move_ready(unit.id): if closest_enemy is not None: dir = go_to_loc( unit, location, closest_enemy.location.map_location() ) #optimal_direction_towards(gc, unit, location, closest_enemy.location.map_location()) if dir is None or dir == variables.directions[8]: dir = optimal_direction_towards( gc, unit, location, closest_enemy.location.map_location()) next_turn_loc = location.add(dir) attack = get_attack(gc, unit, next_turn_loc, targeting_units) if attack is not None: move_then_attack = True else: if variables.curr_planet == bc.Planet.Earth: # print('IS RUNNING TOWARDS INIT LOC') dir = run_towards_init_loc_new( gc, unit, location, direction_to_coord) else: # print('EXPLORING') dir = get_explore_dir(gc, unit, location) # if variables.print_count < 10: # print("Getting direction:", time.time() - start_time) else: # if there are no enemies in sight, check if there is an ongoing battle. If so, go there. if len(rocket_locs ) > 0 and variables.curr_planet == bc.Planet.Earth and ( gc.round() > 600 or (variables.num_enemies < 5 and gc.round() > 275)): dir = move_to_rocket(gc, unit, location, direction_to_coord, bfs_array) if dir is not None: return dir, attack, snipe, move_then_attack, visible_enemies, closest_enemy, signals if len(battle_locs) > 0: # print('IS GOING TO BATTLE') dir = go_to_battle_new(gc, unit, battle_locs, location, direction_to_coord) # queued_paths[unit.id] = target else: # dir = move_away(gc, unit, battle_locs) if variables.curr_planet == bc.Planet.Earth: # print('IS RUNNING TOWARDS INIT LOC') dir = run_towards_init_loc_new(gc, unit, location, direction_to_coord) else: # print('EXPLORING') dir = get_explore_dir(gc, unit, location) """ elif unit.id in queued_paths: if location!=queued_paths[unit.id]: dir = optimal_direction_towards(gc, unit, location, queued_paths[unit.id]) return dir, attack, snipe, move_then_attack, visible_enemies, signals else: del queued_paths[unit.id] """ # if variables.print_count < 10: # print("regular movement:", time.time() - start_time) return dir, attack, snipe, move_then_attack, visible_enemies, closest_enemy, signals """
def timestep(gc, unit, info, karbonite_locations, blueprinting_queue, blueprinting_assignment, building_assignment, current_roles): #print(building_assignment) # last check to make sure the right unit type is running this if unit.unit_type != bc.UnitType.Worker: # prob should return some kind of error return my_team = gc.team() my_location = unit.location # make sure unit can actually perform actions ie. not in garrison if not my_location.is_on_map(): return if my_location.map_location().planet is bc.Planet.Mars: mine_mars(gc, unit) return my_role = "idle" for role in current_roles: if unit.id in current_roles[role]: my_role = role # print() # print("on unit #",unit.id, "position: ",unit.location.map_location(), "role: ",my_role) #print("KARBONITE: ",gc.karbonite() current_num_workers = info[0] max_num_workers = get_replication_cap(gc, karbonite_locations) worker_spacing = 8 workers_per_building = 4 #print("REPLICATION CAP: ",max_num_workers) # replicates if unit is able to (cooldowns, available directions etc.) if current_num_workers < max_num_workers: try_replicate = replicate(gc, unit) if try_replicate: return # runs this block every turn if unit is miner if my_role == "miner": mine(gc, unit, karbonite_locations, current_roles, building_assignment) # if unit is builder elif my_role == "builder": build(gc, unit, building_assignment, current_roles, workers_per_building) # if unit is blueprinter elif my_role == "blueprinter": blueprint(gc, unit, blueprinting_queue, building_assignment, blueprinting_assignment, current_roles) # if unit is boarder elif my_role == "boarder": board(gc, unit, current_roles) # if unit is idle elif my_role == "repairer": repair(gc, unit, current_roles) else: nearby = gc.sense_nearby_units_by_team(my_location.map_location(), worker_spacing, gc.team()) away_from_units = sense_util.best_available_direction(gc, unit, nearby) #print(unit.id, "at", unit.location.map_location(), "is trying to move to", away_from_units) movement.try_move(gc, unit, away_from_units)