Projekt_Sztuczna_Inteligencja/game.py

from random import choice, randint

import project_constants as const

from assets.display_assets import blit_graphics
from algorithms.search import a_star

from minefield import Minefield

from objects.mines.mine_models.time_mine import TimeMine

from ui.ui_components_manager import UiComponentsManager
from ui.text_box import TextBox
from ui.button import Button
from ui.input_box import InputBox


class Game:
    def __init__(self, turn=0, minefield=None, window=None):
        # loading game settings
        self.window = window if window is not None else const.SCREEN

        # setting in game data
        self.turn = turn
        self.turn_on_which_last_action_was_taken = turn
        self.goal = (0, 0)

        # assigning minefield and agent to variables
        self.minefield = minefield if minefield is not None else Minefield(const.MAP_RANDOM_10x10)
        self.initial_minefield = self.minefield.__copy__()
        self.agent = self.minefield.agent
        self.agent_action = None
        self.millisecond_timer = 0
        self.delta_time = 0
        self.action_timer = 0
        self.action_delta_time = 0

        # declaring and initializing gui components
        #   ui_component managers
        self.in_game_gui_components_manager = UiComponentsManager()
        self.game_over_gui_components_manager = UiComponentsManager()

        #   in game gui
        self.input_box_row = InputBox((0, 0), (0, 0))
        self.input_box_column = InputBox((0, 0), (0, 0))
        self.button_auto = Button((0, 0), (0, 0))
        self.button_genetic_algorithm = Button((0, 0), (0, 0))
        self.button_random = Button((0, 0), (0, 0))
        self.button_ok = Button((0, 0), (0, 0))

        #   game over screen
        self.text_box_game_over = TextBox((0, 0), (0, 0))
        self.button_try_again = Button((0, 0), (0, 0))
        self.button_close = Button((0, 0), (0, 0))

    # draws minefield and agent instances
    def draw_minefield(self):
        blit_graphics(self.minefield)
        self.agent.update_and_draw(self.window, self.action_delta_time, self.minefield)

    # draws menu
    def run_in_game_menu_overlay(self, mouse_position, events):
        # drawing and updating all gui components
        self.in_game_gui_components_manager.run_all(self.window, mouse_position, events)
        self.in_game_gui_components_manager.switch_selected_objects_with_arrow_keys(mouse_position, events)

        # setting random goal if random button is clicked
        if self.button_random.is_clicked(mouse_position, events):
            self.goal = (randint(0, 9), randint(0, 9))
            self.input_box_row.set_texts(user_input=str(self.goal[0]))
            self.input_box_column.set_texts(user_input=str(self.goal[1]))

        # if any input box is empty don't allow player to run game
        self.button_ok.set_flags(is_active=not (self.input_box_row.empty() or self.input_box_column.empty()))

        # updating goal if input boxes are filled and highlighting chosen tile destination
        if not (self.input_box_row.empty() or self.input_box_column.empty()):
            # updating goal
            self.goal = (min(9, int(self.input_box_row.get_input())), min(9, int(self.input_box_column.get_input())))

            # highlighting chosen tile destination
            self.window.blit(const.HIGHLIGHT, const.get_tile_coordinates(self.goal))

    # makes agent take next action
    def agent_take_next_action(self, action_sequence):
        # give agent an action if there is one
        self.agent.take_action(self.agent_action)

        # check what the next action is going to be
        self.agent_action = action_sequence.pop(0)

        # start animating agents next action
        self.agent.animate(self.agent_action)

    # updates in game time and timers
    def update_time(self, number_of_seconds_since_last_tick):
        self.millisecond_timer += number_of_seconds_since_last_tick / 1000
        self.action_timer = self.millisecond_timer / const.TURN_INTERVAL
        self.delta_time = number_of_seconds_since_last_tick / 1000
        self.action_delta_time = self.delta_time / const.TURN_INTERVAL

    # updates number of turns in game
    def update_turns(self):
        # if one turns time passed: updating number of turns
        if self.millisecond_timer >= const.TURN_INTERVAL:
            self.turn += 1
            self.minefield.next_turn()

            # resetting timer
            self.millisecond_timer %= const.TURN_INTERVAL

    # returns turn number
    def get_turn_number(self):
        return self.turn

    # draws a random mine to disarm (in auto mode)
    def set_random_mine_as_target(self):
        if any(self.minefield.get_active_mines()):
            self.goal = choice(self.minefield.get_active_mines()).position

            # display new destination
            self.input_box_row.set_texts(user_input=str(self.goal[0]))
            self.input_box_column.set_texts(user_input=str(self.goal[1]))

            # prevents highlighting input_box_row,
            # couldn't find any better solution w/o major Game class changes
            self.input_box_row.set_is_selected(False)

            return True

        else:
            return False

    # gets action sequence for agent
    def get_action_sequence(self, target_type: str = "tile"):
        return a_star.graphsearch(
            initial_state=a_star.State(
                row=self.agent.row,
                column=self.agent.column,
                direction=self.agent.direction
            ),
            minefield=self.minefield,
            target_type=target_type,
            tox=self.goal[0],
            toy=self.goal[1]
        )

    # returns a mine on a given position
    def get_mine(self, position):
        row, column = position
        return self.minefield.matrix[row][column].mine

    # initializes attributes before game loop begins
    def initialize_before_game_loop(self):
        self.agent_action = None
        self.millisecond_timer = 0
        self.action_timer = 0
        self.delta_time = 0
        self.action_delta_time = 0

        for component in self.in_game_gui_components_manager.selectable_ui_components:
            component.set_flags(is_active=False)

    # gives agent last action
    def agent_take_last_action(self):
        self.agent.take_action(self.agent_action)

    # cleans up after game loop ends
    def cleanup_after_game_loop(self):
        self.agent.update_and_draw(self.window, self.action_delta_time, self.minefield)
        self.agent.reset_actions()

        for comp in self.in_game_gui_components_manager.selectable_ui_components:
            comp.set_flags(is_active=True)

        if not any([comp.is_selected for comp in self.in_game_gui_components_manager.selectable_ui_components]):
            self.input_box_row.set_is_selected(True)

    # returns True if agents should take an action in this turn, or False otherwise
    def agent_should_take_next_action(self, action_sequence):
        number_of_turns_since_last_action = self.turn - self.turn_on_which_last_action_was_taken
        agent_action_cost = 1 if self.agent_action != const.Action.GO else self._get_next_tiles_entering_cost()

        if number_of_turns_since_last_action >= agent_action_cost and any(action_sequence):
            self.turn_on_which_last_action_was_taken = self.turn

            return True

        return False

    # returns True if agent made all actions he was instructed to do, or False otherwise
    def agent_made_all_actions(self, action_sequence):
        number_of_turns_since_last_action = self.turn - self.turn_on_which_last_action_was_taken
        agent_action_cost = 1 if self.agent_action != const.Action.GO else self._get_next_tiles_entering_cost()

        if number_of_turns_since_last_action >= agent_action_cost and not any(action_sequence):
            self.turn_on_which_last_action_was_taken = self.turn

            return True

        return False

    # runs game over screen
    def run_game_over_screen(self, mouse_position, events):
        self.window.fill((255, 255, 255))
        self.game_over_gui_components_manager.run_all(self.window, mouse_position, events)

        # resetting minefield to the original state
        if self.button_try_again.is_clicked(mouse_position, events):
            del self.minefield
            del self.agent
            self.minefield = self.initial_minefield.__copy__()
            self.agent = self.initial_minefield.agent

    # initializes old ui components and assigns them to attributes
    def initialize_gui_components(self):
        # calculating in game gui coordinates
        gui_width = const.V_SIDE_MENU_WIDTH
        ib_height, bt_height = const.V_INPUT_BOX_HEIGHT, const.V_BUTTON_HEIGHT
        gui_x = const.V_TILE_AREA_WIDTH + 2 * const.V_SCREEN_PADDING + const.V_NUMBER_PADDING
        gui_y = const.SCREEN.get_height() / 2 - (2 * ib_height + 3 * bt_height + 50) / 2

        # creating in game gui components
        self.input_box_row = InputBox(
            position=(gui_x, gui_y),
            dimensions=(gui_width, ib_height),
            text="row",
            box_color=(100, 200, 100),
            bottom_strip_color=(120, 220, 120),
            inner_box_color=(120, 220, 120),
            outline_color=(80, 180, 80),
            outline_additional_pixel=True,
            valid_input_characters="1234567890",
            input_centered=True,
            clear_input_on_click=True
        )

        self.input_box_column = InputBox(
            position=(gui_x, gui_y + ib_height + 10),
            dimensions=(gui_width, ib_height),
            text="column",
            box_color=(100, 200, 100),
            bottom_strip_color=(120, 220, 120),
            inner_box_color=(120, 220, 120),
            outline_color=(80, 180, 80),
            outline_additional_pixel=True,
            valid_input_characters="1234567890",
            input_centered=True,
            clear_input_on_click=True
        )

        self.button_auto = Button(
            position=(gui_x, gui_y + 2 * ib_height + 20),
            dimensions=(gui_width, bt_height),
            text="auto",
            box_color=(100, 200, 100),
            outline_color=(80, 180, 80),
            outline_additional_pixel=True
        )

        self.button_genetic_algorithm = Button(
            position=(gui_x, gui_y + 2 * ib_height + bt_height + 30),
            dimensions=(gui_width, bt_height),
            text="genetic",
            box_color=(100, 200, 100),
            outline_color=(80, 180, 80),
            outline_additional_pixel=True
        )

        self.button_random = Button(
            position=(gui_x, gui_y + 2 * ib_height + 2 * bt_height + 40),
            dimensions=(gui_width, bt_height),
            text="random",
            box_color=(100, 200, 100),
            outline_color=(80, 180, 80),
            outline_additional_pixel=True
        )

        self.button_ok = Button(
            position=(gui_x, gui_y + 2 * ib_height + 3 * bt_height + 50),
            dimensions=(gui_width, bt_height),
            text="ok",
            box_color=(100, 200, 100),
            outline_color=(80, 180, 80),
            outline_additional_pixel=True
        )

        gui_list = [
            self.input_box_row,
            self.input_box_column,
            self.button_auto,
            self.button_genetic_algorithm,
            self.button_random,
            self.button_ok
        ]
        self.in_game_gui_components_manager = UiComponentsManager(gui_list)

        # creating game over gui components
        self.text_box_game_over = TextBox(position=(150, 200), dimensions=(500, 100), text="Game Over")
        self.button_try_again = Button(position=(350, 350), dimensions=(100, 50), text="Try again")
        self.button_close = Button(position=(350, 450), dimensions=(100, 50), text="Close")

        gui_list = [self.text_box_game_over, self.button_try_again, self.button_close]
        self.game_over_gui_components_manager = UiComponentsManager(gui_list, select_first_item=False)

    # returns true if there is a time mine that went out of time
    def time_mine_exploded(self):
        # auxiliary function that checks if a tile contains a time mine which timer went to 0
        for i in range(const.V_GRID_HOR_TILES):
            for j in range(const.V_GRID_VER_TILES):
                mine = self.minefield.matrix[i][j].mine
                if mine is not None and isinstance(mine, TimeMine) and mine.timer <= 0:

                    return True

        return False

    # sets all in game components is_active flags to a given value
    def set_is_active_flag_for_all_in_game_gui_components(self, is_active):
        for component in self.in_game_gui_components_manager.selectable_ui_components:
            component.set_flags(is_active=is_active)

    # returns cost of entering tile in front of the agent
    def _get_next_tiles_entering_cost(self):
        row, column = self._get_next_agent_position()

        return self.minefield.matrix[row][column].cost.value

    # returns position in front of agent
    def _get_next_agent_position(self):
        # heading either up or down
        if self.agent_action == const.Action.GO and self.agent.direction.value % 2 == 0:
            return max(0, min(9, self.agent.row + self.agent.direction.value - 1)), self.agent.column

        # heading either left or right
        else:
            return self.agent.row, max(0, min(9, self.agent.column - self.agent.direction.value + 2))