107 changed files with 218 additions and 3818 deletions
--- a/.gitignore
+++ b/.gitignore
@ -149,5 +149,4 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-.idea/
+.idea/
 /algorithms/neural_network/data/
--- a/algorithms/a_star.py
+++ b/algorithms/a_star.py
@ -1,189 +0,0 @@
 from __future__ import annotations
 import heapq
 from dataclasses import dataclass, field
 from typing import Tuple, Optional, List
 from algorithms.genetic.const import MAP_ALIASES
 from common.constants import ROWS, COLUMNS, LEFT, RIGHT, UP, DOWN
 from common.helpers import directions
 EMPTY_FIELDS = [MAP_ALIASES.get("SAND"), MAP_ALIASES.get("GRASS"), ' ']
 TURN_LEFT = 'TURN_LEFT'
 TURN_RIGHT = 'TURN_RIGHT'
 FORWARD = 'FORWARD'
@dataclass
 class State:
    position: Tuple[int, int]
    direction: str
    def __eq__(self, other: State) -> bool:
        return other.position == self.position and self.direction == other.direction
    def __lt__(self, state):
        return self.position < state.position
    def __hash__(self) -> int:
        return hash(self.position)
@dataclass
 class Node:
    state: State
    parent: Optional[Node]
    action: Optional[str]
    grid: List[List[str]]
    cost: int = field(init=False)
    depth: int = field(init=False)
    def __lt__(self, node) -> None:
        return self.state < node.state
    def __post_init__(self) -> None:
        if self.grid[self.state.position[0]][self.state.position[1]] == 'g':
            self.cost = 1 if not self.parent else self.parent.cost + 1
        else:
            self.cost = 2 if not self.parent else self.parent.cost + 2
        self.depth = 0 if not self.parent else self.parent.depth + 1
    def __hash__(self) -> int:
        return hash(self.state)
 def expand(node: Node, grid: List[List[str]]) -> List[Node]:
    return [child_node(node=node, action=action, grid=grid) for action in actions(node.state, grid)]
 def child_node(node: Node, action: str, grid: List[List[str]]) -> Node:
    next_state = result(state=node.state, action=action)
    return Node(state=next_state, parent=node, action=action, grid=grid)
 def next_position(current_position: Tuple[int, int], direction: str) -> Tuple[int, int]:
    next_row, next_col = directions[direction]
    row, col = current_position
    return next_row + row, next_col + col
 def valid_move(position: Tuple[int, int], grid: List[List[str]]) -> bool:
    row, col = position
    return grid[row][col] in EMPTY_FIELDS
 def actions(state: State, grid: List[List[str]]) -> List[str]:
    possible_actions = [FORWARD, TURN_LEFT, TURN_RIGHT]
    row, col = state.position
    direction = state.direction
    if direction == UP and row == 0:
        remove_forward(possible_actions)
    if direction == DOWN and row == ROWS - 1:
        remove_forward(possible_actions)
    if direction == LEFT and col == 0:
        remove_forward(possible_actions)
    if direction == RIGHT and col == COLUMNS - 1:
        remove_forward(possible_actions)
    if FORWARD in possible_actions and not valid_move(next_position(state.position, direction), grid):
        remove_forward(possible_actions)
    return possible_actions
 def remove_forward(possible_actions: List[str]) -> None:
    if FORWARD in possible_actions:
        possible_actions.remove(FORWARD)
 def result(state: State, action: str) -> State:
    next_state = State(state.position, state.direction)
    if state.direction == UP:
        if action == TURN_LEFT:
            next_state.direction = LEFT
        elif action == TURN_RIGHT:
            next_state.direction = RIGHT
        elif action == FORWARD:
            next_state.position = next_position(state.position, UP)
    elif state.direction == DOWN:
        if action == TURN_LEFT:
            next_state.direction = RIGHT
        elif action == TURN_RIGHT:
            next_state.direction = LEFT
        elif action == FORWARD:
            next_state.position = next_position(state.position, DOWN)
    elif state.direction == LEFT:
        if action == TURN_LEFT:
            next_state.direction = DOWN
        elif action == TURN_RIGHT:
            next_state.direction = UP
        elif action == FORWARD:
            next_state.position = next_position(state.position, LEFT)
    elif state.direction == RIGHT:
        if action == TURN_LEFT:
            next_state.direction = UP
        elif action == TURN_RIGHT:
            next_state.direction = DOWN
        elif action == FORWARD:
            next_state.position = next_position(state.position, RIGHT)
    return next_state
 def goal_test(state: State, goal_list: List[Tuple[int, int]]) -> bool:
    return state.position in goal_list
 def h(state: State, goal: Tuple[int, int]) -> int:
    """heuristics that calculates Manhattan distance between current position and goal"""
    x1, y1 = state.position
    x2, y2 = goal
    return abs(x1 - x2) + abs(y1 - y2)
 def f(current_node: Node, goal: Tuple[int, int]) -> int:
    """f(n) = g(n) + h(n), g stands for current cost, h for heuristics"""
    return current_node.cost + h(state=current_node.state, goal=goal)
 def get_path_from_start(node: Node) -> List[str]:
    path = [node.action]
    while node.parent is not None:
        node = node.parent
        if node.action:
            path.append(node.action)
    path.reverse()
    return path
 def a_star(state: State, grid: List[List[str]], goals: List[Tuple[int, int]]) -> List[str]:
    node = Node(state=state, parent=None, action=None, grid=grid)
    frontier = list()
    heapq.heappush(frontier, (f(node, goals[0]), node))
    explored = set()
    while frontier:
        r, node = heapq.heappop(frontier)
        if goal_test(node.state, goals):
            return get_path_from_start(node)
        explored.add(node.state)
        for child in expand(node, grid):
            p = f(child, goals[0])
            if child.state not in explored and (p, child) not in frontier:
                heapq.heappush(frontier, (p, child))
            elif (r, child) in frontier and r > p:
                heapq.heappush(frontier, (p, child))
    return []
--- a/algorithms/bfs.py
+++ b/algorithms/bfs.py
@ -1,120 +0,0 @@
 from __future__ import annotations
 from typing import List
 from common.constants import ACTION, Direction, ROWS, COLUMNS
 class State:
    def __init__(self, row, column, direction):
        self.row = row
        self.column = column
        self.direction = direction
 class Node:
    def __init__(self, state, parent=None, action=None):
        self.state = state
        self.parent = parent
        self.action = action
 def goal_test(goal_list, state: State):
    if (state.row, state.column) in goal_list:
        return True
    return False
 def get_successors(state: State, map):
    successors = list()
    state_left = State(state.row, state.column, state.direction.left())
    successors.append((ACTION.get("rotate_left"), state_left))
    state_right = State(state.row, state.column, state.direction.right())
    successors.append((ACTION.get("rotate_right"), state_right))
    target = go(state.row, state.column, state.direction)
    if is_valid_move(map, target[0], target[1]):
        state_go = State(target[0], target[1], state.direction)
        successors.append((ACTION.get("go"), state_go))
    return successors
 def graphsearch(initial_state: State, map, goal_list, fringe: List[Node] = None, explored: List[Node] = None):
    # fringe and explored initialization
    if fringe is None:
        fringe = list()
    if explored is None:
        explored = list()
    explored_states = set()
    fringe_states = set()
    # train Node
    fringe.append(Node(initial_state))
    fringe_states.add((initial_state.row, initial_state.column, initial_state.direction))
    while True:
        # fringe empty -> solution not found
        if not any(fringe):
            print("Brak rozwiazania")
            return []
        # get first element from fringe
        element = fringe.pop(0)
        fringe_states.remove((element.state.row, element.state.column, element.state.direction))
        # if solution was found, prepare and return actions sequence
        if goal_test(goal_list, element.state):
            actions_sequence = [element.action]
            parent = element.parent
            while parent is not None:
                # train's action will be None, don't add it
                if parent.action is not None:
                    actions_sequence.append(parent.action)
                parent = parent.parent
            actions_sequence.reverse()
            return actions_sequence
        # add current node to explored (prevents infinite cycles)
        explored.append(element)
        explored_states.add((element.state.row, element.state.column, element.state.direction))
        # loop through every possible next action
        for successor in get_successors(element.state, map):
            # make sure not to fall into a cycle
            successor_state = (successor[1].row, successor[1].column, successor[1].direction)
            if successor_state not in fringe_states and successor_state not in explored_states:
                # create new Node and add it at the end of fringe
                new_node = Node(state=successor[1],
                                parent=element,
                                action=successor[0])
                fringe.append(new_node)
                fringe_states.add((new_node.state.row, new_node.state.column, new_node.state.direction))
 # TEMPORARY METHOD
 def go(row, column, direction):
    target = tuple()
    if direction == Direction.RIGHT:
        target = row, column + 1
    elif direction == Direction.LEFT:
        target = row, column - 1
    elif direction == Direction.UP:
        target = row - 1, column
    elif direction == Direction.DOWN:
        target = row + 1, column
    return target
 def is_valid_move(map, target_row, target_column):
    if 0 <= target_row < ROWS and 0 <= target_column < COLUMNS and map[target_row][target_column] in ['g', 's', ' ']:
        return True
    return False
--- a/algorithms/genetic/common.py
+++ b/algorithms/genetic/common.py
@ -1,142 +0,0 @@
 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 get_tiles_positions(grid: npt.NDArray):
    sands = []
    trees = []
    waters = []
    monsters = []
    for row_num in range(len(grid)):
        for col_num in range(len(grid[row_num])):
            if grid[row_num][col_num] == MAP_ALIASES.get('WATER'):
                waters.append(Position(row=row_num, col=col_num))
            elif grid[row_num][col_num] == MAP_ALIASES.get('TREE'):
                trees.append(Position(row=row_num, col=col_num))
            elif grid[row_num][col_num] == MAP_ALIASES.get('SAND'):
                sands.append(Position(row=row_num, col=col_num))
            elif grid[row_num][col_num] == MAP_ALIASES.get('MONSTER'):
                monsters.append(Position(row=row_num, col=col_num))
    return sands, trees, waters, monsters
--- a/algorithms/genetic/const.py
+++ b/algorithms/genetic/const.py
@ -1,29 +0,0 @@
 # map config
 KNIGHTS_PER_TEAM_COUNT = 4
 SAND_COUNT = 21
 WATER_COUNT = 21
 TREE_COUNT = 37
 MONSTERS_COUNT = 2
 CASTLES_COUNT = 1
 ROWS = 19
 COLUMNS = 24
 KNIGHTS_SPAWN_WIDTH = 4
 KNIGHTS_SPAWN_HEIGHT = 7
 LEFT_KNIGHTS_SPAWN_FIRST_ROW = 6
 LEFT_KNIGHTS_SPAWN_FIRST_COL = 0
 RIGHT_KNIGHTS_SPAWN_FIRST_ROW = 6
 RIGHT_KNIGHTS_SPAWN_FIRST_COL = 20
 CASTLE_SPAWN_FIRST_ROW = 7
 CASTLE_SPAWN_FIRST_COL = 11
 # map aliases
 MAP_ALIASES = {
    "GRASS": 0,
    "SAND": 1,
    "WATER": 2,
    "TREE": 3,
    "MONSTER": 4,
    "CASTLE": 5,
    "KNIGHT_RED": 6,
    "KNIGHT_BLUE": 7,
 }
--- a/algorithms/genetic/genome.py
+++ b/algorithms/genetic/genome.py
@ -1,166 +0,0 @@
 import math
 import random
 from copy import deepcopy
 from random import randrange
 from typing import List
 import numpy as np
 import numpy.typing as npt
 from common import Position, get_islands, AREAS_TO_CROSS, find_neighbours, get_tiles_positions
 from const import *
 class Genome:
    grid: npt.NDArray
    knights_red: List[Position]
    knights_blue: List[Position]
    waters: List[Position]
    trees: List[Position]
    sands: List[Position]
    monsters: List[Position]
    fitness: int
    sand_islands: List[Position]
    tree_islands: List[Position]
    water_islands: List[Position]
    def __init__(self):
        self.grid = np.zeros((ROWS, COLUMNS), dtype=int)
        self.fitness = 0
        self.knights_red = spawn_objects_in_given_area(
            grid=self.grid,
            object_alias=MAP_ALIASES.get("KNIGHT_RED"),
            objects_count=KNIGHTS_PER_TEAM_COUNT,
            spawn_position_start=Position(row=LEFT_KNIGHTS_SPAWN_FIRST_ROW, col=LEFT_KNIGHTS_SPAWN_FIRST_COL),
            width=KNIGHTS_SPAWN_WIDTH,
            height=KNIGHTS_SPAWN_HEIGHT
        )
        self.knights_blue = spawn_objects_in_given_area(
            grid=self.grid,
            object_alias=MAP_ALIASES.get("KNIGHT_BLUE"),
            objects_count=KNIGHTS_PER_TEAM_COUNT,
            spawn_position_start=Position(row=RIGHT_KNIGHTS_SPAWN_FIRST_ROW, col=RIGHT_KNIGHTS_SPAWN_FIRST_COL),
            width=KNIGHTS_SPAWN_WIDTH,
            height=KNIGHTS_SPAWN_HEIGHT
        )
        spawn_objects_in_given_area(
            grid=self.grid,
            object_alias=MAP_ALIASES.get("CASTLE"),
            objects_count=4,
            spawn_position_start=Position(row=CASTLE_SPAWN_FIRST_ROW, col=CASTLE_SPAWN_FIRST_COL),
            width=2,
            height=2
        )
        self.waters = spawn_objects_in_given_area(grid=self.grid, object_alias=MAP_ALIASES.get("WATER"),
                                                  objects_count=WATER_COUNT)
        self.trees = spawn_objects_in_given_area(grid=self.grid, object_alias=MAP_ALIASES.get("TREE"),
                                                 objects_count=TREE_COUNT)
        self.sands = spawn_objects_in_given_area(grid=self.grid, object_alias=MAP_ALIASES.get("SAND"),
                                                 objects_count=SAND_COUNT)
        self.monsters = spawn_objects_in_given_area(grid=self.grid, object_alias=MAP_ALIASES.get("MONSTER"),
                                                    objects_count=MONSTERS_COUNT)
        self.sand_islands = get_islands(self.grid, self.sands)
        self.tree_islands = get_islands(self.grid, self.trees)
        self.water_islands = get_islands(self.grid, self.waters)
    def update_map(self):
        self.sands, self.trees, self.waters, self.monsters = get_tiles_positions(self.grid)
        self.sand_islands = get_islands(self.grid, self.sands)
        self.tree_islands = get_islands(self.grid, self.trees)
        self.water_islands = get_islands(self.grid, self.waters)
    def calc_fitness(self):
        score = SAND_COUNT + TREE_COUNT + WATER_COUNT
        score = score - len(self.sand_islands) - len(self.tree_islands) - len(self.water_islands)
        sands, trees, waters, monsters = get_tiles_positions(self.grid)
        if len(monsters) != MONSTERS_COUNT:
            self.fitness = 0
            return
        if len(sands) < SAND_COUNT or len(trees) < TREE_COUNT or len(waters) < WATER_COUNT:
            self.fitness = 5
            return
        self.fitness = score
    def crossover(self, partner):
        # replace a randomly selected part of the grid with partner's part
        child = Genome()
        child.grid = deepcopy(self.grid)
        area_to_cross = random.choice(AREAS_TO_CROSS)
        for row in range(area_to_cross.position.row, area_to_cross.position.row + area_to_cross.height):
            for col in range(area_to_cross.position.col, area_to_cross.position.col + area_to_cross.width):
                child.grid[row][col] = partner.grid[row][col]
        child.update_map()
        return child
    def mutate(self, mutation_rate: float):
        # remove 1 item from a random island and add a neighbor to another island
        if random.random() < mutation_rate:
            # select islands of the same, random type
            islands_of_same_type = random.choice([self.sand_islands, self.tree_islands, self.water_islands])
            random_index = random.randint(0, len(islands_of_same_type) - 1)
            island = islands_of_same_type[random_index]
            next_island = islands_of_same_type[(random_index + 1) % len(islands_of_same_type)]
            free_tiles_nearby = find_neighbours(self.grid, next_island.col, next_island.row)
            tile_type = self.grid[island.row][island.col]
            self.grid[island.row][island.col] = MAP_ALIASES.get('GRASS')
            # todo: if there are no free tiles around then randomize another next_island
            if len(free_tiles_nearby) > 0:
                random_free_tile = random.choice(free_tiles_nearby)
                island.row = random_free_tile.row
                island.col = random_free_tile.col
                self.grid[island.row][island.col] = tile_type
                self.update_map()
 def is_empty(grid: npt.NDArray, position: Position) -> bool:
    return grid[position.row, position.col] in [MAP_ALIASES.get("GRASS"), MAP_ALIASES.get("SAND")]
 def is_invalid_area(spawn_position_start, height, width) -> bool:
    return spawn_position_start.row + height - 1 < 0 or \
           spawn_position_start.row + height - 1 >= ROWS or \
           spawn_position_start.col + width - 1 < 0 or \
           spawn_position_start.col + width - 1 >= COLUMNS
 def spawn_objects_in_given_area(grid: npt.NDArray,
                                object_alias: str,
                                objects_count: int = 1,
                                spawn_position_start: Position = Position(row=0, col=0),
                                width: int = COLUMNS,
                                height: int = ROWS) -> List[Position]:
    if is_invalid_area(spawn_position_start, height, width):
        raise ValueError("Invalid spawn area")
    objects_remaining = int(objects_count)
    positions = []
    while objects_remaining > 0:
        row = randrange(spawn_position_start.row, spawn_position_start.row + height)
        col = randrange(spawn_position_start.col, spawn_position_start.col + width)
        position = Position(row=row, col=col)
        if is_empty(grid=grid, position=position):
            grid[position.row, position.col] = object_alias
            positions.append(position)
            objects_remaining -= 1
    return positions
