def __init__(self):
self.board = Board(ROWS, COLUMNS)
self.gui = GUI(ROWS, COLUMNS, SIZE, self.board)
self.rules = Rules()
self.cursor = Cursor()
self.player1 = Player(1)
self.player2 = AIPlayer(2, self.rules, self.board)
self.currentPlayer = self.assign_player()
self.gameOver = False
self.menuFlag = False
def begin(self):
# Get controller inputs from current states
# Run integrator threads, update quadcopter states
# Wait until maximum of threads finished or dt hit
# Update gui
# Repeat
simulate = multiprocessing.Process(None,
self.integration,
args=(self.queue, ))
simulate.start()
self.GUI = GUI(model=self.models[-1]["model"], queue=self.queue)
def moderate(self):
loader_back = Loader('Orchestrator/Back/dist')
loader_front = Loader('Orchestrator/Front/dist')
core = Core()
core.verify_rulers()
gui = GUI()
gui.get_data()
gui.show()
gui2 = GUI2()
gui2.get_data()
gui2.show()
notification = Notification()
notification.notify()
def run(self):
gui = GUI(WIN_WIDTH, WIN_HEIGHT, GRID_SIZE)
if self.gui_active:
gui.start()
while True:
grid = Grid(GRID_SIZE)
if not grid.read_grid(self.sudoku_file):
msg = "Sudoku not in valid format"
if self.gui_active:
gui.print_message(msg)
else:
print(msg)
break
msg = "Initial sudoku grid"
if self.gui_active:
if not gui.initial_screen(grid, msg):
break
else:
print(msg)
grid.print()
# Perform constraint propagation
grid.propagate_constraints_all_cells()
msg = "After constraint propagation"
if self.gui_active:
if not gui.screen_with_message(grid, msg):
break
else:
print(msg)
grid.print()
# Try deducing values of some cells
grid.deduce_vals_all_cells()
msg = "After deducing values"
if self.gui_active:
if not gui.screen_with_message(grid, msg):
break
else:
print(msg)
grid.print()
if grid.not_solvable():
msg = "Sudoku not solvable"
if self.gui_active:
if gui.final_screen(msg):
continue
else:
break
else:
print(msg)
if grid.all_cells_fixed():
msg = "Sudoku solved"
if self.gui_active:
if gui.final_screen(msg):
continue
else:
break
else:
print(msg)
# Solve using ant colony system
msg = "Ant colony system"
if self.gui_active:
gui.print_message(msg)
else:
print(msg)
solver = AntSolver(grid, GLOBAL_PHER_UPDATE, BEST_PHER_EVAPORATION,
NUM_OF_ANTS, gui, self.gui_active)
solution = solver.solve(LOCAL_PHER_UPDATE, GREEDINESS)
if solution.is_valid():
msg = "Sudoku solved!"
if self.gui_active:
if gui.final_screen(msg):
continue
else:
break
else:
print(msg)
break
else:
msg = "Sudoku solution not valid"
if self.gui_active:
if gui.final_screen(msg):
continue
else:
break
else:
print(msg)
break
if self.gui_active:
gui.end()
logger.debug('Starting main')
simon = SimplePlayer
human = SimpleHumanPlayer
nanny = NNSimpleGamePlayer
# nanny = NeuralNetwork
player1 = human()
player2 = nanny()
# player1 = randy()
# player1 = simon('simon')
human = None
for player in [player1, player2]:
if type(player) is SimpleHumanPlayer:
human = player
if player.requires_model_load:
player.load_model()
player1_wins = 0
player2_wins = 0
game = SimpleGame(player1, player2)
if human is not None:
human.UI = GUI(game, human)
human.UI.mainloop()
else:
GameHelpers.play_automated_games(game, 1000)
def main():
json = JSON()
congress = json.Read() # Called the json reading method to insert the data in the tree
GUI(congress) # Called the GUI, passing him the class with the tree
def main():
base = 3
automaton = Automaton()
comb = automaton.createBase(base)
automaton.createCell(comb, 10, base - 1, ['Bajo', 'Guitarra', 'Voz'])
GUI(automaton)
def main():
json = JSON()
graph = json.Read()
GUI(graph)
from GUI.GUI import GUI window = GUI() window.run()
def __init__(self):
self.gui = GUI(self, list(self.selection_methods.keys()), list(self.mutation_methods.keys()),
list(self.crossing_methods.keys()))
class Genetic:
selection_methods = {
"The best of selection": (TheBestOfSelection,),
"Roulette selection": (RouletteSelection,),
"Tournament Selection": (TournamentSelection,)
}
crossing_methods = {
"One point crossing": (PointCrossover, ("points", 1)),
"Two point crossing": (PointCrossover, ("points", 2)),
"Three point crossing": (PointCrossover, ("points", 3)),
"Uniform crossing": (UniformCrossover,),
"Arithmetic crossing": (ArithmeticCrossover,),
"Heuristic crossing": (HeuristicCrossover,)
}
mutation_methods = {
"One point mutation": (PointMutation, ("points", 1)),
"Two point mutation": (PointMutation, ("points", 2)),
"Three point mutation": (PointMutation, ("points", 3)),
"Edge mutation": (EdgeMutation,),
"Uniform mutation": (UniformMutation,)
}
def __init__(self):
self.gui = GUI(self, list(self.selection_methods.keys()), list(self.mutation_methods.keys()),
list(self.crossing_methods.keys()))
def run(self):
self.gui.show()
@staticmethod
def create_strategy(config):
strategy = config[0]()
for dict_element in config[1:]:
strategy[dict_element[0]] = dict_element[1]
return strategy
def start_work(self, x_value, digits_count, population_size, generations_number, elite_strategy_value,
inversion_probability, crossing_probability, mutation_probability, selection_method_name,
tournament_size, mutation_method_name, crossing_method_name, minimum, k_selection):
file = open("result.txt", "w")
elite_strategy_count = round(population_size * elite_strategy_value)
variables_names = ['x', 'y']
chromosome_size = calculate_the_number_of_genes(x_value) + digits_count
population = make_random_population(population_size, chromosome_size, variables_names)
precisions = {"x": digits_count, "y": digits_count}
if minimum:
fitness_function = partial(ackley_function_minimum_fitness_funtion, precisions)
else:
fitness_function = partial(ackley_function_maximum_fitness_funtion, precisions)
selection_strategy = self.create_strategy(self.selection_methods[selection_method_name])
selection_strategy["count"] = round(population_size - elite_strategy_count)
selection_strategy["fitness_function"] = fitness_function
selection_strategy["tournament_size"] = tournament_size
selection_strategy.check_required_parameters()
mutation_strategy = self.create_strategy(self.mutation_methods[mutation_method_name])
mutation_strategy["chromosomes"] = variables_names
mutation_strategy["probability"] = mutation_probability
mutation_strategy["min"] = -x_value
mutation_strategy["max"] = x_value - 1
mutation_strategy["precision"] = digits_count
mutation_strategy["fill"] = chromosome_size
mutation_strategy.check_required_parameters()
crossing_strategy = self.create_strategy(self.crossing_methods[crossing_method_name])
crossing_strategy["chromosomes"] = variables_names
crossing_strategy["probability"] = crossing_probability
crossing_strategy["k_selection_function"] = lambda: k_selection
crossing_strategy["precisions"] = precisions
crossing_strategy["fills"] = {"x": chromosome_size, "y": chromosome_size}
crossing_strategy.check_required_parameters()
inversion_strategy = Inversion()
inversion_strategy["chromosomes"] = variables_names
inversion_strategy["probability"] = inversion_probability
inversion_strategy.check_required_parameters()
elite_strategy = EliteStrategy()
elite_strategy["count"] = elite_strategy_count
elite_strategy["fitness_function"] = fitness_function
elite_strategy["tournament_size"] = tournament_size
elite_strategy.check_required_parameters()
simulation = Simulation(population, generations_number, selection_strategy, crossing_strategy,
mutation_strategy, fitness_function, elite_strategy, inversion_strategy, minimum)
result_params, result_value, value_history = simulation.simulate()
self.gui.show_result(result_params, result_value)
PlotGenerator().generate(value_history, minimum)
for epoch in value_history:
file.write(str(epoch) + '\n')
file.close()
from GUI.GUI import GUI
if __name__ == '__main__':
GUI()
class Game:
def __init__(self):
self.board = Board(ROWS, COLUMNS)
self.gui = GUI(ROWS, COLUMNS, SIZE, self.board)
self.rules = Rules()
self.cursor = Cursor()
self.player1 = Player(1)
self.player2 = AIPlayer(2, self.rules, self.board)
self.currentPlayer = self.assign_player()
self.gameOver = False
self.menuFlag = False
def assign_player(self):
a = random.randint(0, 1)
if a == 0:
self.gui.next_move_message(self.player1.get_id())
return self.player1
else:
self.gui.next_move_message(self.player2.get_id())
return self.player2
def switch_players(self):
if self.currentPlayer == self.player1:
self.currentPlayer = self.player2
else:
self.currentPlayer = self.player1
self.gui.next_move_message(self.currentPlayer.get_id())
def reset(self):
self.menuFlag = False
self.board.reset()
def change_rules(self, rule):
if rule == 1:
self.rules = Rules()
elif rule == 2:
self.rules = DiagonalOnly()
else:
self.rules = RowsColumnsOnly()
self.reset()
def update_cursor(self, event):
x = event.pos[0]
y = event.pos[1]
self.cursor.update(x, y)
def mouse_motion(self):
if self.gameOver is False and self.menuFlag is False:
if self.gui.are_buttons_hovered(self.cursor.gety()):
self.gui.buttons_hovered(self.cursor.getx())
else:
self.gui.draw_gui(self.board)
elif self.menuFlag:
if self.gui.are_rules_hovered(self.cursor.getx(),
self.cursor.gety()):
self.gui.rules_hovered(self.cursor.getx(), self.cursor.gety())
else:
self.gui.draw_gui(self.board)
def move_made(self):
if self.rules.winning_move(self.board.get_board(),
self.currentPlayer.get_id(),
self.board.get_columns(),
self.board.get_rows()):
self.gameOver = True
self.gui.winning_move_message(self.currentPlayer.get_id())
elif self.board.is_full():
self.gui.draw_message()
self.gameOver = True
else:
self.switch_players()
#print(self.board.get_board())
def mouse_clicked(self):
if self.gameOver is False and self.menuFlag is False:
if self.gui.are_buttons_hovered(self.cursor.gety()):
col = int(math.floor(self.cursor.getx() / self.gui.get_size()))
if self.currentPlayer.make_move(self.board, col):
self.move_made()
else:
self.gui.not_valid_loc_message(self.currentPlayer.get_id())
self.gui.draw_gui(self.board)
elif self.menuFlag:
if self.gui.are_rules_hovered(self.cursor.getx(),
self.cursor.gety()):
rule = self.gui.get_rule(self.cursor.getx(),
self.cursor.gety())
self.change_rules(rule)
self.gui.shut_rules()
self.gameOver = self.menuFlag = False
self.reset()
if self.gui.reset_hovered(self.cursor.getx(), self.cursor.gety()):
self.board.reset()
self.assign_player()
self.gameOver = self.menuFlag = False
if self.gui.are_options_hovered(self.cursor.getx(),
self.cursor.gety()):
self.gui.options_hovered(self.menuFlag)
self.menuFlag = not self.menuFlag
self.gui.draw_gui(self.board)
def start_game(self):
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if self.currentPlayer.get_type() == "player":
if event.type == pygame.MOUSEMOTION:
self.update_cursor(event)
self.mouse_motion()
elif event.type == pygame.MOUSEBUTTONDOWN:
self.update_cursor(event)
self.mouse_clicked()
elif self.currentPlayer.get_type() == "AI":
if not self.gameOver and not self.menuFlag:
if self.currentPlayer.make_move(self.board, 0):
self.move_made()
else:
self.gui.not_valid_loc_message(
self.currentPlayer.get_id())
self.gui.draw_gui(self.board)
else:
self.currentPlayer = self.player1
def main():
automaton = Automaton()
automaton.AddRoot(4, 0, [], 'L')
GUI(automaton)