Machine_learning_2023/Interface/vacuum_render.py

from enum import Enum
import random
from typing import List
from Interface.grid_draw import GridDraw, Colors
import sys
import pygame
from Interface.movement import movement_key_press


# window_dimensions says how many pixels window have
# board_size says how many lines board have in one row
def initial_draw(window_dimensions, board_size):
    # window name
    pygame.display.set_caption("AI Vacuum Cleaner")

    # define additional variables
    tile_size = window_dimensions / board_size

    # initialize board array
    newGrid = Grid(board_size, window_dimensions=window_dimensions, board_size=board_size)
    newGrid.add(objectOnTile(1, 1, acceptedType.PLAYER))
    newGrid.add(objectOnTile(7, 8, acceptedType.ANIMAL))
    player = newGrid.findFirst(acceptedType.PLAYER)
    newGrid.move(1, 1, 1, 2)
    newGrid.move(1, 2, 1, 1)

    # set window dimension
    window_width = window_dimensions
    window_height = window_dimensions

    # initialize drawer
    drawer = GridDraw(window_width, window_height)

    # rendering loop
    while True:
        drawer.start_draw()
        drawer.board(board_size, board_size)

        player = newGrid.findFirst(acceptedType.PLAYER)

        (x, y) = movement_key_press(board_size, player.position_x, player.position_y)

        newGrid.move(player.position_x, player.position_y, x, y)

        newGrid.render(drawer, newGrid=newGrid)
        drawer.end_draw()
        pygame.time.delay(30)


# TODO wrap it all to another file that handles array rendering
class acceptedType(Enum):
    EMPTY = "empty"
    PLAYER = "player"
    RUBBISH = "rubbish"
    PLANT = "plant"
    ANIMAL = "animal"


class objectOnTile:
    def __init__(
        self, position_x: int, position_y: int, type: acceptedType = acceptedType.EMPTY
    ):
        self.position_x = position_x
        self.position_y = position_y
        self.type = type


# calculate position from array position to window position eg.: array_position = 0 => window_position = 50 (px)
def _translate_array_to_window_position(array_position, tile_size_window) -> int:
    return array_position * tile_size_window + tile_size_window / 2