--- a/algorithms/genetic/map_generator.py
+++ b/algorithms/genetic/map_generator.py
@ -1,26 +0,0 @@
 from algorithms.genetic.genome import Genome
 from algorithms.genetic.map_importer_exporter import export_map
 from population import Population
 def main() -> None:
    population_size = 500
    mutation_rate = 0.3
    population = Population(mutation_rate, population_size, 55)
    while not population.evaluate():
        # create next generation
        population.generate()
        # calc fitness
        population.calc_fitness()
    print(population.best_genome.grid)
    print("Fitness of the best: ", population.best_genome.fitness)
    export_map(population.best_genome.grid)
 if __name__ == '__main__':
    main()
--- a/algorithms/genetic/map_importer_exporter.py
+++ b/algorithms/genetic/map_importer_exporter.py
@ -1,42 +0,0 @@
 import json
 import random
 import string
 from datetime import datetime
 from pathlib import Path
 import numpy
 import numpy.typing as npt
 from os import listdir
 from os.path import isfile, join
 # Save map to file
 def export_map(grid: npt.NDArray):
    json_data = {"map": grid.tolist()}
    now = datetime.now()
    file_name = "map_" + now.strftime("%Y_%m_%d_%H_%M_%S") + ".json"
    path = Path("../../resources/maps/")
    file_to_open = path / file_name
    with open(file_to_open, "w+") as write_file:
        json.dump(json_data, write_file)
    print("Saved map to file " + file_name)
 def import_random_map() -> object:
    path = "resources/maps"
    files = [f for f in listdir(path) if isfile(join(path, f))]
    random_map_name = random.choice(files)
    return import_map(random_map_name)
 # Read map from file
 def import_map(file_name: string) -> object:
    file_to_open = "resources/maps/" + file_name
    with open(file_to_open, "r") as read_file:
        print("Reading map from file " + file_name)
        decoded_json = json.load(read_file)
        decoded_grid = numpy.asarray(decoded_json["map"])
        print(decoded_grid)
    return decoded_grid.tolist()
--- a/algorithms/genetic/population.py
+++ b/algorithms/genetic/population.py
@ -1,81 +0,0 @@
 import random
 from typing import List
 import numpy as np
 import numpy.typing as npt
 from genome import Genome
 class Population:
    population: List[Genome] = []  # array to hold the current population
    mating_pool: List[Genome] = []  # array which we will use for our "mating pool"
    generations: int = 0  # number of generations
    finished: bool = False  # are we finished evolving?
    mutation_rate: float
    perfect_score: int
    best_genome: Genome
    def __init__(self, mutation_rate, population_size, perfect_score=20):
        self.mutation_rate = mutation_rate
        self.perfect_score = perfect_score
        for i in range(0, population_size):
            new_genome = Genome()
            new_genome.calc_fitness()
            self.population.append(new_genome)
    # create a new generation
    def generate(self):
        max_fitness = 0
        for genome in self.population:
            if genome.fitness > max_fitness:
                max_fitness = genome.fitness
        print("Max fitness of generation " + str(self.generations) + " = " + str(max_fitness))
        # refill the population with children from the mating pool
        new_population = []
        for genome in self.population:
            partner_a = self.accept_reject(max_fitness)
            partner_b = self.accept_reject(max_fitness)
            child = partner_a.crossover(partner_b)
            child.mutate(self.mutation_rate)
            new_population.append(child)
        self.population = new_population
        self.generations += 1
    # select random with correct probability from population
    def accept_reject(self, max_fitness: int):
        safe_flag = 0
        while safe_flag < 10000:
            partner = random.choice(self.population)
            r = random.randint(0, max_fitness)
            if r < partner.fitness:
                return partner
            safe_flag += 1
    # compute the current "most fit" member of the population
    def evaluate(self):
        record = 0
        best_index = 0
        for index in range(len(self.population)):
            genome = self.population[index]
            if genome.fitness > record:
                record = genome.fitness
                best_index = index
        self.best_genome = self.population[best_index]
        if record >= self.perfect_score:
            self.finished = True
        return self.finished
    def calc_fitness(self):
        for genome in self.population:
            genome.calc_fitness()
--- a/algorithms/neural_network/init.py
+++ b/algorithms/neural_network/init.py
--- a/algorithms/neural_network/lightning_logs/version_23/checkpoints/epoch=3-step=324.ckpt
+++ b/algorithms/neural_network/lightning_logs/version_23/checkpoints/epoch=3-step=324.ckpt
--- a/algorithms/neural_network/lightning_logs/version_23/events.out.tfevents.1653922926.DESKTOP-97QK98R.9912.0
+++ b/algorithms/neural_network/lightning_logs/version_23/events.out.tfevents.1653922926.DESKTOP-97QK98R.9912.0
--- a/algorithms/neural_network/lightning_logs/version_23/hparams.yaml
+++ b/algorithms/neural_network/lightning_logs/version_23/hparams.yaml
@ -1 +0,0 @@
 {}
--- a/algorithms/neural_network/neural_network.py
+++ b/algorithms/neural_network/neural_network.py
@ -1,64 +0,0 @@
 import torch
 import pytorch_lightning as pl
 import torch.nn as nn
 from torch.optim import SGD, Adam, lr_scheduler
 import torch.nn.functional as F
 from torch.utils.data import DataLoader
 from watersandtreegrass import WaterSandTreeGrass
 from common.constants import DEVICE, BATCH_SIZE, NUM_EPOCHS, LEARNING_RATE, SETUP_PHOTOS, ID_TO_CLASS
 class NeuralNetwork(pl.LightningModule):
    def __init__(self, numChannels=3, batch_size=BATCH_SIZE, learning_rate=LEARNING_RATE, num_classes=4):
        super(NeuralNetwork, self).__init__()
        self.conv1 = nn.Conv2d(numChannels, 24, (3, 3), padding=1)
        self.relu1 = nn.ReLU()
        self.maxpool1 = nn.MaxPool2d((2, 2), stride=2)
        self.conv2 = nn.Conv2d(24, 48, (3, 3), padding=1)
        self.relu2 = nn.ReLU()
        self.fc1 = nn.Linear(48*18*18, 800)
        self.relu3 = nn.ReLU()
        self.fc2 = nn.Linear(800, 400)
        self.relu4 = nn.ReLU()
        self.fc3 = nn.Linear(400, 4)
        self.logSoftmax = nn.LogSoftmax(dim=1)
        self.batch_size = batch_size
        self.learning_rate = learning_rate
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.relu2(x)
        x = x.reshape(x.shape[0], -1)
        x = self.fc1(x)
        x = self.relu3(x)
        x = self.fc2(x)
        x = self.relu4(x)
        x = self.fc3(x)
        x = self.logSoftmax(x)
        return x
    def configure_optimizers(self):
        optimizer = Adam(self.parameters(), lr=self.learning_rate)
        return optimizer
    def training_step(self, batch, batch_idx):
        x, y = batch
        scores = self(x)
        loss = F.nll_loss(scores, y)
        return loss
    def validation_step(self, batch, batch_idx):
        x, y = batch
        scores = self(x)
        val_loss = F.nll_loss(scores, y)
        self.log("val_loss", val_loss, on_step=True, on_epoch=True, sync_dist=True)
    def test_step(self, batch, batch_idx):
        x, y = batch
        scores = self(x)
        test_loss = F.nll_loss(scores, y)
        self.log("test_loss", test_loss, on_step=True, on_epoch=True, sync_dist=True)
--- a/algorithms/neural_network/neural_network_interface.py
+++ b/algorithms/neural_network/neural_network_interface.py
@ -1,125 +0,0 @@
 import torch
 import common.helpers
 from common.constants import DEVICE, BATCH_SIZE, NUM_EPOCHS, LEARNING_RATE, SETUP_PHOTOS, ID_TO_CLASS
 from watersandtreegrass import WaterSandTreeGrass
 from torch.utils.data import DataLoader
 from neural_network import NeuralNetwork
 from torchvision.io import read_image, ImageReadMode
 import torch.nn as nn
 from torch.optim import Adam
 import matplotlib.pyplot as plt
 import pytorch_lightning as pl
 from pytorch_lightning.callbacks import EarlyStopping
 import torchvision.transforms.functional as F
 from PIL import Image
 def check_accuracy_tiles():
    answer = 0
    for i in range(100):
        if what_is_it('../../resources/textures/grass_with_tree.jpg') == 'tree':
            answer = answer + 1
    print("Accuracy(%) grass_with_tree.jpg",  answer)
    answer = 0
    for i in range(100):
        if what_is_it('../../resources/textures/grass2.png') == 'grass':
            answer = answer + 1
    print("Accuracy(%) grass2.png",  answer)
    answer = 0
    for i in range(100):
        if what_is_it('../../resources/textures/grass3.png') == 'grass':
            answer = answer + 1
    print("Accuracy(%) grass3.png",  answer)
    answer = 0
    for i in range(100):
        if what_is_it('../../resources/textures/grass4.png') == 'grass':
            answer = answer + 1
    print("Accuracy(%) grass4.png", answer)
    answer = 0
    for i in range(100):
        if what_is_it('../../resources/textures/grass1.png') == 'grass':
            answer = answer + 1
    print("Accuracy(%) grass1.png", answer)
    answer = 0
    for i in range(100):
        if what_is_it('../../resources/textures/water.png') == 'water':
            answer = answer + 1
    print("Accuracy(%) water.png", answer)
    answer = 0
    for i in range(100):
        if what_is_it('../../resources/textures/sand.png') == 'sand':
            answer = answer + 1
    print("Accuracy(%) sand.png", answer)
 def what_is_it(img_path, show_img=False):
    image = Image.open(img_path).convert('RGB')
    if show_img:
        plt.imshow(image)
        plt.show()
    image = SETUP_PHOTOS(image).unsqueeze(0)
    model = NeuralNetwork.load_from_checkpoint('./lightning_logs/version_20/checkpoints/epoch=3-step=324.ckpt')
    with torch.no_grad():
        model.eval()
        idx = int(model(image).argmax(dim=1))
        return ID_TO_CLASS[idx]
 def check_accuracy(tset):
    model = NeuralNetwork.load_from_checkpoint('./lightning_logs/version_23/checkpoints/epoch=3-step=324.ckpt')
    num_correct = 0
    num_samples = 0
    model = model.to(DEVICE)
    model.eval()
    with torch.no_grad():
        for photo, label in tset:
            photo = photo.to(DEVICE)
            label = label.to(DEVICE)
            scores = model(photo)
            predictions = scores.argmax(dim=1)
            num_correct += (predictions == label).sum()
            num_samples += predictions.size(0)
        print(f'Got {num_correct} / {num_samples} with accuracy {float(num_correct)/float(num_samples)*100:.2f}%')
 def check_accuracy_data():
    trainset = WaterSandTreeGrass('./data/train_csv_file.csv', transform=SETUP_PHOTOS)
    testset = WaterSandTreeGrass('./data/test_csv_file.csv', transform=SETUP_PHOTOS)
    train_loader = DataLoader(trainset, batch_size=BATCH_SIZE, shuffle=True)
    test_loader = DataLoader(testset, batch_size=BATCH_SIZE)
    print("Accuracy of train_set:")
    check_accuracy(train_loader)
    print("Accuracy of test_set:")
    check_accuracy(test_loader)
 #CNN = NeuralNetwork()
 #common.helpers.createCSV()
 #trainer = pl.Trainer(accelerator='gpu', callbacks=EarlyStopping('val_loss'), devices=1, max_epochs=NUM_EPOCHS)
 #trainer = pl.Trainer(accelerator='gpu', devices=1, auto_lr_find=True, max_epochs=NUM_EPOCHS)
 #trainset = WaterSandTreeGrass('./data/train_csv_file.csv', transform=SETUP_PHOTOS)
 #testset = WaterSandTreeGrass('./data/test_csv_file.csv', transform=SETUP_PHOTOS)
 #train_loader = DataLoader(trainset, batch_size=BATCH_SIZE, shuffle=True)
 #test_loader = DataLoader(testset, batch_size=BATCH_SIZE)
 #trainer.fit(CNN, train_loader, test_loader)
 #trainer.tune(CNN, train_loader, test_loader)
 #print(what_is_it('../../resources/textures/grass2.png', True))
 #check_accuracy_data()
 #check_accuracy_tiles()
