def on_game_start(self, config): """ Read in config and perform any initial setup here """ gamelib.debug_write("Configuring your custom algo strategy...") self.config = config global WALL, SUPPORT, TURRET, SCOUT, DEMOLISHER, INTERCEPTOR, MP, SP WALL = config["unitInformation"][0]["shorthand"] SUPPORT = config["unitInformation"][1]["shorthand"] TURRET = config["unitInformation"][2]["shorthand"] SCOUT = config["unitInformation"][3]["shorthand"] DEMOLISHER = config["unitInformation"][4]["shorthand"] INTERCEPTOR = config["unitInformation"][5]["shorthand"] MP = 1 SP = 0 global HOME_FIELD, OPP_SIDE, SCORE_LOC, DEPLOY_LOC, mp_threshold HOME_FIELD = self.get_my_grid() OPP_SIDE = self.get_opp_grid() SCORE_LOC = self.get_scoring_locs() DEPLOY_LOC = self.get_deploy_loc() self.is_attacking = False self.attacking_round_start = -1 self.attacking_right = False mp_threshold = 8 # This is a good place to do initial setup self.scored_on_locations = [] self.damaged_locs = [] self.REINFORCE_MID = False self.enemy_units = [[], [], [], [], [], [], [], []] self.BEGIN = True self.DEMOLISHER = False self.last_demolisher_run = 0 # Used for the support logic self.support_locations = [] for i in range(14, 11, -1): # for j in range(5, 2, -1): for j in range(5, 3, -1): self.support_locations.append([i, j]) self.built_supports = [] self.upgraded_supports = []
def on_game_start(self, config): """ Read in config and perform any initial setup here """ gamelib.debug_write('Configuring your custom algo strategy...') self.config = config global FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER, BITS, CORES FILTER = config["unitInformation"][0]["shorthand"] ENCRYPTOR = config["unitInformation"][1]["shorthand"] DESTRUCTOR = config["unitInformation"][2]["shorthand"] PING = config["unitInformation"][3]["shorthand"] EMP = config["unitInformation"][4]["shorthand"] SCRAMBLER = config["unitInformation"][5]["shorthand"] BITS = 1 CORES = 0 # This is a good place to do initial setup self.scored_on_locations = []
def on_turn(self, turn_state): """ This function is called every turn with the game state wrapper as an argument. The wrapper stores the state of the arena and has methods for querying its state, allocating your current resources as planned unit deployments, and transmitting your intended deployments to the game engine. """ start_time = time.time() game_state = gamelib.GameState(self.config, turn_state) gamelib.debug_write('Performing turn {} of your custom algo strategy'.format(game_state.turn_number)) game_state.suppress_warnings(True) # Comment or remove this line to enable warnings. self.evaluate_self_defence(game_state) self.evaluate_enemy_defence(game_state) self.populate_defense(game_state, [13], start_time) self.__place__attackers__(game_state, start_time) game_state.submit_turn()
def on_game_start(self, config): """ Read in config and perform any initial setup here """ gamelib.debug_write('Configuring your custom algo strategy...') self.config = config global WALL, SUPPORT, TURRET, SCOUT, DEMOLISHER, INTERCEPTOR, MP, SP WALL = config["unitInformation"][0]["shorthand"] SUPPORT = config["unitInformation"][1]["shorthand"] TURRET = config["unitInformation"][2]["shorthand"] SCOUT = config["unitInformation"][3]["shorthand"] DEMOLISHER = config["unitInformation"][4]["shorthand"] INTERCEPTOR = config["unitInformation"][5]["shorthand"] MP = 1 SP = 0 # This is a good place to do initial setup self.scored_on_locations = []
def prioritize_action(self, id: str) -> None: """ Moves an action to the front of the priority queue by id """ index = -1 for i, entry in enumerate(self.action_queue): if entry['id'] == id: index = i break if index == -1: debug_write("[DEBUG] cannot prioritize nonexistant action:", id) raise ValueError('Cannot prioritize nonexistant action') self.change_flag = True value = self.action_queue.pop(index) self.action_queue.insert(0, value)
def on_turn(self, turn_state): """ This function is called every turn with the game state wrapper as an argument. The wrapper stores the state of the arena and has methods for querying its state, allocating your current resources as planned unit deployments, and transmitting your intended deployments to the game engine. """ game_state = gamelib.GameState(self.config, turn_state) gamelib.debug_write( 'Performing turn {} of your custom algo strategy'.format( game_state.turn_number)) # game_state.suppress_warnings(True) #Uncomment this line to suppress warnings. self.starter_strategy(game_state) game_state.submit_turn()
def on_game_start(self, config): """ Read in config and perform any initial setup here """ gamelib.debug_write("Configuring your custom algo strategy...") self.config = config global FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER, BITS, CORES FILTER = config["unitInformation"][0]["shorthand"] ENCRYPTOR = config["unitInformation"][1]["shorthand"] DESTRUCTOR = config["unitInformation"][2]["shorthand"] PING = config["unitInformation"][3]["shorthand"] EMP = config["unitInformation"][4]["shorthand"] SCRAMBLER = config["unitInformation"][5]["shorthand"] BITS = 1 CORES = 0 # This is a good place to do initial setup self.scored_on_locations = [] Units = namedtuple("Units", "FILTER ENCRYPTOR DESTRUCTOR PING EMP SCRAMBLER") self.units = Units(FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER) # Assume right side is vulnerable self.is_right_opening = True self.filter_locs = [ [0, 13], [1, 13], [5, 13], [6, 13], [7, 13], [8, 13], [9, 13], [11, 13], [12, 13], [13, 13], [14, 13], [15, 13], [16, 13], [18, 13], [19, 13], [20, 13], [21, 13], [22, 13], [26, 13], [27, 13], ]
def __init__(self): super().__init__() seed = random.randrange(maxsize) random.seed(seed) gamelib.debug_write('Random seed: {}'.format(seed)) self.grid_map = [] j_start = 13 j_end = 15 for i in range(0, 14): self.grid_map.append([0] * (j_end - j_start)) j_start -= 1 j_end += 1 j_start = 0 j_end = 28 for i in range(14, 28): self.grid_map.append([0] * (j_end - j_start)) j_start += 1 j_end -= 1
def were_corners_attacked(self, curr_state, prev_state): """ Checks if corners were attacked in the last round. :param curr_state: state object. :param prev_state: state object. """ left_damage, right_damage = 0, 0 if not self.R_CORNER_ATTACKED: right_damage = max(0, self.check_corner(curr_state, prev_state, self.RIGHT_CORNER_MASK)) debug_write("Right damage ", right_damage) if not self.L_CORNER_ATTACKED: left_damage = max(0, self.check_corner(curr_state, prev_state, self.LEFT_CORNER_MASK)) debug_write("Left damage ", left_damage) self.R_CORNER_ATTACKED = right_damage > self.CORNER_DAMAGE_THRESH self.L_CORNER_ATTACKED = left_damage > self.CORNER_DAMAGE_THRESH
def on_game_start(self, config): """ Read in config and perform any initial setup here """ gamelib.debug_write('Configuring your custom algo strategy...') self.config = config global FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER FILTER = config["unitInformation"][0]["shorthand"] ENCRYPTOR = config["unitInformation"][1]["shorthand"] DESTRUCTOR = config["unitInformation"][2]["shorthand"] PING = config["unitInformation"][3]["shorthand"] EMP = config["unitInformation"][4]["shorthand"] SCRAMBLER = config["unitInformation"][5]["shorthand"] self.cores = 0 self.bits = 0 self.scored_on_locations = dict() self.damaged_on_locations = dict() self.sp = False
def build_first_round(self, game_state): """ Set up first round """ gamelib.debug_write('Turn[{}] build_first_round() - start'.format( game_state.turn_number)) for location in self.init_destructor: if game_state.can_spawn(DESTRUCTOR, location): game_state.attempt_spawn(DESTRUCTOR, location) for location in self.init_middle_destructor: if game_state.can_spawn(DESTRUCTOR, location): game_state.attempt_spawn(DESTRUCTOR, location) for location in self.init_flower: uplocation = [location[0], location[1] + 1] if not game_state.contains_stationary_unit( uplocation) and not location in self.open_location_right: if game_state.can_spawn(ENCRYPTOR, location): game_state.attempt_spawn(ENCRYPTOR, location)
def on_game_start(self, config): self.turnNum = 0 gamelib.debug_write('Configuring your custom algo strategy...') self.config = config global FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER FILTER = config["unitInformation"][0]["shorthand"] ENCRYPTOR = config["unitInformation"][1]["shorthand"] DESTRUCTOR = config["unitInformation"][2]["shorthand"] PING = config["unitInformation"][3]["shorthand"] EMP = config["unitInformation"][4]["shorthand"] SCRAMBLER = config["unitInformation"][5]["shorthand"] self.scored_on_locations = [] self.destructorLocations = [[3,12],[24,12],[8,9],[19,9],[12,9],[15,9]] self.filterLocations = [[ 0, 13],[ 1, 13],[ 2, 13],[ 3, 13],[ 4, 13],[ 23, 13],[ 24, 13],[ 25, 13],[ 26, 13],[ 27, 13],[ 4, 12],[ 23, 12],[ 4, 11],[ 23, 11],[ 5, 10],[ 7, 10],[ 8, 10],[ 9, 10],[ 11, 10],[ 12, 10],[ 15, 10],[ 16, 10],[ 18, 10],[ 19, 10],[ 20, 10],[ 22, 10],[ 6, 9],[ 7, 9],[ 9, 9],[ 10, 9],[ 11, 9],[ 16, 9],[ 17, 9],[ 18, 9],[ 20, 9],[ 21, 9]] self.spawnLoc = [22,8] self.scramSpawn = [[22,8],[5,8]] self.encryptLoc = [[ 11, 7],[ 12, 7],[ 13, 7],[ 14, 7],[ 15, 7],[ 16, 7],[ 12, 6],[ 13, 6],[ 14, 6],[ 15, 6],[ 12, 5],[ 13, 5],[ 14, 5],[ 15, 5]] self.encryptorCount = 0
def starter_strategy(self, game_state): """ For defense we will use a spread out layout and some Scramblers early on. We will place destructors near locations the opponent managed to score on. For offense we will use long range EMPs if they place stationary units near the enemy's front. If there are no stationary units to attack in the front, we will send Pings to try and score quickly. """ # First, place basic defenses self.build_defences(game_state) # Now build reactive defenses based on where the enemy scored # self.build_reactive_defense(game_state) self.attack(game_state) self.enemy_health_overtime.append(game_state.enemy_health) gamelib.debug_write('enemy health last time was {}'.format( self.enemy_health_overtime))
def __init__(self): super().__init__() seed = random.randrange(maxsize) random.seed(seed) gamelib.debug_write('Random seed: {}'.format(seed)) # Locations passed by reference to GameState. Should only be updated in GameState self.turret_locations = [] self.wall_locations = [] self.support_locations = [] # Fake gamestate creation support self.remove_loc_check = [] for j in range(13, -1, -1): for i in range(13-j, 15+j): self.remove_loc_check.append([i, j]) self.enemy_attack_predictor = GaussianNB()
def complete_requests(self, game_state, request_list, max_priority=math.inf): for request in request_list: # gamelib.debug_write(request) if (game_state.get_resource(CORES) < self.cores_to_keep) or (request[3] > max_priority): return if request[0] == 0: # gamelib.debug_write(f"Running game_state.can_spawn({request[1]}, {request[2]})") if game_state.can_spawn(request[1], request[2]): game_state.attempt_spawn(request[1], request[2]) gamelib.debug_write("Number of cores left: " + str(game_state.get_resource(CORES)) + " \n") elif request[0] == 1: game_state.attempt_upgrade(request[2])
def on_turn(self, turn_state): """ This function is called every turn with the game state wrapper as an argument. The wrapper stores the state of the arena and has methods for querying its state, allocating your current resources as planned unit deployments, and transmitting your intended deployments to the game engine. """ game_state = gamelib.AdvancedGameState(self.config, turn_state) if game_state.turn_number == 0: while game_state.can_spawn(PING, self.firstTurnTroopCoord): game_state.attempt_spawn(PING, self.firstTurnTroopCoord) # no building this turn else: left_corner_stats = game_state.get_area_stats( self.enemy_left_corner_area) gamelib.debug_write( 'left_corner_stats = {}'.format(left_corner_stats)) right_corner_stats = game_state.get_area_stats( self.enemy_left_corner_area) gamelib.debug_write( 'right_corner_stats = {}'.format(right_corner_stats)) if game_state.get_resource(game_state.BITS) >= 8: self.readyToAttack = True else: self.readyToAttack = False # determine which side is more vulnerable if left_corner_stats.destructor_count < right_corner_stats.destructor_count: self.SetSideToAttack(Sides.LEFT, game_state) else: self.SetSideToAttack(Sides.RIGHT, game_state) if self.readyToAttack: if self.useRammingTroops: self.deployRammingTroops(game_state) self.deployTroops(game_state) self.buildWalls(game_state) self.markForRefund(game_state) game_state.submit_turn()
def build_the_wall(self, game_state): filters_built = 0 encryptors_built = 0 destructors_built = 0 gamelib.debug_write('Building wall') # Adding left side corner shield destructors_built += game_state.attempt_spawn( DESTRUCTOR, self.get_line_points([0, 13], [2, 13])) # Adding right side corner shield destructors_built += game_state.attempt_spawn( DESTRUCTOR, self.get_line_points([25, 13], [27, 13])) # Adding V of power # First, putting down two destructors on each side # [5,10] [8,7] destructors_built += game_state.attempt_spawn(DESTRUCTOR, ([5, 10], [8, 7])) # [19, 7] [22, 10] destructors_built += game_state.attempt_spawn(DESTRUCTOR, ([19, 7], [22, 10])) # Then, draw lines of encryptors encryptors_built += game_state.attempt_spawn( ENCRYPTOR, self.get_line_points([2, 13], [10, 5])) encryptors_built += game_state.attempt_spawn( ENCRYPTOR, self.get_line_points([17, 5], [25, 13])) # Building the channel encryptors_built += game_state.attempt_spawn(ENCRYPTOR, [11, 5]) encryptors_built += game_state.attempt_spawn(ENCRYPTOR, [16, 5]) destructors_built += game_state.attempt_spawn( DESTRUCTOR, ([12, 4], [12, 5], [15, 4], [15, 5])) # Shields for destructors # filters_built += game_state.attempt_spawn( # DESTRUCTOR, [[12, 4], [15, 4]]) # filters_built += game_state.attempt_spawn( # DESTRUCTOR, [[11, 5], [12, 5]]) # filters_built += game_state.attempt_spawn( # DESTRUCTOR, [[15, 5], [16, 5]]) gamelib.debug_write("Built " + str(destructors_built) + "D " + str(encryptors_built) + "E") return filters_built
def on_game_start(self, config): """ Read in config and perform any initial setup here """ gamelib.debug_write('Configuring your custom algo strategy...') self.config = config global FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER, BARREL_MASK, BARREL_MASK_IDX, BASE_PASSIVE_LOCS self.filter, self.encryptor, self.destructor, \ self.ping, self.emp, self.scrambler = [i for i in range(6)] FILTER = config["unitInformation"][0]["shorthand"] ENCRYPTOR = config["unitInformation"][1]["shorthand"] DESTRUCTOR = config["unitInformation"][2]["shorthand"] PING = config["unitInformation"][3]["shorthand"] EMP = config["unitInformation"][4]["shorthand"] SCRAMBLER = config["unitInformation"][5]["shorthand"] BARREL_MASK = [ # Destructors [23, 13], [24, 13], # Encryptors [23, 12], [24, 12], [25, 13], [23, 11], # Filters [1, 13], [1, 12], [0, 13], [18, 10], [18, 11], [13, 11], [9, 10], [9, 11], [5, 11], ] BARREL_MASK_IDX = { "destructors": (0, 2), "encryptors": (2, 6), "filters": (6, 15) } BASE_PASSIVE_LOCS = [[3, 12], [10, 10], [17, 8]] self.prev_state = None
def on_turn(self, turn_state): #____LOOP______ #____NEEDED____ game_state = gamelib.GameState(self.config, turn_state) gamelib.debug_write( 'Performing turn {} of your custom algo strategy'.format( game_state.turn_number)) game_state.suppress_warnings(True) #______________ FILTER_DEPLOY_LOCATION = [[0, 13], [1, 13], [2, 13], [3, 13], [4, 13], [5, 13], [6, 13], [7, 13], [8, 13], [9, 13], [10, 13], [17, 13], [18, 13], [19, 13], [20, 13], [21, 13], [22, 13], [23, 13], [24, 13], [25, 13], [26, 13], [27, 13]] ENCRYPTOR_DEPLOY_LOCATION = [[10, 11], [17, 11], [10, 10], [17, 10], [4, 9], [5, 9], [6, 9], [7, 9], [8, 9], [9, 9], [18, 9], [19, 9], [20, 9], [21, 9], [22, 9], [23, 9]] DESTRUCTOR_DEPLOY_LOCATION = [[1, 12], [4, 12], [7, 12], [10, 12], [17, 12], [20, 12], [23, 12], [26, 12], [10, 9], [17, 9]] UNITBLOCK_DEPLOY_LOCATION = [[11, 13], [16, 13], [11, 12], [16, 12], [11, 11], [16, 11], [11, 10], [16, 10], [11, 9], [16, 9], [5, 8], [6, 8], [7, 8], [8, 8], [9, 8], [10, 8], [11, 8], [16, 8], [17, 8], [18, 8], [19, 8], [20, 8], [21, 8], [22, 8]] #[[ 5, 8],[ 22, 8],[ 6, 7],[ 21, 7]] if game_state.turn_number % 2: self.deploy_information(game_state, [5, 8], SCRAMBLER, 2) self.deploy_information(game_state, [6, 7], EMP, 1) else: self.deploy_information(game_state, [22, 8], SCRAMBLER, 2) self.deploy_information(game_state, [21, 7], EMP, 1) self.deploy_fireWall(game_state, UNITBLOCK_DEPLOY_LOCATION, FILTER) self.deploy_fireWall(game_state, DESTRUCTOR_DEPLOY_LOCATION, DESTRUCTOR) self.deploy_fireWall(game_state, FILTER_DEPLOY_LOCATION, FILTER) self.deploy_fireWall(game_state, ENCRYPTOR_DEPLOY_LOCATION, ENCRYPTOR) game_state.submit_turn()
def on_action_frame(self, turn_string): """ This is the action frame of the game. This function could be called hundreds of times per turn and could slow the algo down so avoid putting slow code here. Processing the action frames is complicated so we only suggest it if you have time and experience. Full doc on format of a game frame at: https://docs.c1games.com/json-docs.html """ # Let's record at what position we get scored on state = json.loads(turn_string) events = state["events"] breaches = events["breach"] P2 = 2 frame = state['turnInfo'][2] for attack in events['attack']: # first attack by enemy ping or emp if attack[6] == P2 and (attack[3] == 3 or attack[3] == 4) and attack[4] not in self.unit_counted: # onto player's left side if attack[1][1] <= 13 and attack[1][0] <= 13 and frame // 8 < len(self.attacks_on_frame): self.attacks_on_frame[frame // 8] += 1 self.unit_counted[attack[4]] = True if len(events['spawn']) > 0: spent = 0 for spawn in events['spawn']: if spawn[3] == P2: if spawn[1] == 3: spent += 1 if spawn[1] == 4: spent += 3 if spent >= self.MIN_BITS_SPENT_ATTACK: self.bits_to_enemy_attack[self.enemy_bits] = True else: self.bits_to_enemy_attack[self.enemy_bits] = False for breach in breaches: location = breach[0] unit_owner_self = True if breach[4] == 1 else False # When parsing the frame data directly, # 1 is integer for yourself, 2 is opponent (StarterKit code uses 0, 1 as player_index instead) if not unit_owner_self: gamelib.debug_write("Got scored on at: {}".format(location)) self.scored_on_locations.append(location) gamelib.debug_write("All locations: {}".format(self.scored_on_locations))
def on_turn(self, turn_state): """ This function is called every turn with the game state wrapper as an argument. The wrapper stores the state of the arena and has methods for querying its state, allocating your current resources as planned unit deployments, and transmitting your intended deployments to the game engine. """ game_state = gamelib.AdvancedGameState(self.config, turn_state) gamelib.debug_write('Performing turn {} of your custom algo strategy'.format(game_state.turn_number)) game_state.suppress_warnings(True) #Uncomment this line to suppress warnings. # Perform setup if the turn number is zero # Check if we should move up our setup, or not. if game_state.turn_number == 0: self.initial_setup(game_state) return ''' OVERARCHING STRATEGY LOGIC If getting rushed --> Defend and rush other side If they have a solid defence --> Build escort strategy If they have a dumb opening --> Rush them If the game is super passive --> Build encryptors and defend ''' # Patch up any holes in our defences self.reactive_defence() # Check if we want to rush them, if so, then do it! rush_loc, rush_unit = self.find_rush_spot(game_state) if rush_loc is not None: self.attack_hole(game_state, rush_loc, rush_unit) game_state.submit_turn() return # The idea is that they will constantly update defences. Find out what their heavy side # is, and determine if we should go escort or not heavy_side = self.scan_opponent_defences(game_state) self.escort_strategy(game_state, heavy_side) game_state.submit_turn()
def on_game_start(self, config): """ Read in config and perform any initial setup here """ gamelib.debug_write('Configuring your custom algo strategy...') self.config = config global FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER FILTER = config["unitInformation"][0]["shorthand"] ENCRYPTOR = config["unitInformation"][1]["shorthand"] DESTRUCTOR = config["unitInformation"][2]["shorthand"] PING = config["unitInformation"][3]["shorthand"] EMP = config["unitInformation"][4]["shorthand"] SCRAMBLER = config["unitInformation"][5]["shorthand"] # This is a good place to do initial setup self.scored_on_locations = [] self.attack_stage = 0 self.attack_config = [ ] # (direction, attack_type, attack_num, support)
def build_defenses(self, location_list, firewall_unit, game_state, row=None): for location in location_list: if not type(location) == list: location = [location, row] if game_state.can_spawn(firewall_unit, location): game_state.attempt_spawn(firewall_unit, location) gamelib.debug_write(f"{firewall_unit} deployed at {location}") game_state._player_resources[0][ 'cores'] -= game_state.type_cost(firewall_unit) elif not game_state.contains_stationary_unit(location): return False return True
def __init__(self): super().__init__() seed = random.randrange(maxsize) random.seed(seed) gamelib.debug_write('Random seed: {}'.format(seed)) # a = np.ones((10,1)) # b = np.ones((10,1)) # c = np.sum(a * b, axis=0) # gamelib.debug_write('numpy test: {}'.format(c)) a = torch.randn(2, 2) a = ((a * 3) / (a - 1)) gamelib.debug_write(a.requires_grad) a.requires_grad_(True) gamelib.debug_write(a.requires_grad) b = (a * a).sum() gamelib.debug_write(b.grad_fn) b.backward() gamelib.debug_write(a.grad)
def on_game_start(self, config): """ Read in config and perform any initial setup here """ gamelib.debug_write('Configuring your custom algo strategy...') self.config = config global FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER FILTER = config["unitInformation"][0]["shorthand"] ENCRYPTOR = config["unitInformation"][1]["shorthand"] DESTRUCTOR = config["unitInformation"][2]["shorthand"] PING = config["unitInformation"][3]["shorthand"] EMP = config["unitInformation"][4]["shorthand"] SCRAMBLER = config["unitInformation"][5]["shorthand"] # Batch ping threshold self.batch_ping_num = 10 # If we sent out our ping batch last round self.sent_pings_last_round = False # Enemy health before we sent out our last ping batch self.enemy_health_before_attack = 30
def stall_with_scramblers(self, game_state): for loc in list(self.scored_on_locations): gamelib.debug_write("Scrambler Location: {}".format(loc)) # send a scrambler for every 3 enemy num of bits num_scramblers = (int)(game_state.get_resource(BITS, 1)) // 4 + 1 gamelib.debug_write("NumScrams: {}".format(num_scramblers)) if num_scramblers > 3: num_scramblers = 3 for i in range(0, num_scramblers): while loc[1] >= 11: x, y = loc if loc[0] > loc[1]: x -= 1 y -= 1 if loc[1] > loc[0]: x += 1 y -= 1 game_state.attempt_spawn(SCRAMBLER, [x, y])
def deploy_attackers(self, game_state): """ if (game_state.turn_number == 0 and game_state.can_spawn(EMP, [25, 11])) or RIGHT_SIDE_EMERGENCY: game_state.attempt_spawn(EMP, [25, 11]) if game_state.number_affordable(PING) > 4 and game_state.can_spawn(SCRAMBLER, [5,8]): game_state.attempt_spawn(SCRAMBLER,[5,8]) """ while game_state.get_resource( game_state.BITS) >= game_state.type_cost(PING): #gamelib.debug_write('resources for PINGS...') if game_state.can_spawn(PING, [14, 0]): game_state.attempt_spawn(PING, [14, 0]) else: gamelib.debug_write( '{} Bits cant spawn PINGS at [14,0]'.format( game_state.turn_number)) return
def on_game_start(self, config): """ Read in config and perform any initial setup here """ gamelib.debug_write('Configuring your custom algo strategy...') self.config = config global FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER self.filter, self.encryptor, self.destructor, self.ping, self.emp, self.scrambler = [i for i in range(6)] FILTER = config["unitInformation"][0]["shorthand"] ENCRYPTOR = config["unitInformation"][1]["shorthand"] DESTRUCTOR = config["unitInformation"][2]["shorthand"] PING = config["unitInformation"][3]["shorthand"] EMP = config["unitInformation"][4]["shorthand"] SCRAMBLER = config["unitInformation"][5]["shorthand"] self.unique_locs = [] self.emp_num = 0 self.defences = Defences(config) self.prev_state = None
def stall_with_scramblers(self, game_state): for loc in list(self.scored_on_locations): gamelib.debug_write("Scrambler Location: {}".format(loc)) # send a scrambler for every 3 enemy num of bits num_scramblers = (int)(game_state.get_resource(BITS, 1)) // 4 + 1 gamelib.debug_write("NumScrams: {}".format(num_scramblers)) if num_scramblers > 3: num_scramblers = 3 for i in range(0, num_scramblers): # Build destructor one space above so that it doesn't block our own edge spawn locations while loc[1] >= 11: if loc[0] > loc[1]: loc[0] -= 1 loc[1] -= 1 if loc[1] > loc[0]: loc[0] += 1 loc[1] -= 1 game_state.attempt_spawn(SCRAMBLER, [loc[0], loc[1]])
def starter_strategy(self, game_state): self.build_defences(game_state) #TODO better heuristic for seeing if firing is worthwhile... do real tracking ... can help us fire earlier too ping_count = game_state.get_resource(BITS)//1; bit_increment = (game_state.turn_number // 10) + 5 ping_spawn_location_options = [[11, 2], [16, 2]] if self.can_ping(game_state, ping_count, ping_spawn_location_options) and self.ENEMY_HEALTH-ping_count < 5 and self.ENEMY_HEALTH-ping_count > 0: gamelib.debug_write("Stalling") elif self.can_ping(game_state, ping_count, ping_spawn_location_options) and ping_count > 12: best_location = self.least_damage_spawn_location(game_state, ping_spawn_location_options) game_state.attempt_spawn(PING, best_location, 1000); elif not self.can_ping(game_state, ping_count, ping_spawn_location_options): if ping_count > 18: best_location = self.least_damage_spawn_location(game_state, ping_spawn_location_options) game_state.attempt_spawn(EMP, best_location, 1000);