def final_dock_placement(self):
"""
POPULATE DOCK PLACEMENT
"""
shipyard = self.game.me.shipyard
matrix = copy.deepcopy(self.myMatrix.cell_average.top_N)
## OLD WAY
print_matrix("Average: top N", self.myMatrix.cell_average.top_N)
## ELIMINATE TOP N CLOSE TO SHIPYARD
populate_manhattan(matrix, Matrix_val.ZERO, shipyard.position,
MyConstants.build.min_dist_btw_docks,
Option.REPLACE)
print_matrix("Eliminate close to shipyard: top N", matrix)
## ELIMINATE TOP N CLOSE TO ENEMY SHIPYARD
for id, player in self.game.players.items():
if id != self.game.me.id:
enemyShipyard_position = player.shipyard.position
populate_manhattan(matrix, Matrix_val.ZERO,
enemyShipyard_position,
MyConstants.build.min_dist_btw_docks,
Option.REPLACE)
print_matrix("Eliminate close to enemy shipyard: top N", matrix)
## GET COORD OF HIGHEST VALUE IN MATRIX
## LOCATED ON HIGHEST HALITE (WITH HIGHEST AVERAGE VALUE FROM THAT SECTION)
curr_cell = (shipyard.position.y, shipyard.position.x)
coord, distance, val = get_coord_closest(
matrix.max(), matrix, self.myMatrix.distances.cell[curr_cell],
Inequality.EQUAL)
while val > 1:
## ELIMINATE TOP N CLOSE TO THIS AREA
position = Position(coord[1], coord[0])
populate_manhattan(matrix, Matrix_val.ONE, position,
MyConstants.build.min_dist_btw_docks,
Option.REPLACE)
## POPULATE DOCK PLACEMENT
# # self.myMatrix.locations.dock_placement[position.y][position.x] = Matrix_val.ONE
# for i in range(0, MyConstants.build.dock_manhattan):
# populate_manhattan(self.myMatrix.docks.placement, Matrix_val.ONE, position, i, Option.CUMMULATIVE)
self.myMatrix.docks.placement[position.y][
position.x] = Matrix_val.ONE
## GET COORD OF NEXT HIGHEST VALUE IN MATRIX
coord, distance, val = get_coord_closest(
matrix.max(), matrix, self.myMatrix.distances.cell[curr_cell],
Inequality.EQUAL)
print_matrix("Final dock placement", self.myMatrix.docks.placement)
def get_closest_dock_coord(self, ship):
curr_cell = (ship.position.y, ship.position.x)
dock_coord, distance, val = get_coord_closest(
MyConstants.build.dock_manhattan,
self.data.myMatrix.docks.manhattan,
self.data.init_data.myMatrix.distances.cell[curr_cell],
Inequality.EQUAL)
return dock_coord
def get_closest_enemy_position(self, ship):
"""
GET DIRECTIONS AND POSITION OF THE CLOSEST ENEMY GIVEN THE SHIP
"""
curr_cell = (ship.position.y, ship.position.x)
coord, distance, val = get_coord_closest(
Matrix_val.ONE, self.data.myMatrix.locations.enemyShips,
self.data.init_data.myMatrix.distances.cell[curr_cell],
Inequality.EQUAL)
enemy_position = Position(coord[1], coord[0])
directions = self.get_directions_target(ship, enemy_position)
return directions, enemy_position
def populate_heap_return(self, ship):
"""
GET DISTANCE FROM SHIPYARD/DOCKS
"""
## TAKING DOCKS INTO ACCOUNT
if ship.id not in self.heap_set_dist:
self.heap_set_dist.add(ship.id)
curr_cell = (ship.position.y, ship.position.x)
coord, distance, value = get_coord_closest(Matrix_val.ONE,
self.data.myMatrix.locations.myDocks,
self.data.init_data.myMatrix.distances.cell[curr_cell],
Inequality.EQUAL)
dock_position = Position(coord[1], coord[0])
directions = self.get_directions_target(ship, dock_position)
num_directions = len(directions)
s = FarthestShip(distance, num_directions, ship.id, directions, dock_position)
heapq.heappush(self.heap_dist, s)
def get_criteria(self, ship):
curr_cell = (ship.position.y, ship.position.x)
coord, distance, val = get_coord_closest(
Matrix_val.ONE, self.data.myMatrix.locations.myDocks,
self.data.init_data.myMatrix.distances.cell[curr_cell],
Inequality.EQUAL)
ally_count = count_manhattan(self.data.myMatrix.locations.myShips,
Matrix_val.ONE, ship.position,
MyConstants.build.far_enemy_perimeter)
enemy_count = count_manhattan(self.data.myMatrix.locations.enemyShips,
Matrix_val.ONE, ship.position,
MyConstants.build.far_enemy_perimeter)
if distance >= MyConstants.build.considered_far_distance \
and enemy_count > ally_count:
passCriteria = True
else:
passCriteria = False
return passCriteria
def get_dock_order(self):
"""
GET ORDER OF WHAT DOCKS TO BUILD
"""
order_num = 1
shipyard = self.game.me.shipyard
shipyard_coord = (shipyard.position.y, shipyard.position.x)
value_matrix = copy.deepcopy(self.myMatrix.cell_average.top_N)
distance_coords = {shipyard_coord}
## ELIMINATE TOP N CLOSE TO SHIPYARD
populate_manhattan(value_matrix, Matrix_val.ZERO, shipyard.position,
MyConstants.build.min_dist_btw_docks,
Option.REPLACE)
print_matrix("Eliminate close to shipyard: top N", value_matrix)
## ELIMINATE TOP N CLOSE TO ENEMY SHIPYARD
for id, player in self.game.players.items():
if id != self.game.me.id:
enemyShipyard_position = player.shipyard.position
populate_manhattan(value_matrix, Matrix_val.ZERO,
enemyShipyard_position,
MyConstants.MIN_DIST_BTW_DOCKS,
Option.REPLACE)
print_matrix("Eliminate close to enemy shipyard: top N", value_matrix)
ratio, distances = self.get_ratio(value_matrix, distance_coords)
print_matrix("ratio order_num {}".format(order_num), ratio)
## GET HIGHEST RATIO
coord, distance, val = get_coord_closest(ratio.max(), ratio, distances,
Inequality.EQUAL)
while val > 0:
## POPULATE ORDER MATRIX
position = Position(coord[1], coord[0])
self.myMatrix.docks.order[position.y][position.x] = order_num
order_num += 1
## ELIMINATE TOP N CLOSE TO THIS AREA
populate_manhattan(value_matrix, Matrix_val.ZERO, position,
MyConstants.build.min_dist_btw_docks,
Option.REPLACE)
print_matrix("order matrix", self.myMatrix.docks.order)
## CLEAR THAT LOCATION
value_matrix[position.y][position.x] = Matrix_val.ZERO
## ADD THIS COORD TO DISTANCES TO TAKE INTO ACCOUNT
distance_coords.add(coord)
ratio, distances = self.get_ratio(value_matrix, distance_coords)
print_matrix("ratio order_num {}".format(order_num), ratio)
## GET HIGHEST RATIO
coord, distance, val = get_coord_closest(ratio.max(), ratio,
distances,
Inequality.EQUAL)