--- a/algorithms/neural_network/watersandtreegrass.py
+++ b/algorithms/neural_network/watersandtreegrass.py
@ -1,27 +0,0 @@
 import torch
 from torch.utils.data import Dataset
 import pandas as pd
 from torchvision.io import read_image, ImageReadMode
 from common.helpers import createCSV
 from PIL import Image
 class WaterSandTreeGrass(Dataset):
    def __init__(self, annotations_file, transform=None):
        createCSV()
        self.img_labels = pd.read_csv(annotations_file)
        self.transform = transform
    def __len__(self):
        return len(self.img_labels)
    def __getitem__(self, idx):
        image = Image.open(self.img_labels.iloc[idx, 0]).convert('RGB')
        label = torch.tensor(int(self.img_labels.iloc[idx, 1]))
        if self.transform:
            image = self.transform(image)
        return image, label
--- a/common/init.py
+++ b/common/init.py
--- a/common/colors.py
+++ b/common/colors.py
@ -1,7 +0,0 @@
 BLACK = (0, 0, 0)
 WHITE = (255, 255, 255)
 ORANGE = (249, 141, 42)
 RED = (255, 58, 58)
 GREEN = (0, 255, 0)
 FONT_DARK = (37, 37, 37)
--- a/common/constants.py
+++ b/common/constants.py
@ -1,96 +0,0 @@
 from enum import Enum
 import torchvision.transforms as transforms
 import torch
 GAME_TITLE = 'WMICraft'
 WINDOW_HEIGHT = 800
 WINDOW_WIDTH = 1360
 FPS_COUNT = 60
 TURN_INTERVAL = 200
 GRID_CELL_PADDING = 5
 GRID_CELL_SIZE = 36
 ROWS = 19
 COLUMNS = 24
 BORDER_WIDTH = 10
 BORDER_RADIUS = 5
 KNIGHTS_SPAWN_WIDTH = 4
 KNIGHTS_SPAWN_HEIGHT = 7
 LEFT_KNIGHTS_SPAWN_FIRST_ROW = 6
 LEFT_KNIGHTS_SPAWN_FIRST_COL = 0
 RIGHT_KNIGHTS_SPAWN_FIRST_ROW = 6
 RIGHT_KNIGHTS_SPAWN_FIRST_COL = 20
 CASTLE_SPAWN_WIDTH = 6
 CASTLE_SPAWN_HEIGHT = 5
 CASTLE_SPAWN_FIRST_ROW = 7
 CASTLE_SPAWN_FIRST_COL = 9
 NBR_OF_WATER = 16
 NBR_OF_TREES = 20
 NBR_OF_MONSTERS = 2
 NBR_OF_SANDS = 35
 TILES = [
    'grass1.png',
    'grass2.png',
    'grass3.png',
    'grass4.png',
    'sand.png',
    'water.png',
    'grass_with_tree.jpg',
 ]
 class Direction(Enum):
    UP = 0
    RIGHT = 1
    DOWN = 2
    LEFT = 3
    def right(self):
        v = (self.value + 1) % 4
        return Direction(v)
    def left(self):
        v = (self.value - 1) % 4
        return Direction(v)
 ACTION = {
    "rotate_left": -1,
    "rotate_right": 1,
    "go": 0,
 }
 LEFT = 'LEFT'
 RIGHT = 'RIGHT'
 UP = 'UP'
 DOWN = 'DOWN'
 # HEALTH_BAR
 BAR_ANIMATION_SPEED = 1
 BAR_WIDTH_MULTIPLIER = 0.9  # (0;1>
 BAR_HEIGHT_MULTIPLIER = 0.1
 #NEURAL_NETWORK
 LEARNING_RATE = 0.000630957344480193
 BATCH_SIZE = 64
 NUM_EPOCHS = 9
 DEVICE = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
 print("Using ", DEVICE)
 CLASSES = ['grass', 'sand', 'tree', 'water']
 SETUP_PHOTOS = transforms.Compose([
    transforms.ToTensor(),
    transforms.Resize((36, 36)),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
 ])
 ID_TO_CLASS = {i: j for i, j in enumerate(CLASSES)}
 CLASS_TO_ID = {value: key for key, value in ID_TO_CLASS.items()}
--- a/common/helpers.py
+++ b/common/helpers.py
@ -1,119 +0,0 @@
 from typing import Tuple, List
 import pygame
 from algorithms.genetic.const import MAP_ALIASES
 from common.constants import GRID_CELL_PADDING, GRID_CELL_SIZE, COLUMNS, ROWS, CLASSES, CLASS_TO_ID
 import csv
 import os
 from common.constants import GRID_CELL_PADDING, GRID_CELL_SIZE
 from common.constants import ROWS, COLUMNS, LEFT, RIGHT, UP, DOWN
 directions = {
    LEFT: (0, -1),
    RIGHT: (0, 1),
    UP: (-1, 0),
    DOWN: (1, 0)
 }
 def draw_text(text, color, surface, x, y, text_size=30, is_bold=False):
    if is_bold:
        font = pygame.font.Font('resources/fonts/Poppins-SemiBold.ttf', text_size)
    else:
        font = pygame.font.Font('resources/fonts/Poppins-Regular.ttf', text_size)
    textobj = font.render(text, 1, color)
    textrect = textobj.get_rect()
    textrect.topleft = (x, y)
    surface.blit(textobj, textrect)
 def createCSV():
    train_data_path = './data/train'
    test_data_path = './data/test'
    if os.path.exists(train_data_path):
        train_csvfile = open('./data/train_csv_file.csv', 'w', newline="")
        writer = csv.writer(train_csvfile)
        writer.writerow(["filepath", "type"])
        for class_name in CLASSES:
            class_dir = train_data_path + "/" + class_name
            for filename in os.listdir(class_dir):
                f = os.path.join(class_dir, filename)
                if os.path.isfile(f):
                    writer.writerow([f, CLASS_TO_ID[class_name]])
        train_csvfile.close()
    else:
        print("Brak plików do uczenia")
    if os.path.exists(test_data_path):
        test_csvfile = open('./data/test_csv_file.csv', 'w', newline="")
        writer = csv.writer(test_csvfile)
        writer.writerow(["filepath", "type"])
        for class_name in CLASSES:
            class_dir = test_data_path + "/" + class_name
            for filename in os.listdir(class_dir):
                f = os.path.join(class_dir, filename)
                if os.path.isfile(f):
                    writer.writerow([f, CLASS_TO_ID[class_name]])
        test_csvfile.close()
    else:
        print("Brak plików do testowania")
 def print_numbers():
    display_surface = pygame.display.get_surface()
    font = pygame.font.SysFont('Arial', 16)
    for row_index in range(ROWS):
        for col_index in range(COLUMNS):
            x = (GRID_CELL_PADDING + GRID_CELL_SIZE) * col_index + GRID_CELL_PADDING + 7
            y = (GRID_CELL_PADDING + GRID_CELL_SIZE) * row_index + GRID_CELL_PADDING + 16
            display_surface.blit(font.render(f'[{col_index}, {row_index}]', True, (255, 0, 0)), (x, y))
    pygame.display.update()
 # parse array index to screen x or y coordinate
 def parse_cord(cord):
    return (GRID_CELL_PADDING + GRID_CELL_SIZE) * cord + GRID_CELL_PADDING + 7
 def castle_neighbors(map, castle_bottom_right_row, castle_bottom_right_col):
    neighbors = []
    for row_add in range(-2, 2):
        new_row = castle_bottom_right_row + row_add
        if 0 <= new_row <= len(map) - 1:
            for col_add in range(-2, 2):
                new_col = castle_bottom_right_col + col_add
                if 0 <= new_col <= len(map) - 1:
                    if (new_col == castle_bottom_right_col - 1 and new_row == castle_bottom_right_row - 1) \
                            or (new_col == castle_bottom_right_col and new_row == castle_bottom_right_row - 1) \
                            or (new_col == castle_bottom_right_col - 1 and new_row == castle_bottom_right_row) \
                            or (new_col == castle_bottom_right_col and new_row == castle_bottom_right_row):
                        continue
                    neighbors.append((new_col, new_row))
    return neighbors
 def find_neighbours(grid: List[List[int]], col: int, row: int) -> List[Tuple[int, int]]:
    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 rr < 0 or cc < 0: continue
        if rr >= ROWS or cc >= COLUMNS: continue
        if grid[rr][cc] not in [MAP_ALIASES.get("GRASS"), MAP_ALIASES.get("SAND"), '.']: continue
        neighbours.append((rr, cc))
    return neighbours
--- a/constants.py
+++ b/constants.py
@ -0,0 +1,31 @@
 GAME_TITLE = 'WMICraft'
 WINDOW_HEIGHT = 800
 WINDOW_WIDTH = 1360
 GRID_CELL_PADDING = 5
 GRID_CELL_WIDTH = 54
 GRID_CELL_HEIGHT = 54
 ROWS = 13
 COLUMNS = 16
 BORDER_WIDTH = 15
 FPS_COUNT = 60
 TILES = [
    'grass1.png',
    'grass2.png',
    'grass3.png',
    # 'grass4.png',
    # 'grass5.png',
    # 'grass6.png',
    'sand.png',
    'water.png',
    # 'grass_with_tree.jpg',
 ]
 OBJECTS = [
    {
        'name': 'tree',
        'location': 'tree1.png'
    },
    {
        'name': 'knight',
        'location': 'knight.png'
    }
 ]
--- a/field.py
+++ b/field.py
@ -0,0 +1,4 @@
 class Field:
    def __init__(self, texture_path, converted_texture):
        self.texture_path = texture_path
        self.converted_texture = converted_texture
--- a/game.py
+++ b/game.py
@ -0,0 +1,126 @@
 import pygame, sys
 from glob import glob
 from grid import Grid
 from constants import GAME_TITLE, WINDOW_WIDTH, WINDOW_HEIGHT, FPS_COUNT, TILES
 from stats import Stats
 from helpers import draw_text
 class Game:
    def __init__(self):
        pygame.init()
        pygame.display.set_caption(GAME_TITLE)
        pygame.display.set_icon(pygame.image.load('resources/icons/sword.png'))
        self.screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
        self.font = pygame.font.SysFont(None, 30)
        self.clock = pygame.time.Clock()
        self.tiles = []
        for tile_path in TILES:
            converted_tile = pygame.image.load('resources/textures/' + tile_path).convert_alpha()
            self.tiles.append((tile_path, converted_tile))
        self.bg = pygame.image.load("resources/textures/menu_bg2.jpg")
    click = False
    def main_menu(self):
        while True:
            self.screen.blit(self.bg, (0, 0))
            pygame.draw.rect(self.screen, (255, 255, 255), pygame.Rect(800, 100, 400, 500), 0, 5)
            draw_text('MAIN MENU', self.font, (0, 0, 0), self.screen, 850, 150)
            mx, my = pygame.mouse.get_pos()
            button_1 = pygame.Rect(850, 250, 300, 50)
            button_2 = pygame.Rect(850, 350, 300, 50)
            button_3 = pygame.Rect(850, 450, 300, 50)
            if button_1.collidepoint((mx, my)):
                if click:
                    self.game()
            if button_2.collidepoint((mx, my)):
                if click:
                    self.options()
            if button_3.collidepoint((mx, my)):
                if click:
                    self.credits()
            pygame.draw.rect(self.screen, (0, 191, 255), button_1, 0, 4)
            draw_text('PLAY', self.font, (255, 255, 255), self.screen, 870, 265)
            pygame.draw.rect(self.screen, (0, 191, 255), button_2, 0, 4)
            draw_text('OPTIONS', self.font, (255, 255, 255), self.screen, 870, 365)
            pygame.draw.rect(self.screen, (0, 191, 255), button_3, 0, 4)
            draw_text('CREDITS', self.font, (255, 255, 255), self.screen, 870, 465)
            click = False
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        pygame.quit()
                        sys.exit()
                if event.type == pygame.MOUSEBUTTONDOWN:
                    if event.button == 1:
                        click = True
            pygame.display.update()
            self.clock.tick(60)
    def options(self):
        running = True
        while running:
            self.screen.fill((0, 0, 0))
            draw_text('options', self.font, (255, 255, 255), self.screen, 20, 20)
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        running = False
            pygame.display.update()
            self.clock.tick(60)
    def credits(self):
        running = True
        while running:
            self.screen.fill((0, 0, 0))
            draw_text('credits', self.font, (255, 255, 255), self.screen, 20, 20)
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        running = False
            pygame.display.update()
            self.clock.tick(60)
    def game(self):
        running = True
        grid = Grid(self.tiles)
        stats = Stats()
        while running:
            self.screen.blit(self.bg, (0, 0))
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        running = False
            grid.draw(self.screen)
            stats.draw(self.screen, self.font)
            pygame.display.update()
            self.clock.tick(FPS_COUNT)
--- a/grid.py
+++ b/grid.py
@ -0,0 +1,35 @@
 import pygame
 import random
 from field import Field
 from constants import ROWS, COLUMNS, GRID_CELL_PADDING, GRID_CELL_WIDTH, GRID_CELL_HEIGHT, BORDER_WIDTH
 class Grid:
    def __init__(self, textures):
        self.textures = textures
        self.grid = []
        for row in range(ROWS):
            self.grid.append([])
            for _ in range(COLUMNS):
                texture_path, converted_texture = self.get_random_texture()
                field = Field(texture_path, converted_texture)
                self.grid[row].append(field)
    def get_random_texture(self):
        texture_index = random.randint(0, len(self.textures) - 1)
        return self.textures[texture_index]
    def draw(self, screen):
        bg_width = (GRID_CELL_PADDING + GRID_CELL_WIDTH) * COLUMNS + BORDER_WIDTH
        bg_height = (GRID_CELL_PADDING + GRID_CELL_HEIGHT) * ROWS + BORDER_WIDTH
        pygame.draw.rect(screen, (255, 255, 255), pygame.Rect(10, 8, bg_width, bg_height))
        for row in range(ROWS):
            for column in range(COLUMNS):
                box_rect = [(GRID_CELL_PADDING + GRID_CELL_WIDTH) * column + GRID_CELL_PADDING + 15,
                            (GRID_CELL_PADDING + GRID_CELL_HEIGHT) * row + GRID_CELL_PADDING + 13,
                            GRID_CELL_WIDTH,
                            GRID_CELL_HEIGHT]
                image = self.grid[row][column].converted_texture
                screen.blit(pygame.transform.scale(image, (GRID_CELL_WIDTH, GRID_CELL_HEIGHT)), box_rect)
--- a/helpers.py
+++ b/helpers.py
@ -0,0 +1,5 @@
 def draw_text(text, font, color, surface, x, y):
    textobj = font.render(text, 1, color)
    textrect = textobj.get_rect()
    textrect.topleft = (x, y)
    surface.blit(textobj, textrect)
