def test_return_animation(self): """ execution scenarios: - self.view.animate_return(self.ray_coords): True/False - len(self.board.columns[self.ray_coords['position']].figures) == 0 - self.board.columns[self.ray_coords['position']].figures[-1].fits(self.player.captured_figure) == True - self.board.columns[self.ray_coords['position']].figures[-1].empty is True """ # set object state mock_view = mock.Mock() mock_view.animate_return.return_value = False mock_player = mock.Mock() mock_player.capture_figure.return_value = figure.Figure() mock_mq = mock.Mock() mock_broker = mock.Mock() test_ctrl = controller.Controller(mock_view, mock_player, mock_mq, mock_broker) test_ctrl.board = board.Board() test_ctrl.ray_coords = {'position': 3} # setup scenario mock_view.animate_return.return_value = True # execute method test_ctrl.return_animation() # assert expected results (nothing happens) # TODO: actual assertions # setup scenario mock_view.animate_return.return_value = False # execute method test_ctrl.return_animation()
def test_explode_all_targets(self): """ execution scenarios: - self.frame < 16 """ # set object state mock_view = mock.Mock() mock_player = mock.Mock() mock_player.score = 10 mock_mq = mock.Mock() mock_broker = mock.Mock() test_ctrl = controller.Controller(mock_view, mock_player, mock_mq, mock_broker) mock_board = mock.Mock() mock_board.eliminate_targets.return_value = 1 test_ctrl.board = mock_board # setup scenario test_ctrl.frame = 15 # execute method test_ctrl.explode_all_targets() # assert expected results self.assertTrue(mock_view.draw_explosion.called) self.assertEqual(test_ctrl.frame, 16) # setup scenario frame == 16 # execute method test_ctrl.explode_all_targets() # assert expected results self.assertTrue(mock_view.draw_explosion.called) self.assertEqual(test_ctrl.frame, 0) self.assertTrue(mock_board.eliminate_targets.called)
def main(): """ Main function of the application. """ # Initialize the event manager. event_manager = events.EventManager() AppState.get_state().set_event_manager(event_manager) # Initialize and register the application heartbeat. heart_beat = HeartBeat() event_manager.register_listener(heart_beat) # Initialize and register the world. basic_experiment = experiment.basic.BasicExperiment() world = basic_experiment.get_world() event_manager.register_listener(world) AppState.get_state().set_world(world) # Initialize pygame. surface = init() # Initialize and register the view. main_view = view.View(surface) event_manager.register_listener(main_view) # Initialize and register the controller. main_controller = controller.Controller() event_manager.register_listener(main_controller) # Start the heartbeat. heart_beat.run()
def test_check_on_opponent(self): """ execution scenarios: - message not None - info['status'] : 'OVER'/'PLAYING' - self.rows_received * 20 < int(self.opponent_state['score']) """ # set object state mock_view = mock.Mock() mock_player = mock.Mock() mock_mq = mock.Mock() mock_broker = mock.Mock() test_ctrl = controller.Controller(mock_view, mock_player, mock_mq, mock_broker) # setup scenario mock_mq.sub_receive_multi.return_value = [0, b'{"status": "OVER"}', b'{"score": 1}'] # execute method test_ctrl.check_on_opponent() # assert expected results (nothing) self.assertEqual(test_ctrl.keyword, 'victory') self.assertTrue(test_ctrl.draw_again) # setup scenario mock_mq.sub_receive_multi.return_value = [0, b'{"status": "PLAYING"}', b'{"score": 25}'] mock_board = mock.Mock() test_ctrl.board = mock_board test_ctrl.rows_received = 1 # execute method test_ctrl.check_on_opponent() # assert expected results (nothing) self.assertEqual(test_ctrl.keyword, 'victory') self.assertTrue(test_ctrl.draw_again) self.assertTrue(mock_board.add_row.called) self.assertEqual(test_ctrl.rows_received, 2)
def __init__(self): super().__init__() # Set up the player info '''self.player = Player(player_img)''' # Don't show the mouse cursor self.window.set_mouse_visible(True) arcade.set_background_color(arcade.color.DARK_VANILLA) self.key_list = None self.wall_list = None self.portal_list = None self.background_list = None self.player_list = None self.damage_list = None # Where is the right edge of the map? self.end_of_map = 0 self.physics_engine = None # Level self.level = 1 self.level_finished = 0 self.controlador = controller.Controller() try: self.collect_sound = arcade.load_sound("assets/sounds/coin.wav") self.jump_sound = arcade.load_sound("assets/sounds/jumping.wav") self.block_sound = arcade.load_sound("assets/sounds/block.wav") except FileNotFoundError: print("missing collect sounds")
def test_capture_animation(self): """ execution scenarios: - self.view.animate_return(self.ray_coords): True/False """ # set object state mock_view = mock.Mock() mock_player = mock.Mock() mock_player.capture_figure.return_value = figure.Figure() mock_mq = mock.Mock() mock_broker = mock.Mock() test_ctrl = controller.Controller(mock_view, mock_player, mock_mq, mock_broker) test_ctrl.board = board.Board() test_ctrl.ray_coords = {'position': 3} # setup scenario mock_view.animate_return.return_value = False # execute method test_ctrl.capture_animation() # assert expected results self.assertTrue(mock_view.animate_return.called) self.assertTrue(mock_player.capture_figure.called) # setup scenario mock_player = mock.Mock() # reset mock player test_ctrl.player = mock_player mock_view = mock.Mock() # reset mock view test_ctrl.view = mock_view mock_view.animate_return.return_value = True # execute method test_ctrl.capture_animation() # assert expected results self.assertTrue(mock_view.animate_return.called) self.assertFalse(mock_player.capture_figure.called)
def test_draw(self): # we test for every possible value of keyword # set object state mock_view = mock.Mock() mock_player = mock.Mock() mock_mq = mock.Mock() mock_broker = mock.Mock() test_ctrl = controller.Controller(mock_view, mock_player, mock_mq, mock_broker) # execute method inputs = test_ctrl.draw('start') # assert expected results self.assertIsNotNone(inputs) self.assertTrue(mock_view.draw_start_screen.called) # execute method inputs = test_ctrl.draw('game') # assert expected results self.assertIsNone(inputs) # execute method inputs = test_ctrl.draw('online_setup') # assert expected results self.assertIsNotNone(inputs) self.assertTrue(mock_view.draw_online_options_screen.called) test_ctrl.landing_data = [1, 2, b'{"hello": 1}'] mock_player.name = 'my_player_name' # execute method inputs = test_ctrl.draw('landing_page') # assert expected results self.assertIsNotNone(inputs) self.assertTrue(mock_view.draw_landing_screen.called) # execute method inputs = test_ctrl.draw('find_online_match') # assert expected results self.assertIsNone(inputs) self.assertTrue(mock_view.draw_wait_screen.called) # execute method inputs = test_ctrl.draw('settings') # assert expected results self.assertIsNotNone(inputs) self.assertTrue(mock_view.draw_settings_screen.called) # execute method inputs = test_ctrl.draw('confirm_exit') # assert expected results self.assertIsNotNone(inputs) self.assertTrue(mock_view.confirm_exit.called) # execute method inputs = test_ctrl.draw('confirm_leave') # assert expected results self.assertIsNotNone(inputs) self.assertTrue(mock_view.confirm_leave_game.called) # execute method inputs = test_ctrl.draw('game_over') # assert expected results self.assertIsNone(inputs) self.assertTrue(mock_view.draw_game_over.called) # execute method inputs = test_ctrl.draw('victory') # assert expected results self.assertIsNone(inputs) self.assertTrue(mock_view.draw_victory.called)
def __init__(self): super().__init__() self.ui_manager = UIManager() self.controlador = controller.Controller() self.player_1 = Player('assets/blue') self.player_2 = Player('assets/yellow') self.cards_list = None self.text = "Jogador azul escolha carta 0/2"
def main(): controller = c.Controller(number_of_rows=5, number_of_columns=5, weights=w.weights_aggressive, barrier=5, verbose=True) controller.play() if controller.winner == gs.GameStates.STATE_DRAW: print "Oh noes, no winner :'( We've got a DRAW!" else: print "Yay, we got a winner! Winner is player no. {0}!".format( controller.winner)
def game(self): self.player = player.Player() # start view self.view = view.View() # online objects self.mq = zmq_client.ZmqConnector() self.broker = online_broker.OnlineBroker(self.player, self.mq) # start controller self.ctrl = controller.Controller(self.view, self.player, self.mq, self.broker) self.ctrl.load_external_resources(self.ctrl.view, os.path.join(os.getcwd(), '../resources')) self.ctrl.main_loop() pygame.quit() sys.exit()
def main(): """Method responsible only for initializing the application.""" try: logger.info("Starting...") pid = os.getpid() so = platform.system() logger.info("PID: {} -> Platform: {}.".format(pid, so)) ctrl.Controller(DEFAULT_HOST, DEFAULT_PORT).StartServer() except Exception as e: err = wrapError(startApplicationError, e) err = setErrorContext(err, "pid", pid) err = setErrorContext(err, "platform", so) logger.critical(err) finally: logger.info("Finished.")
def main(): """ Main function of the application. """ # Initialize the event manager. event_manager = events.EventManager() AppState.get_state().set_event_manager(event_manager) # Initialize and register the application heartbeat. heart_beat = HeartBeat() event_manager.register_listener(heart_beat) # Initialize and register the world. #experiment_ = experiment.experiment.Experiment.load_experiment("20161126T003019.p") experiment_ = experiment.basic.BasicVisionExperiment() AppState.get_state().set_experiment(experiment_) world = experiment_.get_world() event_manager.register_listener(world) AppState.get_state().set_world(world) # Initialize pygame. surface = init() # Initialize and register the view. main_view = view.View(surface) event_manager.register_listener(main_view) # Initialize the website trace history view. trace_view = agentevents.AgentEvents() event_manager.register_listener(trace_view) # Initialize and register the controller. main_controller = controller.Controller() event_manager.register_listener(main_controller) # Add the experiment controller to the controller main_controller.set_experiment_controller( lambda e, coords: experiment_.controller( e, main_view.window_coords_to_world_coords(coords))) # Start the webserver. webserver.trace_view = trace_view webserver.start() # Start the heartbeat. heart_beat.run()
def controller_synthesis_algorithm(mode, grid, goal, nusmv_path, nusmv_model_folder, output_path_folder): ''' Generate a grid controller using the selected algorithm. Return an instance of the controller class. This instance represents the generated controller. So the set of states that have at least one path up to the goal was generated; that is, it allows to use the function K which returns true if a state-action pair is lawful (the state must be a controllable state, therefore it must be in the set of states calculated). Parameters ---------- mode : int Controller synthesis selected algorithm: - 0 standard algorithm - 1 optimized algorithm grid : matrix of int Starting game grid, where the values within it are either 0 or 1. goal : tuple of int Coordinates of the goal cell. nusmv_path : string Path of the NuSMV executable file. model_path : string Path of the NuSMV model file. Returns ------- controller : Controller The instance of the grid controller. ''' controller = ctrl.Controller(grid, goal, nusmv_path, nusmv_model_folder, output_path_folder) if mode == 0: controller.controller_synthesis() if mode == 1: controller.optimized_controller_synthesis() return controller
def test_update_match_state(self): """ execution scenarios: - player.steps > 15 - self.board.longest_column_count >= 10 """ # set object state mock_view = mock.Mock() mock_player = mock.Mock() mock_mq = mock.Mock() mock_broker = mock.Mock() test_ctrl = controller.Controller(mock_view, mock_player, mock_mq, mock_broker) mock_board = mock.Mock() test_ctrl.board = mock_board # setup scenario mock_player.steps = 16 mock_board.longest_column_count = 10 # execute method test_ctrl.update_match_state() # assert expected results self.assertTrue(mock_board.add_row.called) self.assertEqual(mock_player.steps, 0) self.assertEqual(test_ctrl.keyword, 'game_over') self.assertTrue(test_ctrl.draw_again) # setup scenario mock_player = mock.Mock() mock_player.steps = 15 test_ctrl.player = mock_player mock_board = mock.Mock() mock_board.longest_column_count = 9 test_ctrl.board = mock_board test_ctrl.keyword = '' test_ctrl.draw_again = False # execute method test_ctrl.update_match_state() # assert expected results self.assertFalse(mock_board.add_row.called) self.assertNotEqual(mock_player.steps, 0) self.assertNotEqual(test_ctrl.keyword, 'game_over') self.assertFalse(test_ctrl.draw_again)
def test_init(self): # check nulls self.assertIsNone(controller.Controller.view) self.assertIsNone(controller.Controller.player) self.assertIsNone(controller.Controller.FPSCLOCK) # set object state mock_view = mock.Mock() mock_player = mock.Mock() mock_mq = mock.Mock() mock_broker = mock.Mock() # execute method test_ctrl = controller.Controller(mock_view, mock_player, mock_mq, mock_broker) # assert expected outcome self.assertIsNotNone(test_ctrl.targets) self.assertIsNotNone(test_ctrl.FPSCLOCK) self.assertEqual(mock_view, test_ctrl.view) self.assertEqual(mock_mq, test_ctrl.mq) self.assertEqual(mock_broker, test_ctrl.broker)
def test_game_handler(self): # TODO: assert execution of test_ctrl own methods with # test for player.status: capturing/returning and all_targets_acquired True # set object state mock_view = mock.Mock() mock_player = mock.Mock() mock_mq = mock.Mock() mock_broker = mock.Mock() test_ctrl = controller.Controller(mock_view, mock_player, mock_mq, mock_broker) mock_board = mock.Mock() mock_board.longest_column_count = 3 test_ctrl.board = mock_board mock_player.steps = 5 test_ctrl.opponent = "opponent_me" # set player status # execute method test_ctrl.game_handler() # assert expected outcome self.assertTrue(mock_board.update_counts.called) self.assertTrue(mock_view.update_game_screen.called)
def test_reset_state(self): # set object state mock_view = mock.Mock() mock_player = mock.Mock() mock_mq = mock.Mock() mock_broker = mock.Mock() test_ctrl = controller.Controller(mock_view, mock_player, mock_mq, mock_broker) mock_board = mock.Mock() test_ctrl.board = mock_board # execute method test_ctrl.reset_state() # assert expected results self.assertIsNone(test_ctrl.opponent) self.assertEqual(test_ctrl.opponent_state, {'id': '', 'name': '', 'status': '', 'score': 0, 'total': 0, 'longest': 0}) self.assertEqual(test_ctrl.explosion_counter, 1) self.assertEqual(test_ctrl.rows_received, 0) self.assertTrue(mock_player.reset.called) self.assertTrue(mock_mq.send.called) self.assertTrue(mock_mq.disconnect.called)
def test_find_match(self): """ execution scenarios: - opponent None - player.online == 'available'/'ready' - opponent not none """ # set object state mock_view = mock.Mock() mock_player = mock.Mock() mock_mq = mock.Mock() mock_broker = mock.Mock() test_ctrl = controller.Controller(mock_view, mock_player, mock_mq, mock_broker) # setup scenario mock_broker.negotiate_match.return_value = None mock_player.online = 'available' # execute method test_ctrl.find_match() # assert expected results self.assertEqual(test_ctrl.txt_msg, 'Waiting for challengers') # setup scenario mock_broker.negotiate_match.return_value = None mock_player.online = 'ready' # execute method test_ctrl.find_match() # assert expected results self.assertEqual(test_ctrl.txt_msg, 'Get ready to start') # setup scenario mock_broker.negotiate_match.return_value = 'opponent_me' # execute method test_ctrl.find_match() # assert expected results self.assertEqual(test_ctrl.opponent, 'opponent_me') self.assertEqual(mock_player.online, 'playing') self.assertEqual(test_ctrl.keyword, 'game') self.assertTrue(test_ctrl.draw_again) self.assertIsNotNone(test_ctrl.board)
def test_update_player_stats(self): # set object state mock_view = mock.Mock() mock_player = mock.Mock() stats = { 'id': 'my id', 'name': 'player_name', 'status': 'im ok', 'score': 25 } mock_player.get_stats.return_value = stats mock_mq = mock.Mock() mock_broker = mock.Mock() test_ctrl = controller.Controller(mock_view, mock_player, mock_mq, mock_broker) test_ctrl.player_stats = {} mock_board = mock.Mock() test_ctrl.board = mock_board # execute method test_ctrl.update_player_stats() # assert expected results self.assertEqual(test_ctrl.player_stats, stats) self.assertTrue(mock_mq.send.called)
def __init__(self, personagem): super().__init__() self.ui_manager = UIManager() self.controlador = controller.Controller() self.personagem = personagem
from controller import controller as controller if __name__ == '__main__': # Main function, run this to start application NewInstance = controller.Controller()
from controller import controller ct = controller.Controller() # Run window window = ct.view.window window.mainloop()
def __init__(self): super().__init__() self.ui_manager = UIManager() self.controlador = controller.Controller()
def __init__(self): super().__init__() self.ui_manager = UIManager() self.controlador = controller.Controller() self.personagem_list = None
def run_experiment(experiment_, render = True, interactive = True, console_output = True, save_logs = True): """ Run an experiment until it halts. Simulates the world defined by the experiment and handles control events. :param experiment_: An object of type Experiment. :param render: A boolean indicating whether the simulation is to be rendered to the screen. :param interactive: A boolean indicating whether interactive is to be enabled. If interactive mode is on, rendering should be on as well. :param console_output: A boolean indicating whether simulation output is to be displayed in the console. :param save_logs: A boolean indicating whether simulation output is to be saved in a log file. """ if interactive: assert render, "render must be true if interactive mode is set" # Reset the app state AppState.get_state().reset() # Initialize the event manager. event_manager = events.EventManager() AppState.get_state().set_event_manager(event_manager) # Initialize and register the application heartbeat. heart_beat = HeartBeat() event_manager.register_listener(heart_beat) # Initialize and register the world. AppState.get_state().set_experiment(experiment_) world = experiment_.get_world() event_manager.register_listener(world) AppState.get_state().set_world(world) # Initialize pygame. surface = init() if render: # Initialize and register the view. main_view = view.View(surface) event_manager.register_listener(main_view) # Initialize the website trace history view. trace_view = agentevents.AgentEvents() event_manager.register_listener(trace_view) # Initialize and register the controller. main_controller = controller.Controller() event_manager.register_listener(main_controller) if interactive: # Add the experiment controller to the controller main_controller.set_experiment_controller(lambda e, coords: experiment_.controller(e, main_view.window_coords_to_world_coords(coords))) if console_output: # Enable console logger AppState.get_state().enable_console_logger() if save_logs: # Store experiment logs if not os.path.isdir(settings.RESULTS_DIR): os.makedirs(settings.RESULTS_DIR) file_path = os.path.join(settings.RESULTS_DIR, "%s - %s.log" % (strftime("%Y%m%dT%H%M%S"), experiment_.__class__.__name__)) AppState.get_state().enable_file_logger(file_path) # Start the webserver. webserver.register({'traces': trace_view}) webserver.start() # Start the heartbeat. heart_beat.run(slow = render, halt_fun = experiment_.halt, metrics_fun = experiment_.calculate_metrics) if len(heart_beat.metrics) > 0: # Store experiment results if not os.path.isdir(settings.RESULTS_DIR): os.makedirs(settings.RESULTS_DIR) file_path = os.path.join(settings.RESULTS_DIR, "%s - %s.json" % (strftime("%Y%m%dT%H%M%S"), experiment_.__class__.__name__)) with open(file_path, 'w') as f: json.dump(heart_beat.metrics, f, indent=4, sort_keys=True)
def __init__(self): # Initialize the service layer and run the console. self.state = 'first' self.console = controller.Controller(self) self.console.run()
def main(): # ioDAO.setLogger() cont = controller.Controller() cont.start()
import sys import getopt import pyglet from controller import controller def get_parameters(argv): try: opts, args = getopt.getopt(argv, "l", ["label"]) except getopt.GetoptError: print("bad usage") sys.exit(2) for opt, arg in opts: if opt == "-l" or opt == "--label": draw_label = True return {'draw_label': draw_label} if __name__ == "__main__": parameters = get_parameters(sys.argv[1:]) simulation = controller.Controller(draw_label=parameters['draw_label']) pyglet.app.run()
def __init__(self): super().__init__() self.buttons_list = None self.ui_manager = UIManager() self.controlador = controller.Controller()
def __init__(self, mensagem): super().__init__() self.ui_manager = UIManager() self.controlador = controller.Controller() self.mensagem = mensagem