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