--- a/learning/init.py
+++ b/learning/init.py
--- a/learning/dataset_tree_1000.csv
+++ b/learning/dataset_tree_1000.csv
--- a/learning/dataset_tree_300.csv
+++ b/learning/dataset_tree_300.csv
@ -1,302 +0,0 @@
 tower_dist;mob1_dist;mob2_dist;opp1_dist;opp2_dist;opp3_dist;opp4_dist;agent_hp;tower_hp;mob1_hp;mob2_hp;opp1_hp;opp2_hp;opp3_hp;opp4_hp;goal
 24;37;41;19;37;29;20;3;38;13;3;12;9;0;10;tower
 1;35;11;38;37;10;34;4;11;15;7;5;0;6;4;tower
 7;10;5;41;17;27;19;8;31;14;2;2;7;4;0;mob2
 15;3;12;18;9;25;40;8;44;7;5;10;0;5;9;mob1
 18;19;21;12;8;13;10;2;44;5;2;9;7;1;10;opp3
 19;30;11;34;17;26;13;3;35;4;2;0;12;2;12;mob2
 13;17;10;7;9;30;9;2;40;1;5;10;9;12;3;opp4
 14;30;21;11;18;21;7;12;28;5;3;4;0;11;0;tower
 7;38;7;21;5;25;15;6;14;1;4;12;10;12;8;tower
 40;24;41;39;1;9;38;2;12;6;1;1;1;9;11;opp2
 41;2;24;15;17;19;3;10;54;6;6;11;1;2;0;mob1
 25;42;32;25;6;19;11;12;25;10;3;8;11;4;6;tower
 6;19;38;10;32;17;24;5;67;12;3;8;4;10;2;tower
 24;35;32;37;10;7;9;4;75;10;7;11;3;12;10;opp2
 16;25;11;23;6;35;30;11;71;9;4;8;9;12;0;mob2
 37;38;5;22;23;13;25;7;6;3;0;8;12;10;1;mob2
 40;42;34;28;34;8;15;1;54;4;5;10;6;9;1;opp4
 6;16;2;4;18;27;5;12;73;8;7;10;12;5;11;mob2
 9;1;1;18;40;34;20;6;69;12;5;10;6;1;9;mob1
 13;22;4;20;25;29;7;7;27;2;1;9;7;1;3;mob2
 34;15;39;5;37;23;1;3;15;2;1;1;9;10;5;opp1
 38;20;4;22;43;23;22;6;60;6;3;4;4;8;0;mob1
 12;31;5;14;23;15;27;1;50;7;2;6;8;6;3;mob2
 14;37;2;25;23;26;8;4;53;10;0;12;9;9;11;mob2
 33;8;22;35;42;21;21;8;68;6;6;6;6;7;6;mob1
 17;11;7;25;6;16;8;5;52;7;7;0;11;2;2;mob2
 28;12;20;3;7;32;28;12;74;0;6;0;5;12;9;opp2
 21;9;10;38;1;40;41;1;61;3;5;9;7;9;2;opp2
 16;1;39;36;7;36;17;1;37;2;6;10;2;7;4;opp2
 22;15;31;27;3;40;26;9;71;1;0;10;9;5;9;mob1
 27;26;25;9;13;7;27;2;2;9;4;1;1;3;10;opp1
 28;43;18;15;21;16;18;3;51;3;4;10;0;5;0;mob2
 41;8;4;4;6;11;23;12;54;14;5;6;9;8;0;mob2
 15;34;12;17;18;15;19;1;75;5;4;5;1;1;7;opp3
 42;36;1;3;28;24;28;2;54;13;3;6;7;11;7;mob2
 25;22;23;34;8;42;14;9;40;14;5;2;1;7;12;opp2
 41;14;7;43;15;26;19;4;16;3;0;9;12;1;7;mob1
 18;40;1;40;38;10;5;2;54;14;4;11;2;11;9;mob2
 14;35;5;3;5;43;37;3;23;2;1;10;9;11;8;mob2
 40;10;23;25;33;37;26;1;42;14;6;2;11;5;6;mob1
 32;9;26;2;39;27;17;1;36;14;0;6;5;9;1;opp4
 17;12;15;16;29;18;5;9;75;15;0;12;10;1;11;opp3
 23;19;24;31;37;16;23;1;5;8;1;3;7;1;5;tower
 16;23;41;24;20;40;29;2;44;11;0;12;7;0;4;tower
 21;39;26;16;33;17;29;7;53;12;6;11;2;8;9;tower
 9;28;22;33;10;23;8;7;65;15;0;3;9;11;11;mob1
 29;9;34;7;14;7;20;5;69;2;5;4;1;4;4;mob1
 40;39;19;5;14;3;5;11;49;8;1;9;5;1;11;opp3
 19;22;33;29;24;5;39;2;60;15;4;9;5;2;10;opp3
 5;28;7;34;12;6;7;6;42;5;0;8;1;11;2;opp4
 31;36;11;5;34;7;2;7;57;8;7;3;11;2;4;opp3
 20;37;9;38;29;33;14;9;69;0;1;7;0;10;10;mob2
 27;5;9;13;26;8;42;7;0;15;5;3;9;10;4;opp1
 17;38;5;23;34;42;21;2;7;2;6;5;11;12;7;mob2
 37;14;33;32;7;31;41;8;72;1;0;3;6;1;1;opp2
 13;35;21;35;33;7;42;9;57;7;7;4;4;12;9;mob2
 16;40;35;15;19;35;21;8;53;10;3;10;4;0;10;mob1
 25;11;39;2;9;7;18;6;13;0;6;9;4;1;2;mob1
 16;2;41;6;20;21;30;7;45;1;4;9;8;0;2;mob1
 29;33;23;36;38;27;34;6;76;10;4;6;3;8;8;mob2
 15;40;7;41;5;11;14;6;69;6;0;7;11;4;7;mob2
 3;33;35;3;29;20;25;12;22;12;7;4;2;1;7;tower
 12;14;27;30;18;6;35;10;21;1;1;9;4;3;10;tower
 27;21;21;7;10;17;34;5;77;4;5;3;4;0;12;opp1
 29;9;9;18;22;1;13;3;78;12;2;5;1;2;7;opp3
 4;8;6;1;20;38;39;7;50;14;2;10;11;2;2;mob2
 29;10;20;25;24;9;13;11;16;11;6;10;5;5;1;opp4
 35;28;30;42;32;28;29;1;32;11;0;10;2;9;3;mob1
 22;25;1;4;40;18;26;9;80;4;5;8;4;10;2;mob1
 19;29;21;17;35;17;10;9;49;3;0;4;2;9;11;tower
 19;40;5;2;10;5;15;2;14;13;0;6;1;2;0;opp3
 21;33;13;32;15;15;40;6;66;3;0;4;12;8;2;mob1
 14;5;32;32;25;27;1;7;24;8;1;5;5;1;3;opp4
 19;15;24;31;31;40;20;3;54;8;2;8;6;2;0;mob2
 38;15;1;35;14;15;27;4;33;11;2;1;6;7;11;mob2
 1;24;25;23;37;25;19;6;2;12;6;10;0;10;2;tower
 37;19;29;19;2;33;20;12;29;3;6;5;7;8;0;opp2
 5;16;28;42;16;15;30;8;11;0;6;6;5;12;11;tower
 23;2;37;42;40;3;15;7;28;11;2;3;7;0;8;mob1
 11;10;31;11;20;18;9;10;76;5;7;7;5;3;8;mob1
 11;4;16;7;1;39;25;4;66;12;1;2;3;3;7;opp2
 28;2;31;26;43;29;30;9;23;6;7;7;11;9;1;mob1
 9;40;12;13;10;41;29;8;27;2;0;5;3;3;6;tower
 26;37;23;14;23;17;6;4;56;0;7;9;6;5;2;opp4
 26;14;35;13;11;4;38;8;49;3;6;1;11;0;9;mob1
 5;42;19;22;36;16;37;9;46;9;7;2;11;4;10;tower
 20;24;34;29;24;16;2;3;23;0;1;2;10;2;12;tower
 32;40;7;41;38;43;25;8;5;0;0;4;6;10;12;mob2
 28;15;25;14;13;7;30;7;37;11;0;6;10;11;1;mob1
 40;24;28;10;35;38;23;1;40;11;7;0;11;3;12;mob1
 10;6;5;6;20;20;37;12;13;9;0;6;1;10;7;mob1
 36;15;39;28;28;17;14;7;37;6;5;12;12;8;11;mob1
 12;12;30;43;36;42;35;5;41;12;6;0;3;0;2;tower
 37;21;17;8;18;13;33;11;59;4;2;0;0;0;9;mob2
 43;6;20;21;17;29;30;1;55;2;7;5;10;6;4;mob1
 28;27;28;40;12;39;20;9;71;13;5;12;6;7;10;opp2
 3;17;24;31;12;34;43;6;16;11;5;10;1;6;12;tower
 17;35;37;15;16;15;29;5;69;3;2;3;4;7;10;opp1
 30;19;24;1;12;21;32;6;57;12;2;5;7;0;10;mob1
 35;38;20;7;21;38;41;12;66;1;3;4;2;7;8;opp1
 25;13;7;39;18;17;7;12;46;0;1;9;2;10;11;mob2
 35;19;33;11;13;32;15;1;48;3;3;4;4;5;10;opp1
 24;37;36;7;30;32;10;4;5;8;0;7;0;12;7;tower
 18;10;11;35;34;9;39;12;44;6;5;1;0;11;6;mob1
 1;12;33;5;27;3;18;5;75;8;5;10;11;1;10;opp3
 17;34;39;25;35;31;9;5;75;12;5;11;6;6;3;opp4
 35;22;3;24;12;18;32;11;76;5;7;5;10;10;8;mob2
 27;14;42;4;22;29;20;12;50;1;1;9;8;3;8;mob1
 31;30;34;19;35;36;13;6;26;7;5;1;9;11;12;opp1
 29;9;3;27;12;11;25;7;68;13;1;10;11;1;2;opp3
 40;14;35;23;2;26;29;7;69;8;6;0;3;1;10;opp2
 3;33;40;24;34;39;41;3;11;5;1;4;5;0;7;tower
 4;14;35;5;5;1;17;3;37;8;0;5;2;8;0;opp2
 28;35;25;18;21;12;3;4;20;4;4;6;12;7;1;opp4
 42;23;4;26;37;34;35;3;2;15;2;8;12;5;12;mob2
 28;43;9;27;23;5;30;2;48;7;5;5;7;12;6;mob2
 1;42;1;39;12;8;12;3;6;11;4;4;0;11;0;tower
 17;20;15;2;26;11;25;4;62;1;2;1;6;7;5;opp1
 23;5;23;22;11;31;23;11;64;4;7;10;1;11;10;opp2
 18;41;29;22;12;14;29;1;17;3;0;12;9;8;9;tower
 32;11;22;27;27;22;21;6;27;10;4;10;11;11;9;tower
 37;10;39;34;7;4;1;4;72;8;7;7;10;5;5;opp4
 29;6;26;21;37;34;18;3;65;8;4;0;9;12;9;mob1
 9;25;36;39;37;9;20;3;80;11;5;3;11;8;11;tower
 34;23;40;25;23;22;40;6;13;14;0;4;9;12;0;tower
 5;1;40;21;11;42;30;4;56;0;2;6;10;2;0;mob1
 13;20;17;5;35;17;11;5;20;8;0;0;11;2;6;mob1
 35;41;7;14;37;33;25;4;15;1;3;6;1;12;12;mob2
 19;35;37;29;11;20;26;12;38;3;2;11;8;10;9;tower
 32;8;39;14;5;3;9;5;23;12;4;5;1;12;7;opp2
 7;20;1;31;35;15;5;3;72;4;4;12;1;7;1;opp4
 7;41;39;30;1;32;22;4;36;13;6;3;0;9;9;tower
 17;3;40;22;38;40;23;8;43;13;2;5;3;2;4;mob1
 35;34;34;42;35;34;33;8;12;11;7;12;10;11;2;tower
 42;29;10;22;30;36;27;8;25;3;7;0;2;1;9;mob2
 12;2;9;38;13;15;1;7;63;9;4;0;10;1;0;mob1
 23;23;43;24;15;20;36;3;19;4;0;8;8;9;11;tower
 30;18;16;32;20;41;8;10;58;0;0;6;7;3;1;opp4
 7;25;2;31;26;34;15;4;6;11;0;2;5;11;2;tower
 38;20;32;30;37;15;8;7;5;9;6;12;1;4;2;opp4
 34;37;9;11;2;7;32;7;79;13;4;9;9;5;6;opp3
 33;5;14;34;40;21;26;5;31;5;0;4;11;12;1;mob2
 30;36;41;19;9;10;9;7;41;1;6;2;4;4;6;opp2
 6;35;28;8;25;3;21;2;79;11;0;6;10;2;4;opp3
 42;11;27;28;34;14;37;1;10;6;0;5;11;6;4;mob1
 36;38;23;21;15;32;25;2;50;10;0;10;5;2;2;mob1
 4;26;31;19;18;32;40;5;25;12;7;7;2;8;9;tower
 18;29;38;42;4;13;36;9;61;12;5;3;4;7;7;opp2
 5;37;22;24;27;26;32;5;65;4;2;1;6;8;7;tower
 7;32;10;37;23;43;18;12;54;15;1;6;5;4;5;mob2
 21;36;30;41;29;31;2;3;58;9;0;9;6;8;12;mob1
 14;17;5;19;16;39;20;5;43;13;1;2;4;3;4;mob2
 16;28;7;12;28;40;9;8;69;13;1;11;0;1;1;opp4
 33;25;5;18;12;24;24;12;29;11;1;12;7;3;10;mob2
 16;2;31;43;29;16;14;9;25;5;5;6;10;5;1;opp4
 32;18;36;13;29;40;20;12;13;14;2;10;10;11;11;tower
 23;22;23;3;27;24;2;8;62;1;1;3;5;5;8;opp1
 15;2;20;16;10;41;18;2;29;4;3;2;11;7;6;mob1
 19;13;20;8;4;29;15;12;32;10;1;9;11;9;9;mob1
 13;32;41;1;33;33;11;1;28;5;1;10;5;9;6;tower
 27;18;5;2;34;27;17;8;66;9;5;8;2;2;12;mob2
 24;21;17;3;24;4;17;12;52;5;5;6;3;9;0;opp1
 3;5;29;23;27;24;38;1;62;4;4;1;3;0;11;tower
 35;3;28;33;31;6;36;11;69;1;7;4;5;5;0;mob1
 2;15;17;39;6;29;39;3;43;4;2;11;6;1;3;tower
 17;35;10;36;18;4;27;11;5;0;3;5;1;4;3;mob2
 18;15;11;40;24;31;10;7;58;7;0;3;8;4;1;opp4
 11;23;8;20;7;38;6;3;51;12;0;11;10;10;2;opp4
 7;16;13;27;41;1;13;10;25;9;4;11;10;11;5;mob1
 1;37;22;9;20;24;36;10;53;12;0;3;9;10;2;tower
 10;27;42;42;19;26;39;7;35;0;5;9;2;2;10;tower
 10;1;28;12;9;10;7;9;5;2;4;6;0;9;7;mob1
 28;19;27;8;3;37;34;11;25;7;1;11;0;1;3;mob1
 39;15;23;9;7;32;1;3;52;8;1;6;7;0;2;opp4
 11;9;5;16;17;8;29;4;45;3;6;2;12;6;1;mob2
 42;40;37;31;37;37;30;4;6;11;3;9;6;2;4;mob1
 39;6;12;16;32;13;20;7;52;4;5;0;4;9;3;mob1
 18;8;42;26;27;15;13;6;41;11;1;2;4;7;12;mob1
 25;32;15;24;31;18;7;12;24;0;4;12;9;3;2;opp4
 38;34;32;6;18;27;30;6;8;12;7;12;11;10;9;tower
 39;29;10;29;12;42;10;7;15;6;2;3;8;10;5;mob2
 26;9;18;24;1;23;27;2;78;8;2;3;6;0;2;opp2
 16;30;13;4;10;29;8;4;78;4;1;7;3;5;10;opp2
 2;36;22;20;42;1;15;10;30;11;6;2;4;12;11;tower
 21;24;25;17;32;4;10;9;31;14;3;11;7;0;5;mob1
 37;10;14;10;2;38;23;1;39;10;5;2;10;12;1;opp1
 11;34;26;20;26;30;6;4;50;3;4;4;3;1;12;tower
 14;8;30;29;17;41;3;4;77;8;6;8;4;3;9;mob1
 16;25;10;14;23;15;41;11;24;1;7;8;9;11;8;mob2
 36;16;16;24;25;34;17;1;51;13;5;9;11;0;5;mob2
 35;17;2;18;29;38;39;12;31;5;5;3;0;2;11;mob2
 11;39;41;5;5;27;17;11;30;6;0;0;8;11;11;tower
 14;21;13;17;7;21;16;5;48;8;6;10;11;10;0;mob2
 9;23;19;33;12;15;34;11;36;10;1;12;11;7;0;tower
 32;2;43;38;28;3;27;9;67;9;3;7;8;8;7;opp3
 32;2;32;21;13;6;16;10;37;3;7;9;5;12;2;opp4
 5;6;43;9;31;15;15;2;75;11;7;4;12;12;11;mob1
 26;20;27;28;40;32;17;2;56;6;2;8;7;3;10;mob1
 24;10;25;25;25;38;35;5;47;14;0;6;0;2;11;mob1
 26;39;26;33;14;39;14;2;24;12;7;3;2;7;12;opp2
 3;32;20;38;40;39;25;2;66;8;3;11;10;3;2;tower
 40;6;41;21;1;4;25;3;79;10;2;12;8;5;9;mob1
 8;39;19;4;14;15;5;10;52;9;0;3;7;12;4;opp1
 18;12;29;42;33;43;23;9;69;12;1;5;1;11;2;mob1
 4;26;28;23;20;34;14;8;7;0;0;10;1;12;12;tower
 25;24;29;40;25;37;33;1;64;8;0;3;0;6;5;mob1
 29;12;41;37;3;42;16;11;43;7;3;10;1;0;0;opp2
 19;4;8;34;34;1;7;10;62;5;4;10;1;3;1;opp4
 11;24;27;43;10;9;32;12;43;10;2;1;0;11;2;tower
 30;42;34;12;41;6;6;8;57;6;5;6;8;11;9;opp1
 21;25;26;10;18;19;15;8;13;14;4;8;11;0;8;tower
 36;24;25;6;10;30;13;1;64;9;3;5;9;4;6;opp1
 18;29;20;19;30;21;3;11;36;1;7;4;12;8;0;tower
 32;23;3;40;14;8;19;8;77;13;5;10;5;11;5;mob1
 30;31;27;13;8;35;35;8;75;0;7;4;1;1;4;opp2
 30;43;1;5;3;2;20;2;33;1;2;6;0;10;1;mob2
 33;40;5;36;7;25;40;9;72;5;0;6;6;5;6;mob1
 42;32;16;30;7;6;14;2;64;1;5;8;0;6;8;mob2
 13;25;6;38;26;23;30;2;5;2;7;9;0;10;8;tower
 5;24;10;7;15;1;37;6;69;10;6;0;7;2;11;opp3
 13;38;12;18;42;23;16;8;21;12;0;6;12;1;10;tower
 15;6;32;40;12;26;11;1;1;3;7;7;4;0;8;mob1
 9;38;29;26;19;22;28;6;52;8;5;11;2;5;3;tower
 18;19;23;43;21;28;19;8;42;14;4;11;0;5;6;tower
 6;37;4;35;10;4;26;11;44;6;1;2;5;4;12;mob2
 4;26;36;9;34;11;38;10;18;4;7;6;9;12;5;tower
 10;36;8;16;8;42;9;11;67;6;4;1;10;9;3;opp1
 15;7;22;13;19;16;28;2;20;7;5;0;3;7;8;mob1
 16;22;8;35;10;12;32;5;33;0;3;6;10;4;5;mob2
 27;4;3;9;29;26;22;1;1;9;1;3;0;8;6;mob2
 31;5;29;5;41;17;5;4;12;12;7;8;0;12;4;opp4
 29;42;10;39;5;40;43;12;3;15;4;11;2;12;9;opp2
 19;22;17;14;36;11;2;9;69;8;0;12;8;8;12;mob1
 11;5;3;34;37;37;20;7;37;15;7;4;4;9;12;mob1
 5;12;10;4;34;26;30;3;5;3;5;0;8;11;9;tower
 31;9;42;22;10;8;32;9;16;6;7;10;5;1;0;opp3
 22;27;31;10;21;18;41;3;39;4;6;5;1;12;11;opp2
 5;19;26;28;37;26;22;1;31;4;6;10;7;5;11;tower
 3;7;2;8;3;26;24;9;12;10;4;7;6;4;7;tower
 41;30;13;25;36;41;7;12;11;2;3;7;12;8;3;opp4
 23;26;24;13;17;21;24;9;29;15;5;8;0;4;11;tower
 36;6;7;18;6;1;15;1;12;14;6;4;1;11;9;opp2
 5;23;43;2;5;6;11;10;75;15;2;0;12;11;4;opp4
 17;39;8;7;41;14;16;7;45;8;1;2;2;2;8;opp1
 37;26;34;5;9;20;18;12;41;13;6;0;0;6;6;tower
 40;35;12;6;10;10;18;10;29;14;1;2;11;0;11;opp1
 2;35;18;2;9;34;10;4;42;0;0;2;3;10;6;opp1
 1;14;1;3;17;8;39;8;56;3;4;2;1;5;4;mob2
 40;28;8;20;37;2;42;10;19;8;1;3;7;8;0;mob2
 31;28;14;3;6;17;1;7;45;2;3;2;9;3;0;opp1
 24;13;15;11;38;28;13;12;51;3;4;6;4;2;12;mob2
 30;38;6;26;11;11;30;4;40;15;2;6;4;1;8;opp3
 42;37;32;2;5;19;35;2;64;9;5;12;3;8;3;opp2
 23;24;32;40;4;24;1;3;78;14;4;5;9;10;2;opp4
 5;22;19;22;41;3;34;11;50;5;2;6;10;1;3;opp3
 3;38;20;2;25;6;25;6;59;15;3;3;0;10;8;opp1
 33;41;39;42;38;29;27;5;33;14;5;5;2;1;12;opp3
 20;10;27;16;14;7;35;1;24;13;6;7;11;4;4;opp3
 6;8;4;35;12;40;15;10;38;12;7;0;10;6;5;mob2
 18;41;35;8;13;14;4;1;70;6;1;0;7;11;6;opp4
 39;42;12;28;11;40;7;3;71;3;7;5;2;1;10;opp2
 32;32;24;19;13;14;40;12;18;6;1;1;8;11;10;opp1
 31;14;16;12;33;25;5;5;8;8;6;8;6;5;2;opp4
 38;31;34;27;5;26;27;8;75;3;6;6;10;1;5;mob1
 2;7;23;8;24;28;20;2;31;5;7;9;0;11;11;tower
 39;43;17;21;31;13;41;8;43;10;5;4;10;6;8;mob1
 3;6;17;7;22;23;22;6;40;8;6;7;1;7;11;tower
 3;42;13;24;32;1;33;5;68;7;0;4;6;1;10;opp3
 12;26;4;18;2;42;29;10;41;11;3;10;10;10;9;mob2
 21;26;7;24;31;10;33;4;51;1;2;8;2;8;3;mob2
 39;22;7;20;5;29;38;10;8;4;1;9;12;11;0;mob2
 20;19;1;22;36;13;5;7;4;3;7;3;9;1;2;mob2
 4;7;42;17;6;14;26;11;45;9;4;10;6;11;2;tower
 23;27;11;25;38;26;34;10;77;13;7;4;3;5;9;mob1
 40;10;29;8;7;32;32;12;32;9;2;10;11;2;4;mob2
 37;22;34;17;17;25;40;5;74;9;3;3;8;2;9;opp1
 23;10;36;43;31;26;32;5;59;1;1;2;3;8;3;mob1
 14;32;8;4;17;33;8;9;74;5;1;7;12;7;3;mob2
 8;14;21;26;16;43;10;5;26;1;1;5;0;1;5;tower
 7;3;19;7;39;28;12;11;32;9;0;7;12;11;10;tower
 11;21;13;31;30;15;43;10;73;6;1;3;11;9;12;mob2
 28;10;32;28;26;36;38;4;15;11;0;12;11;12;7;mob1
 39;2;25;11;11;25;35;8;36;14;0;9;10;1;7;mob1
 43;41;39;38;16;5;35;12;48;14;4;7;3;11;6;opp2
 36;31;28;41;40;23;23;11;27;7;2;11;0;6;11;mob1
 28;8;38;39;31;3;7;7;47;0;6;8;0;2;6;opp3
 5;8;19;26;26;9;1;8;66;15;3;8;11;7;7;opp4
 36;28;27;7;25;1;21;10;63;0;6;4;2;10;4;opp1
 19;3;6;35;5;29;3;9;63;2;7;3;12;1;3;opp4
 27;5;36;31;6;10;27;12;9;8;6;10;9;6;11;mob1
 21;21;27;18;26;9;39;1;43;6;3;5;10;0;7;mob1
 12;39;15;31;32;9;39;7;26;4;0;12;5;0;12;tower
 41;18;22;33;25;6;37;1;77;14;7;12;7;4;8;opp3
 8;33;19;22;5;36;28;3;69;15;5;5;0;7;3;mob1
 24;8;15;16;21;18;15;9;78;4;0;4;9;5;4;mob2
 38;24;26;28;41;21;43;2;65;15;3;1;10;5;4;mob1
 33;17;6;4;34;36;25;6;35;4;4;10;9;0;3;mob2
 29;25;30;19;35;38;33;6;68;5;1;0;5;11;6;mob1
 23;43;41;25;27;26;19;7;12;8;3;4;10;11;9;tower
 7;9;18;31;36;21;16;4;23;8;4;9;8;11;5;tower
 35;21;39;36;36;37;33;10;41;9;4;1;0;7;0;mob1
