Trees empty field calculator

import random
import tkinter


class Field:
    def __init__(self, size: int = 10, trees: int = 10, *, window: tkinter.Tk, canvas_size: int) -> None:
        """
    Create new field
        :type window: window
        :param size: size field
        :param trees: number of trees
        """
        self._start_size = size
        self._start_trees = trees
        self._new_canvas(canvas_size, window)
        self.new_field(size, trees)

    def new_field(self, size: int = 10, trees: int = 10) -> None:
        """
    Create new field
        :param size: size field
        :param trees: number of trees
        """
        self._field_generate(size)
        self._trees_generate(trees)
        self._max_empty_square()

    def reload_field(self):
        self.new_field(self._start_size, self._start_trees)

    def new_random_tree(self):
        if self._trees_number < self._trees_max_number:
            exit_program = False
            while not exit_program:
                x = random.randint(0, self._size - 1)
                y = random.randint(0, self._size - 1)
                if not self._check_field_cell(x, y):
                    self._trees[x][y] = True
                    exit_program = True
            self._max_empty_square()

    def _new_canvas(self, size: int, window: tkinter.Tk):
        self._canvas_size = size
        self._canvas = tkinter.Canvas(window, bg="#888888",
                                      width=size,
                                      height=size)
        self._canvas.place(x=0, y=0)

    def _draw(self, start_x, start_y, size_square):
        interval = self._canvas_size / self._size
        self._canvas.delete("all")
        self._draw_trees(interval)
        self._draw_max_square(start_x, start_y, size_square, interval)
        self._draw_grid(self._size, interval)

    def _draw_trees(self, interval):
        for x in range(self._size):
            for y in range(self._size):
                if self._check_field_cell(x, y):
                    cell_x = x * interval
                    cell_y = y * interval
                    self._canvas.create_rectangle(cell_x, cell_y, cell_x + interval, cell_y + interval, fill="#008800")

    def _draw_max_square(self, start_x, start_y, size_square, interval):
        x = start_x * interval
        y = start_y * interval
        size = size_square * interval
        self._canvas.create_rectangle(x, y, x + size, y + size, fill="#00aaaa")

    def _draw_grid(self, size, interval):
        for x in range(size + 1):
            for y in range(size + 1):
                self._canvas.create_line(x * interval, 0, x * interval, self._canvas_size, width=1)
                self._canvas.create_line(0, y * interval, self._canvas_size, y * interval, width=1)

    def _field_generate(self, size: int) -> None:
        """
    Create new field
        :param size: size field
        """
        self._size = size
        self._field = list()
        self._trees = list()
        for i in range(size):
            self._field.append(list())
            self._trees.append(list())
            for j in range(size):
                self._field[i].append(0)
                self._trees[i].append(False)

    def _trees_generate(self, trees_number: int) -> None:
        """
    Generation of trees in the field
        :param trees_number: number of trees
        """
        self._trees_max_number = self._size ** 2 - 1
        self._trees_number = min(trees_number, self._trees_max_number)
        count = 0
        while count < self._trees_number:
            x = random.randint(0, self._size - 1)
            y = random.randint(0, self._size - 1)
            if not self._check_field_cell(x, y):
                self._trees[x][y] = True
                count += 1

    def _check_field_cell(self, x: int, y: int) -> bool:
        """
    Check field cell
        :param x: start x coord
        :param y: start y coord
        :return: cell contains tree
        """
        return self._trees[x][y]

    def _check_square(self, x: int, y: int, size: int) -> bool:
        """
    Check square
        :param x: start x coord
        :param y: start y coord
        :param size: size square
        :return: square contains tree
        """
        output = False
        for i in range(size):
            for j in range(size):
                output = output or self._check_field_cell(x + i, y + j)
        return output

    def _max_empty_square(self) -> None:
        """
    Get max empty square
        :return: square
        """
        for max_offset in range(self._size):
            size = self._size - max_offset
            for x in range(max_offset + 1):
                for y in range(max_offset + 1):
                    if not self._check_square(x, y, size):
                        return self._draw(x, y, size)


class Program:
    def __init__(self, size=300):
        self._window = tkinter.Tk()
        self._window.title("Trees")
        self._window.geometry(f"{size + 100}x{size + 20}")
        field = Field(25, 0, canvas_size=size, window=self._window)
        reload_button = tkinter.Button(self._window, text="Reload", command=field.reload_field)
        reload_button.grid(row=0, column=0, padx=size+20, pady=20)
        new_random_tree_button = tkinter.Button(self._window, text="Random tree", command=field.new_random_tree)
        new_random_tree_button.grid(row=1, column=0)

    def run(self):
        self._window.mainloop()


def main():
    program = Program()
    program.run()


main()