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.
"""
# TODO: remove advanced state from function signatures if we initialize it here already.
game_state = gamelib.AdvancedGameState(self.config, turn_state)
game_state.suppress_warnings(
True) # Uncomment this line to suppress warnings.
self.build_barrel(game_state)
self.shoot(game_state)
damaged_locations = self._find_damaged_def_units(game_state)
if damaged_locations:
self.build_reactive_defence(game_state, damaged_locations)
self.build_passive_defence(game_state)
# Must run at the very end of the algo.
self.prev_state = copy.deepcopy(game_state)
game_state.submit_turn()
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.
emp_cheese = True if self.emp_num > 1 and len(self.unique_locs) == 1 else False
if emp_cheese:
d, f = self.can_block(self.unique_locs[0], copy.deepcopy(turn_state))
self.defences.build_template(game_state, self.prev_state, emp_cheese)
self.prev_state = copy.deepcopy(game_state)
if game_state.turn_number != 0:
try:
self.best_spawn(game_state)
except Exception:
self.attack(game_state)
game_state.submit_turn()
def get_destructors_on_path(self, game_state, start_point, end_points):
path = gamelib.ShortestPathFinder.navigate_multiple_endpoints(
start_point, end_points, game_state)
adv_game_state = gamelib.AdvancedGameState(game_state)
retval = 0
for location in path:
attackers = adv_game_state.get_attackers(location, 0)
retval = retval + len(attackers)
return retval
def on_turn(self, cmd):
'''
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, cmd)
gamelib.debug_write('Performing turn {} of your custom algo strategy'.format(game_state.turn_number))
self.starter_strategy(game_state)
game_state.submit_turn()
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.
self.defend(game_state)
self.attack(game_state)
game_state.submit_turn()
def on_turn(self, turn_state):
game_state = gamelib.AdvancedGameState(self.config, turn_state)
#p1UnitCount = len(self.jsonState.get('p1Units')[0])
p2UnitCount = len(self.jsonState.get('p2Units')[0])
gamelib.debug_write('p2 has {} units'.format(p2UnitCount))
if game_state.turn_number != 0:
if p2UnitCount < 8:
self.attackForMaxPain(game_state)
else:
self.attackForMaxDestruction(game_state)
self.reinforceBreachLocation(game_state)
self.breach_list = []
game_state.submit_turn()
def on_turn(self, turn_state):
game_state = gamelib.AdvancedGameState(self.config, turn_state)
#p1UnitCount = len(self.jsonState.get('p1Units')[0])
p2UnitCount = len(self.jsonState.get('p2Units')[0]) + len(
self.jsonState.get('p2Units')[1]) + len(
self.jsonState.get('p2Units')[2])
gamelib.debug_write('p2 has {} units'.format(p2UnitCount))
shouldRebuild = game_state.turn_number > 7
needsStrongerCorners = game_state.turn_number > 3
self.buildFirewalls(game_state, self.cornerTowers, DESTRUCTOR,
shouldRebuild)
if needsStrongerCorners:
self.buildFirewalls(game_state, self.cornerFilters, DESTRUCTOR,
shouldRebuild)
else:
self.buildFirewalls(game_state, self.cornerFilters, FILTER,
shouldRebuild)
self.buildFirewalls(game_state, self.lightHouseTowers, DESTRUCTOR,
shouldRebuild)
self.reinforceDestructors(game_state, self.lightHouseTowers,
shouldRebuild)
self.buildFirewalls(game_state, self.filterWall, FILTER, shouldRebuild)
self.buildFirewalls(game_state, self.tunnelTowers, DESTRUCTOR,
shouldRebuild)
self.buildFirewalls(game_state, self.cornerPhaseTwo, FILTER,
shouldRebuild)
self.buildFirewalls(game_state, self.encryptorPhaseOne, ENCRYPTOR,
False)
self.buildFirewalls(game_state, self.row_ten, DESTRUCTOR, False)
self.buildFirewalls(game_state, self.encryptorPhaseTwo, ENCRYPTOR,
False)
if self.attackWithPings:
if game_state.number_affordable(
PING) >= 8 + (game_state.turn_number // 10):
self.attackForMaxPain(game_state)
if game_state.turn_number > 4:
self.attackWithPings = False
else:
if game_state.number_affordable(
EMP) > 2 + (game_state.turn_number // 18):
self.attackForMaxDestruction(game_state)
self.attackWithPings = True
game_state.submit_turn()
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)
p1UnitCount = len(self.jsonState.get('p1Units')[0])
p2UnitCount = len(self.jsonState.get('p2Units')[0])
#gamelib.debug_write('p1 has {} units. p2 has {} units'.format(p1UnitCount, p2UnitCount))
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_right_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 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_turn(self, turn_state):
game_state = gamelib.AdvancedGameState(self.config, turn_state)
#p1UnitCount = len(self.jsonState.get('p1Units')[0])
p2UnitCount = len(self.jsonState.get('p2Units')[0]) + len(self.jsonState.get('p2Units')[1]) + len(self.jsonState.get('p2Units')[2])
gamelib.debug_write('p2 has {} units'.format(p2UnitCount))
shouldRebuild = game_state.turn_number > 7
needsStrongerCorners = game_state.turn_number > 3
self.buildFirewalls(game_state, self.mainTowers, DESTRUCTOR, False)
self.buildFirewalls(game_state, self.filterWall, FILTER, False)
self.buildFirewalls(game_state, self.extraCornerTower, DESTRUCTOR, False)
self.buildFirewalls(game_state, self.frontWall, FILTER, False)
self.buildFirewalls(game_state, self.encryptors, ENCRYPTOR, False)
while game_state.can_spawn(EMP, [24, 10]):
game_state.attempt_spawn(EMP, [24, 10])
game_state.submit_turn()
def on_turn(self, turn_state):
game_state = gamelib.AdvancedGameState(self.config, turn_state)
#p1UnitCount = len(self.jsonState.get('p1Units')[0])
p2UnitCount = len(self.jsonState.get('p2Units')[0])
gamelib.debug_write('p2 has {} units'.format(p2UnitCount))
self.reinforceBreachLocation(game_state)
# line detection #
firstRowDefenderCount = game_state.get_enemy_unit_count_for_row(
game_state.game_map.FIRST_ENEMY_ROW)
secondRowDefenderCount = game_state.get_enemy_unit_count_for_row(
game_state.game_map.SECOND_ENEMY_ROW)
thirdRowDefenderCount = game_state.get_enemy_unit_count_for_row(
game_state.game_map.THIRD_ENEMY_ROW)
fourthRowDefenderCount = game_state.get_enemy_unit_count_for_row(
game_state.game_map.FOURTH_ENEMY_ROW)
gamelib.debug_write('row counts: {},{},{},{}'.format(
firstRowDefenderCount, secondRowDefenderCount,
thirdRowDefenderCount, fourthRowDefenderCount))
if firstRowDefenderCount > 8:
self.mirrorEnemy(game_state, game_state.game_map.FIRST_ENEMY_ROW)
elif secondRowDefenderCount > 6:
self.mirrorEnemy(game_state, game_state.game_map.SECOND_ENEMY_ROW)
elif thirdRowDefenderCount > 6:
self.mirrorEnemy(game_state, game_state.game_map.THIRD_ENEMY_ROW)
elif fourthRowDefenderCount > 6:
self.mirrorEnemy(game_state, game_state.game_map.FOURTH_ENEMY_ROW)
if game_state.turn_number != 0:
if p2UnitCount < 8:
self.attackForMaxPain(game_state)
else:
self.attackForMaxDestruction(game_state)
self.breach_list = []
game_state.submit_turn()
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.
"""
#if not first turn, parse last turn's action phase strings
if self.game_state is not None:
self.parse_action_phase()
self.__action_strings = []
self.game_state = gamelib.AdvancedGameState(self.config, turn_state)
gamelib.debug_write(
'Performing turn {} of your custom algo strategy'.format(
self.game_state.turn_number))
#self.game_state.suppress_warnings(True) # Uncomment this line to suppress warnings.
self.starter_algo(self.game_state)
self.game_state.submit_turn()
def on_turn(self, turn_state):
game_state = gamelib.AdvancedGameState(self.config, turn_state)
p1UnitCount = len(self.jsonState.get('p1Units')[0]) + len(self.jsonState.get('p1Units')[1]) + len(self.jsonState.get('p1Units')[2])
p2UnitCount = len(self.jsonState.get('p2Units')[0]) + len(self.jsonState.get('p2Units')[1]) + len(self.jsonState.get('p2Units')[2])
gamelib.debug_write('p2 has {} units'.format(p2UnitCount))
gamelib.debug_write('p2 army cost last turn = {}'.format(self.enemy_army_cost))
if self.army_dict.get('total_cost', 0) > 0:
self.lastEnemyArmyDict = self.army_dict.copy()
if 'total_cost' in self.lastEnemyArmyDict and game_state.get_resource(game_state.BITS, 1) >= self.lastEnemyArmyDict['total_cost']:
gamelib.debug_write('I predict that p2 will spawn an army this turn!')
shouldRebuild = game_state.turn_number > 3
shouldRebuildWall = p1UnitCount >= 27 #only reinforce if the full wall is in place
needsStrongerCorners = game_state.turn_number > 3
towersToBuild = 1
self.coresToSpendOnRebuilding = 4
if game_state.turn_number == 0:
self.buildFirewalls(game_state, self.filterCorners, FILTER, False)
self.buildFirewalls(game_state, self.turnZeroTowers, DESTRUCTOR, False)
#game_state.attempt_spawn(EMP, self.turnZeroEMPCoord)
#game_state.attempt_spawn(SCRAMBLER, self.turnZeroScramblerCoord)
else:
if game_state.turn_number == 1:
self.shieldEMPs = False
# copy game_state twice, build left and right door and see which provides more targets
# consider making a full line across to see how many targets are in range?
# with the goal of maximizing the targets safe to hit from behind our wall??
# That might be enough to beat George?
# Also, add more weight to high-value targets, if we can safely take out DESTRUCTORs, do it!!
game_state_try_left = copy.deepcopy(game_state)
self.buildFirewalls(game_state_try_left, self.leftDoorTowers, DESTRUCTOR, False, 3)
self.buildFirewalls(game_state_try_left, self.leftDoorFilters, FILTER, False)
leftValue = self.attackForMaxDestruction(game_state_try_left)
game_state_try_right = copy.deepcopy(game_state)
self.buildFirewalls(game_state_try_right, self.rightDoorTowers, DESTRUCTOR, False, 3)
self.buildFirewalls(game_state_try_right, self.rightDoorFilters, FILTER, False)
rightValue = self.attackForMaxDestruction(game_state_try_right)
gamelib.debug_write("leftValue = {}, rightValue = {}".format(leftValue, rightValue))
self.useRightDoor = (rightValue > leftValue)
if self.useRightDoor:
self.reservedCoords.append([2, 12])
self.reservedCoords.append([2, 13])
else:
self.reservedCoords.append([25, 12])
self.reservedCoords.append([25, 13])
towersToBuild = 3
self.threatenSpawn(game_state)
if game_state.turn_number >= 2 and not self.earlyEncryptorBuilt:
if game_state.number_affordable(ENCRYPTOR) > 0:
self.earlyEncryptorBuilt = True
if self.useRightDoor:
game_state.attempt_spawn(ENCRYPTOR, [6, 9])
else:
game_state.attempt_spawn(ENCRYPTOR, [21, 9])
# if we've been breached in the corner, strengthen it!
if [27, 13] in self.breach_list:
self.buildFirewalls(game_state, [[26, 12]], DESTRUCTOR, True)
self.buildFirewalls(game_state, [[26, 13]], FILTER, True)
if [0, 13] in self.breach_list:
self.buildFirewalls(game_state, [[1, 12]], DESTRUCTOR, True)
self.buildFirewalls(game_state, [[1, 13]], FILTER, True)
self.buildFirewalls(game_state, self.filterCorners, FILTER, shouldRebuild)
self.buildFirewalls(game_state, self.turnZeroTowers, DESTRUCTOR, shouldRebuild)
if self.useRightDoor:
self.buildFirewalls(game_state, self.rightDoorTowers, DESTRUCTOR, shouldRebuildWall, towersToBuild)
self.buildFirewalls(game_state, self.rightDoorFilters, FILTER, shouldRebuildWall)
self.buildFirewalls(game_state, self.rightExtraCornerTower, DESTRUCTOR, False)
self.buildFirewalls(game_state, self.rightRearHallway, FILTER, False)
self.buildFirewalls(game_state, [[22, 8]], ENCRYPTOR, False)
# the front wall might be fruitless - if the same things are getting destoryed
# over and over, it would probably do better to build encryptors to break the stalemate
# could even finance it by selling the rear hallway.
self.buildFirewalls(game_state, self.rightFrontWall, FILTER, False)
self.buildFirewalls(game_state, self.rightEncryptors, ENCRYPTOR, False)
else:
self.buildFirewalls(game_state, self.leftDoorTowers, DESTRUCTOR, shouldRebuildWall, towersToBuild)
self.buildFirewalls(game_state, self.leftDoorFilters, FILTER, shouldRebuildWall)
self.buildFirewalls(game_state, self.leftExtraCornerTower, DESTRUCTOR, False)
self.buildFirewalls(game_state, self.leftRearHallway, FILTER, False)
self.buildFirewalls(game_state, [[5, 8]], ENCRYPTOR, False)
# the front wall might be fruitless - if the same things are getting destoryed
# over and over, it would probably do better to build encryptors to break the stalemate
# could even finance it by selling the rear hallway.
self.buildFirewalls(game_state, self.leftFrontWall, FILTER, False)
self.buildFirewalls(game_state, self.leftEncryptors, ENCRYPTOR, False)
if game_state.turn_number == 1 or game_state.turn_number > 5:
copy_of_game_state = copy.deepcopy(game_state)
risk = self.attackForMaxPain(copy_of_game_state)
if risk == 0:
self.attackForMaxPain(game_state)
# we may need to counter their troops
if game_state.turn_number <= 3 and self.useRightDoor and [3, 10] not in self.spawnBlacklist:
while game_state.can_spawn(EMP, [3, 10]):
game_state.attempt_spawn(EMP, [3, 10])
elif game_state.turn_number <= 3 and not self.useRightDoor and [24, 10] not in self.spawnBlacklist:
while game_state.can_spawn(EMP, [24, 10]):
game_state.attempt_spawn(EMP, [24, 10])
else:
self.attackForMaxDestruction(game_state)
# reset the dictionary for the next analysis
self.army_dict['total_count'] = 0
self.army_dict['total_cost'] = 0
self.army_dict['ping_count'] = 0
self.army_dict['EMP_count'] = 0
self.army_dict['scrambler_count'] = 0
self.enemy_spawns.clear()
self.my_EMP_ids.clear()
game_state.submit_turn()
def on_turn(self, turn_state):
game_state = gamelib.AdvancedGameState(self.config, turn_state)
p1UnitCount = len(self.jsonState.get('p1Units')[0]) + len(
self.jsonState.get('p1Units')[1]) + len(
self.jsonState.get('p1Units')[2])
p2UnitCount = len(self.jsonState.get('p2Units')[0]) + len(
self.jsonState.get('p2Units')[1]) + len(
self.jsonState.get('p2Units')[2])
gamelib.debug_write('p2 has {} units'.format(p2UnitCount))
gamelib.debug_write('p2 army cost last turn = {}'.format(
self.enemy_army_cost))
if self.army_dict.get('total_cost', 0) > 0:
self.lastEnemyArmyDict = self.army_dict.copy()
if 'total_cost' in self.lastEnemyArmyDict and game_state.get_resource(
game_state.BITS, 1) >= self.lastEnemyArmyDict['total_cost']:
gamelib.debug_write(
'I predict that p2 will spawn an army this turn!')
shouldRebuild = game_state.turn_number > 3
shouldRebuildWall = p1UnitCount >= 27 #only reinforce if the full wall is in place
needsStrongerCorners = game_state.turn_number > 3
towersToBuild = 1
self.coresToSpendOnRebuilding = 4
if game_state.turn_number == 0:
self.buildFirewalls(game_state,
[[1, 13], [3, 13], [24, 13], [26, 13]], FILTER,
False)
self.buildFirewalls(game_state,
[[2, 13], [6, 11], [21, 11], [25, 13]],
DESTRUCTOR, False)
game_state.attempt_spawn(SCRAMBLER, [22, 8])
game_state.attempt_spawn(SCRAMBLER, [5, 8])
elif game_state.turn_number == 1:
if game_state.get_enemy_destructor_count_for_locations(
[[0, 14], [1, 14], [2, 14], [3, 14], [4, 14], [5, 14]]) > 0:
self.buildFirewalls(game_state, [[3, 11], [5, 11]], FILTER,
False)
self.buildFirewalls(game_state, [[4, 11]], ENCRYPTOR, False)
self.possibleLeftSpawnCoords = [[3, 10]]
elif game_state.get_enemy_destructor_count_for_locations(
[[1, 15], [2, 15], [3, 15], [4, 15], [5, 15]]) > 0:
self.buildFirewalls(game_state, [[3, 12], [5, 12]], FILTER,
False)
self.buildFirewalls(game_state, [[4, 12]], ENCRYPTOR, False)
self.possibleLeftSpawnCoords = [[2, 11]]
else:
self.buildFirewalls(game_state, [[4, 13], [5, 13]], FILTER,
False)
self.buildFirewalls(game_state, [[4, 11]], ENCRYPTOR, False)
self.possibleLeftSpawnCoords = [[1, 12]]
if game_state.get_enemy_destructor_count_for_locations([[
22, 14
], [23, 14], [24, 14], [25, 14], [26, 14], [27, 14]]) > 0:
self.buildFirewalls(game_state, [[22, 11], [24, 11]], FILTER,
False)
self.buildFirewalls(game_state, [[23, 11]], ENCRYPTOR, False)
self.possibleRightSpawnCoords = [[24, 10]]
elif game_state.get_enemy_destructor_count_for_locations(
[[22, 15], [23, 15], [24, 15], [25, 15], [26, 15]]) > 0:
self.buildFirewalls(game_state, [[22, 12], [24, 12]], FILTER,
False)
self.buildFirewalls(game_state, [[23, 12]], ENCRYPTOR, False)
self.possibleRightSpawnCoords = [[25, 11]]
else:
self.buildFirewalls(game_state, [[22, 13], [23, 13]], FILTER,
False)
self.buildFirewalls(game_state, [[23, 11]], ENCRYPTOR, False)
self.possibleRightSpawnCoords = [[26, 12]]
game_state.attempt_spawn(EMP, self.possibleLeftSpawnCoords[0])
game_state.attempt_spawn(EMP, self.possibleRightSpawnCoords[0])
else:
game_state.attempt_spawn(EMP, self.possibleLeftSpawnCoords[0])
game_state.attempt_spawn(EMP, self.possibleRightSpawnCoords[0])
# EMPs will be neutralized by my own encrypted EMPs. Check if I need more encryptors
if len(self.enemy_EMP_spawn_coords) > 0:
leftEMPSpawnCoords = []
rightEMPSpawnCoords = []
for c in self.enemy_EMP_spawn_coords:
x, y = c
if x < 14:
leftEMPSpawnCoords.append(c)
else:
rightEMPSpawnCoords.append(c)
leftEncryptorStrength = 0
rightEncryptorStrenth = 0
for c in self.jsonState.get('p2Units')[1]:
x = c[0]
if x < 14:
leftEncryptorStrength += 1
else:
rightEncryptorStrenth += 1
enemyEMPsAffordable = game_state.get_resource(
game_state.BITS, 1) // 3
# we want to build EMP army size + encryptor strength in encryptors
if len(leftEMPSpawnCoords) > 0:
if game_state.count_units_in_locations(
self.leftEncryptorCoords
) < enemyEMPsAffordable + leftEncryptorStrength:
self.buildFirewalls(game_state,
self.leftEncryptorCoords,
ENCRYPTOR, False, 1)
if len(rightEMPSpawnCoords) > 0:
if game_state.count_units_in_locations(
self.rightEncryptorCoords
) < enemyEMPsAffordable + rightEncryptorStrenth:
self.buildFirewalls(game_state,
self.rightEncryptorCoords,
ENCRYPTOR, False, 1)
# towers will be the way to neutralize pings
if len(self.enemy_ping_spawn_coords) > 0:
self.buildFirewalls(game_state, self.middleTowerCoords,
DESTRUCTOR, False)
# towers will be the way to neutralize scramblers
if len(self.enemy_scrambler_spawn_cords) > 0:
self.buildFirewalls(game_state, self.middleTowerCoords,
DESTRUCTOR, False)
# reset the dictionary for the next analysis
self.army_dict['total_count'] = 0
self.army_dict['total_cost'] = 0
self.army_dict['ping_count'] = 0
self.army_dict['EMP_count'] = 0
self.army_dict['scrambler_count'] = 0
self.enemy_spawns.clear()
self.my_EMP_ids.clear()
game_state.submit_turn()
def on_turn(self, turn_state):
game_state = gamelib.AdvancedGameState(self.config, turn_state)
#p1UnitCount = len(self.jsonState.get('p1Units')[0])
p2UnitCount = len(self.jsonState.get('p2Units')[0]) + len(self.jsonState.get('p2Units')[1]) + len(self.jsonState.get('p2Units')[2])
gamelib.debug_write('p2 has {} units'.format(p2UnitCount))
# let's build the corners #
if game_state.can_spawn(DESTRUCTOR, [0,13]):
game_state.attempt_spawn(DESTRUCTOR, [0, 13])
if game_state.can_spawn(DESTRUCTOR, [27, 13]):
game_state.attempt_spawn(DESTRUCTOR, [27, 13])
self.reinforceBreachLocation(game_state)
# line detection #
# only worry about mirror if we have good defense set up?
firstRowDefenderCount = game_state.get_enemy_unit_count_for_row(game_state.game_map.FIRST_ENEMY_ROW)
firstRowDestructorCount = game_state.get_enemy_destructor_count_for_row(game_state.game_map.FIRST_ENEMY_ROW)
secondRowDefenderCount = game_state.get_enemy_unit_count_for_row(game_state.game_map.SECOND_ENEMY_ROW)
secondRowDestructorCount = game_state.get_enemy_destructor_count_for_row(game_state.game_map.SECOND_ENEMY_ROW)
thirdRowDefenderCount = game_state.get_enemy_unit_count_for_row(game_state.game_map.THIRD_ENEMY_ROW)
thirdRowDestructorCount = game_state.get_enemy_destructor_count_for_row(game_state.game_map.THIRD_ENEMY_ROW)
fourthRowDefenderCount = game_state.get_enemy_unit_count_for_row(game_state.game_map.FOURTH_ENEMY_ROW)
fourthRowDestructorCount = game_state.get_enemy_destructor_count_for_row(game_state.game_map.FOURTH_ENEMY_ROW)
gamelib.debug_write('row counts: {},{},{},{}'.format(firstRowDefenderCount, secondRowDefenderCount, thirdRowDefenderCount, fourthRowDefenderCount))
# we may need to move our wall at some point
if firstRowDestructorCount > 6:
self.buildCastleWall = True
self.castleWallRow = 10
elif secondRowDestructorCount > 6:
self.buildCastleWall = True
self.castleWallRow = 11
elif thirdRowDestructorCount > 6:
self.buildCastleWall = True
self.castleWallRow = 12
elif fourthRowDefenderCount > 6:
self.buildCastleWall = True
self.castleWallRow = 13
# this is problematic when it keeps dying
if self.buildCastleWall:
self.buildWall(game_state)
if game_state.turn_number != 0:
if game_state.turn_number > 70:
# what about sending scramblers?
if game_state.my_health < 5 and game_state.number_affordable(PING) > 20:
self.attackForMaxPain(game_state)
elif game_state.project_future_bits() < game_state.get_resource(game_state.BITS) + 1:
self.attackForMaxPain(game_state)
elif p2UnitCount < 8:
self.attackForMaxPain(game_state)
elif game_state.turn_number != 1 and game_state.turn_number % 28 in [0, 1, 2]:
if game_state.turn_number % 28 == 1:
for x in range(4):
game_state.attempt_remove([20, 13 - x])
elif game_state.turn_number % 28 == 2:
self.attackForMaxTargets(game_state)
else:
self.attackForMaxDestruction(game_state)
for location in self.reversedCoords:
game_state.attempt_remove(location)
game_state.submit_turn()
def on_turn(self, turn_state):
game_state = gamelib.AdvancedGameState(self.config, turn_state)
p1UnitCount = len(self.jsonState.get('p1Units')[0]) + len(
self.jsonState.get('p1Units')[1]) + len(
self.jsonState.get('p1Units')[2])
p2UnitCount = len(self.jsonState.get('p2Units')[0]) + len(
self.jsonState.get('p2Units')[1]) + len(
self.jsonState.get('p2Units')[2])
gamelib.debug_write('p2 has {} units'.format(p2UnitCount))
gamelib.debug_write('p2 army cost last turn = {}'.format(
self.enemy_army_cost))
self.totalCoresSpent = 0
self.reservedCoordsForThisTurn = []
for coord in self.reservedCoords:
self.reservedCoordsForThisTurn.append(coord)
if game_state.can_spawn(FILTER, [25, 13]):
game_state.attempt_spawn(FILTER, [25, 13])
path = game_state.find_path_to_edge([13, 0],
game_state.game_map.TOP_RIGHT)
reinforcementCoords = game_state.game_map.get_locations_in_range(
[23, 11], 3)
if not any((True for c in reinforcementCoords if c in path)):
gamelib.debug_write('we are outside the path!')
self.buildFirewalls(game_state, self.nineWall, FILTER, False)
cornerCoords = [[0, 13], [1, 12], [2, 11]]
if game_state.my_health <= 15 and any(
(True for c in cornerCoords if c in self.breach_list)):
self.buildFirewalls(game_state, self.rightCornerTowers, DESTRUCTOR,
False, 1)
self.buildFirewalls(game_state, self.rightCornerFilters, FILTER,
False, 1)
self.buildFirewalls(game_state, self.rightAssaultTowerCoords,
DESTRUCTOR, False, 1)
self.buildFirewalls(game_state, self.rightAssaultTowerFilterCoords,
FILTER, False, 2)
self.buildFirewalls(game_state, self.rightAssaultEncryptorCoords,
ENCRYPTOR, False, 1)
self.reinforceLocationsEvenly(game_state, self.enemy_spawn_coords)
shouldAttack = True
path = game_state.find_path_to_edge([13, 0],
game_state.game_map.TOP_RIGHT)
if not any((True for c in reinforcementCoords if c in path)):
gamelib.debug_write('we are outside the path!')
shouldAttack = False
gamelib.debug_write('{} - attack path={}'.format(
game_state.turn_number, len(path)))
if len(path) > 30:
shouldAttack = False
defendingDestructors = len(game_state.get_attackers([26, 13], 0))
defendingFilters = game_state.get_enemy_filter_count_for_locations(
[[26, 14], [27, 14]])
if game_state.number_affordable(
PING) < defendingDestructors + defendingFilters + 1:
shouldAttack = False
if shouldAttack:
x, y = path[-1]
gamelib.debug_write('Final step: {}'.format(path[-1]))
if [26, 13] in path and game_state.turn_number > 0:
if self.attackedWithScramblers and self.lastEnemyHealth >= game_state.enemy_health - 4:
if game_state.number_affordable(
EMP) >= 3 + 1 * game_state.turn_number // 12:
game_state.attempt_spawn(
EMP, [13, 0], game_state.number_affordable(EMP))
self.attackedWithScramblers = False
self.attackedLastTurn = True
shouldAttack = False
else:
shouldAttack = False
elif y == 13 or self.attackedLastTurn and self.lastEnemyHealth >= game_state.enemy_health - 4:
game_state.attempt_spawn(
SCRAMBLER, [24, 10],
defendingDestructors + defendingFilters + 1)
self.attackedWithScramblers = True
self.attackedLastTurn = True
if shouldAttack and game_state.number_affordable(PING) > 2:
game_state.attempt_spawn(PING, [13, 0],
game_state.number_affordable(PING))
self.attackedLastTurn = True
else:
self.attackedLastTurn = False
self.lastEnemyHealth = game_state.enemy_health
game_state.submit_turn()
def on_turn(self, turn_state):
game_state = gamelib.AdvancedGameState(self.config, turn_state)
#p1UnitCount = len(self.jsonState.get('p1Units')[0])
p2UnitCount = len(self.jsonState.get('p2Units')[0]) + len(
self.jsonState.get('p2Units')[1]) + len(
self.jsonState.get('p2Units')[2])
gamelib.debug_write('p2 has {} units'.format(p2UnitCount))
self.reinforceBreachLocation(game_state)
# line detection #
# only worry about mirror if we have good defense set up?
firstRowDefenderCount = game_state.get_enemy_unit_count_for_row(
game_state.game_map.FIRST_ENEMY_ROW)
firstRowDestructorCount = game_state.get_enemy_destructor_count_for_row(
game_state.game_map.FIRST_ENEMY_ROW)
secondRowDefenderCount = game_state.get_enemy_unit_count_for_row(
game_state.game_map.SECOND_ENEMY_ROW)
secondRowDestructorCount = game_state.get_enemy_destructor_count_for_row(
game_state.game_map.SECOND_ENEMY_ROW)
thirdRowDefenderCount = game_state.get_enemy_unit_count_for_row(
game_state.game_map.THIRD_ENEMY_ROW)
thirdRowDestructorCount = game_state.get_enemy_destructor_count_for_row(
game_state.game_map.THIRD_ENEMY_ROW)
fourthRowDefenderCount = game_state.get_enemy_unit_count_for_row(
game_state.game_map.FOURTH_ENEMY_ROW)
fourthRowDestructorCount = game_state.get_enemy_destructor_count_for_row(
game_state.game_map.FOURTH_ENEMY_ROW)
gamelib.debug_write('row counts: {},{},{},{}'.format(
firstRowDefenderCount, secondRowDefenderCount,
thirdRowDefenderCount, fourthRowDefenderCount))
# we may need to advance our wall
# a common pattern is a row of filters infront of a row of destructors, we want to focus on the destructors!
if secondRowDestructorCount > 4:
self.mirrorEnemy(game_state, game_state.game_map.SECOND_ENEMY_ROW)
elif thirdRowDestructorCount > 4:
self.mirrorEnemy(game_state, game_state.game_map.THIRD_ENEMY_ROW)
elif fourthRowDestructorCount > 4:
self.mirrorEnemy(game_state, game_state.game_map.FOURTH_ENEMY_ROW)
elif firstRowDefenderCount > 8:
self.mirrorEnemy(game_state, game_state.game_map.FIRST_ENEMY_ROW)
elif secondRowDefenderCount > 6:
self.mirrorEnemy(game_state, game_state.game_map.SECOND_ENEMY_ROW)
elif thirdRowDefenderCount > 6:
self.mirrorEnemy(game_state, game_state.game_map.THIRD_ENEMY_ROW)
elif fourthRowDefenderCount > 6:
self.mirrorEnemy(game_state, game_state.game_map.FOURTH_ENEMY_ROW)
# make sure we haven't blocked ourselves in
for x in range(4):
openSpots = game_state.row_openings(13 - x)
if openSpots == 0:
# open it back up!
game_state.attempt_remove([20, 13 - x])
if game_state.turn_number != 0:
if p2UnitCount < 8:
self.attackForMaxPain(game_state)
else:
self.attackForMaxDestruction(game_state)
game_state.submit_turn()
def on_turn(self, turn_state):
game_state = gamelib.AdvancedGameState(self.config, turn_state)
#p1UnitCount = len(self.jsonState.get('p1Units')[0])
p2UnitCount = len(self.jsonState.get('p2Units')[0]) + len(
self.jsonState.get('p2Units')[1]) + len(
self.jsonState.get('p2Units')[2])
gamelib.debug_write('p2 has {} units'.format(p2UnitCount))
self.totalCoresSpent = 0
self.reservedCoordsForThisTurn = []
for coord in self.reservedCoords:
self.reservedCoordsForThisTurn.append(coord)
self.buildTurnZeroTowers(game_state)
# consider front line being FILTERS? Does it matter if they use EMPs? YES!! PINGS need these to be towers
# NEED TO COUNTER HEAVY EMP DESTRUCTION, we can't afford to build enough defense when EMPs wreck havok
if self.enemy_EMP_spawn_count > self.enemy_ping_spawn_count:
gamelib.debug_write('p2 likes to spawn EMPs. {} > {}'.format(
self.enemy_EMP_spawn_count, self.enemy_ping_spawn_count))
for x in range(28):
if [x, 13] not in self.betterAsFilter:
self.betterAsFilter.append([x, 13])
else:
gamelib.debug_write('p2 likes to spawn Pings. {} < {}'.format(
self.enemy_EMP_spawn_count, self.enemy_ping_spawn_count))
self.betterAsFilter = []
if not self.doesEnemyHorde and game_state.turn_number > 4 and game_state.get_resource(
game_state.CORES, 1) >= 10:
gamelib.debug_write('p2 is a HORDER! CORES:{}'.format(
game_state.get_resource(game_state.CORES, 1)))
# once a horder, always a horder
self.doesEnemyHorde = True
self.attackForPain = True
if self.attackedLastTurn:
if self.attackForPain and game_state.enemy_health == self.lastEnemyHealth:
gamelib.debug_write(
'Tried to hurt them and failed! Changing strategies.')
if not self.doesEnemyHorde:
self.attackForPain = False
elif p2UnitCount >= self.lastEnemyUnitCount + 4:
# TODO # This is not good enough, we lose some games where switching to PINGS might have made the difference
gamelib.debug_write(
'Tried to damage them and failed! Changing strategies.')
self.attackForPain = True
self.attackedLastTurn = False
# we need to be careful overbuilding on any one turn, so pretend we never have more than 26 cores #
# TODO # DONE
if game_state.turn_number == 0:
self.spawnScramblerJammers(game_state)
else:
# if we haven't seen an enemy spawn yet (and it's still early)
if game_state.turn_number < 3 and len(
self.enemy_spawn_coords) == 0:
self.spawnScramblerJammers(game_state)
self.markForRefund(game_state)
# NEED TO CONSIDER ALGOs THAT HORDE CORES AND WHAT HAPPENS AFTER MASSIVE DESTRUCTION
# more complex comparisson would be if they can afford to replace all that was destroyed ...
if self.lastEnemyUnitCount > p2UnitCount and game_state.get_resource(
game_state.CORES, 1) > 6:
coordsToReinforce = self.reinforceLocationsEvenly(
self.lastTurnGameState, self.enemy_spawn_coords)
for location in coordsToReinforce:
attackers = len(game_state.get_attackers(location, 1))
if attackers < 5:
self.reinforceLocation(game_state, location,
5 - attackers)
else:
self.reinforceLocationsEvenly(game_state,
self.enemy_spawn_coords)
if self.attackForPain:
if game_state.number_affordable(
PING) >= 12 + game_state.turn_number // 5:
self.attackForMaxPain(game_state)
self.attackedLastTurn = True
else:
self.attackedLastTurn = False
else:
if game_state.number_affordable(
EMP) >= 3 + game_state.turn_number // 15:
self.attackForMaxDestruction(game_state)
self.attackedLastTurn = True
else:
self.attackedLastTurn = False
gamelib.debug_write('SUMBITTING TURN {}'.format(
game_state.turn_number))
self.lastEnemyHealth = game_state.enemy_health
self.lastEnemyUnitCount = p2UnitCount
self.lastTurnGameState = game_state
game_state.submit_turn()