--- a/learning/decision_tree.py
+++ b/learning/decision_tree.py
@ -1,78 +0,0 @@
 from typing import List, Tuple
 import pandas as pd
 from sklearn.preprocessing import LabelEncoder
 from sklearn.tree import DecisionTreeClassifier
 from common.helpers import castle_neighbors, find_neighbours
 from models.castle import Castle
 from models.knight import Knight
 from models.monster import Monster
 def manhattan_distance(p1: Tuple[int, int], p2: Tuple[int, int]) -> int:
    x1, y1 = p1
    x2, y2 = p2
    return abs(x1 - x2) + abs(y1 - y2)
 def parse_hp(hp: int) -> int:
    return max(0, hp)
 def parse_idx_of_opp_or_monster(s: str) -> int:
    return int(s[-1]) - 1
 class DecisionTree:
    def __init__(self) -> None:
        data_frame = pd.read_csv('learning/dataset_tree_1000.csv', delimiter=';')
        unlabeled_goals = data_frame['goal']
        self.goals_label_encoder = LabelEncoder()
        self.goals = self.goals_label_encoder.fit_transform(unlabeled_goals)
        self.train_set = data_frame.drop('goal', axis='columns')
        self.model = DecisionTreeClassifier(criterion='entropy')
        self.model.fit(self.train_set.values, self.goals)
    def predict_move(self, grid: List[List[int]], current_knight: Knight, castle: Castle, monsters: List[Monster],
                     opponents: List[Knight]) -> \
            List[Tuple[int, int]]:
        distance_to_castle = manhattan_distance(current_knight.position, castle.position)
        monsters_parsed = []
        for monster in monsters:
            monsters_parsed.append((manhattan_distance(current_knight.position, monster.position), parse_hp(
                monster.health_bar.current_hp)))
        opponents_parsed = []
        for opponent in opponents:
            opponents_parsed.append(
                (manhattan_distance(current_knight.position, opponent.position),
                 parse_hp(opponent.health_bar.current_hp)))
        prediction = self.get_prediction(tower_dist=distance_to_castle, tower_hp=castle.health_bar.current_hp,
                                         mob1_dist=monsters_parsed[0][0], mob1_hp=monsters_parsed[0][1],
                                         mob2_dist=monsters_parsed[1][0], mob2_hp=monsters_parsed[1][1],
                                         opp1_dist=opponents_parsed[0][0], opp1_hp=opponents_parsed[0][1],
                                         opp2_dist=opponents_parsed[1][0], opp2_hp=opponents_parsed[1][1],
                                         opp3_dist=opponents_parsed[2][0], opp3_hp=opponents_parsed[2][1],
                                         opp4_dist=opponents_parsed[3][0], opp4_hp=opponents_parsed[3][1],
                                         agent_hp=current_knight.health_bar.current_hp)
        print(f'Prediction = {prediction}')
        if prediction == 'tower':  # castle...
            return castle_neighbors(grid, castle_bottom_right_row=castle.position[0],
                                    castle_bottom_right_col=castle.position[1])
        elif prediction.startswith('opp'):
            idx = parse_idx_of_opp_or_monster(prediction)
            return find_neighbours(grid, opponents[idx].position[1], opponents[idx].position[0])
        else:
            idx = parse_idx_of_opp_or_monster(prediction)
            return find_neighbours(grid, monsters[idx].position[1], monsters[idx].position[0])
    def get_prediction(self, tower_dist: int, mob1_dist: int, mob2_dist: int, opp1_dist: int, opp2_dist: int,
                       opp3_dist: int, opp4_dist: int, agent_hp: int, tower_hp: int, mob1_hp: int, mob2_hp: int,
                       opp1_hp: int, opp2_hp: int, opp3_hp: int, opp4_hp) -> str:
        prediction = self.model.predict(
            [[tower_dist, mob1_dist, mob2_dist, opp1_dist, opp2_dist, opp3_dist, opp4_dist, agent_hp,
              tower_hp, mob1_hp, mob2_hp, opp1_hp, opp2_hp, opp3_hp, opp4_hp]])
        return self.goals_label_encoder.inverse_transform(prediction)[0]
