s452652/inteligentny-traktor
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Breadth-First Search

Browse Source 
Strategie przeszukiwania 1b
This commit is contained in:
Aga 2023-04-27 15:56:10 +02:00
parent 3569f7e739
commit f5fa862365
5 changed files with 433 additions and 356 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
bfs.py Normal file
View File

@ -0,0 +1,45 @@
class BFS:
# Finds a suitable path from point A to point B using Breadth-First-Search Algorithm
def __init__(self, graph, start, goal):
self.graph = graph
self.start = start
self.goal = goal
def solve(self):
print('Start\n\n')
print(self.graph)
print('\n\n')
# keep track of explored nodes
explored = []
# keep track of all paths to be checked
queue = [[self.start]]
# return path if start is goal
if self.start == self.goal:
return 'That was easy. Start == Goal'
# keep looping until all possible paths are explored
while queue:
# pop the first path from the queue
path = queue.pop(0)
# get the last node from the path
node = path[-1]
if node not in explored:
neighbors = self.graph[node]
# go through all neighbor nodes
# push it into the queue
for neighbor in neighbors:
new_path = list(path)
new_path.append(neighbor)
queue.append(new_path)
if neighbor == self.goal:
return new_path
# mark node as explored
explored.append(node)
# in case there is no path
return "path not accessible"

71
board.py Normal file
View File

@ -0,0 +1,71 @@
import pygame
from screen import SCREEN
global BLACK
# global SCREEN
global BLACK
global gridObjects
global imgTree
global imgTree
imgTree = pygame.image.load('img/tree.png')
gridObjects = {} # Store grid-box objects from Grid Class
class Grid(object):
# ta klasa rysuje kratę na ekranie
def __init__(self, x, y, sx, sy):
self.x = x
self.y = y
self.sx = sx
self.sy = sy
self.width = 1
def draw(self):
# global SCREEN
global BLACK
# SCREEN = pygame.display.set_mode([600,650])
BLACK = (0, 0, 0)
pygame.draw.rect(SCREEN, BLACK, (self.x, self.y, self.sx, self.sy), self.width)
class Box(object):
# global SCREEN
def __init__(self, x, y, sx, sy, color):
self.x = x
self.y = y
self.sx = sx
self.sy = sy
self.color = color
def draw(self):
# global SCREEN
# SCREEN = pygame.display.set_mode([600,650])
# global BLACK
pygame.draw.rect(SCREEN, self.color, pygame.Rect(self.x, self.y, self.sx, self.sy))
class Obstacle(object):
def __init__(self, mouseObj):
self.mseX = mouseObj[0]
self.mseY = mouseObj[1]
for grid in gridObjects:
g = getGridBoxes(grid)
self.x = g.x
self.y = g.y
self.sx = g.sx
self.sy = g.sy
if self.mseX > self.x and self.mseX < self.x + self.sx:
if self.mseY > self.y and self.mseY < self.y + self.sy:
self.posX = self.x
self.posY = self.y
self.gridBox = grid
def draw(self):
# pygame.draw.rect(SCREEN, GREY, pygame.Rect(self.posX, self.posY, self.sx, self.sy))
global imgTree
SCREEN.blit(imgTree, (self.posX, self.posY))
# pygame.display.update()
def getGridBoxes(grid_box):
global gridObjects
return gridObjects[grid_box]

24
classes.py Normal file
View File

@ -0,0 +1,24 @@
class Field:
def __init__(self, fieldType, plantType, isWet, wetTime, isFertilized, fertilizedTime):
self.fieldType =fieldType # good/bad
self.plantType =plantType # wheat/carrot/cabbage
self.isWet =isWet # yes/no
self.wetTime =wetTime # number
self.isFertilized =isFertilized # yes/no
self.fertilizedTime =fertilizedTime # number
class Plant:
def __init__(self, plantType, growthState):
self.plantType = plantType # wheat/carrot/cabbage
self.growthState = growthState # growing/grown
class Fertilizer:
def __init__(self, fertilizerType):
self.fertilizerType = fertilizerType # wheat/carrot/cabbage
class Player:
x = 0
y = 0
rotation = 0

