def test_is_in_next_step():
"""Test click the position which is legal place, which means the location
should be in self.next_step_map"""
gc = GameController(800, 100)
assert gc.is_in_next_step(3, 2) is True
assert gc.is_in_next_step(5, 4) is True
assert gc.is_in_next_step(7, 7) is False
def main():
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
pygame.display.set_caption('pyarcanoid')
pygame.display.set_icon(pygame.image.load('assets/brick.png'))
screen = pygame.display.set_mode(
[settings.SCREEN_WIDTH, settings.SCREEN_HEIGHT])
pygame_clock = pygame.time.Clock()
background = Background(screen)
game_controller = GameController(screen)
running = True
while running:
pygame_clock.tick(60)
screen.fill([0, 0, 0])
background.update()
game_controller.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
game_controller.pause = not game_controller.pause
pygame.display.flip()
pygame.quit()
def __init__(self,
delay,
collect_cases=False,
use_merge_input_nodes=False,
*args,
**kwargs):
tk.Tk.__init__(self, *args, **kwargs)
self.title("2048-solver Neural nets")
self.cell_width = self.cell_height = 100
self.dim = (4, 4)
self.delay = delay
screen_width = self.dim[0] * self.cell_width + 1
screen_height = self.dim[1] * self.cell_height + 1
self.canvas = tk.Canvas(self,
width=screen_width,
height=screen_height,
borderwidth=0,
highlightthickness=0)
self.canvas.pack(side="top", fill="both", expand="true")
self.color_dict = self.fill_color_dict()
#self.bind_keys()
self.controller = GameController(
collect_cases=collect_cases,
use_merge_input_nodes=use_merge_input_nodes)
self.do_iteration()
def test_score_position():
gc = GameController(SPACE, filename)
board = [[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1], [-1, -1, 1, 0, -1, -1, -1],
[-1, 1, 1, 0, -1, -1, -1], [-1, 0, 1, 0, -1, -1, -1]]
assert gc.score_position(board, HUMAN) == -81
assert gc.score_position(board, AI) == -82
def test_makevalidmove():
gc = GameController(400, 400)
bd = Board(4, 4, gc)
# Actual coordinates on grid
# If we try to place a disk object in the table
# index that already has a disk object, will end function
# and return None
assert bd.makevalidmove(100, 100) == None
# If we try to click on a spot that does not have an object
# but is not valid, will return empty list, because no tiles
# were flipped
assert bd.makevalidmove(50, 50) == []
# If we successfully add a disk in a spot, color flag
# will change and it will be the other color's turn, in this
# case, True flag (Black) switches to False (White)
gc1 = GameController(400, 400)
bd1 = Board(4, 4, gc1)
bd1.table[0][0] = Disk(0, 0, 255)
bd1.table[0][1] = Disk(0, 1, 255)
bd1.table[0][2] = Disk(0, 2, 255)
bd1.table[1][0] = Disk(1, 0, 255)
bd1.table[1][1] = Disk(1, 1, 255)
bd1.table[1][2] = Disk(1, 2, 0)
bd1.table[2][0] = Disk(2, 0, 255)
bd1.table[2][1] = Disk(2, 1, 0)
bd1.table[2][2] = Disk(2, 2, 0)
assert bd1.color_flag
bd1.makevalidmove(350, 350)
assert not bd1.color_flag
def test_start_drop():
gc = GameController(SPACE, filename)
cur_x, cur_y = 300, 30
num_empty_cells_bef = sum(row.count(None) for row in gc.board)
gc.start_drop(cur_x, cur_y)
num_empty_cells_aft = sum(row.count(None) for row in gc.board)
assert num_empty_cells_aft == num_empty_cells_bef - 1
def main():
model = GameModel()
view = GameView(800, 600)
controller = GameController(model, view)
# ---
while (True):
controller.update()
def test_check_all_positions():
gc = GameController(400, 400)
bd = Board(4, 4, gc)
# Tests case where board is filled by all black
# manually insert a white disk at point table[0][0]
# game ends and method returns expected tuple
for y in range(len(bd.table)):
for x in range(len(bd.table)):
bd.table[y][x] = Disk(y, x, 0)
bd.table[0][0] = Disk(0, 0, 255)
assert bd.check_all_positions() == (15, 1)
# Tests case where board is not filled but
# there are no more possible valid moves for
# both sides and game ends. Test returns expected tuple
gc1 = GameController(400, 400)
bd1 = Board(4, 4, gc1)
bd1.table[1][1] = 0
bd1.table[1][2] = 0
bd1.table[2][1] = 0
bd1.table[2][2] = 0
bd1.table[0][0] = Disk(0, 0, 0)
bd1.table[0][1] = Disk(0, 1, 255)
bd1.makevalidmove(250, 0)
assert bd1.check_all_positions() == (3, 0)
def play(self, login, password):
game_controller = GameController()
game_controller.load_board()
board = self.get_board()
# self.board.show()
solver = Solver(board)
solver.solve()
def __init__(self, board_width, game_size, player_name, player_color):
'''
Initializing the game with class Board, and class GameController
'''
self.board = Board(board_width, game_size)
self.tiles = [Tile(board_width / game_size)
for _ in range(game_size ** 2)]
self.gc = GameController(board_width, board_width,
player_name, player_color)
tile = self.tiles.pop()
tile.set_white()
self.board.grids[game_size//2 - 1][game_size//2 - 1] = tile
tile = self.tiles.pop()
tile.set_black()
self.board.grids[game_size // 2][game_size//2 - 1] = tile
tile = self.tiles.pop()
tile.set_black()
self.board.grids[game_size//2 - 1][game_size // 2] = tile
tile = self.tiles.pop()
tile.set_white()
self.board.grids[game_size // 2][game_size // 2] = tile
self.valid_grids = set({})
self.is_black = True
# self.game_start()
# self.skip_times = 0
self.is_control = False
def main():
gc = GameController()
print("------------------------------------")
print("Welcome to the simplified BlackJack!")
gc.start_play()
def play(self, login, password):
game_controller = GameController()
game_controller.load_board()
board = self.get_board()
# self.board.show()
solver = Solver(board)
solver.solve()
def main():
logger = get_logger()
logger.info("取得開始")
game = GameController()
old = 0
# 数字データ
numbers = get_numbers_ndarray()
while True:
screen = game.take_png_screenshot_for_win10(True)
screen = screen[90:90 + 40, -190:-1] # だいたいスキルアイコンの下あたりにある想定でクロップ
mask_image = cv2.inRange(screen, np.array([255, 34, 34]),
np.array([255, 34, 34])) # 赤色文字のみ抽出
mask_image, contours, hierarchy = cv2.findContours(
mask_image, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
rects = convert_contours_to_rects(contours)
rects = remove_same_x_rect(rects)
text = ""
for [x, y, w, h] in rects:
for i, number in enumerate(numbers):
if np.allclose(mask_image[y:y + 9, x:x + 2], number):
text = text + str(i)
if text != "":
num = int(text)
if old != 0:
number_per_minute = num - old
old = num
logger.info("差分撃破数:{0}".format(number_per_minute))
else:
old = num
logger.info("初回取得完了 数字:{0}".format(num))
else:
old = 0
logger.info("撃破数取得エラー")
time.sleep(60)
def fight_start(self):
"""
START按钮响应流程
:return:
"""
self.scaling = self.get_scaling()
if not self.scaling:
return False
self.clear_time = self.get_clear_time()
if not self.clear_time:
return False
self.delay_time = self.get_delay_time()
if not self.delay_time:
return False
self.timing_value = self.get_timimg()
if not self.timing_value:
return False
self.info_save()
# 获取游戏窗口句柄
self.hwnd = check_hwnd(self.label)
if not self.hwnd:
messagebox.showinfo(title='提示', message='游戏没有运行')
return False
# self.shell = win32com.client.Dispatch("WScript.Shell")
# self.shell.SendKeys('%')
jump_window(self.hwnd)
time.sleep(0.5)
self.fight = GameController(self.hwnd, self.scaling)
if self.debug:
self.fight.setdebug(True)
threads = []
thread1 = threading.Thread(target=self.fight_thread,
name='fight_thread')
threads.append(thread1)
thread2 = threading.Thread(target=self.offer_thread,
name='offer_thread')
threads.append(thread2)
thread3 = threading.Thread(target=self.fullrepo_thread,
name='fullrepo_thread')
threads.append(thread3)
if self.listbox_timing_mode.get(
) == '超鬼王模式1' or self.listbox_timing_mode.get() == '超鬼王模式2':
thread4 = threading.Thread(target=self.boss_monitoring_thread,
name='boss_thread')
threads.append(thread4)
# 将线程状态、队列内容置为1
self._running = 1
if self.queue.empty():
self.queue.put(1)
else:
self.queue.get()
self.queue.put(1)
self.start_ctn.configure(state='disabled')
self.stop_ctn.configure(state='active')
for thread in threads:
thread.setDaemon(True)
thread.start()
def test_change_color():
"""Test change color"""
gc = GameController(800, 100)
# the original color is 0 (black color)
assert gc.color == 0
gc.change_color() # execute change color method
# new color is 255 (white color)
assert gc.color == 255
def _compete_game(self, player1, player2):
controller = GameController(player1, player2)
winner = None
moves = []
while winner is None:
winner, move = controller.make_move()
moves.append(move)
return winner, moves
def test_player_move():
""" Test player's move """
gc = GameController(400, 400, 4)
gc.board.tiles.counting_tile()
lst = gc.board.legal_move(0)
gc.player_make_move(200, 300)
assert gc.board.tiles.t_total[2][3].get_color() == 0
assert gc.board.tiles.t_total[2][2].get_color() == 0
assert gc.board.tiles.t_total[2][3].get_color() == 0
def test_col_win():
gc = GameController(SPACE, filename)
board = [[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1], [-1, -1, 1, 0, -1, -1, -1],
[-1, 1, 1, 0, -1, -1, -1], [-1, 0, 1, 0, -1, -1, -1]]
assert not gc.col_win(board, HUMAN)
assert not gc.col_win(board, AI)
board[2][2] = 1
assert gc.col_win(board, HUMAN)
def test_row_win():
gc = GameController(SPACE, filename)
board = [[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1], [-1, 0, 0, 0, -1, -1, -1],
[-1, 1, 1, 1, -1, -1, -1], [-1, 0, 1, 0, 1, -1, -1]]
assert not gc.row_win(board, HUMAN)
assert not gc.row_win(board, AI)
board[4][4] = 1
assert gc.row_win(board, HUMAN)
def start_game(self, player_types_dict):
self.player1 = self.get_and_load_player(self.player1,
player_types_dict["x"],
Board.X)
self.player2 = self.get_and_load_player(self.player2,
player_types_dict["o"],
Board.O)
self.controller = GameController(self.player1, self.player2)
return self._get_game_info(None)
def main(stdscr):
model = Model()
agent = A2CAgent(model)
learning_environment = LearningEnvironment()
agent.initialize_model(learning_environment)
agent.load_model_if_previously_saved()
game_controller = GameController(stdscr)
game_controller.play(agent, learning_environment)
def test_read_file():
WIDTH = 600
stone = Stone(WIDTH)
gc = GameController(WIDTH, stone)
assert gc.score_list == []
# The default when scores.txt is blank
gc.read_file('test_scores.txt')
assert gc.score_list == [['Khai4', 22], ['Khai3', 20]]
def test_ranked_flipped_space():
"""Test ranked flipped space method"""
gc = GameController(800, 100)
assert (gc.ranked_flipped_space({
(3, 2): {(3, 3)},
(5, 4): {(4, 4), (4, 5)},
(4, 5): {(4, 4)},
(2, 3): {(3, 3)}
})) == [((5, 4), {(4, 5), (4, 4)}), ((3, 2), {(3, 3)}), ((4, 5), {(4, 4)}),
((2, 3), {(3, 3)})]
def perform(puzzle, row, col):
listofmoves = []
q = Queue.Queue()
fifo = puzzle
puzzlee = deepcopy(puzzle)
steps = 0
moves = {} # dictionary that holds the visited nodes to refer to
path = []
coord = ["start"] # list of moves
path.append((puzzlee, coord)) # keep track of the path of each node
moves[str(
deepcopy(puzzle))] = "visited" # Add the puzzel as a visited node
while (GameController.is_solved(fifo) !=
1): # while the puzzle is not solved search for solution
for i in range(row):
for e in range(col):
pmove = GameController.perform_move(
deepcopy(fifo), i, e) # perform move on the puzzle
check = str(
pmove) # add state afer performing move to check
steps = steps + 1 # count the number of steps
c = str(e) + str(i) # store coordinates of move in C
if check in moves: # if the node has been visited do nothing
pass
else:
moves[deepcopy(
check
)] = "visited" # add the new state to dictionary of visited nodes
coord.append(c)
q.put(
deepcopy(pmove)) # put the state in our LIFO queue
path.append(
(deepcopy(pmove), deepcopy(coord))
) # Keep track of the path that leads to the state
coord.pop()
fifo = q.get() # get the first state
currentstate, coord = path.pop(
1) # get the state and the matching path to get to it
ret = []
for i in range(row):
for e in range(col):
if coord.count(
(str(i) + str(e))
) % 2 == 1: # if coordinates occur in any muitple of two then it is the same as not
# performing the move so we only want odd number moves
listofmoves.append(str(i) + str(e))
ret.append([str(i), str(e)])
return ret
def test_game_can_proceed():
"""Test the game_can_proceed method."""
tiles = Tiles(800, 100)
board = Board(800, 100, tiles)
player = Player('Alfred', board, 'black')
ai = AI(board, player)
game_controller = GameController(player, ai, board)
assert game_controller.game_can_proceed() is True
for pair in board.on_board:
board.tiles_list[pair[0]][pair[1]].color = 'white'
assert game_controller.ai_has_move() is False
def main():
print("--------------------------------\n\
Welcome to street craps!\n")
print("Rules:")
print("If you roll 7 or 11 on your first roll, you win.\n\
If you roll 2, 3, or 12 on your first roll, you lose.\n\
If you roll anything else, that's your 'point', and\n\
you keep rolling until you either roll your point\n\
again (win) or roll a 7 (lose)\n")
gc = GameController()
gc.start_play()
def test_search_flips():
gc1 = GameController(800, 800)
b1 = Board(800, 800, gc1)
gc2 = GameController(800, 800)
b2 = Board(800, 800, gc2)
# Illegal move.
flips1 = b1.search_flips(0, 0, 0)
# Legal move.
flips2 = b2.search_flips(2, 3, 0)
assert flips1 == {}
assert flips2["right"] == [(3, 3)]
def test_minimax():
gc = GameController(SPACE, filename)
board = [[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, 0, -1, -1, -1],
[-1, -1, -1, 1, 0, -1, -1], [-1, -1, 0, 1, 1, -1, 1]]
depth = 3
alpha = -sys.maxsize
beta = sys.maxsize
maximizing = True
best_col = gc.minimax(board, depth, alpha, beta, maximizing)[0]
assert best_col == 5
def test_can_go():
WIDTH = 600
stone = Stone(WIDTH)
gc = GameController(WIDTH, stone)
gc.counter = 2
gc.stone.total_row[3][3].color = 0 # 4 starting stones
gc.stone.total_row[4][4].color = 0
gc.stone.total_row[3][4].color = 1
gc.stone.total_row[4][3].color = 1
gc.can_go()
assert len(gc.moves_list) == 4 # First move: 4 valids moves for player
def test_get_open_row():
gc = GameController(SPACE, filename)
board = [[-1, -1, 1, 1, -1, -1, -1], [-1, -1, 0, 0, -1, -1, -1],
[-1, 1, 0, 1, -1, -1, -1], [-1, 0, 0, 0, -1, -1, -1],
[-1, 1, 1, 1, -1, -1, -1], [-1, 0, 1, 0, 1, -1, -1]]
col0 = 0
col1 = 1
col4 = 4
assert gc.get_open_row(board, col0) == 5
assert gc.get_open_row(board, col1) == 1
assert gc.get_open_row(board, col4) == 4
def _train_game(self, player1, player2):
controller = GameController(player1, player2)
winner = None
while winner is None:
winner, _ = controller.make_move()
run_if_learner(player1, lambda: player1.store_state())
run_if_learner(player2, lambda: player2.store_state())
run_if_learner(player1, lambda: player1.set_reward(winner))
run_if_learner(player2, lambda: player2.set_reward(winner))
return winner
def main():
pygame.init()
screen = pygame.display.set_mode ((1024, 768), SWSURFACE)
pygame.display.set_caption('Tetris Math')
clock = pygame.time.Clock()
MAX_FPS = 80
controller = GameController(screen)
# try:
while controller.running:
controller.update()
controller.draw()
clock.tick(MAX_FPS)
def perform(puzzle, row, col):
listofmoves = []
q = Queue.Queue()
fifo = puzzle
puzzlee = deepcopy(puzzle)
steps = 0
moves = {} # dictionary that holds the visited nodes to refer to
path = []
coord = ["start"] # list of moves
path.append((puzzlee, coord)) # keep track of the path of each node
moves[str(deepcopy(puzzle))] = "visited" # Add the puzzel as a visited node
while (GameController.is_solved(fifo) != 1): # while the puzzle is not solved search for solution
for i in range(row):
for e in range(col):
pmove = GameController.perform_move(deepcopy(fifo), i, e) # perform move on the puzzle
check = str(pmove) # add state afer performing move to check
steps = steps + 1 # count the number of steps
c = str(e) + str(i) # store coordinates of move in C
if check in moves: # if the node has been visited do nothing
pass
else:
moves[deepcopy(check)] = "visited" # add the new state to dictionary of visited nodes
coord.append(c)
q.put(deepcopy(pmove)) # put the state in our LIFO queue
path.append(
(deepcopy(pmove), deepcopy(coord))) # Keep track of the path that leads to the state
coord.pop()
fifo = q.get() # get the first state
currentstate, coord = path.pop(1) # get the state and the matching path to get to it
ret = []
for i in range(row):
for e in range(col):
if coord.count((str(i) + str(
e))) % 2 == 1: # if coordinates occur in any muitple of two then it is the same as not
# performing the move so we only want odd number moves
listofmoves.append(str(i) + str(e))
ret.append([str(i),str(e)])
return ret
def perform(puzzle, row, col):
# dictionary to keep track of visited nodes
moves = {}
moves[str(deepcopy(puzzle))] = "visited"
listofmoves = []
q = Queue.LifoQueue()
state = puzzle
steps = 0
path = []
coord = ["start"]
path.append((state, coord))
while (GameController.is_solved(state) != 1): # while puzzle is not solved
for i in range(row):
for e in range(col):
move = GameController.perform_move(deepcopy(state), i, e) # perform move on puzzle
check = str(move)
steps = steps + 1 # count the number of steps
c = str(e) + str(i) # store coordinates of move in C
if check in moves: # if node has been visited then do nothing
pass
else:
moves[deepcopy(check)] = "visited" # add state to visited nodes dictionary
coord.append(c)
q.put(deepcopy(move)) # put the state in our LIFO queue
path.append((deepcopy(move), deepcopy(coord))) # Keep track of the path that leads to the state
coord.pop()
# get the last state added to the queue (LIFO) --> this is the next state to perform move on
state = q.get()
currentstate, coord = path.pop()
ret = []
for i in range(row):
for e in range(col):
if coord.count((str(i) + str(
e))) % 2 == 1: # if coordinates occur in any muitple of two then it is the same as not
# performing the move so we only want odd number moves
listofmoves.append(str(i) + str(e))
ret.append([str(i),str(e)])
return ret
def __init__(self, delay, collect_cases=False, use_merge_input_nodes=False, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)
self.title("2048-solver Neural nets")
self.cell_width = self.cell_height = 100
self.dim = (4, 4)
self.delay=delay
screen_width = self.dim[0]*self.cell_width+1
screen_height = self.dim[1]*self.cell_height+1
self.canvas = tk.Canvas(self, width=screen_width, height=screen_height, borderwidth=0, highlightthickness=0)
self.canvas.pack(side="top", fill="both", expand="true")
self.color_dict = self.fill_color_dict()
#self.bind_keys()
self.controller = GameController(collect_cases=collect_cases, use_merge_input_nodes=use_merge_input_nodes)
self.do_iteration()
class Gui(tk.Tk):
def __init__(self, delay, collect_cases=False, use_merge_input_nodes=False, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)
self.title("2048-solver Neural nets")
self.cell_width = self.cell_height = 100
self.dim = (4, 4)
self.delay=delay
screen_width = self.dim[0]*self.cell_width+1
screen_height = self.dim[1]*self.cell_height+1
self.canvas = tk.Canvas(self, width=screen_width, height=screen_height, borderwidth=0, highlightthickness=0)
self.canvas.pack(side="top", fill="both", expand="true")
self.color_dict = self.fill_color_dict()
#self.bind_keys()
self.controller = GameController(collect_cases=collect_cases, use_merge_input_nodes=use_merge_input_nodes)
self.do_iteration()
def do_iteration(self):
self.controller.run_algorithm()
self.draw_board()
if self.controller.continuing:
self.after(self.delay, lambda: self.do_iteration())
def bind_keys(self):
self.bind('<Up>', lambda event: self.move(self, self.game_board.move_up()))
self.bind('<Down>', lambda event: self.move(self, self.game_board.move_down()))
self.bind('<Right>', lambda event: self.move(self, self.game_board.move_right()))
self.bind('<Left>', lambda event: self.move(self, self.game_board.move_left()))
def move(self, event, is_moved):
if is_moved:
self.game_board.generate_new_node()
self.draw_board()
def draw_board(self):
self.canvas.delete("all")
for y in range(self.dim[1]):
for x in range(self.dim[0]):
x1 = x * self.cell_width
y1 = self.dim[1]*self.cell_height - y * self.cell_height
x2 = x1 + self.cell_width
y2 = y1 - self.cell_height
cell_type = self.controller.board[y][x]
text = str(self.controller.board[y][x])
color = self.color_dict[str(self.controller.board[y][x])]
self.canvas.create_rectangle(x1, y1, x2, y2, fill=color, tags="rect")
if cell_type != 0:
self.canvas.create_text(x1+self.cell_width/2, y1-self.cell_height/2, text=text)
def fill_color_dict(self):
color_dict = {
'0': "white",
'2': "lemon chiffon",
'4': "peach puff",
'8': "sandy brown",
'16': "dark orange",
'32': "salmon",
'64': "tomato",
'128': "khaki",
'256': "khaki",
'512': "red",
'1024': "light goldenrod",
'2048': "firebrick",
'4096': "dim grey",
'8192': "light goldenrod",
}
return color_dict
if (choice == '1'):
pass
elif (choice == '2'):
print "Claim functionality not supported yet"
continue
elif (choice == '3'):
break
else:
print "Wrong Input" # can put try/except with loop instead
continue
# TODO Use with to control context
game_id = 24 # TODO This has to be generated and used in DB
game_session = GameController(game_id, _delay) # STARTS new thread
#print "#####", game_session
player_handler = PlayerInputHandler(game_session)
player_handler_thread = threading.Thread(target=player_handler.worker_thread)
player_handler_thread.start()
#print "+++++", player_handler_thread
print "Starting Game\n"
game_session.start()
while (game_session.is_game_over() == False):
#time.sleep(5) # Debug code
# if tkt_claimed from KB, call GamController.keyPress
key = raw_input()
from game_controller import GameController
from bfs import BFS
from dfs import DFS
from a_star import AStar
# work with hash map because checking of already existing state
# -------------------------------------------------------------------------
# row = int(input('Enter number of Rows (Must be > 1): '))
row = 2
# col int(input('Enter number of Columns (Must be > 1): '))
col = 3
puzzel = GameController.create_puzzle(row, col)
puzzel = GameController.scramble(puzzel)
# puzzel = [[' 0 ', ' 0 ', ' 0 '], [' 1 ', ' 0 ', ' 1 ']]
puzzelorg = deepcopy(puzzel)
puzzeldfs = deepcopy(puzzel)
# -------------------------------------------------------------------------
# uncomment this block to use the dfs_ai search algorithm
moves = DFS.perform(puzzel, row, col)
# uncomment to use the A* search
# moves = AStar.perform(puzzel, row,col)
def main():
logging.basicConfig(format='[%(asctime)s] [%(threadName)13s] %(levelname)7s: %(message)s', level=logging.DEBUG)
logging.info("Starting up...")
# ## Loading Configuration
logging.debug("Loading configuration...")
config = configparser.ConfigParser()
config.read('config.ini')
# General
gui_enabled = config["General"].getboolean("GUI")
configure_all(config)
logging.debug("Configuration loaded.")
### Starting up Matrix
matrix_controller = MatrixController()
game_controller = GameController(matrix_controller)
### Starting up Webserver
webserver = MatrixWebserver(game_controller, address="", port=8000)
webserver.start()
root = None
if gui_enabled:
### Starting up GUI
try:
root = tkinter.Tk()
except tkinter.TclError:
logging.warning("Could not initialise Tk class - Disabling GUI")
gui_enabled = False
else:
root.geometry("302x750+50+50")
root.title("LED control panel")
app = GUIapp(root, game_controller)
# Matrix controller will trigger GUI update when data changes
matrix_controller.connect("data_update", app.update)
game_controller.set_game_mode(GameController.Mode.test)
if gui_enabled:
logging.debug("Entering tkinter mainloop")
### MAIN LOOP when GUI is enabled
root.mainloop()
logging.debug("Tkinter mainloop has exited.")
else:
try:
### MAIN LOOP when gui is disabled
run = True
while run:
user_input = input("Type 'q' to stop or 'reset id' to reset all ID's.\n")
if user_input == "q":
run = False
elif user_input == "reset id":
matrix_controller.reset_id_all()
except KeyboardInterrupt:
logging.info("Keyboard interrupt received.")
### STOPPING
logging.info("Stopping...")
webserver.join()
matrix_controller.stop()
logging.info("Stopped.")
def perform2(puzzle, row, col):
listofmoves = []
q = Queue.PriorityQueue()
fifo = puzzle
steps = 0
moves = {}
moves[str(deepcopy(puzzle))] = "visited"
path = Queue.PriorityQueue()
coord = ["start"]
while (GameController.is_solved(fifo) != 1):
for i in range(row):
for e in range(col):
if (fifo != "empty"): # empty is used to represent nodes that have been visited
pmove = GameController.perform_move(deepcopy(fifo), i, e) # perform move on the puzzel
check = str(pmove)
steps = steps + 1 # count the number of steps
state = deepcopy(pmove)
lights = GameController.count_lights(pmove) # count the number of lights
c = str(e) + str(i) # store coordinates of move in C
if check in moves: # if node has been been visited then do nothing
pass
else:
# prioritize puzzles that have been solved
if lights == 0:
moves[deepcopy(check)] = "visited"
q.put((1, state)) # put the state in our queue
coord.append(c)
path.put((1, (
deepcopy(pmove),
deepcopy(coord)))) # Keep track of the path that leads to the state
coord.pop()
# prioritize puzzles that have one more move to solve next
elif lights == 5:
moves[deepcopy(check)] = "visited"
q.put((2, state)) # put the state in our queue
coord.append(c)
path.put((2, (
deepcopy(pmove),
deepcopy(coord)))) # Keep track of the path that leads to the state
coord.pop()
# prioritize puzzles that have one more move to solve next
elif lights == 3:
moves[deepcopy(check)] = "visited"
q.put((3, state)) # put the state in our queue
coord.append(c)
path.put((3, (
deepcopy(pmove),
deepcopy(coord)))) # Keep track of the path that leads to the state
coord.pop()
else: # else treat as a regular state to explore
moves[deepcopy(check)] = "visited"
q.put((4, state)) # put the state in our queue
coord.append(c)
path.put((4, (
deepcopy(pmove),
deepcopy(coord)))) # Keep track of the path that leads to the state
coord.pop()
junk, fifo = q.get() # get the highest priority state
priority, info = path.get()
coord = info[1]
ret = []
for i in range(row):
for e in range(col):
if coord.count((str(i) + str(
e))) % 2 == 1: # if coordinates occur in any muitple of two then it is the same as not
# performing the move so we only want odd number moves
listofmoves.append(str(i) + str(e))
ret.append([str(i), str(e)])
return ret