--- a/logic/init.py
+++ b/logic/init.py
--- a/logic/tests/init.py
+++ b/logic/tests/init.py
--- a/logic/tests/knights_queue_test.py
+++ b/logic/tests/knights_queue_test.py
@ -1,128 +0,0 @@
 import unittest
 from logic.knights_queue import KnightsQueue
 from models.knight import Knight
 class KnightsQueueTest(unittest.TestCase):
    def test_should_skip_dead_knights(self):
        knight1 = Knight(None)
        knight1.max_hp = 0
        knight2 = Knight(None)
        knight2.max_hp = 0
        knight3 = Knight(None)
        knight3.max_hp = 1
        knight4 = Knight(None)
        knight4.max_hp = 0
        knight5 = Knight(None)
        knight5.max_hp = 0
        knight6 = Knight(None)
        knight6.max_hp = 1
        knights_queue = KnightsQueue([knight1, knight2, knight3], [knight4, knight5, knight6])
        res1 = knights_queue.dequeue_knight()
        res2 = knights_queue.dequeue_knight()
        self.assertEqual(res1.max_hp, 1)
        self.assertEqual(res2.max_hp, 1)
    def test_should_return_first_alive_knight(self):
        knight1 = Knight(None)
        knight1.max_hp = 222
        knight2 = Knight(None)
        knight2.max_hp = -1
        knight3 = Knight(None)
        knight3.max_hp = 1
        knights_queue = KnightsQueue([knight1, knight2], [knight3])
        res1 = knights_queue.dequeue_knight()
        res2 = knights_queue.dequeue_knight()
        res3 = knights_queue.dequeue_knight()
        res4 = knights_queue.dequeue_knight()
        self.assertEqual(res1, res3)
        self.assertEqual(res2, res4)
    def test_should_raise_when_knight_died_and_whole_team_dead(self):
        with self.assertRaises(Exception):
            knight1 = Knight(None)
            knight1.max_hp = 222
            knight2 = Knight(None)
            knight2.max_hp = 1
            knights_queue = KnightsQueue([knight1], [knight2])
            knights_queue.dequeue_knight()
            knights_queue.dequeue_knight()
            knight2.max_hp = -2
            knights_queue.dequeue_knight()
            knights_queue.dequeue_knight()
    def test_should_make_valid_next_turn(self):
        knight1 = Knight(None)
        knight1.max_hp = 222
        knight2 = Knight(None)
        knight2.max_hp = 1
        knights_queue = KnightsQueue([knight1], [knight2])
        previous_turn = knights_queue.team_idx_turn
        knights_queue.dequeue_knight()
        current_turn = knights_queue.team_idx_turn
        self.assertNotEqual(previous_turn, current_turn)
    def test_should_raise_when_team_has_dead_knights(self):
        with self.assertRaises(Exception):
            knight1 = Knight(None)
            knight1.max_hp = 0
            knight2 = Knight(None)
            knight2.max_hp = -1
            knight3 = Knight(None)
            knight3.max_hp = -2
            knight4 = Knight(None)
            knight4.max_hp = 20
            knights_queue = KnightsQueue([knight1, knight2, knight3], [knight4])
            knights_queue.dequeue_knight()
            knights_queue.dequeue_knight()
    def test_should_return_knight_from_any_team_and_add_to_queue_again(self):
        knight1 = Knight(None)
        knight1.max_hp = 10
        knight2 = Knight(None)
        knight2.max_hp = 20
        knights_queue = KnightsQueue([knight1], [knight2])
        result1 = knights_queue.dequeue_knight()
        result2 = knights_queue.dequeue_knight()
        result3 = knights_queue.dequeue_knight()
        self.assertIsNotNone(result1)
        self.assertIsNotNone(result2)
        self.assertIsNotNone(result3)
        self.assertTrue(result1.max_hp == result3.max_hp)
    def test_should_raise_when_only_one_team_alive(self):
        with self.assertRaises(Exception):
            knight = Knight(None)
            knight.max_hp = 21
            knights_queue = KnightsQueue([knight], [])
            knights_queue.dequeue_knight()
    def test_should_raise_when_no_team_alive(self):
        with self.assertRaises(Exception):
            knights_queue = KnightsQueue([], [])
            knights_queue.dequeue_knight()
 if __name__ == '__main__':
    unittest.main()
--- a/logic/tests/resources/textures/knight.png
+++ b/logic/tests/resources/textures/knight.png
--- a/logic/exceptions.py
+++ b/logic/exceptions.py
@ -1,2 +0,0 @@
 class FieldNotWalkable(Exception):
    pass
--- a/logic/game.py
+++ b/logic/game.py
@ -1,76 +0,0 @@
 import sys
 import pygame
 from common.constants import *
 from common.helpers import print_numbers
 from logic.level import Level
 from ui.logs import Logs
 from ui.screens.credits import Credits
 from ui.screens.main_menu import MainMenu
 from ui.screens.options import Options
 from ui.stats import Stats
 from logic.health_bar import HealthBar
 class Game:
    def __init__(self):
        pygame.init()
        pygame.display.set_caption(GAME_TITLE)
        pygame.display.set_icon(pygame.image.load('./resources/icons/sword.png'))
        self.screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
        self.clock = pygame.time.Clock()
        self.bg = pygame.image.load("./resources/textures/bg.jpg")
        self.screens = {'credits': Credits(self.screen, self.clock), 'options': Options(self.screen, self.clock)}
    def main_menu(self):
        menu = MainMenu(self.screen, self.clock, self.bg,
                        self.game,
                        self.screens['options'].display_screen,
                        self.screens['credits'].display_screen)
        menu.display_screen()
    def game(self):
        logs = Logs(self.screen)
        level = Level(self.screen, logs)
        # setup clock for rounds
        NEXT_TURN = pygame.USEREVENT + 1
        pygame.time.set_timer(NEXT_TURN, TURN_INTERVAL)
        # create level
        level.create_map()
        stats = Stats(self.screen, level.list_knights_blue, level.list_knights_red)
        level.setup_stats(stats)
        print_numbers_flag = False
        running = True
        while running:
            self.screen.blit(self.bg, (0, 0))
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        running = False
                    if event.key == pygame.K_n:
                        print_numbers_flag = not print_numbers_flag
                if event.type == NEXT_TURN:  # is called every 'TURN_INTERVAL' milliseconds
                    level.handle_turn()
            stats.update()
            logs.draw()
            level.update()
            if print_numbers_flag:
                print_numbers()
            pygame.display.update()
            self.clock.tick(FPS_COUNT)
--- a/logic/health_bar.py
+++ b/logic/health_bar.py
@ -1,59 +0,0 @@
 import pygame
 from common.constants import BAR_ANIMATION_SPEED, BAR_WIDTH_MULTIPLIER, BAR_HEIGHT_MULTIPLIER
 from common.colors import FONT_DARK, ORANGE, WHITE, RED, GREEN, BLACK
 class HealthBar:
    def __init__(self, screen, rect: pygame.rect, current_hp, max_hp, calculate_xy=False, calculate_size=False):
        self.health_ratio = None
        self.rect = rect
        self.screen = screen
        self.current_hp = current_hp
        self.max_hp = max_hp
        self.x = self.rect.x
        self.y = self.rect.y
        self.calculate_xy = calculate_xy
        if calculate_size:
            self.width = int(self.rect.width * BAR_WIDTH_MULTIPLIER) - 2
            self.height = int(self.rect.width * BAR_HEIGHT_MULTIPLIER) - 2
        else:
            self.width = self.rect.width - 2
            self.height = self.rect.height - 2
        self.update_stats()
    def update(self):
        self.update_stats()
        self.show()
    def update_stats(self):
        if self.calculate_xy:
            self.x = int(self.rect.width * (1 - BAR_WIDTH_MULTIPLIER)/2) + self.rect.x + 1
            self.y = int(self.rect.height * BAR_HEIGHT_MULTIPLIER/2) + self.rect.y + 1
        else:
            self.x = self.rect.x + 1
            self.y = self.rect.y + 1
        self.health_ratio = self.max_hp / self.width
    def take_dmg(self, amount):
        if self.current_hp - amount > 0:
            self.current_hp -= amount
        elif self.current_hp - amount <= 0:
            self.current_hp = 0
    def heal(self, amount):
        if self.current_hp + amount < self.max_hp:
            self.current_hp += amount
        elif self.current_hp + amount >= self.max_hp:
            self.current_hp = self.max_hp
    def show(self):
        pygame.Surface.fill(self.screen, BLACK, (self.x-1, self.y-1, self.width+2, self.height+2))
        pygame.Surface.fill(self.screen, RED, (self.x, self.y, self.width, self.height))
        pygame.Surface.fill(self.screen, GREEN, (self.x, self.y, int(self.current_hp / self.health_ratio), self.height))
--- a/logic/knights_queue.py
+++ b/logic/knights_queue.py
@ -1,25 +0,0 @@
 import random
 from collections import deque
 class KnightsQueue:
    def __init__(self, blue_team, red_team):
        self.queues = deque(blue_team), deque(red_team)
        self.team_idx_turn = random.randint(0, 1)
    def dequeue_knight(self):
        if self.both_teams_alive():
            knight = self.queues[self.team_idx_turn].popleft()
            if knight.health_bar.current_hp <= 0:
                return self.dequeue_knight()
            else:
                self.queues[self.team_idx_turn].append(knight)
                self.next_turn()
                return knight
        raise Exception('Game has just ended')
    def both_teams_alive(self):
        return len(self.queues[0]) > 0 and len(self.queues[1]) > 0
    def next_turn(self):
        self.team_idx_turn = (self.team_idx_turn + 1) % 2
