391 lines
18 KiB
Python
391 lines
18 KiB
Python
import math
|
|
import random
|
|
import time
|
|
import pygame
|
|
import agent
|
|
import astar
|
|
import common
|
|
import field
|
|
import settings
|
|
|
|
possibleFields = {
|
|
'dirt': field.Dirt(),
|
|
'grass': field.Grass(),
|
|
'cobble': field.Cobble(),
|
|
'sand': field.Sand(),
|
|
'station': field.Station(),
|
|
'carrot_empty': field.Carrot_empty(),
|
|
'carrot_sow': field.Carrot_sow(),
|
|
'carrot_watered': field.Carrot_watered(),
|
|
'carrot_feritized': field.Carrot_feritized(),
|
|
'potato_empty': field.Potato_empty(),
|
|
'potato_sow': field.Potato_sow(),
|
|
'potato_watered': field.Potato_watered(),
|
|
'potato_feritized': field.Potato_feritized(),
|
|
'wheat_empty': field.Wheat_empty(),
|
|
'wheat_sow': field.Wheat_sow(),
|
|
'wheat_watered': field.Wheat_watered(),
|
|
'wheat_feritized': field.Wheat_feritized()
|
|
}
|
|
|
|
possibleFieldsWithPlants = [
|
|
'carrot_empty',
|
|
'carrot_sow',
|
|
'carrot_watered',
|
|
'carrot_feritized',
|
|
'potato_empty',
|
|
'potato_sow',
|
|
'potato_watered',
|
|
'potato_feritized',
|
|
'wheat_empty',
|
|
'wheat_sow',
|
|
'wheat_watered',
|
|
'wheat_feritized'
|
|
]
|
|
|
|
|
|
def randomize_map():
|
|
fields_array = []
|
|
for i in possibleFields:
|
|
fields_array.append(possibleFields[i].tile.object)
|
|
field_array_big = []
|
|
field_array_small = []
|
|
field_array_big_2 = []
|
|
field_array_big_3 = []
|
|
field_array_small_2 = []
|
|
field_array_small_3 = []
|
|
width = settings.Field.horizontal_count()
|
|
height = settings.Field.vertical_count()
|
|
for i in range(width):
|
|
for j in range(height):
|
|
# k = random.choice(list(possibleFields.keys()))
|
|
x = random.uniform(0, 100)
|
|
if x <= 80:
|
|
plant = random.choice(possibleFieldsWithPlants)
|
|
field_array_small.append(possibleFields[plant].tile.object)
|
|
field_array_small_2.append('dirt')
|
|
field_array_small_3.append(plant)
|
|
elif 80 < x <= 90:
|
|
field_array_small.append(possibleFields['sand'].tile.object)
|
|
field_array_small_2.append('sand')
|
|
field_array_small_3.append('sand')
|
|
elif 90 < x <= 100:
|
|
field_array_small.append(possibleFields['grass'].tile.object)
|
|
field_array_small_2.append('grass')
|
|
field_array_small_3.append('grass')
|
|
field_array_big.append(field_array_small)
|
|
field_array_big_2.append(field_array_small_2)
|
|
field_array_big_3.append(field_array_small_3)
|
|
field_array_small = []
|
|
field_array_small_2 = []
|
|
field_array_small_3 = []
|
|
|
|
for i in range(height):
|
|
field_array_big[math.floor(width / 2)][i] = possibleFields['cobble'].tile.object
|
|
field_array_big_2[math.floor(width / 2)][i] = 'cobble'
|
|
field_array_big_3[math.floor(width / 2)][i] = 'cobble'
|
|
for i in range(width):
|
|
field_array_big[i][math.floor(height / 2)] = possibleFields['cobble'].tile.object
|
|
field_array_big_2[i][math.floor(height / 2)] = 'cobble'
|
|
field_array_big_3[i][math.floor(height / 2)] = 'cobble'
|
|
field_array_big[0][0] = possibleFields['station'].tile.object
|
|
field_array_big_2[0][0] = 'station'
|
|
field_array_big_3[0][0] = 'station'
|
|
return field_array_big, field_array_big_2, field_array_big_3
|
|
|
|
|
|
def read_img(agent, fields):
|
|
window = common.get('window')
|
|
current_field = fields[agent.x()][agent.y()]
|
|
if current_field == possibleFields['grass'].tile.object:
|
|
window.blit(possibleFields['grass'].block.object, (0, 0))
|
|
elif current_field == possibleFields['dirt'].tile.object:
|
|
window.blit(possibleFields['dirt'].block.object, (0, 0))
|
|
elif current_field == possibleFields['sand'].tile.object:
|
|
window.blit(possibleFields['sand'].block.object, (0, 0))
|
|
elif current_field == possibleFields['cobble'].tile.object:
|
|
window.blit(possibleFields['cobble'].block.object, (0, 0))
|
|
elif current_field == possibleFields['station'].tile.object:
|
|
window.blit(possibleFields['station'].block.object, (0, 0))
|
|
|
|
pygame.display.update()
|
|
pygame.time.delay(2000)
|
|
common.set('state_imgShown', False)
|
|
|
|
|
|
def agent_action(action: str):
|
|
if action == 'open_window':
|
|
common.set('state_imgShown', True)
|
|
|
|
|
|
def draw_window(agent, fields):
|
|
window = common.get('window')
|
|
rect = agent.rect
|
|
for i in range(settings.Field.horizontal_count()):
|
|
for j in range(settings.Field.vertical_count()):
|
|
window.blit(fields[i][j], (i * settings.Field.size(), j * settings.Field.size()))
|
|
if agent.direction == 2:
|
|
AGENT_IMG = pygame.image.load('./assets/tracktor/tractor_east.png')
|
|
AGENT = pygame.transform.scale(AGENT_IMG, (settings.Field.size(), settings.Field.size()))
|
|
window.blit(AGENT, (rect.x, rect.y))
|
|
elif agent.direction == 4:
|
|
AGENT_IMG = pygame.image.load('./assets/tracktor/tractor_west.png')
|
|
AGENT = pygame.transform.scale(AGENT_IMG, (settings.Field.size(), settings.Field.size()))
|
|
window.blit(AGENT, (rect.x, rect.y))
|
|
elif agent.direction == 1:
|
|
AGENT_IMG = pygame.image.load('./assets/tracktor/tractor_north.png')
|
|
AGENT = pygame.transform.scale(AGENT_IMG, (settings.Field.size(), settings.Field.size()))
|
|
window.blit(AGENT, (rect.x, rect.y))
|
|
elif agent.direction == 3:
|
|
AGENT_IMG = pygame.image.load('./assets/tracktor/tractor_south.png')
|
|
AGENT = pygame.transform.scale(AGENT_IMG, (settings.Field.size(), settings.Field.size()))
|
|
window.blit(AGENT, (rect.x, rect.y))
|
|
pygame.display.update()
|
|
|
|
|
|
def generate_movement(fields_for_astar, fields_with_plants, fields_for_movement, agent):
|
|
fields_to_sow = []
|
|
fields_to_water = []
|
|
fields_to_feritize = []
|
|
fields_to_harvest = []
|
|
width = settings.Field.horizontal_count()
|
|
height = settings.Field.vertical_count()
|
|
k = 0
|
|
for i in range(width):
|
|
for j in range(height):
|
|
if fields_with_plants[i][j] == 'potato_empty' or fields_with_plants[i][j] == 'carrot_empty' or \
|
|
fields_with_plants[i][j] == 'wheat_empty':
|
|
tab = [i, j]
|
|
fields_to_sow.append(tab)
|
|
elif fields_with_plants[i][j] == 'potato_sow' or fields_with_plants[i][j] == 'carrot_sow' or \
|
|
fields_with_plants[i][j] == 'wheat_sow':
|
|
tab = [i, j]
|
|
fields_to_water.append(tab)
|
|
elif fields_with_plants[i][j] == 'potato_watered' or fields_with_plants[i][j] == 'carrot_watered' or \
|
|
fields_with_plants[i][j] == 'wheat_watered':
|
|
tab = [i, j]
|
|
fields_to_feritize.append(tab)
|
|
elif fields_with_plants[i][j] == 'potato_feritized' or fields_with_plants[i][j] == 'carrot_feritized' or \
|
|
fields_with_plants[i][j] == 'wheat_feritized':
|
|
tab = [i, j]
|
|
fields_to_harvest.append(tab)
|
|
while True:
|
|
decision = False # tu będzie wywołanie drzewa decyzyjnego (powrot do bazy)
|
|
cords = agent.coordinates()
|
|
x = cords['x']
|
|
y = cords['y']
|
|
dir = agent.get_direction()
|
|
if k == 0 and len(fields_to_harvest) > 0 and decision == False: # harvest
|
|
field_to_visit, l = get_closest_field(fields_to_harvest, x, y, dir, fields_for_astar)
|
|
x1, y1 = field_to_visit[0], field_to_visit[1]
|
|
del fields_to_harvest[l]
|
|
if fields_with_plants[x1][y1] == 'wheat_feritized':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_sow.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'wheat_empty'
|
|
fields_for_movement[x1][y1] = possibleFields['wheat_empty'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
elif fields_with_plants[x1][y1] == 'carrot_feritized':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_sow.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'carrot_empty'
|
|
fields_for_movement[x1][y1] = possibleFields['carrot_empty'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
elif fields_with_plants[x1][y1] == 'potato_feritized':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_sow.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'potato_empty'
|
|
fields_for_movement[x1][y1] = possibleFields['potato_empty'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
if len(fields_to_harvest) == 0:
|
|
k += 1
|
|
elif k == 1 and len(fields_to_water) > 0 and decision == False: # water
|
|
field_to_visit, l = get_closest_field(fields_to_water, x, y, dir, fields_for_astar)
|
|
del fields_to_water[l]
|
|
x1, y1 = field_to_visit[0], field_to_visit[1]
|
|
if fields_with_plants[x1][y1] == 'wheat_sow':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_feritize.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'wheat_watered'
|
|
fields_for_movement[x1][y1] = possibleFields['wheat_watered'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
elif fields_with_plants[x1][y1] == 'carrot_sow':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_feritize.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'carrot_watered'
|
|
fields_for_movement[x1][y1] = possibleFields['carrot_watered'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
elif fields_with_plants[x1][y1] == 'potato_sow':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_feritize.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'potato_watered'
|
|
fields_for_movement[x1][y1] = possibleFields['potato_watered'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
if len(fields_to_water) == 0:
|
|
k += 1
|
|
elif k == 2 and len(fields_to_feritize) > 0 and decision == False: # feritize
|
|
field_to_visit, l = get_closest_field(fields_to_feritize, x, y, dir, fields_for_astar)
|
|
del fields_to_feritize[l]
|
|
x1, y1 = field_to_visit[0], field_to_visit[1]
|
|
if fields_with_plants[x1][y1] == 'wheat_watered':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_harvest.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'wheat_feritized'
|
|
fields_for_movement[x1][y1] = possibleFields['wheat_feritized'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
elif fields_with_plants[x1][y1] == 'carrot_watered':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_harvest.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'carrot_feritized'
|
|
fields_for_movement[x1][y1] = possibleFields['carrot_feritized'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
elif fields_with_plants[x1][y1] == 'potato_watered':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_harvest.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'potato_feritized'
|
|
fields_for_movement[x1][y1] = possibleFields['potato_feritized'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
if len(fields_to_feritize) == 0:
|
|
k += 1
|
|
elif k == 3 and len(fields_to_sow) > 0 and decision == False: # sow
|
|
field_to_visit, l = get_closest_field(fields_to_sow, x, y, dir, fields_for_astar)
|
|
del fields_to_sow[l]
|
|
x1, y1 = field_to_visit[0], field_to_visit[1]
|
|
if fields_with_plants[x1][y1] == 'wheat_empty':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_water.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'wheat_sow'
|
|
fields_for_movement[x1][y1] = possibleFields['wheat_sow'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
elif fields_with_plants[x1][y1] == 'carrot_empty':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_water.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'carrot_sow'
|
|
fields_for_movement[x1][y1] = possibleFields['carrot_sow'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
elif fields_with_plants[x1][y1] == 'potato_empty':
|
|
state = astar.State(dir, x, y)
|
|
move_list = (
|
|
astar.graphsearch([], astar.f, [], [field_to_visit[0], field_to_visit[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
agent_movement(move_list, agent, fields_for_movement, fields_for_astar)
|
|
fields_to_water.append(field_to_visit)
|
|
fields_with_plants[x1][y1] = 'potato_sow'
|
|
fields_for_movement[x1][y1] = possibleFields['potato_sow'].tile.object
|
|
draw_window(agent, fields_for_movement)
|
|
if len(fields_to_sow) == 0:
|
|
k = 0
|
|
|
|
|
|
|
|
|
|
def get_closest_field(fields_to_visit, x, y, dir, fields_for_astar):
|
|
j = 0
|
|
closest_field = fields_to_visit[0]
|
|
state = astar.State(dir, x, y)
|
|
move_list_prev = (astar.graphsearch([], astar.f, [], [closest_field[0], closest_field[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
for i in range(1, len(fields_to_visit)):
|
|
curr_field = fields_to_visit[i]
|
|
state = astar.State(dir, x, y)
|
|
move_list = (astar.graphsearch([], astar.f, [], [curr_field[0], curr_field[1]], state, fields_for_astar,
|
|
astar.succ))
|
|
if len(move_list) < len(move_list_prev):
|
|
closest_field = curr_field
|
|
move_list_prev = move_list
|
|
j = i
|
|
return closest_field, j
|
|
|
|
|
|
def agent_movement(move_list, agent, fields, fields_2):
|
|
for action in move_list:
|
|
if action == 'l' or action == 'r':
|
|
agent_action(agent.rotate(action))
|
|
elif action == 'f':
|
|
agent_action(agent.move(action))
|
|
draw_window(agent, fields)
|
|
time.sleep(0.5)
|
|
|
|
|
|
common = common.Instance()
|
|
agent = agent.Instance(1500, 2, 50, 50, 50, 0, 0, 0)
|
|
|
|
|
|
def main():
|
|
common.set('game_running', True)
|
|
common.set('state_imgShown', False)
|
|
common.set(
|
|
'window',
|
|
pygame.display.set_mode((
|
|
settings.Pygame.width(),
|
|
settings.Pygame.height())))
|
|
|
|
pygame.display.set_caption(settings.Pygame.display_name())
|
|
fields, fields_2, fields_3 = randomize_map()
|
|
x = True
|
|
while common.get('game_running'):
|
|
pygame.time.Clock().tick(settings.Pygame.fps())
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.QUIT:
|
|
common.set('game_running', False)
|
|
if common.get('state_imgShown'):
|
|
read_img(agent, fields)
|
|
else:
|
|
draw_window(agent, fields)
|
|
if x:
|
|
generate_movement(fields_2, fields_3, fields, agent)
|
|
x = False
|
|
|
|
agent_action(agent.rotate(None))
|
|
agent_action(agent.move(None))
|
|
|
|
pygame.quit()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|