class Grid:
    
    def __init__(self, size_array, window_dimensions, board_size):
        self.array = [
            [objectOnTile(i, j) for j in range(size_array)] for i in range(size_array)
        ]
        self.list: List[objectOnTile] = []

        self.tile_size = window_dimensions / board_size

        self.cat_last_tick = pygame.time.get_ticks()
        self.cat_cooldown = 1000
        self.cat_velocity = 1
        self.cat_busy = False

        #region images
        self.cat_front_image = pygame.transform.scale(pygame.image.load("Interface/images/cat/standing_front.png"), (self.tile_size, self.tile_size))
        self.cat_back_image = pygame.transform.scale(pygame.image.load("Interface/images/cat/standing_back.png"), (self.tile_size, self.tile_size))
        self.cat_left_image = pygame.transform.scale(pygame.image.load("Interface/images/cat/standing_left.png"), (self.tile_size, self.tile_size))
        self.cat_right_image = pygame.transform.scale(pygame.image.load("Interface/images/cat/standing_right.png"), (self.tile_size, self.tile_size))
        self.cat_current_image = self.cat_front_image
        #endregion

    # render the array
    def render(self, drawer: GridDraw, newGrid):
        #tile_size = window_dimensions / board_size

        # render object with respect to type
        for item in self.list:
            if item.type == acceptedType.PLAYER:
                # constants for player
                PLAYER_RADIUS_RATIO = 3
                PLAYER_COLOR = Colors.RED

                # position on screen
                render_x = _translate_array_to_window_position(
                    item.position_x, self.tile_size
                )
                render_y = _translate_array_to_window_position(
                    item.position_y, self.tile_size
                )

                # image rendering function
                drawer.circle(
                    render_x,
                    render_y,
                    self.tile_size / PLAYER_RADIUS_RATIO,
                    color=PLAYER_COLOR,
                )
            if item.type == acceptedType.ANIMAL:
                now = pygame.time.get_ticks()
                #region cat random movement
                if now - self.cat_last_tick >= self.cat_cooldown:
                    if self.cat_busy == False:
                        self.cat_direction = random.randint(0,3)

                    if self.cat_direction == 0: #up
                        if self.cat_current_image == self.cat_back_image:
                            newGrid.move(item.position_x, item.position_y, item.position_x, item.position_y - 1)
                            self.cat_busy = False
                        else:
                            self.cat_busy = True
                            self.cat_current_image = self.cat_back_image
                    if self.cat_direction == 1: #right
                        if self.cat_current_image == self.cat_right_image:
                            newGrid.move(item.position_x, item.position_y, item.position_x + 1, item.position_y)
                            self.cat_busy = False
                        else:
                            self.cat_busy = True
                            self.cat_current_image = self.cat_right_image
                    if self.cat_direction == 2: #down
                        if self.cat_current_image == self.cat_front_image:
                            newGrid.move(item.position_x, item.position_y, item.position_x, item.position_y + 1)
                            self.cat_busy = False
                        else:
                            self.cat_busy = True
                            self.cat_current_image = self.cat_front_image
                    if self.cat_direction == 3: #left
                        if self.cat_current_image == self.cat_left_image:
                            newGrid.move(item.position_x, item.position_y, item.position_x - 1, item.position_y)
                            self.cat_busy = False
                        else:
                            self.cat_busy = True
                            self.cat_current_image = self.cat_left_image
                    self.cat_last_tick = pygame.time.get_ticks()
                #endregion

                render_x = item.position_x * self.tile_size
                render_y = item.position_y * self.tile_size

                drawer.image(render_x, render_y, self.cat_current_image)

            # TODO act accordingly to other options

    # add new object on grid
    def add(self, newObject: objectOnTile):
        if (
            self.array[newObject.position_x][newObject.position_y].type
            != acceptedType.EMPTY
        ):
            print(
                f"Cannot add object at ({newObject.position_x}, {newObject.position_y}): position already occupied"
            )
            return

        self.array[newObject.position_x][newObject.position_y] = newObject
        self.list.append(newObject)

    # deletes object from game
    # untested, potentially not working
    def delete(self, position_x: int, position_y: int):
        # Find the object with the given position in the list
        for obj in self.list:
            if obj.position_x == position_x and obj.position_y == position_y:
                break

        else:  # No object found with the given position
            print(f"No object found at ({position_x}, {position_y})")
            return

        # Remove the object from both the array and the list
        self.array[position_x][position_y] = objectOnTile(position_x, position_y)
        self.list.remove(obj)

    # move: update position from (start_x, start_y) to (end_x, end_y)
    def move(self, start_x: int, start_y: int, end_x: int, end_y: int):
        # no change
        if start_x == end_x and start_y == end_y:
            return

        # check if obj exist at starting position
        if self.array[start_x][start_y].type == acceptedType.EMPTY:
            print(
                f"Cannot move object at ({start_x}, {start_y}): no object on position"
            )
            return

        # check if destination is empty
        if self.array[end_x][end_y].type != acceptedType.EMPTY:
            print(
                f"Cannot move object to ({end_x}, {end_y}): position already occupied"
            )
            return

        # all OK
        # change position attribute in array
        self.array[start_x][start_y].position_x = end_x
        self.array[start_x][start_y].position_y = end_y

        # change position in array
        self.array[end_x][end_y] = self.array[start_x][start_y]
        self.array[start_x][start_y] = objectOnTile(start_x, start_y)

    def findFirst(self, find_type: acceptedType) -> objectOnTile:
        for item in self.list:
            if item.type == find_type:
                return item
        else:
            print(f"Cannot find object of type: ({find_type})!")