--- a/logic/level.py
+++ b/logic/level.py
@ -1,286 +0,0 @@
 import random
 import pygame
 from algorithms.a_star import a_star, State, TURN_RIGHT, TURN_LEFT, FORWARD
 from algorithms.genetic.const import MAP_ALIASES
 from algorithms.genetic.map_importer_exporter import import_random_map
 from common.constants import *
 from learning.decision_tree import DecisionTree
 from logic.knights_queue import KnightsQueue
 from models.castle import Castle
 from models.knight import Knight
 from models.monster import Monster
 from models.tile import Tile
 class Level:
    def __init__(self, screen, logs):
        self.screen = screen
        self.logs = logs
        self.decision_tree = DecisionTree()
        # sprite group setup
        self.sprites = pygame.sprite.LayeredUpdates()
        self.map = []
        self.list_knights_blue = []
        self.list_knights_red = []
        self.list_monsters = []
        self.list_castles = []
        self.knights_queue = None
        self.stats = None
    def setup_stats(self, stats):
        self.stats = stats
    def add_points(self, team, points_to_add):
        if self.stats is not None:
            self.stats.add_points(team, points_to_add)
    def create_map(self):
        self.map = import_random_map()
        self.setup_base_tiles()
        self.setup_objects()
        self.knights_queue = KnightsQueue(self.list_knights_blue, self.list_knights_red)
    def setup_base_tiles(self):
        textures = []
        for texture_path in TILES:
            converted_texture = pygame.image.load('resources/textures/' + texture_path).convert_alpha()
            converted_texture = pygame.transform.scale(converted_texture, (40, 40))
            textures.append((texture_path, converted_texture))
        for row_index, row in enumerate(self.map):
            for col_index, col in enumerate(row):
                # add base tiles, e.g. water, tree, grass
                if col == MAP_ALIASES.get('WATER'):
                    texture_index = 5
                    texture_surface = textures[texture_index][1]
                    Tile((col_index, row_index), texture_surface, self.sprites, 'w')
                elif col == MAP_ALIASES.get('TREE'):
                    texture_index = 6
                    texture_surface = textures[texture_index][1]
                    Tile((col_index, row_index), texture_surface, self.sprites, 't')
                elif col == MAP_ALIASES.get('SAND'):
                    texture_index = 4
                    texture_surface = textures[texture_index][1]
                    Tile((col_index, row_index), texture_surface, self.sprites)
                else:
                    texture_index = random.randint(0, 3)
                    texture_surface = textures[texture_index][1]
                    Tile((col_index, row_index), texture_surface, self.sprites)
    def setup_objects(self):
        castle_count = 0  # TODO: find some smarter method to print castle
        for row_index, row in enumerate(self.map):
            print(row)
            for col_index, col in enumerate(row):
                # add objects, e.g. knights, monsters, castle
                if col == MAP_ALIASES.get('KNIGHT_BLUE'):
                    knight = Knight(self.screen, (col_index, row_index), self.sprites, "blue")
                    self.map[row_index][col_index] = knight
                    self.list_knights_blue.append(knight)
                elif col == MAP_ALIASES.get('KNIGHT_RED'):
                    knight = Knight(self.screen, (col_index, row_index), self.sprites, "red")
                    self.map[row_index][col_index] = knight
                    self.list_knights_red.append(knight)
                elif col == MAP_ALIASES.get('MONSTER'):
                    monster = Monster(self.screen, (col_index, row_index), self.sprites)
                    self.map[row_index][col_index] = monster
                    self.list_monsters.append(monster)
                elif col == MAP_ALIASES.get('CASTLE'):
                    castle_count += 1
                    if castle_count == 4:
                        castle = Castle(self.screen, (col_index, row_index), self.sprites)
                        self.map[row_index][col_index] = castle
                        self.list_castles.append(castle)
    #def attack_knight(self, knights_list, positions, current_knight):
    #    op_pos_1 = current_knight.position[0] - 1, current_knight.position[1]
    #    positions.append(op_pos_1)
    #    op_pos_2 = current_knight.position[0], current_knight.position[1] - 1
    #    positions.append(op_pos_2)
    #    op_pos_3 = current_knight.position[0] + 1, current_knight.position[1]
    #    positions.append(op_pos_3)
    #    op_pos_4 = current_knight.position[0], current_knight.position[1] + 1
    #    positions.append(op_pos_4)
    #    for some_knight in knights_list:
    #        for some_position in positions:
    #            if (some_knight.position == some_position and some_knight.team != current_knight.team):
    #                some_knight.health_bar.take_dmg(current_knight.attack)
    #                if some_knight.health_bar.current_hp == 0:
    #                    some_knight.kill()
    #    positions.clear()
    def attack_knight_left(self, knights_list, current_knight):
        position_left = current_knight.position[0] - 1, current_knight.position[1]
        for some_knight in knights_list:
            if (some_knight.position == position_left and some_knight.team != current_knight.team):
                some_knight.health_bar.take_dmg(current_knight.attack)
                if some_knight.health_bar.current_hp <= 0:
                    some_knight.kill()
                    self.add_points(current_knight.team, 5)
        for monster in self.list_monsters:
            if monster.position == position_left:
                monster.health_bar.take_dmg(current_knight.attack)
                if monster.health_bar.current_hp <= 0:
                    monster.kill()
                    self.add_points(current_knight.team, monster.points)
                else:
                    current_knight.health_bar.take_dmg(monster.attack)
                    if current_knight.health_bar.current_hp <= 0:
                        current_knight.kill()
        for castle in self.list_castles:
            if castle.position == position_left:
                castle.health_bar.take_dmg(current_knight.attack)
    def attack_knight_right(self, knights_list, current_knight):
        position_right = current_knight.position[0] + 1, current_knight.position[1]
        for some_knight in knights_list:
            if (some_knight.position == position_right and some_knight.team != current_knight.team):
                some_knight.health_bar.take_dmg(current_knight.attack)
                if some_knight.health_bar.current_hp == 0:
                    some_knight.kill()
                    self.add_points(current_knight.team, 5)
        for monster in self.list_monsters:
            if monster.position == position_right:
                monster.health_bar.take_dmg(current_knight.attack)
                if monster.health_bar.current_hp <= 0:
                    monster.kill()
                    self.add_points(current_knight.team, monster.points)
                else:
                    current_knight.health_bar.take_dmg(monster.attack)
                    if current_knight.health_bar.current_hp <= 0:
                        current_knight.kill()
        for castle in self.list_castles:
            if castle.position == position_right:
                castle.health_bar.take_dmg(current_knight.attack)
    def attack_knight_up(self, knights_list, current_knight):
        position_up = current_knight.position[0], current_knight.position[1] - 1
        for some_knight in knights_list:
            if (some_knight.position == position_up and some_knight.team != current_knight.team):
                some_knight.health_bar.take_dmg(current_knight.attack)
                if some_knight.health_bar.current_hp == 0:
                    some_knight.kill()
                    self.add_points(current_knight.team, 5)
        for monster in self.list_monsters:
            if monster.position == position_up:
                monster.health_bar.take_dmg(current_knight.attack)
                if monster.health_bar.current_hp <= 0:
                    monster.kill()
                    self.add_points(current_knight.team, monster.points)
                else:
                    current_knight.health_bar.take_dmg(monster.attack)
                    if current_knight.health_bar.current_hp <= 0:
                        current_knight.kill()
        for castle in self.list_castles:
            if castle.position == position_up:
                castle.health_bar.take_dmg(current_knight.attack)
    def attack_knight_down(self, knights_list, current_knight):
        position_down = current_knight.position[0], current_knight.position[1] + 1
        for some_knight in knights_list:
            if (some_knight.position == position_down and some_knight.team != current_knight.team):
                some_knight.health_bar.take_dmg(current_knight.attack)
                if some_knight.health_bar.current_hp == 0:
                    some_knight.kill()
                    self.add_points(current_knight.team, 5)
        for monster in self.list_monsters:
            if monster.position == position_down:
                monster.health_bar.take_dmg(current_knight.attack)
                if monster.health_bar.current_hp <= 0:
                    monster.kill()
                    self.add_points(current_knight.team, monster.points)
                else:
                    current_knight.health_bar.take_dmg(monster.attack)
                    if current_knight.health_bar.current_hp <= 0:
                        current_knight.kill()
        for castle in self.list_castles:
            if castle.position == position_down:
                castle.health_bar.take_dmg(current_knight.attack)
    def handle_turn(self):
        current_knight = self.knights_queue.dequeue_knight()
        knights_list = self.list_knights_red + self.list_knights_blue
        print("next turn " + current_knight.team)
        knight_pos_x = current_knight.position[0]
        knight_pos_y = current_knight.position[1]
        positions = []
        goal_list = self.decision_tree.predict_move(grid=self.map, current_knight=current_knight,
                                                    monsters=self.list_monsters,
                                                    opponents=self.list_knights_blue
                                                    if current_knight.team_alias() == 'k_r' else self.list_knights_red,
                                                    castle=self.list_castles[0])
        if (len(self.list_knights_blue) == 0 or len(self.list_knights_red) == 0):
            pygame.quit()
        if len(goal_list) == 0:
            return
        state = State((knight_pos_y, knight_pos_x), current_knight.direction.name)
        action_list = a_star(state, self.map, goal_list)
        print(action_list)
        print(goal_list)
        if len(action_list) == 0:
            return
        next_action = action_list.pop(0)
        #if current_knight.health_bar.current_hp != 0:
        #self.attack_knight(knights_list, positions, current_knight)
        if current_knight.direction.name == UP:
            self.attack_knight_up(knights_list, current_knight)
        elif current_knight.direction.name == DOWN:
            self.attack_knight_down(knights_list, current_knight)
        elif current_knight.direction.name == RIGHT:
            self.attack_knight_right(knights_list, current_knight)
        elif current_knight.direction.name == LEFT:
            self.attack_knight_left(knights_list, current_knight)
        if next_action == TURN_LEFT:
            self.logs.enqueue_log(f'AI {current_knight.team}: Obrót w lewo.')
            current_knight.rotate_left()
        elif next_action == TURN_RIGHT:
            self.logs.enqueue_log(f'AI {current_knight.team}: Obrót w prawo.')
            current_knight.rotate_right()
        elif next_action == FORWARD:
            current_knight.step_forward()
            self.map[knight_pos_y][knight_pos_x] = MAP_ALIASES.get("GRASS")
                # update knight on map
            if current_knight.direction.name == UP:
                self.logs.enqueue_log(f'AI {current_knight.team}: Ruch do góry.')
                self.map[knight_pos_y - 1][knight_pos_x] = current_knight.team_alias()
            elif current_knight.direction.name == RIGHT:
                self.logs.enqueue_log(f'AI {current_knight.team}: Ruch w prawo.')
                self.map[knight_pos_y][knight_pos_x + 1] = current_knight.team_alias()
            elif current_knight.direction.name == DOWN:
                self.logs.enqueue_log(f'AI {current_knight.team}: Ruch w dół.')
                self.map[knight_pos_y + 1][knight_pos_x] = current_knight.team_alias()
            elif current_knight.direction.name == LEFT:
                self.logs.enqueue_log(f'AI {current_knight.team}: Ruch w lewo.')
                self.map[knight_pos_y][knight_pos_x - 1] = current_knight.team_alias()
    def update(self):
        bg_width = (GRID_CELL_PADDING + GRID_CELL_SIZE) * COLUMNS + BORDER_WIDTH
        bg_height = (GRID_CELL_PADDING + GRID_CELL_SIZE) * ROWS + BORDER_WIDTH
        pygame.draw.rect(self.screen, (255, 255, 255), pygame.Rect(5, 5, bg_width, bg_height), 0, BORDER_RADIUS)
        # update and draw the game
        self.sprites.draw(self.screen)
        self.sprites.update()
--- a/logic/spawner.py
+++ b/logic/spawner.py
@ -1,33 +0,0 @@
 import random
 from common.constants import COLUMNS, ROWS
 class Spawner:
    def __init__(self, map):
        self.map = map
    def __is_free_field(self, field):
        return field in ['g', 's', ' ']
    def spawn_in_area(self, objects: list, spawn_area_pos_row=0, spawn_area_pos_column=0, spawn_area_width=0,
                      spawn_area_height=0, size=1):
        spawned_objects_count = 0
        while spawned_objects_count != len(objects):
            x = random.randint(0, spawn_area_height) + spawn_area_pos_row
            y = random.randint(0, spawn_area_width) + spawn_area_pos_column
            if x < ROWS - 1 and y < COLUMNS - 1 and self.__is_free_field(self.map[x][y]):
                for i in range(size):
                    for j in range(size):
                        self.map[x - i][y - j] = objects[spawned_objects_count]
                spawned_objects_count += 1
    def spawn_where_possible(self, objects: list):
        spawned_objects_count = 0
        while spawned_objects_count != len(objects):
            x = random.randint(0, ROWS - 1)
            y = random.randint(0, COLUMNS - 1)
            if self.__is_free_field(self.map[x][y]):
                self.map[x][y] = objects[spawned_objects_count]
                spawned_objects_count += 1
--- a/main.py
+++ b/main.py
@ -1,4 +1,4 @@
-from logic.game import Game
+from game import Game
 if __name__ == '__main__':
    game = Game()
--- a/models/init.py
+++ b/models/init.py
--- a/models/castle.py
+++ b/models/castle.py
@ -1,22 +0,0 @@
 import random
 import pygame.image
 from common.helpers import parse_cord
 from logic.health_bar import HealthBar
 class Castle(pygame.sprite.Sprite):
    def __init__(self, screen, position, group):
        super().__init__(group)
        self._layer = 1
        self.image = pygame.image.load("./resources/textures/castle.png").convert_alpha()
        self.image = pygame.transform.scale(self.image, (78, 78))
        self.position = position
        position_in_px = (parse_cord(position[0]), parse_cord(position[1]))
        self.rect = self.image.get_rect(center=position_in_px)
        self.max_hp = 80
        self.health_bar = HealthBar(screen, self.rect, current_hp=self.max_hp, max_hp=self.max_hp, calculate_xy=True, calculate_size=True)
    def update(self):
        self.health_bar.update()
--- a/models/knight.py
+++ b/models/knight.py
@ -1,83 +0,0 @@
 import random
 import pygame.image
 from common.constants import GRID_CELL_SIZE, Direction
 from common.helpers import parse_cord
 from logic.health_bar import HealthBar
 def load_knight_textures(team):
    if team == "blue":
        random_index = 3
    else:
        random_index = 4
    states = [
        pygame.image.load(f'resources/textures/knight_{random_index}_up.png').convert_alpha(),  # up = 0
        pygame.image.load(f'resources/textures/knight_{random_index}_right.png').convert_alpha(),  # right = 1
        pygame.image.load(f'resources/textures/knight_{random_index}_down.png').convert_alpha(),  # down = 2
        pygame.image.load(f'resources/textures/knight_{random_index}_left.png').convert_alpha(),  # left = 3
    ]
    return states
 class Knight(pygame.sprite.Sprite):
    def __init__(self, screen, position, group, team):
        super().__init__(group)
        self.direction = Direction.DOWN
        self.states = load_knight_textures(team)
        self.image = self.states[self.direction.value]
        self.position = position
        self._layer = 1
        position_in_px = (parse_cord(position[0]), parse_cord(position[1]))
        self.rect = self.image.get_rect(topleft=position_in_px)
        self.team = team
        self.max_hp = random.randint(9, 13)
        self.attack = random.randint(2, 4)
        self.defense = random.randint(1, 4)
        self.points = 1
        self.health_bar = HealthBar(screen, self.rect, current_hp=self.max_hp, max_hp=self.max_hp, calculate_xy=True, calculate_size=True)
    def rotate_left(self):
        self.direction = self.direction.left()
        self.image = self.states[self.direction.value]
    def update(self):
        self.health_bar.update()
    def rotate_right(self):
        self.direction = self.direction.right()
        self.image = self.states[self.direction.value]
    def take_dmg(self, amount):
        self.health_bar.take_dmg(amount)
    def heal(self, amount):
        self.health_bar.heal(amount)
    def get_current_hp(self):
        return self.health_bar.current_hp
    def get_max_hp(self):
        return self.health_bar.max_hp
    def step_forward(self):
        if self.direction.name == 'UP':
            self.position = (self.position[0], self.position[1] - 1)
            self.rect.y = self.rect.y - GRID_CELL_SIZE - 5
        elif self.direction.name == 'RIGHT':
            self.position = (self.position[0] + 1, self.position[1])
            self.rect.x = self.rect.x + GRID_CELL_SIZE + 5
        elif self.direction.name == 'DOWN':
            self.position = (self.position[0], self.position[1] + 1)
            self.rect.y = self.rect.y + GRID_CELL_SIZE + 5
        elif self.direction.name == 'LEFT':
            self.position = (self.position[0] - 1, self.position[1])
            self.rect.x = self.rect.x - GRID_CELL_SIZE - 5
    def team_alias(self) -> str:
        return "k_b" if self.team == "blue" else "k_r"
--- a/models/monster.py
+++ b/models/monster.py
@ -1,47 +0,0 @@
 import random
 import pygame.image
 from common.helpers import parse_cord
 from logic.health_bar import HealthBar
 monster_images = [
    pygame.image.load("./resources/textures/dragon2.png"),
    pygame.image.load("./resources/textures/birb.png"),
    pygame.image.load("./resources/textures/wolfart.png"),
    pygame.image.load("./resources/textures/goblin.png"),
 ]
 class Monster(pygame.sprite.Sprite):
    def __init__(self, screen, position, group):
        super().__init__(group)
        self._layer = 1
        self.image = random.choice(monster_images)
        self.image = pygame.transform.scale(self.image, (40, 40))
        position_in_px = (parse_cord(position[0]), parse_cord(position[1]))
        self.rect = self.image.get_rect(topleft=position_in_px)
        self.position = position
        self.max_hp = random.randrange(15, 20)
        self.health_bar = HealthBar(screen, self.rect, current_hp=self.max_hp, max_hp=self.max_hp,
                                    calculate_xy=True, calculate_size=True)
        self.attack = random.randrange(4, 6)
        if self.image == monster_images[0]:
            self.max_hp = 20
            self.attack = 6
            self.points = 10
        elif self.image == monster_images[1]:
            self.max_hp = 15
            self.attack = 7
            self.points = 7
        elif self.image == monster_images[2]:
            self.max_hp = 10
            self.attack = 4
            self.points = 4
        elif self.image == monster_images[3]:
            self.max_hp = 7
            self.attack = 2
            self.points = 2
    def update(self):
        self.health_bar.update()
--- a/models/tile.py
+++ b/models/tile.py
@ -1,13 +0,0 @@
 import pygame
 from common.helpers import parse_cord
 class Tile(pygame.sprite.Sprite):
    def __init__(self, position, image, group, tile_type=' '):
        super().__init__(group)
        self.image = image
        self._layer = 0
        position_in_px = (parse_cord(position[0]), parse_cord(position[1]))
        self.rect = self.image.get_rect(topleft=position_in_px)
        self.tile_type = tile_type
