173 lines
5.5 KiB
Python
173 lines
5.5 KiB
Python
#!/usr/bin/python3
|
|
import copy
|
|
import random
|
|
from queue import Queue, PriorityQueue
|
|
from threading import Event
|
|
|
|
import pygame
|
|
|
|
from config import *
|
|
from app.cmd_parser import Arg
|
|
from app.graphsearch import Node
|
|
from app.board import Board
|
|
from app.tractor import Tractor
|
|
from app.a_star import AStar
|
|
from app.bfs import Bfs
|
|
|
|
|
|
class App:
|
|
def __init__(self, args: list[Arg]):
|
|
self.__running = True
|
|
self.__screen = None
|
|
self.__clock = None
|
|
self.__board = Board(args=args)
|
|
self.__tractor = Tractor(self.__board)
|
|
self.__bot_is_running = Event()
|
|
self.__moves = None
|
|
self.__auto_mode = self.get_auto_mode_arg(args)
|
|
|
|
def get_auto_mode_arg(self, args: list[Arg]):
|
|
for arg in args:
|
|
if arg.get_arg_name() == AUTO_MODE:
|
|
return True
|
|
return False
|
|
|
|
def initialize(self):
|
|
pygame.init()
|
|
pygame.display.set_caption(CAPTION)
|
|
self.__screen = pygame.display.set_mode((WIDTH, HEIGHT))
|
|
|
|
self.__clock = pygame.time.Clock()
|
|
|
|
def event_handler(self, event: pygame.event.Event):
|
|
if event.type == pygame.QUIT:
|
|
self.__running = False
|
|
|
|
def loop_handler(self):
|
|
self.__board.draw(self.__screen)
|
|
self.__tractor.draw(self.__screen)
|
|
|
|
def keys_pressed_handler(self):
|
|
keys = pygame.key.get_pressed()
|
|
|
|
if keys[pygame.K_w]:
|
|
self.__tractor.move()
|
|
print(self.__tractor)
|
|
|
|
if keys[pygame.K_n]:
|
|
self.__bot_is_running.set()
|
|
self.__tractor.harvest_checked_fields_handler(self.__bot_is_running)
|
|
|
|
if keys[pygame.K_h]:
|
|
self.__tractor.harvest()
|
|
|
|
if keys[pygame.K_v]:
|
|
self.__tractor.sow()
|
|
|
|
if keys[pygame.K_j]:
|
|
self.__tractor.hydrate()
|
|
|
|
if keys[pygame.K_f]:
|
|
self.__tractor.fertilize()
|
|
|
|
if keys[pygame.K_l]:
|
|
self.__tractor.rotate_left()
|
|
|
|
if keys[pygame.K_r]:
|
|
self.__tractor.rotate_right()
|
|
|
|
if keys[pygame.K_b]:
|
|
self.get_moves_by_bfs()
|
|
if not self.__moves:
|
|
print(f"Bfs is failed")
|
|
else:
|
|
print(f"Bfs is succeed")
|
|
self.__bot_is_running.set()
|
|
self.__tractor.run_bot_handler(self.__moves, self.__bot_is_running)
|
|
|
|
if keys[pygame.K_c]:
|
|
self.get_moves_by_a_star_with_random_coords()
|
|
if not self.__moves:
|
|
print(f"A Star is failed")
|
|
else:
|
|
print(f"A Star is succeed")
|
|
self.__bot_is_running.set()
|
|
self.__tractor.run_bot_handler(self.__moves, self.__bot_is_running)
|
|
|
|
if keys[pygame.K_a]:
|
|
self.auto_moving_mode()
|
|
|
|
def update_screen(self) -> None:
|
|
pygame.display.flip()
|
|
|
|
def quit(self) -> None:
|
|
pygame.quit()
|
|
|
|
def auto_moving_mode(self):
|
|
coords, action = self.get_coords_and_action()
|
|
x, y = self.__tractor.get_position()
|
|
if coords is not None:
|
|
x1, y1 = coords
|
|
else:
|
|
x1, y1 = None, None
|
|
print(action, coords)
|
|
if action != A_DO_NOTHING and x1 == x and y == y1:
|
|
self.__tractor.do_action_on_fields(action)
|
|
elif action == A_DO_NOTHING:
|
|
print(action)
|
|
elif not self.__moves:
|
|
print(f"A Star is failed")
|
|
else:
|
|
print(f"A Star is succeed")
|
|
self.__bot_is_running.set()
|
|
self.__tractor.run_auto_bot_handler(action, self.__moves, self.__bot_is_running)
|
|
|
|
def get_coords_and_action(self) -> tuple[tuple[int, int], str]:
|
|
coords, action = self.__tractor.choose_action()
|
|
if coords is not None:
|
|
self.get_moves_by_a_star(coords)
|
|
else:
|
|
self.__moves = None
|
|
return coords, action[0]
|
|
|
|
def get_moves_by_a_star_with_random_coords(self) -> None:
|
|
x1 = random.randint(0, HORIZONTAL_NUM_OF_FIELDS)
|
|
y1 = random.randint(0, VERTICAL_NUM_OF_FIELDS)
|
|
dest = (x1, y1)
|
|
self.get_moves_by_a_star(dest)
|
|
|
|
def get_moves_by_a_star(self, coords: tuple[int, int]) -> None:
|
|
x, y = self.__tractor.get_position()
|
|
node = Node(None, x, y, self.__tractor.get_direction(), 0, "movement", "initial state")
|
|
board = copy.deepcopy(self.__board)
|
|
self.__moves = AStar.search_solution(PriorityQueue(), Queue(), coords, node,
|
|
lambda n=node, b=board: AStar.succ(n, b),
|
|
lambda d=coords, n=node: AStar.goaltest_by_coords(d, n), board)
|
|
|
|
def get_moves_by_bfs(self) -> None:
|
|
x, y = self.__tractor.get_position()
|
|
node = Node(None, x, y, self.__tractor.get_direction(), 0, "movement", "initial state")
|
|
board = copy.deepcopy(self.__board)
|
|
self.__moves = Bfs.search(Queue(), Queue(), node,
|
|
lambda n=node, b=board: Bfs.succ(n, b),
|
|
lambda n=node: Bfs.goaltest(n), board)
|
|
|
|
def run(self) -> None:
|
|
self.initialize()
|
|
|
|
while self.__running:
|
|
self.__clock.tick(FPS)
|
|
|
|
for event in pygame.event.get():
|
|
self.event_handler(event)
|
|
|
|
if not self.__bot_is_running.is_set() and not self.__auto_mode:
|
|
self.keys_pressed_handler()
|
|
if not self.__bot_is_running.is_set() and self.__auto_mode:
|
|
self.auto_moving_mode()
|
|
|
|
self.loop_handler()
|
|
self.update_screen()
|
|
|
|
self.quit()
|