Sztuczna_Inteligencja-projekt/basic_grid.py

# Import the pygame module
import pygame

# Import pygame.locals for easier access to key coordinates
from pygame.locals import (
    K_UP,
    K_LEFT,
    K_RIGHT,
    K_ESCAPE,
    KEYDOWN,
    QUIT
)

# Import other files from project
import field as F
import tractor as T
import plant as P
import colors as C
import dimensions as D
import node as N
import mapschema as maps

# Initialize pygame
pygame.init()

# Name the window
pygame.display.set_caption("Inteligentny Traktor")

# Create the screen object
# The size is determined by the constant SCREEN_WIDTH and SCREEN_HEIGHT
screen = pygame.display.set_mode((D.SCREEN_WIDTH, D.SCREEN_HEIGHT))

# Define the map of the field
mapschema = maps.createField()

# Create field array
field = []

# Populate the field array
for row in range(D.GSIZE):
    field.append([])
    for column in range(D.GSIZE):
        fieldbit = F.Field(row, column, mapschema[column][row])
        field[row].append(fieldbit)

# Create Tractor object
tractor = T.Tractor(field, [0,0])

# Define the map of plants
mapschema = maps.createPlants()

# Createt plants array
plants = []

# Populate the plants array
for row in range(D.GSIZE):
    plants.append([])
    for column in range(D.GSIZE):
        if mapschema[column][row] != 0:
            plantbit = P.Plant(field[row][column], mapschema[column][row])
            plants[row].append(plantbit)

# Create list for tractor instructions
path = []

# Variable to keep the main loop running
RUNNING = True

# Variable conroling timed eventes
TICKER = 0

# Initialize clock
clock = pygame.time.Clock()


# Main loop
while RUNNING:

    # Look at every event in the queue
    for event in pygame.event.get():
        # Did the user hit a key?
        if event.type == KEYDOWN:
            # Was it the Escape key? If so, stop the loop.
            if event.key == K_ESCAPE:
                RUNNING = False
        # Did the user click the window close button? If so, stop the loop.
        elif event.type == QUIT:
            RUNNING = False

    # Create key Node that will be used to calculate tractor instructions
    processor = N.Node(field, tractor.position, tractor.direction)

    # If path is empty or nonexistent, create new one
    if path is None or len(path) == 0:
        path = processor.findPathToPlant()

    # control tractor by poping instructions from path list
    if path is not None:
        if path[0] == "move":
            tractor.move()
            path.pop(0)
        elif path[0] =="left":
            tractor.rotate_left()
            path.pop(0)
        elif path[0] == "right":
            tractor.rotate_right()
            path.pop(0)
        elif path[0] == "hydrate":
            tractor.hydrate(field)
            path.pop(0)
        else:
            path.pop(0)

    # Get all keys pressed at a time CURRENTLY UNUSED
    pressed_keys = pygame.key.get_pressed()
    
    # control tractor with pressed keys CURRENTLY UNUSED
    if pressed_keys[K_UP]:
        tractor.move()
    elif pressed_keys[K_LEFT]:
        tractor.rotate_left()
    elif pressed_keys[K_RIGHT]:
        tractor.rotate_right()

    # Set the screen background
    screen.fill(C.DBROWN)

    # Draw the field
    for row in range(D.GSIZE):
        for column in range(D.GSIZE):
            screen.blit(field[row][column].surf, field[row][column].rect)

    # Draw the tactor
    screen.blit(tractor.surf, tractor.rect)

    # Plants grow with every 10th tick, then they are drawn
    for row in plants:
        for plant in row:
            plant.tick()
            plant.grow()
            screen.blit(plant.surf, plant.rect)
    
    # Field are drying with every 100th tick
    if TICKER == 0:
        for row in range(D.GSIZE):
            for column in range(D.GSIZE):
                field[row][column].dehydrate()

    # Increment ticker 
    TICKER = (TICKER + 1)%100

    # Update the screen
    pygame.display.flip()

    # Ensure program maintains a stable framerate
    clock.tick(8)