647
main.py
View File

@ -1,135 +1,49 @@
import pygame import pygame
pygame.init() from classes import Field, Plant, Fertilizer, Player
from bfs import BFS
from board import Grid, Box, Obstacle, getGridBoxes, gridObjects
from screen import SCREEN
# pygame.init()
# Game Constants # Game Constants
Ucelu = False Ucelu = False
SCREENX = 500 SCREENX = 500
SCREENY = 500 SCREENY = 500
# SCREEN = pygame.display.set_mode([600, 600]) pygame.display.set_caption('Inteligentny Traktor')
# screen = pygame.display.set_mode((SCREENX, SCREENY))
SCREEN = pygame.display.set_mode([600,650])
pygame.display.set_caption('Inteligenty Traktor')
# COLORS # COLORS
WHITE = (255, 255, 255) WHITE = (255, 255, 255)
BLACK = (0, 0, 0) BLACK = (0, 0, 0)
RED = (255, 0, 0) RED = (255, 0, 0)
GREEN = (0, 255, 0, 0) GREEN = (0, 255, 0, 0)
BLUE = (0, 0, 255) BLUE = (0, 0, 255, 0)
GREY = (128, 128, 128) GREY = (128, 128, 128)
CLOCK = pygame.time.Clock() CLOCK = pygame.time.Clock()
FPS = 300 FPS = 30
DELAY = 100 DELAY = 300
# np. 10 pól x 10 pól = 100 pól
GRIDX = 10 GRIDX = 10
GRIDY = 10 GRIDY = 10
obstacleObjects = {} # Store the obstacle objects (Blocks on the path) from Obstacle class obstacleObjects = {} # Store the obstacle objects (Blocks on the path) from Obstacle class
gridObjects = {} # Store grid-box objects from Grid Class # global gridObjects
# gridObjects = {} # Store grid-box objects from Grid Class
gridObstacle = {} # Store the grid:obstacle pair stuck together gridObstacle = {} # Store the grid:obstacle pair stuck together
boxObjects = {} boxObjects = {}
boxes = 1 boxes = 1
obstacles = 1 obstacles = 1
# BFS Variables # BFS Variables
startNode = 0 startNode = 0
goalNode = 0 goalNode = 0
graph = dict() graph = dict()
pathFound = [] # Store the path in a list box index to draw on later pathFound = [] # Store the path in a list box index to draw on later
class BFS:
# Finds a suitable path from point A to point B using Breadth-First-Search Algorithm
def __init__(self, graph, start, goal):
self.graph = graph
self.start = start
self.goal = goal
def solve(self):
print('Start\n\n')
print(self.graph)
print('\n\n')
# keep track of explored nodes
explored = []
# keep track of all paths to be checked
queue = [[self.start]]
# return path if start is goal
if self.start == self.goal:
return 'That was easy. Start == Goal'
# keep looping until all possible paths are explored
while queue:
# pop the first path from the queue
path = queue.pop(0)
# get the last node from the path
node = path[-1]
if node not in explored:
neighbors = self.graph[node]
# go through all neighbor nodes
# push it into the queue
for neighbor in neighbors:
new_path = list(path)
new_path.append(neighbor)
queue.append(new_path)
if neighbor == self.goal:
return new_path
# mark node as explored
explored.append(node)
# in case there is no path
return "path not accessible"
class Grid(object):
def __init__(self, x, y, sx, sy):
self.x = x
self.y = y
self.sx = sx
self.sy = sy
self.width = 1
def draw(self):
pygame.draw.rect(SCREEN, BLACK, (self.x, self.y, self.sx, self.sy), self.width)
class Box(object):
def __init__(self, x, y, sx, sy, color):
self.x = x
self.y = y
self.sx = sx
self.sy = sy
self.color = color
def draw(self):
pygame.draw.rect(SCREEN, self.color, pygame.Rect(self.x, self.y, self.sx, self.sy))
class Obstacle(object):
def __init__(self, mouseObj):
self.mseX = mouseObj[0]
self.mseY = mouseObj[1]
for grid in gridObjects:
g = getGridBoxes(grid)
self.x = g.x
self.y = g.y
self.sx = g.sx
self.sy = g.sy
if self.mseX > self.x and self.mseX < self.x + self.sx:
if self.mseY > self.y and self.mseY < self.y + self.sy:
self.posX = self.x
self.posY = self.y
self.gridBox = grid
def draw(self):
# pygame.draw.rect(SCREEN, GREY, pygame.Rect(self.posX, self.posY, self.sx, self.sy))
SCREEN.blit(imgTree, (self.posX, self.posY))
def getGridBoxes(grid_box):
return gridObjects[grid_box]
def drawGrid(sizex,sizey): def drawGrid(sizex,sizey):
spaceX = SCREENX // sizex spaceX = SCREENX // sizex
spaceY = SCREENY // sizey spaceY = SCREENY // sizey
@ -156,18 +70,18 @@ def generateGraph(row,col):
miniG = {} miniG = {}
for grid in range(len(gridObjects)): for grid in range(len(gridObjects)):
grid += 1 # Synchronize index grid += 1 # Synchronize index
mod = grid % col # Used to check the Top and Bottom Grid Boxes! mod = grid % col # Used to check the Top and Bottom Grid Boxes
gN = grid - 1 gN = grid - 1
gS = grid + 1 gS = grid + 1
gE = grid + col gE = grid + col
gW = grid - col gW = grid - col
# CHECK THE NEIGHBORS TO THE GRID-BOXES, ACCOUNTING FOR THE EXTREME GRID-BOXES(BORDERS) # CHECK THE NEIGHBORS TO THE GRID-BOXES, ACCOUNTING FOR THE EXTREME GRID-BOXES(BORDERS)
if mod == 0: # 5,10,15,20,25 - You can't go south from here (Bottom Boxes) if mod == 0: # 5,10,15,20,25 - You can't go south from here (Bottom Boxes)
if grid > col: # Away from the Left Border of the Screen if grid > col: # Away from the Left Border of the Screen
if grid > (col*row)-col: # You are on the Right Border of the screen - You can't go East if grid > (col*row)-col: # You are on the Right Border of the screen - You can't go East
miniG[grid] = [gN, gW] miniG[grid] = [gN, gW]
miniG[grid] = [gN, gW]
else: # Away from the Right Border of the Screen - You can go East else: # Away from the Right Border of the Screen - You can go East
miniG[grid] = [gN, gE, gW] miniG[grid] = [gN, gE, gW]
else: # You are on the Left Edge of the screen - You can't go West else: # You are on the Left Edge of the screen - You can't go West
@ -191,7 +105,6 @@ def generateGraph(row,col):
else: # You are on the Left Edge of the screen - You can't go West else: # You are on the Left Edge of the screen - You can't go West
miniG[grid] = [gN, gS, gE] miniG[grid] = [gN, gS, gE]
# FILTER OUT OBSTACLES FROM THE GRAPH # FILTER OUT OBSTACLES FROM THE GRAPH
miniG2 = {} miniG2 = {}
for grid in range(len(gridObjects)): for grid in range(len(gridObjects)):
@ -205,7 +118,6 @@ def generateGraph(row,col):
if neigbor in gridObstacle: if neigbor in gridObstacle:
miniG2[grid].remove(neigbor) miniG2[grid].remove(neigbor)
# Filtering again as the first Filter block didn't clear out everything # Filtering again as the first Filter block didn't clear out everything
# Filtering through the neighbors # Filtering through the neighbors
for grid in miniG2: for grid in miniG2:
@ -213,93 +125,127 @@ def generateGraph(row,col):
if item in gridObstacle: if item in gridObstacle:
miniG2[grid].remove(item) miniG2[grid].remove(item)
return miniG2 return miniG2
def refreshScreen():
#pygame.display.update()
#SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
def drawGraph(pathF, Ucelu): # -----------------------------
i = 0
while i < len(T):
j = 0
while j < len(T[i]):
#color = (255, 255, 255, 0)
if T[i][j].isWet == 0:
# a = 1
color = (160, 80, 40, 0)
else:
# a = 1
color = (50, 25, 0, 0)
#Covers 'player' on the way
pygame.draw.rect(SCREEN, color, pygame.Rect(50 + 50 * i, 50 + 50 * j, 50, 50))
if T[i][j].plantType == 1:
SCREEN.blit(imgWheat, (50 + 50 * i, 50 + 50 * j))
if T[i][j].plantType == 2:
SCREEN.blit(imgCarrot, (50 + 50 * i, 50 + 50 * j))
if T[i][j].plantType == 3:
SCREEN.blit(imgCabbage, (50 + 50 * i, 50 + 50 * j))
if T[i][j].plantType == 4:
SCREEN.blit(imgTree, (50 + 50 * i, 50 + 50 * j))
j = j + 1
i = i + 1
# Render the trees
for obs in obstacleObjects:
obstacleObjects[obs].draw()
for bx in boxObjects:
boxObjects[bx].draw()
i = 0
while i < len(T)+1:
pygame.draw.line(SCREEN, (0, 0, 0), (50 + i * 50, 50), (50 + i * 50, 50 + len(T) * 50), 1)
pygame.draw.line(SCREEN, (0, 0, 0), (50, 50 + i * 50), (50 + len(T) * 50, 50 + i * 50), 1)
i = i + 1
tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
if player.rotation == 180:
tmpImg = pygame.transform.flip(tmpImg, True, True)
tmpImg = pygame.transform.flip(tmpImg, True, False)
#player is seen on the way
SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
# --------------------------------------
# tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
# # if flip:
# # if flip == True:
# if player.rotation == 180:
# tmpImg = pygame.transform.flip(tmpImg, True, True)
# tmpImg = pygame.transform.flip(tmpImg, True, False)
#
# SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
pygame.display.update()
pygame.time.wait(300)
SCREEN.fill((WHITE))
def drawGraph(pathF):
#Draws the path given the path-list #Draws the path given the path-list
global Ucelu
print(pathF) print(pathF)
if Ucelu == False: if Ucelu == False:
for grid in pathF: for grid in pathF:
g = gridObjects[grid] # Get the grid-box object mentioned in the path g = gridObjects[grid] # Get the grid-box object mentioned in the path
x = g.x x = g.x
y = g.y y = g.y
sx = g.sx sx = g.sx
sy = g.sy sy = g.sy
a = 0
# pygame.draw.rect(SCREEN, GREEN, pygame.Rect(x, y, sx, sy)) # pygame.draw.rect(SCREEN, GREEN, pygame.Rect(x, y, sx, sy))
if player.x < (x/50 - 1):
a = 1
if player.x > (x/50 - 1):
a =2
if player.y < (y/50 - 1):
a =3
if player.y > (y/50 - 1):
a =4
if a==1:
# player.x = x/50 - 1
player.rotation = 0
if a==2:
# player.x = x/50 - 1
player.rotation = 180
if a==3:
# player.y = y/50 - 1
player.rotation = 270
if a==4:
# player.y = y/50 - 1
player.rotation = 90
refreshScreen()
#pygame.time.wait(2000)
player.y = y/50 - 1
player.x = x/50 - 1 player.x = x/50 - 1
player.y =y/50 - 1
# ----------------------------- refreshScreen()
i = 0
while i < len(T):
j = 0
while j < len(T[i]):
#color = (255, 255, 255, 0)
if T[i][j].isWet == 0:
# a = 1
color = (160, 80, 40, 0)
else:
# a = 1
color = (50, 25, 0, 0)
#Covers 'player' on the way
pygame.draw.rect(SCREEN, color, pygame.Rect(50 + 50 * i, 50 + 50 * j, 50, 50))
if T[i][j].plantType == 1:
SCREEN.blit(imgWheat, (50 + 50 * i, 50 + 50 * j))
if T[i][j].plantType == 2:
SCREEN.blit(imgCarrot, (50 + 50 * i, 50 + 50 * j))
if T[i][j].plantType == 3:
SCREEN.blit(imgCabbage, (50 + 50 * i, 50 + 50 * j))
if T[i][j].plantType == 4:
SCREEN.blit(imgTree, (50 + 50 * i, 50 + 50 * j))
j = j + 1
i = i + 1
# Render the trees
for obs in obstacleObjects:
obstacleObjects[obs].draw()
for bx in boxObjects:
boxObjects[bx].draw()
i = 0
while i < len(T)+1:
pygame.draw.line(SCREEN, (0, 0, 0), (50 + i * 50, 50), (50 + i * 50, 50 + len(T) * 50), 1)
pygame.draw.line(SCREEN, (0, 0, 0), (50, 50 + i * 50), (50 + len(T) * 50, 50 + i * 50), 1)
i = i + 1
tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
if player.rotation == 180:
tmpImg = pygame.transform.flip(tmpImg, True, True)
tmpImg = pygame.transform.flip(tmpImg, True, False)
#player is seen on the way
SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
# --------------------------------------
# tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
# # if flip:
# # if flip == True:
# if player.rotation == 180:
# tmpImg = pygame.transform.flip(tmpImg, True, True)
# tmpImg = pygame.transform.flip(tmpImg, True, False)
#
# SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
pygame.display.update()
pygame.time.wait(300)
#SCREEN.fill((WHITE))
# pygame.time.wait(50) # pygame.time.wait(50)
# pygame.draw.rect(SCREEN, WHITE, pygame.Rect(x, y, sx, sy)) # pygame.draw.rect(SCREEN, WHITE, pygame.Rect(x, y, sx, sy))
Ucelu = True Ucelu = True
def UIHandler(mouseObj, Ucelu): def UIHandler(mouseObj):
# drawGrid(GRIDX, GRIDY) # drawGrid(GRIDX, GRIDY)
global Ucelu
drawGrid(10,10) drawGrid(10,10)
for grid in gridObjects: for grid in gridObjects:
@ -312,139 +258,171 @@ def UIHandler(mouseObj, Ucelu):
obstacleObjects[obs].draw() obstacleObjects[obs].draw()
if pathFound: if pathFound:
if Ucelu == False: drawGraph(pathFound)
drawGraph(pathFound, Ucelu) # Ucelu = False
Ucelu = True
def eventHandler(kbdObj,mouseObj, Ucelu): def eventHandler(kbdObj,mouseObj):
global boxes global boxes
global obstacles global obstacles
global startNode global startNode
global goalNode global goalNode
global pathFound global pathFound
global Ucelu
if event.type == pygame.QUIT:
exit("Thank you for new plants <3")
# If Key_f is pressed, set goal node if event.type == pygame.KEYDOWN:
if kbdObj[pygame.K_f]:
gBox = getGridBoxes(int(len(gridObjects)))
# gBox = getGridBoxes()
x = mouseObj[0]
y = mouseObj[1]
# x = gBox.x
# y = gBox.y
sx = gBox.sx
sy = gBox.sy
# ----------------------------------------
mseX = mouseObj[0]
mseY = mouseObj[1]
for grid in gridObjects:
g = getGridBoxes(grid)
x = g.x
y = g.y
sx = g.sx
sy = g.sy
if mseX > x and mseX < x + sx:
if mseY > y and mseY < y + sy:
posX = x
posY = y
gridBox = grid
# SCREEN.blit(imgTree, (posX, posY))
# ---------------------------------------
bo = Box(posX, posY, sx, sy, BLUE)
boxObjects[boxes] = bo
# boxes += 1
boxes = 1
# goalNode = GRIDX*GRIDX
# goalNode = (10 * (x + 1) + (y + 1) - 10)
goalNode = (10 * (posX/50 ) + (posY/50) - 10)
# goalNode = (x/sx) * (y/sy)
# Delay to avoid multiple spawning of objects
pygame.time.wait(DELAY)
# If Key_x is pressed, spawn tree
if kbdObj[pygame.K_x]:
obs = Obstacle(mouseObj)
obstacleObjects[obstacles] = obs
# print(obs.gridBox)
obstacles += 1
# print(obstacleObjects)
gridObstacle[obs.gridBox] = obstacles
# Delay to avoid multiple spawning of objects
pygame.time.wait(DELAY) pygame.time.wait(DELAY)
if event.key == pygame.K_LEFT:
if player.x > 0:
player.x = player.x - 1
player.rotation = 180
# if Key_SPACE is pressed, start the magic if event.key == pygame.K_UP:
if kbdObj[pygame.K_SPACE]: if player.y > 0:
gBox = getGridBoxes(1) player.y = player.y - 1
player.rotation = 90
x = gBox.x if event.key == pygame.K_RIGHT:
y = gBox.y if player.x < 9:
sx = gBox.sx player.x = player.x + 1
sy = gBox.sy player.rotation = 0
x = (player.x +1) * 50 if event.key == pygame.K_DOWN:
y = (player.y +1) * 50 if player.y < 9:
player.y = player.y + 1
player.rotation = 270
# tmpImg = pygame.transform.rotate(imgPlayer, player.rotation) #start lewo prawo, naprzód
# SCREEN.blit(tmpImg, (50 + 50 * player.x, 50 + 50 * player.y)) if event.key == pygame.K_a:
# pygame.display.update() player.rotation = (player.rotation + 90) % 360
if event.key == pygame.K_d:
player.rotation = (player.rotation - 90) % 360
if event.key == pygame.K_w:
if player.rotation == 0:
if player.x < 9:
player.x = player.x + 1
if player.rotation == 180:
if player.x > 0:
player.x = player.x - 1
if player.rotation == 270:
if player.y < 9:
player.y = player.y + 1
if player.rotation == 90:
if player.y > 0:
player.y = player.y - 1
#when on it keeps flashing - among others
#bo = Box(x, y, sx, sy, RED)
#boxObjects[boxes] = bo
# boxes += 1
boxes = 1
startNode = (10 * (player.x + 1) + (player.y + 1) - 10)
# startNode = (((player.x + 1)*10 - 9) * (player.y + 1) )
# startNode = 2
# tmpImg = pygame.transform.rotate(imgPlayer, player.rotation) # If Key_f is pressed, set goal node
# SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y)) if kbdObj[pygame.K_f]:
# pygame.display.update() gBox = getGridBoxes(int(len(gridObjects)))
# gBox = getGridBoxes()
# Delay to avoid multiple spawning of objects x = mouseObj[0]
#pygame.time.wait(DELAY) y = mouseObj[1]
# x = gBox.x
# y = gBox.y
sx = gBox.sx
sy = gBox.sy
# ----------------------------------------
mseX = mouseObj[0]
mseY = mouseObj[1]
graph = generateGraph(GRIDY,GRIDX) for grid in gridObjects:
bfs = BFS(graph, startNode, goalNode) g = getGridBoxes(grid)
# print(bfs.solve()) x = g.x
pathFound = bfs.solve() y = g.y
sx = g.sx
sy = g.sy
if mseX > x and mseX < x + sx:
if mseY > y and mseY < y + sy:
posX = x
posY = y
gridBox = grid
# SCREEN.blit(imgTree, (posX, posY))
# ---------------------------------------
bo = Box(posX, posY, sx, sy, BLUE)
boxObjects[boxes] = bo
# boxes += 1
boxes = 1
# goalNode = GRIDX*GRIDX
# goalNode = (10 * (x + 1) + (y + 1) - 10)
goalNode = (10 * (posX/50 ) + (posY/50) - 10)
# pygame.display.update()
# goalNode = (x/sx) * (y/sy)
# Delay to avoid multiple spawning of objects
pygame.time.wait(DELAY)
# If Key_x is pressed, spawn tree
if kbdObj[pygame.K_x]:
obs = Obstacle(mouseObj)
obstacleObjects[obstacles] = obs
# print(obs.gridBox)
obstacles += 1
# print(obstacleObjects)
gridObstacle[obs.gridBox] = obstacles
# Delay to avoid multiple spawning of objects
pygame.display.update()
pygame.time.wait(DELAY)
# if Key_SPACE is pressed, start the magic
if kbdObj[pygame.K_SPACE]:
Ucelu = False
gBox = getGridBoxes(1)
x = gBox.x
y = gBox.y
sx = gBox.sx
sy = gBox.sy
x = (player.x +1) * 50
y = (player.y +1) * 50
# tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
# SCREEN.blit(tmpImg, (50 + 50 * player.x, 50 + 50 * player.y))
# pygame.display.update()
#when on it keeps flashing - among others
#bo = Box(x, y, sx, sy, RED)
#boxObjects[boxes] = bo
# boxes += 1
boxes = 1
startNode = (10 * (player.x + 1) + (player.y + 1) - 10)
# startNode = (((player.x + 1)*10 - 9) * (player.y + 1) )
# startNode = 2
# tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
# SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
# pygame.display.update()
# Delay to avoid multiple spawning of objects
#pygame.time.wait(DELAY)
graph = generateGraph(GRIDY,GRIDX)
if startNode != goalNode:
bfs = BFS(graph, startNode, goalNode)
# print(bfs.solve())
pathFound = bfs.solve()
# else:
# startNode = (10 * (player.x + 1) + (player.y + 1) - 10)
# Ucelu = True
# Delay to avoid multiple spawning of objects
pygame.time.wait(DELAY)
# startNode = goalNode
# Delay to avoid multiple spawning of objects
pygame.time.wait(DELAY)
#With it it keeps going, if without it turns off #With it it keeps going, if without it turns off
Ucelu = False
class Field: # Ucelu = False
def __init__(self, fieldType, plantType, isWet, wetTime, isFertilized, fertilizedTime):
self.fieldType = fieldType # good/bad
self.plantType = plantType # wheat/carrot/cabbage
self.isWet = isWet # yes/no
self.wetTime = wetTime # number
self.isFertilized = isFertilized # yes/no
self.fertilizedTime = fertilizedTime # number
class Plant:
def __init__(self, plantType, growthState):
self.plantType = plantType # wheat/carrot/cabbage
self.growthState = growthState # growing/grown
class Fertilizer:
def __init__(self, fertilizerType):
self.fertilizerType = fertilizerType # wheat/carrot/cabbage
class Player:
x = 0
y = 0
rotation = 0
T = [[Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)], T = [[Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
@ -458,84 +436,39 @@ T = [[Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0
[Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)], [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)],
[Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)]] [Field(1,0,0,0,0,0),Field(0,0,1,0,0,0),Field(1,1,1,0,0,0),Field(1,2,0,0,0,0),Field(0,3,1,0,0,0),Field(0,0,0,0,0,0),Field(0,0,0,0,0,0),Field(1,0,1,0,0,0),Field(1,0,0,0,0,0),Field(1,0,1,0,0,0)]]
#pygame.init()
# =========================================================================================
# main
pygame.init()
player = Player() player = Player()
# player.x = 2
# player.y = 2
#screen = pygame.display.set_mode([600, 600])
running = True running = True
# clock = pygame.time.Clock() # clock = pygame.time.Clock()
SCREEN.fill(WHITE)
SCREEN.fill((WHITE))
while running: while running:
for event in pygame.event.get(): for event in pygame.event.get():
if event.type == pygame.QUIT: kbd = pygame.key.get_pressed()
running = False mse = pygame.mouse.get_pos()
UIHandler(mse)
if event.type == pygame.KEYDOWN: eventHandler(kbd, mse)
if event.key == pygame.K_LEFT:
if player.x > 0:
player.x = player.x - 1
if event.key == pygame.K_UP:
if player.y > 0:
player.y = player.y - 1
if event.key == pygame.K_RIGHT:
if player.x < 9:
player.x = player.x + 1
if event.key == pygame.K_DOWN:
if player.y < 9:
player.y = player.y + 1
# Aga start lewo prawo, naprzód
if event.key == pygame.K_a:
player.rotation = (player.rotation + 90) % 360
if event.key == pygame.K_d:
player.rotation = (player.rotation - 90) % 360
if event.key == pygame.K_w:
if player.rotation == 0:
if player.x < 9:
player.x = player.x + 1
if player.rotation == 180:
if player.x > 0:
player.x = player.x - 1
if player.rotation == 270:
if player.y < 9:
player.y = player.y + 1
if player.rotation == 90:
if player.y > 0:
player.y = player.y - 1
# left, right, forward
# if it's not here, it leaves a trail WELL NOT ANYMORE
#SCREEN.fill((WHITE))
kbd = pygame.key.get_pressed()
# kbd = event.key()
mse = pygame.mouse.get_pos()
# SCREEN.fill((WHITE))
Ucelu = False
UIHandler(mse, Ucelu)
eventHandler(kbd, mse, Ucelu)
pygame.display.update() pygame.display.update()
# CLOCK.tick(FPS) # CLOCK.tick(FPS)
#screen.fill((175, 255, 50, 0)) #screen.fill((175, 255, 50, 0))
#screen.fill((WHITE))
# SCREEN.fill((WHITE))
imgWheat = pygame.image.load('img/wheat.png') imgWheat = pygame.image.load('img/wheat.png')
imgCarrot = pygame.image.load('img/carrot.png') imgCarrot = pygame.image.load('img/carrot.png')
imgCabbage = pygame.image.load('img/cabbage.png') imgCabbage = pygame.image.load('img/cabbage.png')
imgPlayer = pygame.image.load('img/player.png') imgPlayer = pygame.image.load('img/player.png')
global imgTree
imgTree = pygame.image.load('img/tree.png') imgTree = pygame.image.load('img/tree.png')
# pygame.display.update()
i = 0 i = 0
while i < len(T): while i < len(T):
@ -569,6 +502,14 @@ while running:
pygame.draw.line(SCREEN, (0, 0, 0), (50, 50 + i * 50), (50 + len(T) * 50, 50 + i * 50), 1) pygame.draw.line(SCREEN, (0, 0, 0), (50, 50 + i * 50), (50 + len(T) * 50, 50 + i * 50), 1)
i = i + 1 i = i + 1
for obs in obstacleObjects:
obstacleObjects[obs].draw()
if startNode != goalNode:
for bx in boxObjects:
boxObjects[bx].draw()
tmpImg = pygame.transform.rotate(imgPlayer, player.rotation) tmpImg = pygame.transform.rotate(imgPlayer, player.rotation)
if player.rotation == 180: if player.rotation == 180:
tmpImg = pygame.transform.flip(tmpImg, True, True) tmpImg = pygame.transform.flip(tmpImg, True, True)
@ -577,18 +518,12 @@ while running:
#player seen at the beginning #player seen at the beginning
SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y)) SCREEN.blit(tmpImg, (55 + 50 * player.x, 55 + 50 * player.y))
# set Start Node where the Player is located
# gBox = getGridBoxes(1)
# x = gBox.x # if Ucelu == False:
# y = gBox.y # for bx in boxObjects:
# sx = gBox.sx # boxObjects[bx].draw()
# sy = gBox.sy
# bo = Box(x, y, sx, sy, RED)
# boxObjects[boxes] = bo
# boxes += 1
# startNode = 1
# # Delay to avoid multiple spawning of objects
# pygame.time.wait(DELAY)
font = pygame.font.SysFont('comicsans', 18) font = pygame.font.SysFont('comicsans', 18)
label = font.render('f- punkt końcowy, x- drzewa, spacja- uruchomienie', 1, (0, 0, 0)) label = font.render('f- punkt końcowy, x- drzewa, spacja- uruchomienie', 1, (0, 0, 0))

2
screen.py Normal file
View File

@ -0,0 +1,2 @@
import pygame
SCREEN = pygame.display.set_mode([600,650])