132 lines
3.6 KiB
Python
132 lines
3.6 KiB
Python
from dataclasses import dataclass
|
|
|
|
import numpy as np
|
|
|
|
from const import *
|
|
from typing import List, Dict, Tuple
|
|
|
|
import numpy.typing as npt
|
|
|
|
|
|
@dataclass
|
|
class Position:
|
|
row: int
|
|
col: int
|
|
|
|
|
|
@dataclass
|
|
class Area:
|
|
position: Position
|
|
width: int
|
|
height: int
|
|
|
|
|
|
AREAS_TO_CROSS = [
|
|
# up above left knights spawn
|
|
Area(position=Position(row=0, col=0),
|
|
width=KNIGHTS_SPAWN_WIDTH,
|
|
height=LEFT_KNIGHTS_SPAWN_FIRST_ROW),
|
|
|
|
# down below left knights spawn
|
|
Area(position=Position(row=LEFT_KNIGHTS_SPAWN_FIRST_ROW + KNIGHTS_SPAWN_HEIGHT, col=0),
|
|
width=KNIGHTS_SPAWN_WIDTH,
|
|
height=ROWS - LEFT_KNIGHTS_SPAWN_FIRST_ROW - KNIGHTS_SPAWN_HEIGHT),
|
|
|
|
# between left knights spawn and castle
|
|
Area(position=Position(row=0, col=KNIGHTS_SPAWN_WIDTH),
|
|
width=CASTLE_SPAWN_FIRST_COL - KNIGHTS_SPAWN_WIDTH,
|
|
height=ROWS),
|
|
|
|
# up above castle
|
|
Area(position=Position(row=0, col=CASTLE_SPAWN_FIRST_COL),
|
|
width=2,
|
|
height=CASTLE_SPAWN_FIRST_ROW),
|
|
|
|
# down below castle
|
|
Area(position=Position(row=CASTLE_SPAWN_FIRST_ROW + 2, col=CASTLE_SPAWN_FIRST_COL),
|
|
width=2,
|
|
height=ROWS - CASTLE_SPAWN_FIRST_ROW - 2),
|
|
|
|
# between castle and right knights spawn
|
|
Area(position=Position(row=0, col=CASTLE_SPAWN_FIRST_COL + 2),
|
|
width=RIGHT_KNIGHTS_SPAWN_FIRST_COL - CASTLE_SPAWN_FIRST_COL - 2,
|
|
height=ROWS),
|
|
|
|
# up above right knights spawn
|
|
Area(position=Position(row=0, col=RIGHT_KNIGHTS_SPAWN_FIRST_COL),
|
|
width=KNIGHTS_SPAWN_WIDTH,
|
|
height=RIGHT_KNIGHTS_SPAWN_FIRST_ROW),
|
|
|
|
# down below right knights spawn
|
|
Area(position=Position(row=RIGHT_KNIGHTS_SPAWN_FIRST_ROW + KNIGHTS_SPAWN_HEIGHT, col=RIGHT_KNIGHTS_SPAWN_FIRST_COL),
|
|
width=KNIGHTS_SPAWN_WIDTH,
|
|
height=ROWS - RIGHT_KNIGHTS_SPAWN_FIRST_ROW - KNIGHTS_SPAWN_HEIGHT),
|
|
]
|
|
|
|
|
|
def dfs(grid: npt.NDArray, visited: Dict[Tuple[int, int], bool], position: Position, rows: int, cols: int) -> None:
|
|
visited[(position.row, position.col)] = True
|
|
|
|
row_vector = [0, 0, 1, -1]
|
|
col_vector = [-1, 1, 0, 0]
|
|
|
|
neighbours = []
|
|
for i in range(4):
|
|
rr = position.row + row_vector[i]
|
|
cc = position.col + col_vector[i]
|
|
if rr < 0 or rr >= ROWS:
|
|
continue
|
|
elif cc < 0 or cc >= COLUMNS:
|
|
continue
|
|
else:
|
|
p = Position(rr, cc)
|
|
if (p.row, p.col) in visited:
|
|
neighbours.append(p)
|
|
|
|
for neighbour in neighbours:
|
|
if not visited[(neighbour.row, neighbour.col)]:
|
|
dfs(grid, visited, neighbour, rows, cols)
|
|
|
|
|
|
def get_islands(grid: npt.NDArray, positions: List[Position], rows: int = ROWS, cols: int = COLUMNS) -> List[Position]:
|
|
"""it returns list of all islands roots"""
|
|
visited = {}
|
|
|
|
for position in positions:
|
|
visited[(position.row, position.col)] = False
|
|
|
|
islands = 0
|
|
roots = []
|
|
for position in positions:
|
|
if not visited[(position.row, position.col)]:
|
|
dfs(grid, visited, position, rows, cols)
|
|
roots.append(position)
|
|
islands += 1
|
|
|
|
return roots
|
|
|
|
|
|
def find_neighbours(grid: npt.NDArray, col: int, row: int) -> List[Position]:
|
|
dr = [-1, 1, 0, 0]
|
|
dc = [0, 0, -1, 1]
|
|
|
|
neighbours = []
|
|
|
|
for i in range(4):
|
|
rr = row + dr[i]
|
|
cc = col + dc[i]
|
|
|
|
if 0 <= rr < ROWS and 0 <= cc < COLUMNS and grid[rr][cc] == MAP_ALIASES.get('GRASS'):
|
|
neighbours.append(Position(row=rr, col=cc))
|
|
|
|
return neighbours
|
|
|
|
|
|
def count_in_grid(grid: npt.NDArray, target) -> int:
|
|
count = 0
|
|
for row in grid:
|
|
for col in row:
|
|
if col == target:
|
|
count += 1
|
|
return count
|