--- a/requirements.txt
+++ b/requirements.txt
--- a/resources/fonts/OFL.txt
+++ b/resources/fonts/OFL.txt
@ -1,93 +0,0 @@
 Copyright 2020 The Poppins Project Authors (https://github.com/itfoundry/Poppins)
 This Font Software is licensed under the SIL Open Font License, Version 1.1.
 This license is copied below, and is also available with a FAQ at:
 http://scripts.sil.org/OFL
 -----------------------------------------------------------
 SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
 -----------------------------------------------------------
 PREAMBLE
 The goals of the Open Font License (OFL) are to stimulate worldwide
 development of collaborative font projects, to support the font creation
 efforts of academic and linguistic communities, and to provide a free and
 open framework in which fonts may be shared and improved in partnership
 with others.
 The OFL allows the licensed fonts to be used, studied, modified and
 redistributed freely as long as they are not sold by themselves. The
 fonts, including any derivative works, can be bundled, embedded, 
 redistributed and/or sold with any software provided that any reserved
 names are not used by derivative works. The fonts and derivatives,
 however, cannot be released under any other type of license. The
 requirement for fonts to remain under this license does not apply
 to any document created using the fonts or their derivatives.
 DEFINITIONS
 "Font Software" refers to the set of files released by the Copyright
 Holder(s) under this license and clearly marked as such. This may
 include source files, build scripts and documentation.
 "Reserved Font Name" refers to any names specified as such after the
 copyright statement(s).
 "Original Version" refers to the collection of Font Software components as
 distributed by the Copyright Holder(s).
 "Modified Version" refers to any derivative made by adding to, deleting,
 or substituting -- in part or in whole -- any of the components of the
 Original Version, by changing formats or by porting the Font Software to a
 new environment.
 "Author" refers to any designer, engineer, programmer, technical
 writer or other person who contributed to the Font Software.
 PERMISSION & CONDITIONS
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of the Font Software, to use, study, copy, merge, embed, modify,
 redistribute, and sell modified and unmodified copies of the Font
 Software, subject to the following conditions:
 1) Neither the Font Software nor any of its individual components,
 in Original or Modified Versions, may be sold by itself.
 2) Original or Modified Versions of the Font Software may be bundled,
 redistributed and/or sold with any software, provided that each copy
 contains the above copyright notice and this license. These can be
 included either as stand-alone text files, human-readable headers or
 in the appropriate machine-readable metadata fields within text or
 binary files as long as those fields can be easily viewed by the user.
 3) No Modified Version of the Font Software may use the Reserved Font
 Name(s) unless explicit written permission is granted by the corresponding
 Copyright Holder. This restriction only applies to the primary font name as
 presented to the users.
 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
 Software shall not be used to promote, endorse or advertise any
 Modified Version, except to acknowledge the contribution(s) of the
 Copyright Holder(s) and the Author(s) or with their explicit written
 permission.
 5) The Font Software, modified or unmodified, in part or in whole,
 must be distributed entirely under this license, and must not be
 distributed under any other license. The requirement for fonts to
 remain under this license does not apply to any document created
 using the Font Software.
 TERMINATION
 This license becomes null and void if any of the above conditions are
 not met.
 DISCLAIMER
 THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
 OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
 COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
 DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
 OTHER DEALINGS IN THE FONT SOFTWARE.
--- a/resources/fonts/Poppins-Black.ttf
+++ b/resources/fonts/Poppins-Black.ttf
--- a/resources/fonts/Poppins-BlackItalic.ttf
+++ b/resources/fonts/Poppins-BlackItalic.ttf
--- a/resources/fonts/Poppins-Bold.ttf
+++ b/resources/fonts/Poppins-Bold.ttf
--- a/resources/fonts/Poppins-BoldItalic.ttf
+++ b/resources/fonts/Poppins-BoldItalic.ttf
--- a/resources/fonts/Poppins-ExtraBold.ttf
+++ b/resources/fonts/Poppins-ExtraBold.ttf
--- a/resources/fonts/Poppins-ExtraBoldItalic.ttf
+++ b/resources/fonts/Poppins-ExtraBoldItalic.ttf
--- a/resources/fonts/Poppins-ExtraLight.ttf
+++ b/resources/fonts/Poppins-ExtraLight.ttf
--- a/resources/fonts/Poppins-ExtraLightItalic.ttf
+++ b/resources/fonts/Poppins-ExtraLightItalic.ttf
--- a/resources/fonts/Poppins-Italic.ttf
+++ b/resources/fonts/Poppins-Italic.ttf
--- a/resources/fonts/Poppins-Light.ttf
+++ b/resources/fonts/Poppins-Light.ttf
--- a/resources/fonts/Poppins-LightItalic.ttf
+++ b/resources/fonts/Poppins-LightItalic.ttf
--- a/resources/fonts/Poppins-Medium.ttf
+++ b/resources/fonts/Poppins-Medium.ttf
--- a/resources/fonts/Poppins-MediumItalic.ttf
+++ b/resources/fonts/Poppins-MediumItalic.ttf
--- a/resources/fonts/Poppins-Regular.ttf
+++ b/resources/fonts/Poppins-Regular.ttf
--- a/resources/fonts/Poppins-SemiBold.ttf
+++ b/resources/fonts/Poppins-SemiBold.ttf
--- a/resources/fonts/Poppins-SemiBoldItalic.ttf
+++ b/resources/fonts/Poppins-SemiBoldItalic.ttf
--- a/resources/fonts/Poppins-Thin.ttf
+++ b/resources/fonts/Poppins-Thin.ttf
--- a/resources/fonts/Poppins-ThinItalic.ttf
+++ b/resources/fonts/Poppins-ThinItalic.ttf
--- a/resources/maps/map_2022_06_02_13_27_18.json
+++ b/resources/maps/map_2022_06_02_13_27_18.json
@ -1 +0,0 @@
 {"map": [[0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1], [0, 0, 0, 0, 3, 3, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 3], [0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3], [0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 4, 0, 0, 0, 2, 0, 3], [0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2], [0, 0, 3, 3, 3, 0, 0, 0, 3, 3, 3, 3, 0, 2, 2, 2, 0, 0, 0, 0, 0, 7, 2, 0], [0, 0, 0, 6, 0, 0, 0, 2, 2, 2, 0, 5, 5, 0, 2, 0, 0, 2, 2, 2, 2, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 5, 5, 0, 2, 0, 0, 0, 0, 2, 2, 1, 1, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 3, 1, 7], [6, 0, 0, 6, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 1, 1, 0], [6, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 3, 3, 0, 0, 0, 0, 3, 3, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 0, 1, 1, 7, 0], [0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 3, 1, 1, 1, 0], [0, 3, 3, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 1, 0, 0], [0, 3, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 4, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
--- a/resources/maps/map_2022_06_06_14_55_49.json
+++ b/resources/maps/map_2022_06_06_14_55_49.json
@ -1 +0,0 @@
 {"map": [[0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0], [0, 3, 3, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 3, 3, 0, 0, 0, 2, 0, 0, 0, 0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 2, 2, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 2, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 3, 3, 0, 0, 0, 0, 0, 3, 0, 4, 0, 3, 0, 0, 0, 0, 0, 0, 7, 0, 0], [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 7, 7, 0, 0], [6, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 3, 7, 0, 0, 0], [0, 0, 6, 6, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0], [0, 2, 2, 2, 2, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0], [2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 2, 0, 0, 0, 0, 0, 4, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
--- a/resources/maps/map_2022_06_06_14_58_11.json
+++ b/resources/maps/map_2022_06_06_14_58_11.json
@ -1 +0,0 @@
 {"map": [[0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 3, 3], [0, 0, 0, 0, 2, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 3, 0], [0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0, 0, 2, 0], [0, 0, 3, 3, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 2, 0], [0, 0, 3, 0, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0], [0, 0, 3, 3, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0], [0, 0, 0, 6, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 6, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 5, 5, 1, 2, 0, 0, 0, 0, 0, 0, 7, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0, 4, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0], [0, 0, 3, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 4], [6, 0, 0, 6, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 1, 1, 0, 7, 0, 7, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 3, 2, 0, 0, 0, 0, 0, 0], [0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0], [0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
--- a/resources/textures/License
+++ b/resources/textures/License
@ -1,45 +0,0 @@
 IMPORTANT NOTICE: This license only applies if you downloaded this content as
 an unsubscribed user. If you are a premium user (ie, you pay a subscription)
 you are bound to the license terms described in the accompanying file
 "License premium.txt".
 ---------------------
 You must attribute the image to its author:
 In order to use a content or a part of it, you must attribute it to vectorpocket / Freepik,
 so we will be able to continue creating new graphic resources every day.
 How to attribute it?
 For websites:
 Please, copy this code on your website to accredit the author:
 <a href="http://www.freepik.com">Designed by vectorpocket / Freepik</a>
 For printing:
 Paste this text on the final work so the authorship is known.
 - For example, in the acknowledgements chapter of a book:
 "Designed by vectorpocket / Freepik"
 You are free to use this image:
 - For both personal and commercial projects and to modify it.
 - In a website or presentation template or application or as part of your design.
 You are not allowed to:
 - Sub-license, resell or rent it.
 - Include it in any online or offline archive or database.
 The full terms of the license are described in section 7 of the Freepik
 terms of use, available online in the following link:
  http://www.freepik.com/terms_of_use
 The terms described in the above link have precedence over the terms described
 in the present document. In case of disagreement, the Freepik Terms of Use
 will prevail.
--- a/resources/textures/License
+++ b/resources/textures/License
@ -1,30 +0,0 @@
 IMPORTANT NOTICE: This license only applies if you downloaded this content as
 a subscribed (or "premium") user. If you are an unsubscribed user (or "free"
 user) you are bound to the license terms described in the accompanying file
 "License free.txt".
 ---------------------
 You can download from your profile in Freepik a personalized license stating
 your right to use this content as a "premium" user:
  https://profile.freepik.com/my_downloads
 You are free to use this image:
 - For both personal and commercial projects and to modify it.
 - In a website or presentation template or application or as part of your design.
 You are not allowed to:
 - Sub-license, resell or rent it.
 - Include it in any online or offline archive or database.
 The full terms of the license are described in sections 7 and 8 of the Freepik
 terms of use, available online in the following link:
  http://www.freepik.com/terms_of_use
 The terms described in the above link have precedence over the terms described
 in the present document. In case of disagreement, the Freepik Terms of Use
 will prevail.
--- a/resources/textures/birb.png
+++ b/resources/textures/birb.png
--- a/resources/textures/castle.png
+++ b/resources/textures/castle.png
--- a/resources/textures/data.txt
+++ b/resources/textures/data.txt
@ -1,19 +0,0 @@
 ........................
 .P......................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
 ........................
--- a/resources/textures/dragon.png
+++ b/resources/textures/dragon.png
--- a/resources/textures/dragon2.png
+++ b/resources/textures/dragon2.png
--- a/resources/textures/goblin.png
+++ b/resources/textures/goblin.png
--- a/resources/textures/knight.png
+++ b/resources/textures/knight.png
--- a/resources/textures/knight_1_down.png
+++ b/resources/textures/knight_1_down.png
--- a/resources/textures/knight_1_left.png
+++ b/resources/textures/knight_1_left.png
--- a/resources/textures/knight_1_right.png
+++ b/resources/textures/knight_1_right.png
--- a/resources/textures/knight_1_up.png
+++ b/resources/textures/knight_1_up.png
--- a/resources/textures/knight_2_down.png
+++ b/resources/textures/knight_2_down.png
--- a/resources/textures/knight_2_left.png
+++ b/resources/textures/knight_2_left.png
--- a/resources/textures/knight_2_right.png
+++ b/resources/textures/knight_2_right.png
--- a/resources/textures/knight_2_up.png
+++ b/resources/textures/knight_2_up.png
--- a/resources/textures/knight_3_down.png
+++ b/resources/textures/knight_3_down.png
--- a/resources/textures/knight_3_left.png
+++ b/resources/textures/knight_3_left.png
--- a/resources/textures/knight_3_right.png
+++ b/resources/textures/knight_3_right.png
--- a/resources/textures/knight_3_up.png
+++ b/resources/textures/knight_3_up.png
--- a/resources/textures/knight_4_down.png
+++ b/resources/textures/knight_4_down.png
--- a/resources/textures/knight_4_left.png
+++ b/resources/textures/knight_4_left.png
--- a/resources/textures/knight_4_right.png
+++ b/resources/textures/knight_4_right.png
--- a/resources/textures/knight_4_up.png
+++ b/resources/textures/knight_4_up.png
--- a/resources/textures/menu_bg.jpg
+++ b/resources/textures/menu_bg.jpg
--- a/resources/textures/menu_bg2.jpg
+++ b/resources/textures/menu_bg2.jpg
--- a/resources/textures/shield_blue.png
+++ b/resources/textures/shield_blue.png
--- a/resources/textures/shield_red.png
+++ b/resources/textures/shield_red.png
--- a/resources/textures/wolfart.png
+++ b/resources/textures/wolfart.png
--- a/stats.py
+++ b/stats.py
@ -0,0 +1,15 @@
 import pygame
 from constants import COLUMNS, GRID_CELL_PADDING, GRID_CELL_WIDTH, BORDER_WIDTH
 from helpers import draw_text
 class Stats:
    def __init__(self):
        self.grid = []
    def draw(self, screen, font):
        x = (GRID_CELL_PADDING + GRID_CELL_WIDTH) * COLUMNS + BORDER_WIDTH + 20
        y = 8
        pygame.draw.rect(screen, (255, 255, 255), pygame.Rect(x, y, 370, 782))
        draw_text('GAME STATS', font, (0, 0, 0), screen, x + 120, y + 30)
--- a/ui/init.py
+++ b/ui/init.py
--- a/Show More
+++ b/Show More
		`@ -1 +0,0 @@`
			{"map": [[0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1], [0, 0, 0, 0, 3, 3, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 3], [0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3], [0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 4, 0, 0, 0, 2, 0, 3], [0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2], [0, 0, 3, 3, 3, 0, 0, 0, 3, 3, 3, 3, 0, 2, 2, 2, 0, 0, 0, 0, 0, 7, 2, 0], [0, 0, 0, 6, 0, 0, 0, 2, 2, 2, 0, 5, 5, 0, 2, 0, 0, 2, 2, 2, 2, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 5, 5, 0, 2, 0, 0, 0, 0, 2, 2, 1, 1, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 3, 1, 7], [6, 0, 0, 6, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 1, 1, 0], [6, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 3, 3, 0, 0, 0, 0, 3, 3, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 0, 1, 1, 7, 0], [0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 3, 1, 1, 1, 0], [0, 3, 3, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 1, 0, 0], [0, 3, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 4, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
		`@ -1 +0,0 @@`
			{"map": [[0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0], [0, 3, 3, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 3, 3, 0, 0, 0, 2, 0, 0, 0, 0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 2, 2, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 2, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 3, 3, 0, 0, 0, 0, 0, 3, 0, 4, 0, 3, 0, 0, 0, 0, 0, 0, 7, 0, 0], [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 7, 7, 0, 0], [6, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 3, 7, 0, 0, 0], [0, 0, 6, 6, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0], [0, 2, 2, 2, 2, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0], [2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 2, 0, 0, 0, 0, 0, 4, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
		`@ -1 +0,0 @@`
			{"map": [[0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 3, 3], [0, 0, 0, 0, 2, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 3, 0], [0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0, 0, 2, 0], [0, 0, 3, 3, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 2, 0], [0, 0, 3, 0, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0], [0, 0, 3, 3, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0], [0, 0, 0, 6, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 6, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 5, 5, 1, 2, 0, 0, 0, 0, 0, 0, 7, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0, 4, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0], [0, 0, 3, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 4], [6, 0, 0, 6, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 1, 1, 0, 7, 0, 7, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 3, 2, 0, 0, 0, 0, 0, 0], [0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0], [0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}