def initGameState(self):
"""
This function creates a GUI obj and draw the simulation board
"""
print("Setting game state: ")
self.playGUI = GUI()
self.playGUI.drawBoard(self.player)
class main_:
''' Class that launches everything '''
def __init__(self, *args, **kwargs):
self._initialise_gui(*args, **kwargs)
self._update_display()
self._gui.mainloop()
def _initialise_gui(self, *args, **kwargs):
self._gui = GUI(*args, **kwargs)
def _update_display(self):
self._gui.draw()
self._gui.after(1, self._update_display)
def setUp(self) -> None:
self.disassemble_frame = MagicMock(spec=DisassembleFrame)
self.walk_frame = MagicMock(spec=WalkFrame)
self.crafting_frame = MagicMock(spec=CraftingFrame)
self.double_tap_dodge_frame = MagicMock(spec=DoubleTapDodgeFrame)
frames = {
WalkFrame: self.walk_frame,
CraftingFrame: self.crafting_frame,
DisassembleFrame: self.disassemble_frame,
DoubleTapDodgeFrame: self.double_tap_dodge_frame,
}
self.master = MagicMock()
self.gui = GUI(master=self.master, frames=frames)
self.gui.winfo_toplevel = MagicMock()
self.gui.grid = MagicMock()
self.gui.lift = MagicMock()
def acquireSample(state):
gui = GUI()
board = Board()
board.startDataAcquisition()
gui.loadImage(state)
time.sleep(10)
sample = board.getEGG_Data()
board.releaseBoardSession()
gui.closeImage()
return sample
class State():
def __init__(self):
self.player = Player().getPlayer()
# self.player.getCurrentPlayer()
self.pieceList = self.player.getCurrentPieceList()
self.Zobrist = Zobrist()
self.HashTable = self.Zobrist.getHashTable()
def initGameState(self):
print("Setting game state: ")
self.playGUI = GUI()
self.playGUI.drawBoard(self.player)
# Test Functions:
def playGame(self):
print("\nPlay Game")
if self.EndGame(self.player.getCurrentPieceList()) == True:
print("The End")
return True
else:
# Get pieceList from thong
# Running the code
os.system(
"g++ -g -std=c++11 -I/usr/local/include/opencv4/opencv -I/usr/local/include/opencv4 -L/usr/local/lib main.cpp Piece.cpp -o a.exe -lopencv_dnn -lopencv_gapi -lopencv_highgui -lopencv_ml -lopencv_objdetect -lopencv_photo -lopencv_stitching -lopencv_video -lopencv_calib3d -lopencv_features2d -lopencv_flann -lopencv_videoio -lopencv_imgcodecs -lopencv_imgproc -lopencv_xfeatures2d -lopencv_core --debug <"
)
#input Move
input_result = self.inputMove()
print("Chess piece: {}, pos: {}".format(input_result['Piece'],
input_result['Pos']))
self.movePiece(self.pieceList, input_result['Piece'],
input_result['Pos'])
self.player.UpdatePieceList(self.pieceList)
self.playGUI.drawBoard(self.player)
# print("End game: ",self.EndGame(self.player.getCurrentPieceList()))
# Activate Game bot
AB_result = self.setNextMove_AB()
if AB_result == 0: # Endgame condition
return True
else:
self.player.changeCurrentPlayer()
return AB_result
def find(self, list, key, value):
for i, dic in enumerate(list):
if dic[key] == value:
return i
return -1
def inputMove(self):
chesspiece = input("Input chess piece: ")
if chesspiece == 'end':
return 0
else:
print("input position:")
row = int(input("row: "))
col = int(input("\ncol: "))
pos = (row, col)
# Input from csv
#--------------------------------------------------------------------
input_result = {"Piece": chesspiece, "Pos": (row, col)}
return input_result
def setNextMove_AB(self):
print("1====================================")
# Set timer start here:
start = datetime.datetime.now()
# Call Alpha Beta algorithm. Result is a dict: (score, piece, pos)
result = self.alphabeta(2, False, -9999, 9999)
# Set timer stop here:
end = datetime.datetime.now()
elapse = end - start
print("elapse: ", elapse)
# movePiece using result piece and position:
print("Result: ", result)
old_pos = self.pieceList[self.find(self.pieceList, 'Symbol',
result['Piece'])]['Pos']
check_capture = self.movePiece(self.pieceList, result['Piece'],
result['Pos'])
self.player.UpdatePieceList(self.pieceList)
self.playGUI.drawBoard(self.player)
check_endgame = self.EndGame(self.player.getCurrentPieceList())
if check_endgame == True:
return 0
else:
print(
"Information to pass: Old pos: {}, New pos: {}, check capture: {}, check Endgame: {}"
.format(old_pos, result['Pos'], check_capture, check_endgame))
AB_result = (old_pos, result['Pos'], check_capture)
return AB_result
def movePiece(self, pieceList, piece, pos):
# check captured:
check = self.player.checkCaptured(pieceList, pos)
for i in range(len(pieceList)):
# print("I{} = ".format(i),self.pieceList['Symbol'][i])
if piece == pieceList[i]['Symbol']:
# print('Old: {} to {}'.format( pieceList[i]['Pos'], pos))
self.pieceList[i]['Pos'] = pos
else:
pass
return check
def EndGame(self, pieceList):
check_endgame = not self.player.isGeneralExist(pieceList)
# print("check end game: ",check_endgame)
return check_endgame
def nextState(self, piece, pos):
# Copy current pieceList to new state obj
nextState = copy.deepcopy(self)
nextState.movePiece(nextState.player.getCurrentPieceList(), piece, pos)
return nextState
def alphabeta(self, depth, isMax, alpha, beta):
# Check for endgame condition:
if self.EndGame(self.player.getCurrentPieceList()) == True:
result = {"Score": '', "Piece": '', "Pos": ''}
pass
# Get score of pieceList
result['Score'] = (99999999) * self.player.getCurrentPlayer()
# print("Score in depth 0 = ", result['Score'])
return result
# Check for depth = 0
if depth == 0:
# print("Depth 0")
result = {"Score": '', "Piece": '', "Pos": ''}
pass
# Get score of pieceList
result['Score'] = self.player.getPieceListScore(self.pieceList)
# print("Score in depth 0 = ", result['Score'])
return result
# Get Zobrist key of this State:
# key = self.Zobrist.ZobristKeyGen(self.player.getCurrentPieceList())
# print("Key: ", key)
#Check Hash table:
# Change current player
self.player.changeCurrentPlayer()
# Get possible move of the current player
possibleMoves = self.player.getAllPossibleMoves()
# print(possibleMoves)
eval_result = list()
# Loop through possible move and create new piecelist with each move
for i in range(len(possibleMoves)):
# Collect inputs (piece and piece's position)
piece = possibleMoves[i][0]['Symbol']
to_pos = possibleMoves[i][1]
# Create new pieceList
nextState = self.nextState(piece, to_pos)
# Recall alpha beta to collect score from lower depth
alpha_beta_result = nextState.alphabeta(depth - 1, not isMax,
alpha, beta)
try:
score = alpha_beta_result['Score']
# print("Score type: ",type(score))
except:
print("\nWrong\n")
# print("alpha_beta_result score_{}: ".format(depth),score)
result = {"Score": score, "Piece": piece, "Pos": to_pos}
eval_result.append(result)
# print("eval result: ", eval_result)
# if score >= beta: # LOWER BOUND CASE
# self.HashEntry = {
# 'Zobrist_Key': key,
# 'Depth': depth,
# 'Entry_Type': 'LOWER', # EXACT ( Alpha < eval < Beta), LOWER ( >= Beta) OR UPPER (<= Alpha)
# 'Eval': result # Score
# # 'Ancient': '',
# }
# self.HashTable.insert(self.Zobrist.findIndex(key),self.HashEntry)
# return result
# else:
if isMax:
alpha = max(alpha, score)
if beta <= alpha:
# print("EQUAL")
return eval_result[-1]
else:
beta = min(beta, score)
if beta <= alpha:
# print("EQUAL")
return eval_result[-1]
# Get score from eval result
score_list = list()
index = ''
for j in range(len(eval_result)):
score_list.append(eval_result[j]['Score'])
if isMax:
index = score_list.index(max(score_list))
else:
index = score_list.index(min(score_list))
return eval_result[index]
def initGameState(self):
print("Setting game state: ")
self.playGUI = GUI()
self.playGUI.drawBoard(self.player)
class State():
def __init__(self):
self.current_dir = os.getcwd()
self.checkOpenStatus()
self.player = Player().getPlayer()
self.player.getCurrentPlayer()
self.pieceList = self.player.getCurrentPieceList()
self.red_count = 0
self.black_count = 0
self.Zobrist = Zobrist()
self.HashTable = self.Zobrist.getHashTable()
self.logdata = list()
self.timetable_red = list()
self.timetable_black = list()
self.infi_loop = list()
def initGameState(self):
print("Setting game state: ")
self.playGUI = GUI()
self.playGUI.drawBoard(self.player)
def genDataFiles(self, pieceList):
b_list, r_list = list(), list()
for i in range(len(pieceList)):
eval("{}.append((pieceList[i]['Name'], pieceList[i]['Pos']))".
format('b_list' if pieceList[i]['Team'] == -1 else 'r_list'))
print("red: ", r_list)
print("Black: ", b_list)
pd.DataFrame(b_list, columns=['Name',
'Pos']).to_csv("m_GreenPiece.csv",
index=False)
pd.DataFrame(r_list, columns=['Name', 'Pos']).to_csv("m_RedPiece.csv",
index=False)
# Test Functions:
def playGame(self):
print("\nPlay Game")
if (self.EndGame()):
print("EndGame stt: ", self.EndGame())
print("The End")
return True
else:
# Get pieceList from thong
input_result = self.inputMove()
# input move return 2 forms: True and input result
if input_result is not True:
return input_result
else:
# Export time table to csv
black_timetable = pd.DataFrame(self.timetable_black,
columns=['Iteration',
'Time']).to_csv(
"Time_black.csv",
index=False)
return True
def checkOpenStatus(self):
xl = win32.gencache.EnsureDispatch('Excel.Application')
update_file = "BoardData_update.csv"
update_file_pth = os.path.join(self.current_dir, 'src', update_file)
if xl.Workbooks.Count > 0:
print("opened: ", xl.Workbooks.Count)
# if none of opened workbooks matches the name, openes my_workbook
if any(i.Name == update_file for i in xl.Workbooks):
print("It is opended")
xl.Workbooks.Open(Filename=update_file_pth).Close(True)
else:
print("It is not opended")
def find(self, list, key, value):
for i, dic in enumerate(list):
if dic[key] == value:
return i
return -1
def inputMove(self):
# Check if BoardData_update is still opended
self.checkOpenStatus()
# chesspiece = input("Input chess piece: ")
# if chesspiece == 'end':
# return 0
# else:
# # print("input position:")
# # row = int(input("row: "))
# # col = int(input("\ncol: "))
# # pos = (row, col)
#
# print("command:", chesspiece)
# if chesspiece == 'read':
# Check if BoardData_update is still opended
self.genDataFiles(self.player.getCurrentPieceList())
print("PieceRecog.exe", len(self.player.getCurrentPieceList()))
os.system("PieceRecog.exe " +
str(len(self.player.getCurrentPieceList())))
self.checkOpenStatus()
self.player.updateData('src\\BoardData_update.csv')
self.player.getChessPieceList('src\\BoardData_update.csv')
print(self.player.getCurrentPieceList())
# self.player.UpdatePieceList(self.pieceList)
self.pieceList = self.player.getCurrentPieceList()
print("Piece list after inputmove: ", self.pieceList)
self.playGUI.drawBoard(self.player)
check = self.setNextMove_AB()
if check == 0:
return True
else:
pd.DataFrame(self.player.getCurrentPieceList()).to_csv(
'src\\BoardData_update.csv', index=False)
# self.player.getChessPieceList('src\\BoardData_update.csv')
# self.pieceList = self.player.getCurrentPieceList()
print("Piecelist after Alpha beta: ", self.pieceList)
return check
def autochess(self):
print("Player {}: depth = 2".format(self.player.getCurrentPlayer()))
self.player.changeCurrentPlayer()
red_start = time.time()
result = self.alphabeta(2, True, -9999, 9999, 2)
red_end = time.time()
red_elapse = red_end - red_start
print("red elapse: ", red_elapse)
self.red_count += 1
self.timetable_red.append((self.red_count, red_elapse))
# movePiece using result piece and position:
print("Result: ", result)
self.movePiece(self.pieceList, result['Piece'], result['Pos'])
self.player.UpdatePieceList(self.pieceList)
self.playGUI.drawBoard(self.player)
check = self.setNextMove_AB()
if (self.EndGame()) or (check == 0):
print(self.timetable_black)
return 0
else:
pass
def setNextMove_AB(self):
print("Player {} depth = 2".format(self.player.getCurrentPlayer()))
# self.player.changeCurrentPlayer()
# possibleMove = self.player.getAllPossibleMoves()
# print("Possi: ",possibleMove)
# Set timer start here:
black_start = time.time()
# Call Alpha Beta algorithm. Result is a dict: (score, piece, pos)
result = self.alphabeta(2, False, -9999, 9999, 2)
# Set timer stop here:
black_end = time.time()
black_elapse = black_end - black_start
print("black elapse: ", black_elapse)
self.black_count += 1
self.timetable_black.append((self.black_count, black_elapse))
# movePiece using result piece and position:
print("Result: ", result)
old_pos = self.pieceList[self.find(self.pieceList, 'Symbol',
result['Piece'])]['Pos']
check_capture = self.movePiece(self.pieceList, result['Piece'],
result['Pos'])
self.player.UpdatePieceList(self.pieceList)
self.playGUI.drawBoard(self.player)
df = pd.DataFrame(self.pieceList)
df.set_index('Name', inplace=True)
print("df: \n", df)
df.to_csv("src\\BoardData_Update.csv")
# self.infi_loop.append(result['Pos'])
check_endgame = self.EndGame()
# or ((len(self.infi_loop) >= 5) and self.infi_loop.count(self.infi_loop[0]) >= 2)
if (check_endgame is True):
print(self.timetable_black)
# pd.DataFrame(self.logdata, columns=["Piece", "Pos", "Score", "Depth", "isMax", "Alpha", "Beta"]).to_csv("LogData.csv")
return 0
# elif (len(self.infi_loop) >= 5 and self.infi_loop.count(self.infi_loop[0]) < 2):
# print(self.infi_loop)
# self.infi_loop = []
# self.player.changeCurrentPlayer()
# print("Information to pass: Old pos: {}, New pos: {}, check capture: {}, check Endgame: {}".
# format(old_pos,
# result['Pos'],
# check_capture,
# check_endgame))
# AB_result = (old_pos, result['Pos'], check_capture)
# return AB_result
else:
self.player.changeCurrentPlayer()
print(
"Information to pass: Old pos: {}, New pos: {}, check capture: {}, check Endgame: {}"
.format(old_pos, result['Pos'], check_capture, check_endgame))
AB_result = (old_pos, result['Pos'], check_capture)
return AB_result
def movePiece(self, pieceList, piece, pos):
# check captured:
check = self.player.checkCaptured(self.pieceList, pos)
for i in range(len(pieceList)):
# print("I{} = ".format(i),self.pieceList['Symbol'][i])
if piece == pieceList[i]['Symbol']:
# print('Old: {} to {}'.format( pieceList[i]['Pos'], pos))
self.pieceList[i]['Pos'] = pos
break
else:
pass
return check
def EndGame(self):
check_endgame = not self.player.getPlayer().isGeneralExist()
# print("Check endgame: ", check_endgame)
# print(self.pieceList)
# print("check end game: ",check_endgame)
return check_endgame
def nextState(self, piece, pos):
# Copy current pieceList to new state obj
nextState = copy.deepcopy(self)
nextState.movePiece(nextState.player.getCurrentPieceList(), piece, pos)
return nextState
def alphabeta(self, depth, isMax, alpha, beta, depth_flag):
# Check for endgame condition:
if self.EndGame() == True:
# print(self.player.getCurrentPieceList())
result = {"Score": '', "Piece": '', "Pos": ''}
pass
# Get score of pieceList
result['Score'] = ((99999999) * self.player.getCurrentPlayer(),
depth + 1)
# print("Score in depth 0 = ", result['Score'])
return result
# Check for depth = 0
if depth == 0:
# print("Depth 0")
result = {"Score": '', "Piece": '', "Pos": ''}
pass
# Get score of pieceList
result['Score'] = (self.player.getPieceListScore(self.pieceList),
depth + 1)
# print("Score in depth 0 = ", result['Score'])
return result
# Change current player
self.player.changeCurrentPlayer()
# Get possible move of the current player
possibleMoves = self.player.getAllPossibleMoves()
eval_result = list()
# Loop through possible move and create new piecelist with each move
for i in range(len(possibleMoves)):
# Collect inputs (piece and piece's position)
piece = possibleMoves[i][0]['Symbol']
to_pos = possibleMoves[i][1]
# Create new pieceList
nextState = self.nextState(piece, to_pos)
# Recall alpha beta to collect score from lower depth
alpha_beta_result = nextState.alphabeta(depth - 1, not isMax,
alpha, beta, depth_flag)
try:
score = alpha_beta_result['Score']
# self.logdata.append((piece, to_pos, score, depth, isMax, alpha, beta))
except:
print("\nWrong\n")
# if depth >= depth_flag - 1 or score[0] == 99999999 or score[0] == -99999999:
# print("In Depth {} piece: {}, pos: {}, isMax: {}, score: {}".format(depth, piece, to_pos, isMax, score))
# if score[0] == 99999999 or score[0] == -99999999:
# print("Piece: {}, pos: {}, score: {}, depth: {}, isMax: {}, curr Player: {}, Alpha: {}, Beta: {}".
# format(piece, to_pos, score[0], depth, isMax, self.player.getCurrentPlayer(), alpha, beta))
result = {"Score": score, "Piece": piece, "Pos": to_pos}
eval_result.append(result)
# print("eval result: ", eval_result)
if isMax:
alpha = max(alpha, score[0])
else:
beta = min(beta, score[0])
# Check if depth is at top depth. Don't check beta <= alpha to avoid wrong pruning
if depth == depth_flag and (score[0] != 99999999
or score[0] != -99999999):
# print("Score: {}, depth: {}, Not check:")
pass
else:
if beta <= alpha:
# print("Prun")
return eval_result[-1]
# Get score from eval result
score_list = list()
id = ''
for j in range(len(eval_result)):
score_list.append(eval_result[j]['Score'])
# Check list when depth
# if depth == depth_flag - 1:
# print('score list in depth {}: {}'.format(depth, score_list))
# Find index, check max depth , base on max or min value of tuple score
if isMax:
id = score_list.index(
max(filter(
lambda t: t[0] == max(score_list, key=itemgetter(0))[0],
score_list),
key=itemgetter(1)))
else:
id = score_list.index(
max(filter(
lambda t: t[0] == min(score_list, key=itemgetter(0))[0],
score_list),
key=itemgetter(1)))
return eval_result[id]
import tkinter as tk from src.library import Library from src.GUI import GUI root = tk.Tk() gui = GUI(root) root.mainloop() library = Library()
ble_files = []
zb_files = []
wf_files = []
if __name__ == '__main__':
ble_files.append('./packets/BLE_packets/' + sys.argv[1] + '.json')
ble_files.append('./packets/BLE_packets/' + sys.argv[1] + '.csv')
ble = bluetooth(ble_files)
zb_files.append('./packets/ZB_packets/' + sys.argv[2] + '.json')
zb_files.append('./packets/ZB_packets/' + sys.argv[2] + '.csv')
zb = zigbee(zb_files)
wf_files.append('./packets/WiFi_packets/' + sys.argv[3] + '.json')
wf_files.append('./packets/WiFi_packets/' + sys.argv[3] + '.csv')
wf = wifi(wf_files)
gui = GUI()
gui.add(ble)
gui.add(zb)
gui.add(wf)
# command: 'BLE', 'ZigBee', 'WiFi', 'ALL'
gui.show('ZigBee')
gui.show('BLE')
gui.show('WiFi')
#gui.show('ALL')
def main(): GUI()
smoothing.buffer = GUI.buffer
elif key == ord('1'):
GUI.lines_overlay = not GUI.lines_overlay
elif key == ord('2'):
GUI.polygon_overlay = not GUI.polygon_overlay
elif key == ord('s'):
GUI.vanishing_point_strategy = not GUI.vanishing_point_strategy
elif key == ord('t'):
GUI.target_overlay = not GUI.target_overlay
elif key == ord('3'):
GUI.clear_overlays()
GUI.process_overlay = not GUI.process_overlay
elif key == ord('4') and GUI.process_overlay:
GUI.clear_overlays()
GUI.grayed_overlay = not GUI.grayed_overlay
elif key == ord('5') and GUI.process_overlay:
GUI.clear_overlays()
GUI.blured_overlay = not GUI.blured_overlay
elif key == ord('6') and GUI.process_overlay:
GUI.clear_overlays()
GUI.processed_overlay = not GUI.processed_overlay
elif key == ord('7') and GUI.process_overlay:
class TestGUI(unittest.TestCase):
def setUp(self) -> None:
self.disassemble_frame = MagicMock(spec=DisassembleFrame)
self.walk_frame = MagicMock(spec=WalkFrame)
self.crafting_frame = MagicMock(spec=CraftingFrame)
self.double_tap_dodge_frame = MagicMock(spec=DoubleTapDodgeFrame)
frames = {
WalkFrame: self.walk_frame,
CraftingFrame: self.crafting_frame,
DisassembleFrame: self.disassemble_frame,
DoubleTapDodgeFrame: self.double_tap_dodge_frame,
}
self.master = MagicMock()
self.gui = GUI(master=self.master, frames=frames)
self.gui.winfo_toplevel = MagicMock()
self.gui.grid = MagicMock()
self.gui.lift = MagicMock()
def test_it_configures_styles(self):
self.gui.setup(MagicMock(spec=Config))
self.gui.winfo_toplevel().configure.assert_called_once_with(
background=Styles.secondary_color())
def test_it_configures_title(self):
config = MagicMock(spec=Config)
self.gui.setup(config)
self.gui.winfo_toplevel().title.assert_called_once_with(
config.app_name())
def test_it_configures_grid(self):
self.gui.setup(MagicMock(spec=Config))
self.gui.grid.assert_called_once_with(row=0, column=0)
def test_it_configures_lift(self):
self.gui.setup(MagicMock(spec=Config))
self.gui.lift.assert_called_once()
def test_it_renders_walk_frame(self):
self.gui.render_walk_frame()
self.walk_frame.render.assert_called_once_with(master=self.master)
def test_it_renders_crafting_frame(self):
self.gui.render_crafting_frame()
self.crafting_frame.render.assert_called_once_with(master=self.master)
def test_it_renders_disassemble_frame(self):
self.gui.render_disassemble_frame()
self.disassemble_frame.render.assert_called_once_with(
master=self.master)
def test_it_renders_double_tap_frame(self):
self.gui.render_double_tap_dodge_frame()
self.double_tap_dodge_frame.render.assert_called_once_with(
master=self.master)
from tkinter import Tk
from PIL import Image
# from tkinter.filedialog import askopenfilename
from src.GUI import GUI
root = Tk()
""" [PROD]
# adding the image
File = askopenfilename(parent=root, initialdir="C:/", title='')
image = Image.open(File)
"""
# [DEV] Chemin seulement pour faciliter le développement: à changer en prod
image = Image.open(
"C:/Users/gs63vr/Documents/Grener/app/src/assets/img/confort/N4.png")
root.geometry('952x843')
myGUI = GUI(root, image)
root.mainloop()
from src.GPSHandler import GPSHandler
gpsHandler = GPSHandler(environment)
gpsHandler.start()
# Initiate LiveData
from src.LiveData import LiveData
liveData = LiveData(environment)
liveData.start()
# ECUHandler
from src.ECUHandler import ECUHandler
ecuHandler = ECUHandler(environment)
ecuHandler.start()
try:
# Environment
from src.Environment import Environment
environment = Environment()
environment.start()
gui = GUI(environment)
thread.start_new_thread(initClasses, ())
#Start gui and enter its mainloop
gui.start()
except (KeyboardInterrupt, SystemExit):
print("Exiting...")
sys.exit()
if __name__ == "__main__":
from src.GUI import GUI
g = GUI()
from tkinter import Tk
from src.GUI import GUI
from cefpython3 import cefpython as cef
root = Tk()
root.state('zoomed')
screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
root.maxsize(width=screen_width, height=screen_height)
root.geometry('%sx%s' % (screen_width, screen_height))
root.update()
myGUI = GUI(root)
cef.Initialize()
root.mainloop()
cef.Shutdown()
import sys
from PyQt5.QtWidgets import QApplication
from src.GUI import GUI
if __name__ == "__main__":
app = QApplication(sys.argv)
gui = GUI()
sys.exit(app.exec_())
def main():
"""
Entry point. Main part of the program loop.
"""
mask = compute_mask()
# Screen capture;
screen_cap = capture_window()
original = cv2.cvtColor(screen_cap, cv2.COLOR_BGR2RGB)
canvas = np.zeros_like(original)
# Image processing
grayed = Image(original).gray()
blurred = grayed.gaussian_blur()
processed = blurred.canny()
masked = Image(roi(processed.pixels, [np.array([i.get() for i in mask])]))
lines = masked.find_lines()
color = Colors.green()
# Computing
if lines is not None:
update_smoothing(compute_averages(lines), smoothing)
else:
color = Colors.blue()
smoothed_lines = smoothing.get_left_line(), smoothing.get_right_line()
vanishing_point = compute_vanishing_point(smoothed_lines)
# Lines overlay
if GUI.lines_overlay:
smoothed_lines[0].draw(canvas, color=color, thickness=15)
smoothed_lines[1].draw(canvas, color=color, thickness=15)
vanishing_point.draw(canvas, color=color, thickness=5)
# Target overlay
if GUI.target_overlay:
GUI.draw_target(vanishing_point, original, canvas)
# Merge original image & overlay
combo_image = cv2.addWeighted(original, 1, canvas, 0.4, 2)
if GUI.polygon_overlay:
draw_polygon(combo_image, mask)
GUI.draw(combo_image)
# Split image layout
if GUI.process_overlay:
left = combo_image
if GUI.grayed_overlay:
right = grayed.np
elif GUI.blured_overlay:
right = blurred.np
elif GUI.processed_overlay:
right = processed.np
elif GUI.masked_overlay:
right = masked.np
else:
right = original
both = np.concatenate((left, right), axis=1)
cv2.imshow('Linor window', both)
else:
cv2.imshow('Linor window', combo_image)
def _initialise_gui(self, *args, **kwargs):
self._gui = GUI(*args, **kwargs)
class State:
"""
This class is a bridge to all other classes and contain the Minimax algorithm with Alpha-Beta pruning
"""
def __init__(self):
self.current_dir = os.getcwd()
self.checkOpenStatus()
self.player = Player().getPlayer()
self.player.getCurrentPlayer()
self.pieceList = self.player.getCurrentPieceList()
self.red_count = 0
self.black_count = 0
self.logdata = list()
self.timetable_red = list()
self.timetable_black = list()
self.infi_loop = list()
def initGameState(self):
"""
This function creates a GUI obj and draw the simulation board
"""
print("Setting game state: ")
self.playGUI = GUI()
self.playGUI.drawBoard(self.player)
def genDataFiles(self, pieceList):
"""
This function creates 2 csv files (m_GreenPiece.csv and m_RedPiece.csv) based on the chess piece list data
:param pieceList: The current chess piece list
"""
b_list, r_list = list(), list()
for i in range(len(pieceList)):
eval("{}.append((pieceList[i]['Name'], pieceList[i]['Pos']))".
format('b_list' if pieceList[i]['Team'] == -1 else 'r_list'))
print("red: ", r_list)
print("Black: ", b_list)
pd.DataFrame(b_list, columns=['Name',
'Pos']).to_csv("m_GreenPiece.csv",
index=False)
pd.DataFrame(r_list, columns=['Name', 'Pos']).to_csv("m_RedPiece.csv",
index=False)
def playGame(self):
"""
This function calls the inputMove() function
:return: True if the Game has ended, else the result to pass to the SCARA arm
"""
print("\nPlay Game")
if (self.EndGame()):
print("EndGame stt: ", self.EndGame())
print("The End")
return True
else:
# Get pieceList from thong
input_result = self.inputMove()
# input move return 2 forms: True and input result
if input_result is not True:
return input_result
else:
# Export time table to csv
black_timetable = pd.DataFrame(self.timetable_black,
columns=['Iteration',
'Time']).to_csv(
"Time_black.csv",
index=False)
return True
def checkOpenStatus(self):
"""
This function checks whether the BoardData_update.csv is still open to avoid problem when writing to that file
"""
xl = win32.gencache.EnsureDispatch('Excel.Application')
update_file = "BoardData_update.csv"
update_file_pth = os.path.join(self.current_dir, 'src', update_file)
if xl.Workbooks.Count > 0:
print("opened: ", xl.Workbooks.Count)
# if none of opened workbooks matches the name, openes my_workbook
if any(i.Name == update_file for i in xl.Workbooks):
print("It is opended")
xl.Workbooks.Open(Filename=update_file_pth).Close(True)
else:
print("It is not opended")
def find(self, list, key, value):
"""
This function give the index of a key in the dictionary in a list that match the input value
:param list: The collection of dictionaries
:param key: the key of a dictionary
:param value: the input key that needs to be found
:return: The index of the dictionary containing the key that match the input key
"""
for i, dic in enumerate(list):
if dic[key] == value:
return i
return -1
def inputMove(self):
"""
This function handles the inputs from the recognition system and call the Alpha-Beta function
:return: True if the game has ended, else return the result to pass to the SCARA arm
"""
# Check if BoardData_update is still opended
self.checkOpenStatus()
self.genDataFiles(self.player.getCurrentPieceList())
print("PieceRecog.exe", len(self.player.getCurrentPieceList()))
# Call the recognition function
os.system("PieceRecog.exe " +
str(len(self.player.getCurrentPieceList())))
# Check if BoardData_update is still opended
self.checkOpenStatus()
self.player.updateData('src\\BoardData_update.csv')
self.player.getChessPieceList('src\\BoardData_update.csv')
self.pieceList = self.player.getCurrentPieceList()
# Update the simulation board
self.playGUI.drawBoard(self.player)
check = self.setNextMove_AB()
if check == 0:
return True
else:
pd.DataFrame(self.player.getCurrentPieceList()).to_csv(
'src\\BoardData_update.csv', index=False)
print("Piecelist after Alpha beta: ", self.pieceList)
return check
def autochess(self):
"""
Simulation chess engine which will replace the player role. The depth in this chess engine is fixed to 2
:return: 0 if the game has ended, else does not return
"""
print("Player {}: depth = 2".format(self.player.getCurrentPlayer()))
self.player.changeCurrentPlayer()
red_start = time.time()
result = self.alphabeta(2, True, -9999, 9999, 2)
red_end = time.time()
red_elapse = red_end - red_start
print("red elapse: ", red_elapse)
self.red_count += 1
self.timetable_red.append((self.red_count, red_elapse))
# movePiece using result piece and position:
print("Result: ", result)
self.movePiece(self.pieceList, result['Piece'], result['Pos'])
self.player.UpdatePieceList(self.pieceList)
self.playGUI.drawBoard(self.player)
check = self.setNextMove_AB()
if (self.EndGame()) or (check == 0):
print(self.timetable_black)
return 0
else:
pass
def setNextMove_AB(self):
"""
This function calls the Minimax algorithm with Alpha-Beta pruning and update the Board data with its result
and pass that result to the SCARA arm
:return: result containing (old_pos, new_pos, check_capture) to the SCARA arm
"""
print("Player {} depth = 2".format(self.player.getCurrentPlayer()))
# Set timer start here:
black_start = time.time()
# Call Alpha Beta algorithm. Result is a dict: (score, piece, pos)
result = self.alphabeta(2, False, -9999, 9999, 2)
# Set timer stop here:
black_end = time.time()
black_elapse = black_end - black_start
print("black elapse: ", black_elapse)
self.black_count += 1
self.timetable_black.append((self.black_count, black_elapse))
# movePiece using result piece and position:
print("Result: ", result)
old_pos = self.pieceList[self.find(self.pieceList, 'Symbol',
result['Piece'])]['Pos']
check_capture = self.movePiece(self.pieceList, result['Piece'],
result['Pos'])
# Update the chess piece list and the simulation board
self.player.UpdatePieceList(self.pieceList)
self.playGUI.drawBoard(self.player)
# Update BoardData_update.csv
df = pd.DataFrame(self.pieceList)
df.set_index('Name', inplace=True)
print("df: \n", df)
df.to_csv("src\\BoardData_Update.csv")
# Check if the opponent player still has the General
check_endgame = self.EndGame()
if (check_endgame is True):
print(self.timetable_black)
# pd.DataFrame(self.logdata, columns=["Piece", "Pos", "Score", "Depth", "isMax", "Alpha", "Beta"]).to_csv("LogData.csv")
return 0
# Passing result to the SCARA arm
else:
self.player.changeCurrentPlayer()
print(
"Information to pass: Old pos: {}, New pos: {}, check capture: {}, check Endgame: {}"
.format(old_pos, result['Pos'], check_capture, check_endgame))
AB_result = (old_pos, result['Pos'], check_capture)
return AB_result
def movePiece(self, pieceList, piece, pos):
"""
This function update the current position of the chess piece in the chess piece list
:param pieceList: The current chess piece list
:param piece: The chess piece
:param pos: The position to update
:return: The captured status
"""
# check captured:
check = self.player.checkCaptured(self.pieceList, pos)
for i in range(len(pieceList)):
# print("I{} = ".format(i),self.pieceList['Symbol'][i])
if piece == pieceList[i]['Symbol']:
# print('Old: {} to {}'.format( pieceList[i]['Pos'], pos))
self.pieceList[i]['Pos'] = pos
break
else:
pass
return check
def EndGame(self):
"""
This function calls the isGeneralExist() function to check if the game has ended
:return: the Boolean deciding whether the game has ended
"""
check_endgame = not self.player.getPlayer().isGeneralExist()
return check_endgame
def nextState(self, piece, pos):
"""
This function clone the current State to not affect the current chess piece list
:param piece: The chess piece to change position
:param pos: The position to change
:return: The State with the changed position
"""
# Copy current pieceList to new state obj
nextState = copy.deepcopy(self)
nextState.movePiece(nextState.player.getCurrentPieceList(), piece, pos)
return nextState
def alphabeta(self, depth, isMax, alpha, beta, depth_flag):
"""
Minimax algorithm with Alpha-Beta pruning. This algorithm is upgraded
to fix the pruning problem at the highest depth
:param depth: The times a player is changed.
:param isMax: A Boolean to decide whether a Node is a Maximizer or a Minimizer
:param alpha: Initial value is -9999. This variable is updated at every Max node
:param beta: Initial value is 9999. This variable is updated at every Min node
:param depth_flag: The flag to inform and compared with the current depth
:return: The result containing (score, piece, position)
"""
# Check for endgame condition:
if self.EndGame() == True:
# print(self.player.getCurrentPieceList())
result = {"Score": '', "Piece": '', "Pos": ''}
pass
# Get score of pieceList
result['Score'] = ((99999999) * self.player.getCurrentPlayer(),
depth + 1)
return result
# Check for depth = 0
if depth == 0:
# print("Depth 0")
result = {"Score": '', "Piece": '', "Pos": ''}
pass
# Get score of pieceList
result['Score'] = (self.player.getPieceListScore(self.pieceList),
depth + 1)
return result
# Change current player
self.player.changeCurrentPlayer()
# Get possible move of the current player
possibleMoves = self.player.getAllPossibleMoves()
eval_result = list()
# Loop through possible move and create new piecelist with each move
for i in range(len(possibleMoves)):
# Collect inputs (piece and piece's position)
piece = possibleMoves[i][0]['Symbol']
to_pos = possibleMoves[i][1]
# Create new pieceList
nextState = self.nextState(piece, to_pos)
# Recall alpha beta to collect score from lower depth
alpha_beta_result = nextState.alphabeta(depth - 1, not isMax,
alpha, beta, depth_flag)
try:
score = alpha_beta_result['Score']
except:
print("\nWrong\n")
result = {"Score": score, "Piece": piece, "Pos": to_pos}
eval_result.append(result)
if isMax:
alpha = max(alpha, score[0])
else:
beta = min(beta, score[0])
# Check if depth is at top depth. Don't check beta <= alpha to avoid wrong pruning
if depth == depth_flag and (score[0] != 99999999
or score[0] != -99999999):
pass
else:
if beta <= alpha:
# print("Prun")
return eval_result[-1]
# Get score from eval result
score_list = list()
id = ''
for j in range(len(eval_result)):
score_list.append(eval_result[j]['Score'])
# Find index, check max depth , base on max or min value of tuple score
if isMax:
id = score_list.index(
max(filter(
lambda t: t[0] == max(score_list, key=itemgetter(0))[0],
score_list),
key=itemgetter(1)))
else:
id = score_list.index(
max(filter(
lambda t: t[0] == min(score_list, key=itemgetter(0))[0],
score_list),
key=itemgetter(1)))
return eval_result[id]
# Initiate LiveData
from src.LiveData import LiveData
liveData = LiveData(environment)
liveData.start()
# ECUHandler
from src.ECUHandler import ECUHandler
ecuHandler = ECUHandler(environment)
ecuHandler.start()
try:
# Environment
from src.Environment import Environment
environment = Environment()
environment.start()
gui = GUI(environment)
thread.start_new_thread(initClasses, ())
#Start gui and enter its mainloop
gui.start()
except (KeyboardInterrupt, SystemExit):
print("Exiting...")
sys.exit()
def instantiate_dependencies(self):
self.set(Tk, Tk())
self.set(KeyTransformer, KeyTransformer())
self.set(IDLocators, IDLocators())
self.set(CustomTreeBuilder, CustomTreeBuilder())
self.set(XAxis, XAxis(id_locators=self.get(IDLocators)))
self.set(YAxis, YAxis(id_locators=self.get(IDLocators)))
self.set(
WalkKey,
WalkKey(
config=self.get(Config),
transformer=self.get(KeyTransformer),
parser=self.get(CustomTreeBuilder),
),
)
self.set(
WalkEditor,
WalkEditor(
config=self.get(Config),
x_axis=self.get(XAxis),
y_axis=self.get(YAxis),
walk_key=self.get(WalkKey),
parser=self.get(CustomTreeBuilder),
),
)
self.set(CraftingEditor, CraftingEditor(config=self.get(Config)))
self.set(DoubleTapDodgeEditor,
DoubleTapDodgeEditor(config=self.get(Config)))
self.set(DisassembleEditor, DisassembleEditor(config=self.get(Config)))
self.set(
WalkFrame,
WalkFrame(walk_editor=self.get(WalkEditor),
walk_key=self.get(WalkKey)),
)
self.set(
CraftingFrame,
CraftingFrame(editor=self.get(CraftingEditor), ),
)
self.set(
DisassembleFrame,
DisassembleFrame(editor=self.get(DisassembleEditor), ),
)
self.set(
DoubleTapDodgeFrame,
DoubleTapDodgeFrame(
toggle_editor=self.get(DoubleTapDodgeEditor), ),
)
frames = {
WalkFrame: self.get(WalkFrame),
CraftingFrame: self.get(CraftingFrame),
DisassembleFrame: self.get(DisassembleFrame),
DoubleTapDodgeFrame: self.get(DoubleTapDodgeFrame),
}
gui = GUI(master=self.get(Tk), frames=frames)
gui.setup(config=self.get(Config))
self.set(GUI, gui)
