class Facing(Enum):
UP = coordinates.Coords(0, -1)
DOWN = coordinates.Coords(0, 1)
LEFT = coordinates.Coords(-1, 0)
RIGHT = coordinates.Coords(1, 0)
@staticmethod
def random() -> Facing:
return random.choice(
[Facing.UP, Facing.DOWN, Facing.LEFT, Facing.RIGHT])
def turn_left(self) -> Facing:
if self == Facing.UP:
return Facing.LEFT
elif self == Facing.LEFT:
return Facing.DOWN
elif self == Facing.DOWN:
return Facing.RIGHT
elif self == Facing.RIGHT:
return Facing.UP
def turn_right(self) -> Facing:
if self == Facing.UP:
return Facing.RIGHT
elif self == Facing.RIGHT:
return Facing.DOWN
elif self == Facing.DOWN:
return Facing.LEFT
elif self == Facing.LEFT:
return Facing.UP
def cut_positions(cls, terrain: arenas.Terrain,
position: coordinates.Coords,
facing: characters.Facing) -> List[coordinates.Coords]:
return [
coordinates.Coords(*position + (1, 1)),
coordinates.Coords(*position + (-1, 1)),
coordinates.Coords(*position + (1, -1)),
coordinates.Coords(*position + (-1, -1))
]
def estimate_border_point() -> tuple[coordinates.Coords, int]:
if champion.facing == characters.Facing.UP:
return coordinates.Coords(champion.position.x,
0), champion.position[1]
elif champion.facing == characters.Facing.RIGHT:
return coordinates.Coords(
self.size[0] - 1,
champion.position.y), self.size[0] - champion.position[0]
elif champion.facing == characters.Facing.DOWN:
return coordinates.Coords(
champion.position.x,
self.size[1] - 1), self.size[1] - champion.position.y
elif champion.facing == characters.Facing.LEFT:
return coordinates.Coords(
0, champion.position.y), champion.position[0]
def find_vector_to_nearest_mist_tile(
self, knowledge: characters.ChampionKnowledge):
mist_tiles: dict[coordinates.Coords, int] = defaultdict(
int
) # dict for storing distance to each mist tile from current bot position
visible_tiles = knowledge.visible_tiles
for coord in visible_tiles.keys():
if g_distance(self.bot_position,
coord) <= SIGHT_RANGE and self.is_given_type_tile(
knowledge, coord, MIST_DESCRIPTOR):
dist = g_distance(self.bot_position, coord)
mist_tiles[coord] = dist
if len(mist_tiles) > 0:
min_dist_tuple = min(mist_tiles, key=mist_tiles.get)
min_dist_coord = coordinates.Coords(min_dist_tuple[0],
min_dist_tuple[1])
min_dist_vec = (min_dist_coord - self.bot_position)
if self.last_observed_mist_vec is None:
self.last_observed_mist_vec = min_dist_vec
self.run_seq_step = 1
elif g_distance_vec(min_dist_vec) < g_distance_vec(
self.last_observed_mist_vec):
self.last_observed_mist_vec = min_dist_vec
if self.run_seq_step == LONG_SEQ:
self.run_seq_step = 1
return self.last_observed_mist_vec
def load(name: str) -> Arena:
terrain = dict()
arena_file_path = os.path.join('resources', 'arenas', f'{name}.gupb')
with open(arena_file_path) as file:
for y, line in enumerate(file.readlines()):
for x, character in enumerate(line):
if character != '\n':
position = coordinates.Coords(x, y)
if character in TILE_ENCODING:
terrain[position] = TILE_ENCODING[character]()
elif character in WEAPON_ENCODING:
terrain[position] = tiles.Land()
terrain[position].loot = WEAPON_ENCODING[
character]()
return Arena(name, terrain)
def init_enviroment_map(self, map_name: str):
arena = None
try:
arena_object = arenas.Arena.load(map_name)
size = arena_object.size
terrain = arena_object.terrain
arena = [[
self.terrain_mapping(terrain, coordinates.Coords(*(x, y)))
for x in range(size[0])
] for y in range(size[1])]
self.arena = arena
self.enviroment_map = Grid(matrix=arena)
self.arena_size = size
except Exception as e:
# print("Exception" + str(e))
pass
def visible_coords(
self, champion: characters.Champion) -> set[coordinates.Coords]:
def estimate_border_point() -> tuple[coordinates.Coords, int]:
if champion.facing == characters.Facing.UP:
return coordinates.Coords(champion.position.x,
0), champion.position[1]
elif champion.facing == characters.Facing.RIGHT:
return coordinates.Coords(
self.size[0] - 1,
champion.position.y), self.size[0] - champion.position[0]
elif champion.facing == characters.Facing.DOWN:
return coordinates.Coords(
champion.position.x,
self.size[1] - 1), self.size[1] - champion.position.y
elif champion.facing == characters.Facing.LEFT:
return coordinates.Coords(
0, champion.position.y), champion.position[0]
border, distance = estimate_border_point()
left = champion.facing.turn_left().value
targets = [
border + coordinates.Coords(i * left.x, i * left.y)
for i in range(-distance, distance + 1)
]
visible = set()
visible.add(champion.position)
for coords in targets:
ray = bresenham.bresenham(champion.position.x, champion.position.y,
coords[0], coords[1])
next(ray)
for ray_coords in ray:
if ray_coords not in self.terrain:
break
visible.add(ray_coords)
if not self.terrain[ray_coords].transparent:
break
return visible
def _mul(self, coor, scalar: int):
return coordinates.Coords(*(coor[0] * scalar, coor[1] * scalar))
class Move(Enum):
UP = coordinates.Coords(0, -1)
LEFT = coordinates.Coords(-1, 0)
RIGHT = coordinates.Coords(1, 0)
DO_NOTHING = coordinates.Coords(0, 0) # ATTACK
