600 lines
19 KiB
Python
600 lines
19 KiB
Python
import os
|
|
import random
|
|
import time
|
|
from tkinter import *
|
|
import pandas as pd
|
|
|
|
from bin.Classess.Field import Field
|
|
from bin.Classess.Mine import Mine
|
|
from bin.Classess.Travel import Travel
|
|
from bin.Classess.Player import Player
|
|
import bin.Classess.Node as nd
|
|
import bin.Classess.Travel as tr
|
|
from resources.Globals import *
|
|
from bin.Classess.DecisionTree import DecisionTree
|
|
|
|
# WINDOW_X = 533 + 1200
|
|
# WINDOW_Y = 950
|
|
# FRAME_WIDTH = 533
|
|
# FRAME_HEIGHT = 533
|
|
#
|
|
# # Size of small image
|
|
# IMAGE_SIZE = 50
|
|
#
|
|
# AMOUNT_OF_MINES = 10
|
|
#
|
|
# DELAY_TIME = 0.5
|
|
|
|
# Creating objects
|
|
player = Player()
|
|
field = Field()
|
|
travel = Travel()
|
|
decision_tree = DecisionTree()
|
|
|
|
# Globals
|
|
fringe = []
|
|
explored = []
|
|
action_list = []
|
|
images_coord = []
|
|
|
|
label = None
|
|
|
|
|
|
def Arrow(direction):
|
|
image = ""
|
|
if direction == "north":
|
|
image = player.arrow_north_image
|
|
elif direction == "south":
|
|
image = player.arrow_south_image
|
|
elif direction == "west":
|
|
image = player.arrow_west_image
|
|
elif direction == "east":
|
|
image = player.arrow_east_image
|
|
|
|
field.small_field_canvas.itemconfig(player.image_canvas_id, image=image)
|
|
|
|
|
|
# Putting images
|
|
def Fill(bool):
|
|
global images_coord
|
|
if bool:
|
|
field.PuttingSmallImages()
|
|
|
|
travel.points_coord.append(field.small_field_canvas.coords(field.canvas_small_images[0]))
|
|
travel.points_coord.extend(field.mines_coord)
|
|
|
|
for i in range(0, len(travel.points_coord)):
|
|
travel.points_map[i + 1] = travel.points_coord[i]
|
|
|
|
print(travel.points_map)
|
|
|
|
for i in range(0, len(field.canvas_small_images)):
|
|
images_coord.append(field.small_field_canvas.coords(field.canvas_small_images[i]))
|
|
# print("Coords List: ", images_coord)
|
|
|
|
nd.init_data(images_coord, field.cell_expense)
|
|
|
|
# # Drawing red/green rectangles
|
|
# for el in field.state_of_cell_array:
|
|
# if el[0] != 0:
|
|
# field.small_field_canvas.create_rectangle(el[0], el[1], el[0] + player.step - 2,
|
|
# el[1] + player.step - 2, width=3, outline=el[2])
|
|
|
|
DrawingLargeImage()
|
|
|
|
|
|
def DrawingLargeImage():
|
|
large_img_name = field.large_image_array[player.current_array_y][player.current_array_x]
|
|
|
|
field.PuttingLargeImage(large_img_name)
|
|
|
|
|
|
def NextDirection(action):
|
|
# Define next direction
|
|
current_direction = player.direction
|
|
t = -1
|
|
for i in range(4):
|
|
if player.directions[i] == current_direction:
|
|
t = i
|
|
break
|
|
|
|
# Write next direction to Player
|
|
if action == "Right":
|
|
player.direction = player.directions[(t + 1) % 4]
|
|
elif action == "Left":
|
|
player.direction = player.directions[(t - 1) % 4]
|
|
|
|
return player.direction
|
|
|
|
|
|
def MovingForward():
|
|
if player.direction == "east" and field.small_field_canvas.coords(player.image_canvas_id)[0] + player.step < FRAME_WIDTH:
|
|
field.small_field_canvas.move(player.image_canvas_id, player.step, 0)
|
|
elif player.direction == "west" and field.small_field_canvas.coords(player.image_canvas_id)[0] > player.x_start:
|
|
field.small_field_canvas.move(player.image_canvas_id, -player.step, 0)
|
|
elif player.direction == "north" and field.small_field_canvas.coords(player.image_canvas_id)[1] > player.y_start:
|
|
field.small_field_canvas.move(player.image_canvas_id, 0, -player.step)
|
|
elif player.direction == "south" and field.small_field_canvas.coords(player.image_canvas_id)[1] + player.step < FRAME_HEIGHT:
|
|
field.small_field_canvas.move(player.image_canvas_id, 0, player.step)
|
|
|
|
|
|
def Moving(action):
|
|
# Moving
|
|
if action == "Right":
|
|
# player.MovingRight()
|
|
field.Moving()
|
|
Fill(False)
|
|
next_direction = NextDirection(action)
|
|
Arrow(next_direction)
|
|
elif action == "Left":
|
|
# player.MovingLeft()
|
|
field.Moving()
|
|
Fill(False)
|
|
next_direction = NextDirection(action)
|
|
Arrow(next_direction)
|
|
elif action == "Up":
|
|
player.Moving()
|
|
field.Moving()
|
|
Fill(False)
|
|
MovingForward()
|
|
Arrow(player.direction)
|
|
|
|
|
|
def ImagesInArray(directory, array):
|
|
# Filling array from directory
|
|
row = column = 0
|
|
for file in os.listdir(directory):
|
|
image_name = file
|
|
image_path = f"{directory}/{image_name}"
|
|
if directory == "../files/large_images":
|
|
image = PhotoImage(master=field.large_image_canvas, file=image_path)
|
|
else:
|
|
image = PhotoImage(master=field.small_field_canvas, file=image_path)
|
|
|
|
is_done = False
|
|
while not is_done:
|
|
if array[row][column] == 0:
|
|
array[row][column] = image
|
|
is_done = True
|
|
else:
|
|
column += 1
|
|
if column == 10:
|
|
column = 0
|
|
row += 1
|
|
if row == 10:
|
|
break
|
|
|
|
column += 1
|
|
if column == 10:
|
|
column = 0
|
|
row += 1
|
|
if row == 10:
|
|
break
|
|
|
|
|
|
def CellDesignation(array, color):
|
|
for element in array:
|
|
if element[0] == 0:
|
|
element[0] = player.current_x
|
|
element[1] = player.current_y
|
|
element[2] = color
|
|
break
|
|
|
|
|
|
def Action(action):
|
|
if action in ["Right", "Left", "Up", "space"]:
|
|
Moving(action)
|
|
# elif action in ["1", "2"]:
|
|
# if action == "1":
|
|
# CellDesignation(field.state_of_cell_array, "red")
|
|
# else:
|
|
# CellDesignation(field.state_of_cell_array, "green")
|
|
|
|
|
|
# Modified by Artem to search in the status area
|
|
def create_action_list(states, index):
|
|
global fringe
|
|
global action_list
|
|
|
|
if index == 0:
|
|
action_list.reverse()
|
|
return True
|
|
action_list.append(fringe[index].action)
|
|
state_parent = [fringe[index].parent[0], fringe[index].parent[1]]
|
|
create_action_list(states, states.index(state_parent))
|
|
|
|
|
|
def MakeDecision():
|
|
if player.current_array_x != 0 or player.current_array_y != 0:
|
|
mine = field.state_of_cell_array[player.current_array_y][player.current_array_x]
|
|
# print(field.state_of_cell_array)
|
|
# print(mine)
|
|
attributes_dict = {'known': [mine.known], 'power': [mine.power], 'new': [mine.new], 'location': [mine.location],
|
|
'stable': [mine.stable], 'chain_reaction': [mine.chain_reaction]}
|
|
|
|
attributes = f'{mine.known}; {mine.power}; {mine.new}; {mine.location}; {mine.stable}; {mine.chain_reaction}'
|
|
|
|
global label_text
|
|
label_text += attributes + '\n'
|
|
|
|
global label
|
|
label.config(text=label_text)
|
|
field.win.update()
|
|
|
|
data_frame = pd.DataFrame.from_dict(attributes_dict)
|
|
predict = decision_tree.classifier.predict(data_frame)
|
|
|
|
return predict
|
|
|
|
|
|
def MarkMine(prediction):
|
|
if prediction == 0:
|
|
DrawFlag(field.flag_green_img)
|
|
if prediction == 1:
|
|
DrawFlag(field.flag_yellow_img)
|
|
if prediction == 2:
|
|
DrawFlag(field.flag_red_img)
|
|
if prediction == 3:
|
|
DrawFlag(field.flag_bleu_img)
|
|
|
|
field.win.update()
|
|
|
|
|
|
def MouseClickEvent(track):
|
|
global fringe
|
|
global explored
|
|
global action_list
|
|
|
|
print("The best individual is: {} {}".format(track[1], track[0]))
|
|
for point in range(0, len(track[1]) + 1):
|
|
start_position = field.small_field_canvas.coords(player.image_canvas_id)
|
|
if point == len(track[1]):
|
|
end_position = travel.points_map[1]
|
|
else:
|
|
end_position = travel.points_map[track[1][point]]
|
|
|
|
node = nd.Node()
|
|
if len(fringe) == 0:
|
|
node.state.coord = start_position
|
|
node.state.direction = "east"
|
|
else:
|
|
states = []
|
|
for k in range(0, len(fringe)):
|
|
new_state = fringe[k].state.coord
|
|
states.append(new_state)
|
|
start_node = fringe[-1]
|
|
|
|
node.state.coord = start_node.state.coord
|
|
node.state.direction = start_node.state.direction
|
|
|
|
fringe.clear()
|
|
explored.clear()
|
|
action_list.clear()
|
|
fringe = nd.graph_search_A(fringe, explored, node.state, end_position)
|
|
|
|
states = []
|
|
goal_all = []
|
|
for i in range(0, len(fringe)):
|
|
new_state = [fringe[i].state.coord, fringe[i].state.direction]
|
|
states.append(new_state)
|
|
if end_position[0] == fringe[i].state.coord[0] and end_position[1] == fringe[i].state.coord[1]:
|
|
goal_all.append(fringe[i])
|
|
|
|
elem_min = goal_all[0]
|
|
for i in range(1, len(goal_all)):
|
|
if elem_min.priority > goal_all[i].priority:
|
|
elem_min = goal_all[i]
|
|
index = fringe.index(elem_min)
|
|
fringe = fringe[:index + 1]
|
|
|
|
create_action_list(states, -1)
|
|
|
|
# Start moving
|
|
AutoMove()
|
|
|
|
# Decision by tree
|
|
prediction = MakeDecision()
|
|
# Draw the right flag
|
|
MarkMine(prediction)
|
|
|
|
time.sleep(SLEEP_AFTER_CHECK_MINE)
|
|
|
|
|
|
# Check in which locations is mine
|
|
def CheckLocation(x, y):
|
|
# Add x + y like strings that create xy number
|
|
temp_x = str(x)
|
|
temp_y = str(y)
|
|
position_str = temp_x + temp_y
|
|
position = int(position_str)
|
|
|
|
color_number = -1
|
|
if field.cell_expense[position] == standard_cell_cost:
|
|
color_number = 0
|
|
elif field.cell_expense[position] == sand_cell_cost:
|
|
color_number = 1
|
|
elif field.cell_expense[position] == water_cell_cost:
|
|
color_number = 2
|
|
elif field.cell_expense[position] == swamp_cell_cost:
|
|
color_number = 3
|
|
|
|
return color_number
|
|
|
|
|
|
# Add mines on the field and to arrays
|
|
def PutMines(mines_array):
|
|
counter = 0
|
|
|
|
while counter < AMOUNT_OF_MINES:
|
|
x = random.randint(0, 9)
|
|
y = random.randint(0, 9)
|
|
|
|
is_equal = False
|
|
|
|
for mine in mines_array:
|
|
if mine.array_x == x and mine.array_y == y:
|
|
is_equal = True
|
|
if not is_equal:
|
|
if x == 0 and y == 0:
|
|
continue
|
|
else:
|
|
known = random.randint(0, 1)
|
|
power = random.randint(1, 10)
|
|
new = random.randint(0, 1)
|
|
location = CheckLocation(x, y)
|
|
stable = random.randint(0, 1)
|
|
|
|
mine = Mine(x, y, known, power, new, location, stable)
|
|
mines_array.append(mine)
|
|
|
|
# Add mine to array at the right position
|
|
field.state_of_cell_array[x][y] = mine
|
|
|
|
field.field_state_array[x][y] = True
|
|
|
|
counter += 1
|
|
|
|
|
|
def MinesInArrays(mines_array, directory, imgs_array, bool_mines_coord):
|
|
counter = 0
|
|
|
|
temp_array = []
|
|
|
|
if directory == "../../files/small_mines_images":
|
|
for file in os.listdir(directory):
|
|
if counter < AMOUNT_OF_MINES:
|
|
image_name = file
|
|
image_path = f"{directory}/{image_name}"
|
|
image = PhotoImage(master=field.small_field_canvas, file=image_path)
|
|
|
|
temp_array.append(image)
|
|
|
|
counter += 1
|
|
|
|
for i in range(AMOUNT_OF_MINES):
|
|
mines_array[i].small_img = temp_array[i]
|
|
|
|
# Add images in image array
|
|
imgs_array[mines_array[i].array_x][mines_array[i].array_y] = temp_array[i]
|
|
|
|
elif directory == "../../files/large_mines_images":
|
|
for file in os.listdir(directory):
|
|
if counter < AMOUNT_OF_MINES:
|
|
image_name = file
|
|
image_path = f"{directory}/{image_name}"
|
|
image = PhotoImage(master=field.large_image_canvas, file=image_path)
|
|
|
|
temp_array.append(image)
|
|
|
|
counter += 1
|
|
|
|
for i in range(AMOUNT_OF_MINES):
|
|
mines_array[i].large_img = temp_array[i]
|
|
|
|
# Add images in image array
|
|
imgs_array[mines_array[i].array_x][mines_array[i].array_y] = temp_array[i]
|
|
|
|
if bool_mines_coord:
|
|
for i in range(len(mines_array)):
|
|
field.mines_coord.append([mines_array[i].array_x, mines_array[i].array_y])
|
|
|
|
|
|
def DrawFlag(image):
|
|
field.small_field_canvas.create_image(player.current_x, player.current_y, anchor=NW, image=image)
|
|
|
|
|
|
# def IsItMine():
|
|
# visited = 0 # 0 - not mine; 1 - on this mine for the first time; 2 - already been on this mine
|
|
#
|
|
# # Checks if the player is on the mine
|
|
# for i in field.mines_coord:
|
|
# if i[0] == player.current_x and i[1] == player.current_y:
|
|
# visited = 1
|
|
# # Checks if the player has already been on this mine
|
|
# for y in field.visited_mines:
|
|
# if y[0] == player.current_x and y[1] == player.current_y:
|
|
# visited = 2
|
|
# if visited == 1:
|
|
# DrawFlag()
|
|
|
|
|
|
def AutoMove():
|
|
for action in action_list:
|
|
# Program wait for better illustration
|
|
time.sleep(DELAY_TIME)
|
|
# Move once
|
|
Action(action)
|
|
# Check if player on mine and if yes, draw flag
|
|
# IsItMine()
|
|
# Update main window
|
|
field.win.update()
|
|
|
|
|
|
# Draws rectangles that indicate type of cells
|
|
def DrawRectangle():
|
|
x = 4
|
|
y = 4
|
|
|
|
color = None
|
|
# Chose color for rectangle
|
|
for i in range(len(field.cell_expense)):
|
|
if field.cell_expense[i] == standard_cell_cost:
|
|
color = "None"
|
|
elif field.cell_expense[i] == sand_cell_cost:
|
|
color = "yellow"
|
|
elif field.cell_expense[i] == water_cell_cost:
|
|
color = "dodger blue"
|
|
elif field.cell_expense[i] == swamp_cell_cost:
|
|
color = "green4"
|
|
if color != "None":
|
|
field.small_field_canvas.create_rectangle(x, y, x + IMAGE_SIZE + 2, y + IMAGE_SIZE + 2, width=2,
|
|
outline=color)
|
|
x += player.step
|
|
if x + IMAGE_SIZE + 2 > field.width:
|
|
x = 4
|
|
y += player.step
|
|
|
|
|
|
def AddCostCellsToArray(amount, cost):
|
|
counter = 0
|
|
while counter < amount:
|
|
r = random.randint(0, 99)
|
|
if field.cell_expense[r] == 0:
|
|
field.cell_expense[r] = cost
|
|
counter += 1
|
|
|
|
|
|
def CostingOfCells():
|
|
AddCostCellsToArray(amount_of_sand_cells, sand_cell_cost)
|
|
AddCostCellsToArray(amount_of_water_cells, water_cell_cost)
|
|
AddCostCellsToArray(amount_of_swamp_cells, swamp_cell_cost)
|
|
AddCostCellsToArray(
|
|
field.rows * field.columns - (amount_of_sand_cells + amount_of_water_cells + amount_of_swamp_cells),
|
|
standard_cell_cost)
|
|
|
|
# Draw rectangles
|
|
DrawRectangle()
|
|
|
|
|
|
def click_button():
|
|
btn.destroy()
|
|
global label
|
|
label = Label(field.win, text="Wait...\nAI conquers the world...", fg='black', font="20", bg='gray')
|
|
label.place(x=10, y=560)
|
|
field.win.update()
|
|
track = tr.genetic_algorithm(travel.points_map)
|
|
|
|
track[1].remove(1)
|
|
label.config(text=track[1])
|
|
field.win.update()
|
|
MouseClickEvent(track)
|
|
|
|
|
|
# Check if there mines near and if, mark it
|
|
def CheckForMinesNear(x, y):
|
|
if x > 0:
|
|
if field.state_of_cell_array[x - 1][y] != "None":
|
|
# Mark by chain reaction current mine
|
|
field.state_of_cell_array[x][y].chain_reaction = 1
|
|
# Mark by chain reaction mine that near
|
|
field.state_of_cell_array[x - 1][y].chain_reaction = 1
|
|
if x < 9:
|
|
if field.state_of_cell_array[x + 1][y] != "None":
|
|
# Mark by chain reaction current mine
|
|
field.state_of_cell_array[x][y].chain_reaction = 1
|
|
# Mark by chain reaction mine that near
|
|
field.state_of_cell_array[x + 1][y].chain_reaction = 1
|
|
if y > 0:
|
|
if field.state_of_cell_array[x][y - 1] != "None":
|
|
# Mark by chain reaction current mine
|
|
field.state_of_cell_array[x][y].chain_reaction = 1
|
|
# Mark by chain reaction mine that near
|
|
field.state_of_cell_array[x][y - 1].chain_reaction = 1
|
|
if y < 9:
|
|
if field.state_of_cell_array[x][y + 1] != "None":
|
|
# Mark by chain reaction current mine
|
|
field.state_of_cell_array[x][y].chain_reaction = 1
|
|
# Mark by chain reaction mine that near
|
|
field.state_of_cell_array[x][y + 1].chain_reaction = 1
|
|
|
|
|
|
def CheckForChainReaction():
|
|
for x in range(field.columns):
|
|
for y in range(field.rows):
|
|
if field.state_of_cell_array[x][y] != "None":
|
|
CheckForMinesNear(x, y)
|
|
|
|
|
|
def main():
|
|
# Creating the main window of an application
|
|
win_size = f'{WINDOW_X}x{WINDOW_Y}'
|
|
field.win.title("Sapper")
|
|
field.win.configure(bg='gray')
|
|
field.win.geometry(win_size)
|
|
print(f'Amount of mines: {AMOUNT_OF_MINES}')
|
|
|
|
global btn
|
|
btn = Button(field.win,
|
|
text="Search for mines", # текст кнопки
|
|
background="#555", # фоновый цвет кнопки
|
|
foreground="#ccc", # цвет текста
|
|
padx="20", # отступ от границ до содержимого по горизонтали
|
|
pady="8", # отступ от границ до содержимого по вертикали
|
|
font="24", # высота шрифта
|
|
command=click_button
|
|
)
|
|
|
|
btn.place(x=10, y=560)
|
|
|
|
# Create array with mines objects
|
|
mines_array = []
|
|
|
|
CostingOfCells()
|
|
|
|
# Put mines on coordinates
|
|
PutMines(mines_array)
|
|
|
|
CheckForChainReaction()
|
|
|
|
# Add images of mines in arrays
|
|
MinesInArrays(mines_array, "../../files/small_mines_images", field.small_image_array, True)
|
|
MinesInArrays(mines_array, "../../files/large_mines_images", field.large_image_array, False)
|
|
|
|
# Filling image arrays
|
|
small_directory = "../../files/small_images"
|
|
ImagesInArray(small_directory, field.small_image_array)
|
|
large_directory = "../../files/large_images"
|
|
ImagesInArray(large_directory, field.large_image_array)
|
|
|
|
# Add arrow image to Player class
|
|
images = []
|
|
for file in os.listdir("../../files/arrow"):
|
|
path = f"../../files/arrow/{file}"
|
|
img = PhotoImage(master=field.small_field_canvas, file=path)
|
|
images.append(img)
|
|
|
|
player.arrow_east_image = images[0]
|
|
player.arrow_north_image = images[1]
|
|
player.arrow_south_image = images[2]
|
|
player.arrow_west_image = images[3]
|
|
|
|
# Filling window with images
|
|
Fill(True)
|
|
# Drawing arrow (player)
|
|
image = player.arrow_east_image
|
|
player.image_canvas_id = field.small_field_canvas.create_image(player.current_x, player.current_y, anchor=NW,
|
|
image=image)
|
|
# Arrow(player.direction)
|
|
# Rectangle(True, "None")
|
|
# Rectangle()
|
|
# Binding keyboard press to function
|
|
# field.win.bind("<Key>", Action)
|
|
# field.small_field_canvas.bind("<Button-1>", MouseClickEvent)
|
|
|
|
# Starting mainloop for window
|
|
field.win.mainloop()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|