def create_problem_scenario(config): """ Given a config dict describing the problem, create the moving objects and their relationship as specified in the problem description file Arguments: config: dict containing the definition of the moving objects as well as other configuration parameters Returns: dict containing the moving objects """ movers = config['movers'] #definition of the moving objects of the problem moving_objects = { } #dict storing all moving objects from the problem description #Create object for mover in movers: mover_obj = Mover(name=mover['name'], r0=mover['r_0'], v0=mover['v_0'], speed=mover['speed']) #Store in the moving object dict moving_objects[mover_obj.get_name()] = mover_obj #Create pursuer-leader relationships for m in movers: name = m['name'] leader_name = m['leader'] if not leader_name is None: leader = moving_objects[leader_name] moving_objects[name].set_leader(leader) return moving_objects
def run(self): """Runs the main process""" # Instantiating the initial properties for the application pygame.init() height, width = self.col * self.scale, self.row * self.scale # Setting the logo gameIcon = pygame.image.load('logo.png') pygame.display.set_icon(gameIcon) # Setting the height and width self.gameDisplay = pygame.display.set_mode((height, width)) # Setting the caption pygame.display.set_caption('HM0-01') # Initializing the pixel property self.pixel = pygame.PixelArray(self.gameDisplay) # Drawing the map # Instantiating the mover object self.obj = Mover(self.pixel) self.obj.set_dimensions(self.col, self.row) # Setting the scale for that self.obj.set_scale(self.scale) # generating the blocks within the maze self.maze() # Finalizing the process of making the map self.generate_map()
def __init__(self, path="", single_mode=False): self.path = path self.single_mode = single_mode self.mover = Mover() self.wheel_encoder = WheelEncoder() self.odom_publisher = OdometryPublisher(1 / (3.14 * BASE_WIDTH), path) self.now = None self.pid_list = self.load_settings() self.active_controller = None self.set_active_controller(5) # initializing ROS publishers, subscribers and messages self.prev_pwms = (0, 0) rospy.Subscriber('/cmd_vel', Twist, self.move, queue_size=1) rospy.Subscriber("/PID_settings", PID_settings, self.set_k, queue_size=1) self.pub_l = rospy.Publisher("PID_l", PID_out, queue_size=10) self.pub_r = rospy.Publisher("PID_r", PID_out, queue_size=10) self.data_msg_l = PID_out(wheel="left") self.data_msg_r = PID_out(wheel="right") print("PID Master loaded") self.update_pwms()
class Navigator(tk.Frame): """ Composite GUI element composed of a Mover and a Jumper, allowing a user to navigate an x-y space. """ def __init__(self, master, move_callback: Callable[[str], None], jump_callback: Callable[[int, int], None], bg: str = "#ffffff"): """ Initialise this Navigator. :param master: parent container of this Navigator :param move_callback: function to call when the user clicks on of the directional buttons :param jump_callback: function to call when the user clicks the jump button :param bg: background colour of this Navigator """ super().__init__(master, bg=bg) self._mover = Mover(self, move_callback, bg=bg) self._mover.pack(side=tk.LEFT) self._jumper = Jumper(self, jump_callback, bg=bg) self._jumper.pack(side=tk.LEFT) def display_position(self, x: int, y: int) -> None: """ Display a given (x, y) coordinate in this object's text entry fields. :param x: x coordinate to display :param y: y coordinate to display """ self._jumper.display_position(x, y)
def test_mover_returns_all_the_possible_next_moves_for_edges(self): moveStates = [[[0, 2, 3], [1, 8, 4], [7, 6, 5]], [[1, 2, 3], [8, 0, 4], [7, 6, 5]], [[1, 2, 3], [7, 8, 4], [0, 6, 5]]] target = Tile() target = Mover.move_left(target) results = [] for tile in Mover.possible_moves(target): results.append(tile.layout) self.assertEqual(results, moveStates)
def level5(file_path): start = (1, 1) end = (26, 25) board = Board(file_path, 32) board.set_knight_location(start) mover = Mover(board) path = mover.find_longest_path(start, end) print path mover.move(path, display=True)
def level3(file_path): """Find the shortest path between the start and end positions""" start = (1, 1) end = (6, 6) # Set starting point board = Board(file_path, 8) board.set_knight_location(start) mover = Mover(board) path = mover.find_shortest_path(start, end) print path mover.move(path, display=True)
def level4(file_path): """Find the shortest path between the start and end of the 32x32 weighted board, with additional constraints """ start = (1, 1) end = (26, 25) board = Board(file_path, 32) board.set_knight_location(start) mover = Mover(board) path = mover.find_shortest_path(start, end) print path mover.move(path, display=True)
def __init__(self, args): self.delta_theta = None # subprocess.Popen( # [args['vrep_exec_path'], '-h', '-gREMOTEAPISERVERSERVICE_' + str(args['server_port']) + '_FALSE_TRUE', # args['vrep_scene_file']]) self.mover = Mover(args['server_ip'], args['server_port']) self.mover.init_client() self.per_step_reward = args['per_step_reward'] self.final_reward = args['final_reward'] self.tolerance = args['tolerance'] self.server_ip, self.server_port = args['server_ip'], args['server_port'] self.spawn_radius = args['spawn_radius'] self.begin_pos = None self.goal = 0
def __init__(self): #サーバー初期化 baxter = baxter_interface.RobotEnable() baxter.enable() #右手を使う self.limb = "right" self.right = baxter_interface.Limb(self.limb) #アームの速度上限 self.right.set_joint_position_speed(0.3) self.control_cmd = dict() self.IKservice = IKsolve(self.limb) self.Mover = Mover() self.rate = rospy.Rate(100000) #初期位置に移動 self.right.move_to_neutral() #ReFlexHand初期化とか # Services can automatically call hand calibration self.calibrate_fingers = rospy.ServiceProxy( '/reflex_takktile/calibrate_fingers', Empty) self.calibrate_tactile = rospy.ServiceProxy( '/reflex_takktile/calibrate_tactile', Empty) # Services can set tactile thresholds and enable tactile stops self.enable_tactile_stops = rospy.ServiceProxy( '/reflex_takktile/enable_tactile_stops', Empty) self.disable_tactile_stops = rospy.ServiceProxy( '/reflex_takktile/disable_tactile_stops', Empty) self.set_tactile_threshold = rospy.ServiceProxy( '/reflex_takktile/set_tactile_threshold', SetTactileThreshold) # This collection of publishers can be used to command the hand self.command_pub = rospy.Publisher('/reflex_takktile/command', Command, queue_size=1) self.pos_pub = rospy.Publisher('/reflex_takktile/command_position', PoseCommand, queue_size=1) self.vel_pub = rospy.Publisher('/reflex_takktile/command_velocity', VelocityCommand, queue_size=1) # Constantly capture the current hand state #rospy.Subscriber('/reflex_takktile/hand_state', Hand, hand_state_cb) f1 = FingerPressure([10, 10, 10, 10, 10, 10, 10, 10, 1000]) f2 = FingerPressure([10, 10, 10, 10, 10, 10, 10, 10, 1000]) f3 = FingerPressure([10, 10, 10, 10, 10, 10, 10, 10, 1000]) threshold = SetTactileThresholdRequest([f1, f2, f3])
def __init__(self, drivechain, single_mode=False, path=""): self.path = path self.single_mode = single_mode self.mover = Mover() self.now = None # load up DriveChains self.load_drivechains() self.active_drivechain = None self.set_active_drivechain(5) # set up ROS publishers, subscribers and messages rospy.Subscriber('/cmd_vel', Twist, self.move, queue_size=1) print("MotionController loaded") self.update_pwms()
def __init__(self, num_players: int, player_names: List[str]): LOG.info("Call to GameBoard.__init__") self.red_deck = CardDeck( "People" ) # Are these the right color to category mappings? If we want to stick with colors, that's fine self.white_deck = CardDeck("Events") self.blue_deck = CardDeck("Places") self.green_deck = CardDeck("Independence Day") self.die = Die(num_sides=6) self.game_positions = GamePositions() self.players = [] self.current_player = None # It might be useful to have this property to easily access the player whose turn it is self.direction = "" # The direction the player has chosen to move (not yet sure what values this can take) self.pixel_to_position_scaling_factor = 78 # Multiple a game_position location (in matrix) by this number to get the pixel location equivalent self.pixel_to_position_offset = ( 12, 12 ) # add these x and y values to the scaled pixel location to get starting square (since it isn't in top left corner) colors = ['red', 'white', 'blue', 'green'] for player_num in range(0, num_players): self.players.append( Mover(name=player_names[player_num], mover_color=colors[player_num], start_pos_x=0, start_pos_y=0))
def test_move_up_gives_a_board_with_the_blank_in_the_middle(self): inital = Tile() swap = list(inital.layout[1]) inital.layout[1] = list(inital.layout[2]) inital.layout[2] = swap expectedTile = [[1, 2, 3], [7, 0, 5], [8, 6, 4]] self.assertEqual(Mover.move_up(inital).layout, expectedTile)
def expand(self, tile): for outcome in Mover.possible_moves(tile): if (outcome.layout == Tile().layout): return outcome.history if (self.original.layout != outcome.layout and (tile.history == [] or outcome.layout != tile.history[-1])): self.queue.insert(outcome, self.gofH(outcome) + len(tile.history))
class Game: def __init__(self): self.track_m = TrackManager() self.agent = Mover(pygame.math.Vector2(200, 200), 0) self.game_started = False def start(self): self.agent.__init__(self.track_m.active_track.start_pos, 0) self.track_m.active_track.start() self.game_started = True def update(self): if self.game_started: self.agent.update() if self.track_m.active_track.crossed_active_checkpoint( self.agent.prev_pos, self.agent.pos): self.track_m.active_track.next_checkpoint()
def __init__(self): super(GlassWall, self).__init__() self.set_child(DataPoint(DataTypes.GAME_PIECE_TYPE, GamePieceTypes.TERRAIN)) self.set_child(Mover()) self.set_child(Position()) self.set_child(DungeonLevel()) self.set_child(GraphicChar(colors.FLOOR_BG, colors.WHITE, icon.GLASS_WALL)) self.set_child(CharPrinter()) self.set_child(Flag("is_solid"))
def __init__(self): super(PoolOfBlood, self).__init__() self.set_child(DataPoint(DataTypes.GAME_PIECE_TYPE, GamePieceTypes.DUNGEON_TRASH)) self.set_child(Position()) self.set_child(DungeonLevel()) self.set_child(Description("A pool of blood.", "A pool of blood.")) self.set_child(GraphicChar(None, colors.RED, random.choice(icon.BLOOD_ICONS))) self.set_child(CharPrinter()) self.set_child(Mover())
def test_mover_returns_all_the_possible_next_moves(self): moveStates = [[[1, 0, 3], [8, 2, 4], [7, 6, 5]], [[1, 2, 3], [0, 8, 4], [7, 6, 5]], [[1, 2, 3], [8, 4, 0], [7, 6, 5]], [[1, 2, 3], [8, 6, 4], [7, 0, 5]]] results = [] for tile in Mover.possible_moves(Tile()): results.append(tile.layout) self.assertEqual(results, moveStates)
def setup(): size(850, 600) title("Art Generator") background(250) global movers movers = [] for i in range(mover_num): movers.append(Mover())
def set_dungeon_feature_components(dungeon_feature): dungeon_feature.set_child( DataPoint(DataTypes.GAME_PIECE_TYPE, GamePieceTypes.DUNGEON_FEATURE)) dungeon_feature.set_child(Position()) dungeon_feature.set_child(DungeonLevel()) dungeon_feature.set_child(GraphicChar(None, colors.RED, icon.FOUNTAIN_FULL)) dungeon_feature.set_child(CharPrinter()) dungeon_feature.set_child(Mover()) dungeon_feature.set_child(IsDungeonFeature())
def __init__(self): super(Water, self).__init__() self.set_child(DataPoint(DataTypes.GAME_PIECE_TYPE, GamePieceTypes.TERRAIN)) self.set_child(Mover()) self.set_child(Position()) self.set_child(DungeonLevel()) self.set_child(GraphicChar(colors.BLUE_D, colors.BLUE, icon.WATER)) self.set_child(CharPrinter())
def __init__(self): super(Floor, self).__init__() self.set_child(DataPoint(DataTypes.GAME_PIECE_TYPE, GamePieceTypes.TERRAIN)) self.set_child(Mover()) self.set_child(Position()) self.set_child(DungeonLevel()) self.set_child(GraphicChar(colors.FLOOR_BG, colors.FLOOR_FG, icon.CENTER_DOT)) self.set_child(CharPrinter()) self.set_child(Flag(Floor.FLOOR_FLAG))
def set_up_new_entity_with_dungeon(self, dungeon_level): entity = Composite() entity.set_child(Mover()) entity.set_child(Position()) entity.set_child(DataPoint(DataTypes.GAME_PIECE_TYPE, GamePieceTypes.ENTITY)) dungeon_level_component = DungeonLevel() dungeon_level_component.value = dungeon_level entity.set_child(dungeon_level_component) return entity
def __init__(self, master, move_callback: Callable[[str], None], jump_callback: Callable[[int, int], None], bg: str = "#ffffff"): """ Initialise this Navigator. :param master: parent container of this Navigator :param move_callback: function to call when the user clicks on of the directional buttons :param jump_callback: function to call when the user clicks the jump button :param bg: background colour of this Navigator """ super().__init__(master, bg=bg) self._mover = Mover(self, move_callback, bg=bg) self._mover.pack(side=tk.LEFT) self._jumper = Jumper(self, jump_callback, bg=bg) self._jumper.pack(side=tk.LEFT)
def __init__(self): super(Unknown, self).__init__() self.set_child(DataPoint(DataTypes.GAME_PIECE_TYPE, GamePieceTypes.TERRAIN)) self.set_child(Mover()) self.set_child(Position()) self.set_child(DungeonLevel()) self.set_child(CharPrinter()) self.set_child(GraphicChar(colors.BLACK, colors.BLACK, ' ')) self.set_child(Flag("is_unknown")) self.set_child(Flag("is_solid"))
class TestMoverMethods(unittest.TestCase): PWM_LEFT = 33 PWM_RIGHT = 12 GPIO_MOTOR1 = 11 GPIO_MOTOR2 = 15 GPIO_MOTOR3 = 16 GPIO_MOTOR4 = 18 testMover = Mover(debug=True) # setting up the Mover() object calls the GPIO (in some way) def test_moverSetup(self, MockGPIO): gpio = MockGPIO() assert MockGPIO.called # basic assertion def test_startPWM(self, MockGPIO): gpio = MockGPIO(side_effect=RuntimeError( 'A PWM object already exists for this GPIO channel')) self.testMover.start_pwm() def test_stop(self, MockGPIO): gpio = MockGPIO() self.testMover.stop() MockGPIO.assert_has_calls([call()]) def test_moveForward(self, MockGPIO): self.testMover.forward() MockGPIO.assert_has_calls([ call(self.GPIO_MOTOR1, False), call(self.GPIO_MOTOR2, True), call(self.GPIO_MOTOR3, False), call(self.GPIO_MOTOR4, True) ]) def test_moveBackward(self, MockGPIO): self.testMover.reverse() MockGPIO.assert_has_calls([ call(self.GPIO_MOTOR1, True), call(self.GPIO_MOTOR2, False), call(self.GPIO_MOTOR3, True), call(self.GPIO_MOTOR4, False) ]) def test_teardown(self, MockGPIO): gpio = MockGPIO() self.testMover.teardown() MockGPIO.assert_has_calls( [call()]) # this is the best we can do, test that it was called @classmethod def tearDownClass(self): GPIO.cleanup()
class ConnectFour(): """Contains input checker, and 'order' of functions to play the game. Intended to be called in Terminal""" def __init__(self): self.makemoves = Mover() self.checkwins = Wins() def check_input(self): while True: newmove = input("Please make a move. It is " + self.makemoves.player + "'s turn!") try: newmove = int(newmove) except: print("Error! Please use a numeric input.") else: if newmove > 0 and newmove < 8: break else: print("Error! Please use an input between 1 and 7.") return newmove def play_game(self): counter = 0 self.makemoves.board.board_print() while counter < 42: self.makemoves.make_move(self.check_input()) self.makemoves.board.board_print() wincheck = self.checkwins.check_win( position=self.makemoves.moveinfo, player=self.makemoves.player, board=self.makemoves.board.board) if wincheck == 'R': print("Game over! Red wins!") break elif wincheck == 'B': print("Game over! Black wins!") break else: self.makemoves.change_player()
def set_cloud_components(game_state, cloud, density): cloud.set_child(DataPoint(DataTypes.ENERGY, -gametime.single_turn)) cloud.set_child(DataPoint(DataTypes.GAME_PIECE_TYPE, GamePieceTypes.CLOUD)) cloud.set_child(DataPoint(DataTypes.GAME_STATE, game_state)) cloud.set_child(CharPrinter()) cloud.set_child(Position()) cloud.set_child(DungeonLevel()) cloud.set_child(Mover()) cloud.set_child(GraphicChar(None, None, 178)) cloud.set_child(DataPoint(DataTypes.DENSITY, density)) cloud.set_child(DataPoint(DataTypes.MOVEMENT_SPEED, gametime.single_turn)) cloud.set_child(StatusFlags([StatusFlags.FLYING])) cloud.set_child(CloudChangeAppearanceShareTileEffect())
def __init__(self): super(Chasm, self).__init__() self.set_child(DataPoint(DataTypes.GAME_PIECE_TYPE, GamePieceTypes.TERRAIN)) self.set_child(Mover()) self.set_child(Position()) self.set_child(DungeonLevel()) self.set_child(GraphicChar(colors.BLACK, colors.DARKNESS, icon.CHASM2)) self.set_child(CharPrinter()) self.set_child(Flag("is_chasm")) self.set_child(PlayerFallDownChasmAction()) self.set_child(FallRemoveNonPlayerNonFlying()) self.set_child(PromptPlayerChasm())
def __connect_hotkeys(self, root): r = root r.bind("<Key-a>", lambda ev: self.__add_mark_and_select_it()) r.bind("<Prior>", lambda ev: self.__choose_prev_mark()) r.bind("<Next>", lambda ev: self.__choose_next_mark()) r.bind("<Delete>", lambda ev: self.__remove_mark()) self.__mover = Mover(root, self.__move_mark) self.__rotator = Rotator(root, self.__rotate_mark) r.bind("<Control-Left>", lambda ev: self.__change_width(-self.__W_C)) r.bind("<Control-Right>", lambda ev: self.__change_width(self.__W_C)) r.bind("<Control-Up>", lambda ev: self.__change_length(self.__L_C)) r.bind("<Control-Down>", lambda ev: self.__change_length(-self.__L_C))