def initialize(standard_screen): globals.STDSCR = standard_screen globals.MAIN = MainMenu() globals.INTERFACES.append(globals.MAIN) globals.MAP = GameMap() globals.INTERFACES.append(globals.MAP) globals.INVENTORY = Inventory() globals.INTERFACES.append(globals.INVENTORY) globals.PAUSE = PauseMenu() globals.INTERFACES.append(globals.PAUSE) globals.STORY = StoryScreen() globals.INTERFACES.append(globals.STORY) globals.CONTROLS_MAP = Controls(Controls.Type.game_map) globals.INTERFACES.append(globals.CONTROLS_MAP) globals.CONTROLS_INVENTORY = Controls(Controls.Type.inventory) globals.INTERFACES.append(globals.CONTROLS_INVENTORY) globals.CREDITS = Credits() globals.INTERFACES.append(globals.CREDITS) globals.NEW_GAME = NewGameDialog() globals.INTERFACES.append(globals.NEW_GAME) globals.QUIT_GAME = EndGameDialog() globals.INTERFACES.append(globals.QUIT_GAME) globals.SAVE_GAME = SaveGameDialog() globals.INTERFACES.append(globals.SAVE_GAME) globals.MONSTER = MonsterDialog() globals.INTERFACES.append(globals.MONSTER) globals.ITEM = ItemDialog() globals.INTERFACES.append(globals.ITEM) globals.GAME_OVER = GameOverDialog() globals.INTERFACES.append(globals.GAME_OVER) globals.LADDER = LadderDialog() globals.INTERFACES.append(globals.LADDER)
def __init__(self): self.clock = None self.show_path = False self.game = Game() self.surface = pygame.display.set_mode(cfg.WINDOW_SIZE) self.players_alg = [ Algorithm.PLAYER, Algorithm.PLAYER, Algorithm.DIJKSTRA, Algorithm.DFS ] # Controllers initialization self.control_list_select1 = [("Key1", 0)] self.control_list_select2 = [("Key2", 1)] pygame.joystick.init() self.num_of_gamepads = pygame.joystick.get_count() self.controllers = [ Controls(pygame.K_UP, pygame.K_DOWN, pygame.K_LEFT, pygame.K_RIGHT, pygame.K_RCTRL), Controls(pygame.K_w, pygame.K_s, pygame.K_a, pygame.K_d, pygame.K_LCTRL) ] for i in range(self.num_of_gamepads): gamepad = pygame.joystick.Joystick(i) gamepad.init() self.controllers.append(gamepad) if i % 2 == 0: self.control_list_select1.append((f"Joy{i+1}", i + 2)) else: self.control_list_select2.append((f"Joy{i+1}", i + 2)) self.player_controls = [self.controllers[0], self.controllers[1]]
def handle_event(self, slack_event): event = slack_event['event'] event_type = event['type'] if 'user' not in event: return 'OK' user = event['user'] if user == self.config.bot_id: return 'OK' # Dont do anything about own messages channel = event['channel'] if 'text' in event: text = event['text'] print('in handle_event') print('event_type = ' + event_type + ' channel = ' + channel + ' user = '******' text = ' + text) print('---------------') # Reply to request AT_BOT = '<@' + self.config.bot_id + '>' command = text if True: if text.startswith(AT_BOT): command = text.split(AT_BOT)[1].strip().lower() # if command.startswith('quote') or command.startswith('q ') or command.startswith('Q ') or command.startswith('Quote'): sym_or_name = '' if command.lower().startswith('help') == False: toks = command.split(' ') if len(toks) <= 1: sym_or_name = command.strip().upper() else: tok1 = toks[0] tok2 = toks[1] if tok1.lower().startswith('q'): sym_or_name = tok2.upper() user_command = StockQuote(name="stock_quote", intent="get_stock_quote", params={}, raw=command, urls={}) user_command.set_param('company-trie', Bot.company_trie) user_command.set_param('symbol-trie', Bot.symbol_trie) user_command.set_param('selected', sym_or_name) val = Bot.symbol_trie.get(sym_or_name) if val is not None: self.postToSlack(channel, user_command.execute(), {}) else: controls = Controls() Bot.user_commands[channel+user] = user_command controls.message_attachments_company_name_options[0]['actions'][0]['name'] = sym_or_name message = 'Hmm, I don\'t know that stock symbol.\n Please use the search box below' self.postToSlack(channel, message, controls.message_attachments_company_name_options) else: # Fallback to saying hello! user_command = Hello(name="hello", intent="say_hello", params={}, raw=command, urls={}) self.postToSlack(channel, user_command.execute(), {}) return 'OK'
class MainWindow(QMainWindow): width, height = 800, 480 def __init__(self, title, version): super().__init__() self.about_window = AboutWindow(title, version) self.language_doc_window = LanguageDocWindow(title, version) self.help_window = HelpWindow(title, version) self.viewer = Viewer(self) # Rendered commands appear here self.editor = Editor(self) # Commands are written here self.controls = Controls(self) self.move(200, 200) self.setFixedSize(MainWindow.width, MainWindow.height) self.setWindowTitle(title) self.show() def paintEvent(self, event): try: painter = QPainter(self) self.controls.update_mouse_positional_label(self) finally: painter.end()
def create_widgets(self): if globals.debug > 1: print("gui.create_widgets") self.menubar = MenuBar(self.window, self) self.interactiveplot = InteractivePlot( self, relief='sunken', bd=1, ) # Wait until the plot becomes visible to proceed self.update_idletasks() self.update() self.plotcontrols = PlotControls( self, self.interactiveplot.canvas, bg='white', relief='sunken', bd=1, ) self.controls = Controls( self, width=2 * self.dpi, # pixels = inches * dpi bd=1, relief='sunken', padx=5, pady=5, ) self.message_label = tk.Label(self, textvariable=self.message_text, bg='white')
def on_key_press(self, key: int, modifiers: int): """ check for key presses, set the respective instance variable to true. :param key: the last key on the keyboard that the user pressed :param modifiers: n/a :return: n/a """ Controls.handle_key_presses(self, key, modifiers)
def temp_run(): temp_signals = { 'green': False, 'red': False, 'blue': False, 'stop': False, 'metal': False, 'maxTime': False, 'finish': False, 'path': '/home/pi/Filakov/', 'pltCnt': 1, 'imgCnt': 1 } C = Controls("/dev/ttyACM0") if not C.started: debug_print( "Controls of the motors are not started. Aborting program...") return time.sleep(3) cam = cv2.VideoCapture(0) time.sleep(1) if not cam.isOpened(): debug_print("Camera is not opened. Aborting program...") return T_metal = threading.Thread(target=metalCheck, args=( C, temp_signals, )) T_cam = threading.Thread(target=cameraLoop, args=( cam, temp_signals, )) T_metal.start() T_cam.start() # calibrateCamera(C, temp_signals) # if temp_signals['stop']: # return # # C.Lights(1) safeMove(C, 2, 'M', -90, temp_signals) while True: time.sleep(.5) if temp_signals['stop']: temp_signals['finish'] = True break T_cam.join() T_metal.join() # C.Lights(0) C.Close()
def main(): root = Tk() root.title("Simple 3-D Renderer :: Noah Ansel (nba38)") display = Display(root) controls = Controls(root, display) controls.grid(row = 0, column = 0, sticky = N+W) display.grid(row = 0, column = 1, sticky = N+W+E+S) root.mainloop()
def on_key_release(self, key: int, modifiers: int): """ check for the last key to have been released, set the respective instance variable to false. :param key: the last key on the keyboard that the user let go of :param modifiers: n/a :return: n/a """ if self.player.in_water: # the controls in water should only register when the key is released, unlike regular controls Controls.handle_water_controls(self) Controls.handle_key_release(self, key, modifiers)
class GameFSM(FSM): def enterStartMenu(self): self.menu = StartMenu() def exitStartMenu(self): self.menu.destroy() del self.menu def enterTrain(self): self.train = TrainingMode() def exitTrain(self): self.train.destroy() del self.train def enterBattle(self): self.battle = BattleMode() def exitBattle(self): if self.battle.popupText: self.battle.popupText.detachNode() self.battle.popupText = None self.battle.destroy() del self.battle def enterControls(self): self.controls = Controls() def exitControls(self): self.controls.destroy() del self.controls def enterSave(self): self.save = Save() def exitSave(self): self.save.destroy() del self.save def enterLoad(self): self.load = Load() def exitLoad(self): self.load.destroy() del self.load def enterStats(self): self.stats = Stats() def exitStats(self): self.stats.destroy() del self.stats
def __init__(self, resolution=Dimensions(1001, 601), calcThread=None): # Declare constants # General self.fpsLimit = 60 self.simRunning = False self.calcThread = calcThread # Section sizes self.control_width = 200 # Key presses self.L_SHIFT = 1 self.R_SHIFT = 2 self.L_CTRL = 64 self.R_CTRL = 128 self.L_ALT = 256 self.R_ALT = 512 # Declare variables self.populationLimit = 3 self.populationMin = 2 self.generation = 0 # Declare mouse event flags self.processMouse = False self.multiCellDrag = False self.multiCellDragState = True self.mouseHeld = False self.mouseRepeatDelayed = False self.mouseClickTime = 0 # Initialize pygame window pygame.init() self.window = pygame.display.set_mode(resolution, pygame.RESIZABLE) pygame.display.set_caption("Conway's Game of Life") # Create clock to limit FPS self.fpsClock = pygame.time.Clock() # Enable key and mouse hold repeating and set limits pygame.key.set_repeat(500, 75) self.mouseRepeat = (500, 75) # Create the initial grid self.grid = Grid( Dimensions(self.window.get_rect().width - self.control_width, self.window.get_rect().height), Position(0, 0)) # Create control section self.controls = Controls( Dimensions(self.control_width, self.window.get_rect().height), Position(self.grid.width, 0), self)
def main(): parser = argparse.ArgumentParser() parser.add_argument("--player", help="player 1-6", type=int, default=1) args = parser.parse_args() config = Config(CONFIG_FILE, args.player) comms_config = { 'rx_ip': config.client_ip, 'rx_port': config.client_port, 'tx_ip': config.sim_ip, 'tx_port': config.sim_port } print("Rx at {}:{}".format(comms_config["rx_ip"], comms_config["rx_port"])) print("Tx to {}:{}".format(comms_config["tx_ip"], comms_config["tx_port"])) commands_mutex = Lock() # Launch comms in background thread comms = CommsThread(comms_config, False, commands_mutex) comms.daemon = True comms.start() # Launch perception, motion planning, and controls in main thread sweep_builder = SweepBuilder() perception = Perception(config) planning = Planning(config) controls = Controls(config) visualize = Visualize(config) try: while True: vehicle_state = sweep_builder.run(comms.get_vehicle_states()) if vehicle_state is not None: t1 = time.time() world_state = perception.run(vehicle_state) plan = planning.run(world_state) vehicle_commands = controls.run(plan) t2 = time.time() freq = 1 / (t2 - t1) print(f"Running at {freq} Hz") vehicle_commands['draw'] = visualize.run(world_state, plan) with commands_mutex: # hold the lock to prevent the Comms thread from # sending the commands dict while we're modifying it comms.vehicle_commands.update(vehicle_commands) except KeyboardInterrupt: pass
def __init__(self): pygame.init() self.outputs = Outputs() self.stream = Stream(channels=1, sample_rate=60 * 10**3, sample_size=2**11) self.mouse_frequency = 0.0 # visual params self.background_color = pygame.Color(50, 50, 50) self.colorA = pygame.Color("#ff0000") self.colorB = pygame.Color("#0000ff") self.num_bars = self.outputs.get_divisor() # surface params self.height = 1000 self.dimensions = numpy.array([self.outputs.get_width(), self.height]) self.surface_flags = pygame.HWSURFACE | pygame.DOUBLEBUF self.surface = pygame.display.set_mode(self.dimensions, self.surface_flags) self.time_surface = pygame.Surface(self.dimensions // numpy.array([1, 2])) self.freq_surface = pygame.Surface(self.dimensions // numpy.array([1, 2])) self.control_surface = pygame.Surface(self.dimensions // 2) self.control_surface.set_colorkey(self.background_color) self.controls = Controls(self.control_surface) self.sliders = { 'pull': Slider(self.control_surface, pygame.Rect(300, 46, 100, 10), 10, 15, value=0.5), 'smooth': Slider(self.control_surface, pygame.Rect(300, 66, 100, 10), 10, 15, value=0.5) } # smoothing history array self.t_history = numpy.full(self.num_bars, 0.5) self.f_history = numpy.full(self.num_bars, 0.0)
def __init__(self, verbose=True, path=False, width=WIDTH, height=HEIGHT): self.verbose = verbose self.logger = Logerer() self.controls = Controls(verbose=self.verbose) self.path = self.controls.path if not path else path self.log("Game started in " + self.path) self.levels = {} self.current_level = (0, 0) self.width = width self.height = height self.size = self.width, self.height self.slow_clock = 90 self.screen = pygame.display.set_mode( (self.width, self.height), pygame.RESIZABLE) self.npcs_loaded = False
def __init__(self, interface): gtk.Window.__init__(self) self.set_title("mogbar3000") #Create child widgets self.statusbar = gtk.Statusbar() self.controls = Controls(interface) self.notebook = gtk.Notebook() self.notebook.set_scrollable(True) #Add children to VBox self.box = gtk.VBox() self.box.pack_start(self.controls, False, False, 0) self.box.pack_start(self.notebook, True, True, 0) self.box.pack_start(self.statusbar, False, False, 0) self.add(self.box) self.connect('delete_event', gtk.main_quit) def create_playlist(tracks, name): self.notebook.append_page(Playlist(interface), name) interface.create_playlist = create_playlist def add_tracks(tracks): cur = self.notebook.get_current_page() if cur == None: return cur.store.append() #done loading self.show_all()
def __init__(self, window=None, objects=(), controllers=()): # Create a font for score self.font = font.load('Arial', 18) # pyglet.font.Text object to display the score self.score = font.Text(self.font, x=10, y=10, color=(1, 1, 1, 1)) self.control = Controls(window) self.bind_objects(*objects) self.bind_controllers(*controllers) self.score_right = 0 self.score_left = 0 self.draw_score() self.height = window.width self.width = window.height # should this not be handled within the object? # map effects to different objects in the game effects_map = {"fire": None}
def __init__(self, nop): rows, columns = self.get_terminal_dimensions() self.screen = {'rows': rows, 'columns': columns} if not self.multi_player_support(nop): print("Sorry " + str(nop) + " is not supported at present screen aspect ratio.") return self.initialise_screen() self.num_players = nop self.players = [] self.maps = [] self.gameplay_settings = self.configure_gameplay_settings() # os.system('tput civis') # print("the ratio is ", columns / nop) self.welcome_screen() for num_id in range(nop): self.maps.append( level1_map.Level1Map(num_id, self.screen['rows'], int(self.screen['columns'] / nop - 1))) self.players.append( Player(self.maps[-1].initial_player_position, config.PLAYER, num_id, self.maps[-1])) self.controls = Controls() # self.maps[0].view_map() # self.print_screen() # exit(1) if ROOT: for player_id in range(self.num_players): inp_thread = Thread(target=self.get_input_for_player, args=(player_id, )) inp_thread.daemon = True inp_thread.start() time_thread = Thread(target=self.decrease_time, args=(player_id, )) time_thread.daemon = True time_thread.start() control_input_thread = Thread(target=self.get_input_for_control) control_input_thread.daemon = True control_input_thread.start() else: time_thread = Thread(target=self.decrease_time, args=(0, )) time_thread.daemon = True time_thread.start() all_input_thread = Thread(target=self.game_input) all_input_thread.daemon = True all_input_thread.start() msc.play_music_for_action('Player at start') while True: try: if config.stop.is_set() or config.timeout.is_set(): break sleep(0.1) [self.make_updates(x) for x in range(self.num_players)] self.updates() except KeyboardInterrupt: break self.exit()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.connect("delete-event", Gtk.main_quit) root_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.board = Board() self.controls = Controls() self.console = Gtk.Label("Input angle, initial velocity and fire!") self.controls.reset_btn.connect("clicked", self.__on_reset_clicked) self.controls.fire_btn.connect("clicked", self.__on_fire_clicked) root_box.pack_start(self.board, False, False, 0) root_box.pack_end(self.controls, False, False, 10) root_box.pack_end(self.console, False, False, 10) self.add(root_box)
def appStarted(self): # Citation: this is a modified version of image from user BENL at link # https://www.chiefdelphi.com/t/top-down-orthographic-view-of-frcs-2019-playing-field/335397/9 self._fieldImage = self.loadImage("2019-field-blue.png") self.fieldImageScaled = ImageTk.PhotoImage(self._fieldImage) # Citation: from cleanpng.com, contributor: georgen url = "https://icon2.cleanpng.com/20180417/bxw/kisspng-steve-harvey-still-trippin-act-like-a-lady-thin-steve-jobs-5ad626cde40c49.3709911715239840779341.jpg" self._robotImage = self.scaleImage(self.loadImage(url), 0.6) self._WAYPOINT_RADIUS = 30 self.setAppDims() self.resetUserInputs() self.FIELD_REAL_WIDTH = 8.23 # meters self.FIELD_REAL_HEIGHT = 9 # 16.46 self.timerDelay = 30 # milliseconds self.robot = RobotModel(1.0, 1.0, 0.0) self.leftVoltage, self.rightVoltage = 0.0, 0.0 self.simTime = 0.0 self.ODOMETRY_UPDATE_RATE = 100 odometryThread = threading.Thread(target=self.odometryPeriodic, daemon=True) odometryThread.start() self.waypoints = [] self.controls = Controls(self.waypoints, self.robot) self.CONTROLS_UPDATE_RATE = 100 controlThread = threading.Thread(target=self.controlsPeriodic, daemon=True) controlThread.start() self.logger = Logger() self.logger.registerLoggerDict(self.robot.logDict, "robot") self.logger.registerLoggerDict(self.controls.logDict, "controls") yAxes = [ self.logger.dict["robot.heading"], self.logger.dict["robot.vel"], self.logger.dict["controls.ffSpeed"] ] self.graph = StackedTimeGraph(self.logger.time, yAxes, (self.fieldImageWidth, self.width), (self.height, 0))
def appStarted(self): self._fieldImage = self.loadImage("2019-field-blue.png") self.fieldImageScaled = ImageTk.PhotoImage(self._fieldImage) self.setAppDims() self.FIELD_REAL_WIDTH = 8.23 # meters self.FIELD_REAL_HEIGHT = 9 # 16.46 self.robot = RobotModel(1.0, 1.0, 0.0) self._robotImage = self.scaleImage(self.loadImage("steve.jpg"), 0.6) self.leftVoltage, self.rightVoltage = 0.0, 0.0 self.ODOMETRY_UPDATE_RATE = 100 odometryThread = threading.Thread(target=self.odometryPeriodic, daemon=True) odometryThread.start() self.logger = {} self.waypoints = [] self.waypointRadius = 30 self.selectedWaypoint = None self.rotatingWaypoint = False self.lastClickTime = 0 self.DOUBLE_CLICK_TIME = 0.2 self.timerDelay = 50 # milliseconds self.timer = 0 self.releaseDelay = 0.1 self.inputKeys = { "Up": KeyLatch(self.releaseDelay), "Down": KeyLatch(self.releaseDelay), "Right": KeyLatch(self.releaseDelay), "Left": KeyLatch(self.releaseDelay) } self.autoDriving = False self.autoDrivingStart = False self.controls = Controls(self.waypoints, self.robot) self.CONTROLS_UPDATE_RATE = 100 controlThread = threading.Thread(target=self.controlsPeriodic, daemon=True) controlThread.start()
class Game: def __init__(self, screen): self.screen = screen self.assets = Assets() self.gameplay = GamePlay(self) self.clock = pygame.time.Clock() self.controls = Controls() def run(self): while True: self.controls.update() if self.controls.ctrl_exit: sys.exit(0) ticks = self.clock.tick_busy_loop(30) self.gameplay.update(ticks) self.screen.fill((0, 0, 0)) self.gameplay.draw() pygame.display.flip()
def __init__(self): self.snake = Snake() self.controls = Controls() self.textFont = pygame.font.Font(config.FONT, 13) self.game_over = False self.textOffset = (3, 3) self.scoreText = Text( self.textFont, "Your Score: {:}".format(self.snake.snake_length - 1), config.BLACK, tX=self.textOffset[0], tY=self.textOffset[0]) self.spawnTime = 50 # In frames self.foodSmall = Food( (config.DIS_WIDTH, config.DIS_HEIGHT - self.scoreText.tH - self.textOffset[1]), 2) self.foodBig = Food( (config.DIS_WIDTH, config.DIS_HEIGHT - self.scoreText.tH - self.textOffset[1]), 3, self.spawnTime, 0.5, config.GREEN, blink_rate=2) self.foodBig.turn_idle() self.cursorPos = 0 self.eatSound = pygame.mixer.Sound("sounds/eat.wav") self.eatBigSound = pygame.mixer.Sound("sounds/eatBig_2.wav") self.selectSound = pygame.mixer.Sound("sounds/select.wav") self.nextScene = self self.screen_shake = 0 self.menuScene = None self.pauseMenu = Menu(self.textFont, ('P A U S E', config.WHITE), ('Continue', config.WHITE), ('Exit', config.WHITE)) self.gameOverMenu = Menu(self.textFont, ('G A M E O V E R', config.RED), ('Retry', config.WHITE), ('Exit', config.WHITE))
def setUp(self): config = Mock() config.drive_kp = 40 config.drive_ki = 1 config.drive_kd = 1 config.heading_error_threshold = 0.2 config.max_forward_speed = 512 config.max_intake_speed = 512 config.max_outtake_speed = 512 self.controls = Controls(config) self.plan_state = { 'pose': ((0, 0), 0), 'trajectory': None, 'tube_mode': 'NONE', 'direction': 0, 'field_outtake': 0, 'flail': False, 'goal': None, } self.vehicle_commands = {}
def __init__(self, title, version): super().__init__() self.about_window = AboutWindow(title, version) self.language_doc_window = LanguageDocWindow(title, version) self.help_window = HelpWindow(title, version) self.viewer = Viewer(self) # Rendered commands appear here self.editor = Editor(self) # Commands are written here self.controls = Controls(self) self.move(200, 200) self.setFixedSize(MainWindow.width, MainWindow.height) self.setWindowTitle(title) self.show()
def main(): pygame.init() pygame.font.init() screen = pygame.display.set_mode(DISPLAY, FLAGS, DEPTH) pygame.display.set_caption("Use arrows to move!") timer = pygame.time.Clock() up = down = left = right = running = False bg = Surface((16,16)) bg.convert() bg.fill(Color("#FFFFFF")) entities = pygame.sprite.Group() x = y = 0 start_level = Level(30, 30) controls = Controls(start_level) while 1: timer.tick(60) for e in pygame.event.get(): if e.type == QUIT: raise SystemExit, "QUIT" controls.process_event(e) start_level.update(screen) pygame.display.update()
class GroundStation(): def __init__(self, ip): self.sender = Sender(ip) self.receiver = Receiver() # thread that sends data self.receiver.start() # thread that receives data self.overlay = Overlay(self.receiver, self.sender) # overlay thread self.video = Video() # video thread self.controls = Controls(self.video) # controls thread self.controls.start() self.sender.set_controls(self.controls) self.overlay.set_controls(self.controls) self.video.run() self.sender.start() self.video.connect('configure_event', self.on_configure_event) # move master -> move dog self.video.connect('destroy', lambda w: Gtk.main_quit()) # close master -> end program def on_configure_event(self, *args): x, y = self.video.get_position() sx, sy = self.video.get_size() tx = self.video.get_style().xthickness self.overlay.move(x+tx, y+30) self.overlay.resize(sx, sy)
def __init__(self, ip): self.sender = Sender(ip) self.receiver = Receiver() # thread that sends data self.receiver.start() # thread that receives data self.overlay = Overlay(self.receiver, self.sender) # overlay thread self.video = Video() # video thread self.controls = Controls(self.video) # controls thread self.controls.start() self.sender.set_controls(self.controls) self.overlay.set_controls(self.controls) self.video.run() self.sender.start() self.video.connect('configure_event', self.on_configure_event) # move master -> move dog self.video.connect('destroy', lambda w: Gtk.main_quit()) # close master -> end program
def createObjects(self): self.intake_motor = ctre.TalonSRX(10) self.intake_arm_motor = PIDSparkMax(7) self.shooter_motor = PIDSparkMax(16) self.shooter_feeder_motor = ctre.TalonSRX(19) self.drivetrain_motorr1 = CANSparkMax(5, MotorType.kBrushless) self.drivetrain_motorr2 = CANSparkMax(8, MotorType.kBrushless) self.drivetrain_motorl1 = CANSparkMax(17, MotorType.kBrushless) self.drivetrain_motorl2 = CANSparkMax(13, MotorType.kBrushless) self.joystick_left = wpilib.Joystick(0) self.joystick_right = wpilib.Joystick(1) self.controls = Controls(self.joystick_left, self.joystick_right)
def __init__(self, window=None, objects=(), controllers=()): #Create a font for score self.font = font.load('Arial', 18) #pyglet.font.Text object to display the score self.score = font.Text(self.font, x = 10, y=10, color=(1, 1, 1, 1)) self.control = Controls(window) self.bind_objects(*objects) self.bind_controllers(*controllers) self.score_right = 0 self.score_left = 0 self.draw_score() self.height = window.width self.width = window.height #should this not be handled within the object? #map effects to different objects in the game effects_map = { "fire": None}
def __init__(self, verbose=False, path=path): self.levels = {} self.home = os.environ['HOME'] self.path = path if path else os.environ['PWD'] self.game = pygame.init() self.game_exit = False self.current_level = "0-0" self.levels_loaded = False self.main_character_loaded = False self.clock = pygame.time.Clock() self.verbose = verbose self.width = 0 self.height = 0 self.scalar = 70 self.screen = None self.controls = Controls(path=path) self.game_locations = {}
def __init__(self, qubic, controller, *args, **kwargs): super().__init__(*args, **kwargs) taille = len(qubic) self.qubic = qubic qubic.add_observers(self) self.settings = _VueQubicSettings() target = (taille / 2 - .5, 0, taille / 2 - .5) self.qamera = self.settings.qamera_type(target) self.components.append(self.qamera) self.board = _Board(qubic, controller) self.components.append(self.board) controls_type = Controls.get_controls(self.settings.control_method) self.controls = controls_type(qubic, self, controller) self.components.append(self.controls) self.pions = [[[None for _ in range(taille)] for _ in range(taille)] for _ in range(taille)] self.components.append(Lights())
def main(): app = QtWidgets.QApplication(sys.argv) main_view = MainView(app) controls = Controls() main_view.subscribe_controls(controls) metrics_engine = MetricsEngine() metrics_engine.subscribe_view(main_view) metrics_engine.load_metrics() controls.subscribe_view(main_view) image_handler = ImageHandler() image_handler.subscribe_view(main_view) modifications_provider = ModificationsProvider() modifications_provider.subscribe_image_handler(image_handler) controls.subscribe_image_handler(image_handler) controls.subscribe_modifications_provider(modifications_provider) image_handler.subscribe_metrics_engine(metrics_engine) main_view.show() sys.exit(app.exec_())
def __init__(self, screen: Surface, map_: str, heroes: int, monsters: int, items: int): """ Создаёт игру :param heroes: колличество героев в игре. Если players_count=0, то создаст читера. """ self.start_time = datetime.now() self.screen = screen # map self.map: Map = self._init_map(map_) # карта self.maps: Group = Group(self.map) # sprites self.characters: Group = Group() # спрайты с героями и монстрами self.heroes: Group = self._init_heroes(heroes) # спрайты с героями self.monsters: Group = self._init_monsters( monsters) # спрайты с монстрами self.items: Group = self._init_items(items) # спрайты с вещами self._start_turn() self.dashboard = Dashboard(self) # приборная панель self.backpack: Backpack = Backpack(self) # рюкзак self.controls: Controls = Controls(self) # help self.monsters_killed = 0
def test_controls(self): '''Fake some key ups and key downs then check that changes control booleans''' self.screen = pygame.display.set_mode((50, 50), pygame.RESIZABLE) test_controls = Controls(verbose=False) test_controls.path = test_controls.path.replace( 'static', 'test/static') events = [pygame.event.Event(pygame.KEYDOWN, key=control, mod=4096) for control in test_controls.control_lookup] test_controls.get_events(events, self.screen, 50, 50) for key in test_controls.buttons: self.assertTrue(test_controls.buttons[key]) events = [pygame.event.Event(pygame.KEYUP, key=control, mod=4096) for control in test_controls.control_lookup] test_controls.get_events(events, self.screen, 50, 50) for key in test_controls.buttons: self.assertFalse(test_controls.buttons[key])
def __init__(self, resolution = Dimensions(1001, 601), calcThread=None): # Declare constants # General self.fpsLimit = 60 self.simRunning = False self.calcThread = calcThread # Section sizes self.control_width = 200 # Key presses self.L_SHIFT = 1 self.R_SHIFT = 2 self.L_CTRL = 64 self.R_CTRL = 128 self.L_ALT = 256 self.R_ALT = 512 # Declare variables self.populationLimit = 3 self.populationMin = 2 self.generation = 0 # Initialize pygame window pygame.init() self.window = pygame.display.set_mode(resolution, pygame.RESIZABLE) pygame.display.set_caption("Conway's Game of Life") # Create clock to limit FPS self.fpsClock = pygame.time.Clock() # Enable key hold repeating and set limits pygame.key.set_repeat(500,75) # Create the initial grid self.grid = Grid(Dimensions(self.window.get_rect().width - self.control_width, self.window.get_rect().height), Position(0, 0)) # Create control section self.controls = Controls(Dimensions(self.control_width, self.window.get_rect().height), Position(self.grid.rect.width, 0), self)
def test_controls(self): '''Fake some key ups and key downs then check that changes control booleans''' self.screen = pygame.display.set_mode((50, 50), pygame.RESIZABLE) test_controls = Controls(verbose=False) test_controls.path = test_controls.path.replace( 'static', 'test/static') events = [ pygame.event.Event(pygame.KEYDOWN, key=control, mod=4096) for control in test_controls.control_lookup ] test_controls.get_events(events, self.screen, 50, 50) for key in test_controls.buttons: self.assertTrue(test_controls.buttons[key]) events = [ pygame.event.Event(pygame.KEYUP, key=control, mod=4096) for control in test_controls.control_lookup ] test_controls.get_events(events, self.screen, 50, 50) for key in test_controls.buttons: self.assertFalse(test_controls.buttons[key])
class MainWindow(Gtk.Window): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.connect("delete-event", Gtk.main_quit) root_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.board = Board() self.controls = Controls() self.console = Gtk.Label("Input angle, initial velocity and fire!") self.controls.reset_btn.connect("clicked", self.__on_reset_clicked) self.controls.fire_btn.connect("clicked", self.__on_fire_clicked) root_box.pack_start(self.board, False, False, 0) root_box.pack_end(self.controls, False, False, 10) root_box.pack_end(self.console, False, False, 10) self.add(root_box) def __on_reset_clicked(self, button): self.board.reset() self.controls.angle_control.set_text('') self.controls.velocity_control.set_text('') self.console.set_text("Input angle, initial velocity and fire!") def __on_fire_clicked(self, button): try: angle, velocity = self.controls.get_angle_and_velocity() if not 0 <= angle <= 90: raise ValueError("angle must be between 0 and 90") hit = self.board.fire(angle, velocity) msg = "HIT!" if hit else "Missed" self.console.set_text(msg) except ValueError as e: self.console.set_text("Wrong values: %s" % e)
class Interface(): # Constructor def __init__(self, resolution = Dimensions(1001, 601), calcThread=None): # Declare constants # General self.fpsLimit = 60 self.simRunning = False self.calcThread = calcThread # Section sizes self.control_width = 200 # Key presses self.L_SHIFT = 1 self.R_SHIFT = 2 self.L_CTRL = 64 self.R_CTRL = 128 self.L_ALT = 256 self.R_ALT = 512 # Declare variables self.populationLimit = 3 self.populationMin = 2 self.generation = 0 # Initialize pygame window pygame.init() self.window = pygame.display.set_mode(resolution, pygame.RESIZABLE) pygame.display.set_caption("Conway's Game of Life") # Create clock to limit FPS self.fpsClock = pygame.time.Clock() # Enable key hold repeating and set limits pygame.key.set_repeat(500,75) # Create the initial grid self.grid = Grid(Dimensions(self.window.get_rect().width - self.control_width, self.window.get_rect().height), Position(0, 0)) # Create control section self.controls = Controls(Dimensions(self.control_width, self.window.get_rect().height), Position(self.grid.rect.width, 0), self) def setCalcThread(self,calcThread): self.calcThread = calcThread self.controls.updateSpeedDisplay(self.calcThread.speed) def update(self): # Process any mouse/keyboard events if not self.processEvents(): return False # Draw objects self.draw() # Update window pygame.display.update() # Limit FPS self.fpsClock.tick(self.fpsLimit) return True def processEvents(self): click_pos=(-1,-1) # Get pygame events to see if/what key is pressed for event in pygame.event.get(): if event.type == QUIT: pygame.quit() return False elif event.type == MOUSEBUTTONDOWN: if event.button == 1: self.controls.collidepoint(pygame.mouse.get_pos()) self.grid.collidepoint(pygame.mouse.get_pos()) elif event.type == KEYDOWN: mods = pygame.key.get_mods()# Get modifier keys if event.key == K_LEFT: if mods == self.L_SHIFT: self.popLimitDown() elif mods == self.L_CTRL: self.popMinDown() else: self.speedDown() elif event.key == K_RIGHT: if mods == self.L_SHIFT: self.popLimitUp() elif mods == self.L_CTRL: self.popMinUp() else: self.speedUp() elif event.key == K_SPACE: self.pause() elif event.key == K_RETURN: self.stepForward() else: pass elif event.type == VIDEORESIZE: self.resize(event.dict['size']) else: pass return True def draw(self): # Set background as white self.window.fill(pygame.Color("white")) # Draw grid self.grid.draw(self.window) # Draw control interface self.controls.draw(self.window) def resize(self, size): # Resize window self.window = pygame.display.set_mode(size, pygame.RESIZABLE) # Resize grid if (self.window.get_rect().width < self.control_width): # Grid size is less than zero, so set it to 2x2 pixels instead # (which should create a single cell). # It will get covered by the controls, anyway. # If grid is 0x0 and the calcThread starts, it will crash self.grid.resize(Dimensions(2, 2), Position(0, 0)) else: self.grid.resize(Dimensions(self.window.get_rect().width - self.control_width, self.window.get_rect().height), Position(0, 0)) # Resize controls self.controls.resize(Dimensions(self.control_width, self.window.get_rect().height), Position(self.grid.rect.width, 0)) def reset(self): self.__init__(Dimensions(self.window.get_rect().width, self.window.get_rect().height), self.calcThread) self.calcThread.__init__(self) def pause(self): self.simRunning = not(self.simRunning) self.controls.updateStatusDisplay(self.simRunning) def speedUp(self): self.calcThread.speed += 1 self.controls.updateSpeedDisplay(self.calcThread.speed) def speedDown(self): if (self.calcThread.speed > 1): self.calcThread.speed -= 1 self.controls.updateSpeedDisplay(self.calcThread.speed) def popLimitUp(self): if self.populationLimit < 8: self.populationLimit += 1 self.controls.updatePopLimitDisplay(self.populationLimit) def popLimitDown(self): if self.populationLimit > 1: self.populationLimit -= 1 self.controls.updatePopLimitDisplay(self.populationLimit) def popMinUp(self): if self.populationMin < 8: self.populationMin += 1 self.controls.updatePopMinDisplay(self.populationMin) def popMinDown(self): if self.populationMin > 1: self.populationMin -= 1 self.controls.updatePopMinDisplay(self.populationMin) def stepForward(self): if self.simRunning: self.pause() self.calcThread.calc()
def on_update(self, delta_time: float): """ Update the positions and statuses of all game objects If paused, do nothing :param delta_time: Time since the last update """ if not self.game_over or not self.paused: self.physics_engine.step() # handle background music self.play_music() if self.screen_wipe_rect: # when the game is transitioning to a new level/restarting a level self.screen_wipe_rect.center_x += self.screen_wipe_rect.change_x self.screen_wipe_rect.center_y = self.view_bottom + (SCREEN_HEIGHT / 2) # handle loading level here, after screen is covered in blue wipe if (self.screen_wipe_rect.center_x > SCREEN_WIDTH) and (self.update_level): self.load_level(self.level) self.update_level = False # lower flag when level begins to load if self.screen_wipe_rect.center_x > SCREEN_WIDTH * 2: self.screen_wipe_rect = None # Update everything self.player_list.update() self.all_sprites.update() self.enemies_list.update() self.moving_platforms_list.update() self.cannons_list.update() Controls.handle_control_actions(self) if self.player.in_water: Controls.handle_water_physics(self) self.process_damage() self.track_moving_sprites(delta_time) self.cannon_toggle() self.in_water_physics() if ar.check_for_collision_with_list(self.player, self.keys_list) and not self.update_level: current_key = ar.check_for_collision_with_list(self.player, self.keys_list)[0] if self.key_colors[current_key] == WHITE: # this if statement is redundant so that we don't immediately enter the else statement below if self.hidden_platform_list: self.orb_off_sound.play(volume=0.2) for platform in self.hidden_platform_list: self.physics_engine.remove_sprite(platform) self.hidden_platform_list = None self.player.color = WHITE else: if not self.hidden_platform_list: self.orb_touched_sound.play(volume=0.2) self.load_layer("Hidden Platforms", self.key_colors[current_key]) self.player.color = self.key_colors[current_key] # if player gets to the right edge of the level, go to next level if self.player.right >= self.end_of_map: self.update_level = True # raise this flag to properly restart level self.level += 1 # switch to next level self.screen_wipe_rect = Transition() self.screen_wipe_rect.setup() self.player_teleported = True self.physics_engine.set_horizontal_velocity(self.player, 0) self.physics_engine.set_position(self.player, self.player.spawnpoint) # if the player hits the bottom of the level, player dies and respawns at the start of the level if self.player.bottom <= 0: self.update_level = True # raise this flag to properly restart level self.screen_wipe_rect = Transition() self.screen_wipe_rect.setup() self.player_teleported = True self.physics_engine.set_horizontal_velocity(self.player, 0) self.physics_engine.set_position(self.player, self.player.spawnpoint) if self.physics_engine.is_on_ground(self.player) and self.player.jumping: self.player.jumping = False # track if we need to change the view port changed = False # Scroll left left_bndry = self.view_left + VIEWPORT_LEFT_MARGIN if self.player.left < left_bndry and self.player.left > VIEWPORT_LEFT_MARGIN: self.view_left -= left_bndry - self.player.left changed = True # Scroll right right_bndry = self.view_left + SCREEN_WIDTH - VIEWPORT_RIGHT_MARGIN if self.player.right > right_bndry and (self.player.right < (self.end_of_map - VIEWPORT_RIGHT_MARGIN)): self.view_left += self.player.right - right_bndry changed = True # Scroll up top_bndry = self.view_bottom + SCREEN_HEIGHT - VIEWPORT_MARGIN_TOP if self.player.top > top_bndry and (self.player.top < (self.top_of_map - VIEWPORT_MARGIN_TOP)): self.view_bottom += self.player.top - top_bndry changed = True # Scroll down bottom_bndry = self.view_bottom + VIEWPORT_MARGIN_BOTTOM if self.player.bottom < bottom_bndry and self.player.bottom > VIEWPORT_MARGIN_BOTTOM: self.view_bottom -= bottom_bndry - self.player.bottom changed = True # If we need to scroll, go ahead and do it. # also change viewport when player has teleported (when switching levels, respawning, etc) if changed: self.view_left = int(self.view_left) self.view_bottom = int(self.view_bottom) ar.set_viewport(self.view_left, SCREEN_WIDTH + self.view_left, self.view_bottom, SCREEN_HEIGHT + self.view_bottom) if self.player_teleported and self.screen_wipe_rect.center_x > SCREEN_WIDTH: self.view_left = 0 self.view_bottom = 0 ar.set_viewport(self.view_left, SCREEN_WIDTH + self.view_left, self.view_bottom, SCREEN_HEIGHT + self.view_bottom) self.player_teleported = False
import time import argparse if __name__ == '__main__': parser = argparse.ArgumentParser( description="Scan some film") parser.add_argument('-f', '--format', help="the output format. (jpg, tif, png)", required="true", type=str) parser.add_argument('-o', '--output', help="Path of Output Directory.", required="true") args = vars(parser.parse_args()) format = args['format'] output = args['output'] controls = Controls() controls.microstep('sixteenth') controls.motor_setup() controls.backlight_on() capture = FrameCapture(output, format, low_res=(270, 512), hi_res=(1080, 2048)) detector = PerfDetector(gauge='16mm') while True: for step in range(0, 50): time.sleep(0.004) controls.motor_forward() frame = capture.capture_low_res() if detector.detect_perfs(frame) is True: capture.capture_hi_res_async() capture.clear_buffer()
def __init__(self, handle): activity.Activity.__init__(self, handle) self.player = None self._alert = None self._playlist_jobject = None self.set_title(_('Jukebox Activity')) self.max_participants = 1 self._toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) activity_toolbar = activity_button.page self._toolbar_box.toolbar.insert(activity_button, 0) self.title_entry = activity_toolbar.title self._view_toolbar = ViewToolbar() self._view_toolbar.connect('go-fullscreen', self.__go_fullscreen_cb) self._view_toolbar.connect('toggle-playlist', self.__toggle_playlist_cb) view_toolbar_button = ToolbarButton( page=self._view_toolbar, icon_name='toolbar-view') self._view_toolbar.show() self._toolbar_box.toolbar.insert(view_toolbar_button, -1) view_toolbar_button.show() self._control_toolbar = Gtk.Toolbar() self._control_toolbar_button = ToolbarButton( page=self._control_toolbar, icon_name='media-playback-start') self._control_toolbar.show() self._toolbar_box.toolbar.insert(self._control_toolbar_button, -1) self._control_toolbar_button.hide() self.set_toolbar_box(self._toolbar_box) self._toolbar_box.show_all() self.connect('key_press_event', self.__key_press_event_cb) self.connect('playlist-finished', self.__playlist_finished_cb) # We want to be notified when the activity gets the focus or # loses it. When it is not active, we don't need to keep # reproducing the video self.connect('notify::active', self.__notify_active_cb) self._video_canvas = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL) self._playlist_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.playlist_widget = PlayList() self.playlist_widget.connect('play-index', self.__play_index_cb) self.playlist_widget.connect('missing-tracks', self.__missing_tracks_cb) self.playlist_widget.set_size_request( Gdk.Screen.width() * PLAYLIST_WIDTH_PROP, 0) self.playlist_widget.show() self._playlist_box.pack_start(self.playlist_widget, expand=True, fill=True, padding=0) self._playlist_toolbar = Gtk.Toolbar() move_up = ToolButton("go-up") move_up.set_tooltip(_("Move up")) move_up.connect("clicked", self._move_up_cb) self._playlist_toolbar.insert(move_up, 0) move_down = ToolButton("go-down") move_down.set_tooltip(_("Move down")) move_down.connect("clicked", self._move_down_cb) self._playlist_toolbar.insert(move_down, 1) self._playlist_box.pack_end(self._playlist_toolbar, False, False, 0) self._video_canvas.pack_start(self._playlist_box, False, False, 0) # Create the player just once logging.debug('Instantiating GstPlayer') self.player = GstPlayer() self.player.connect('eos', self.__player_eos_cb) self.player.connect('error', self.__player_error_cb) self.player.connect('play', self.__player_play_cb) self.control = Controls(self, self._toolbar_box.toolbar, self._control_toolbar) self._separator = Gtk.SeparatorToolItem() self._separator.props.draw = False self._separator.set_expand(True) self._separator.show() self._toolbar_box.toolbar.insert(self._separator, -1) self._stop = StopButton(self) self._toolbar_box.toolbar.insert(self._stop, -1) self._empty_widget = Gtk.Label(label="") self._empty_widget.show() self.videowidget = VideoWidget() self.set_canvas(self._video_canvas) self._init_view_area() self.show_all() # need hide the playlist by default self._playlist_box.hide() self._configure_cb() self.player.init_view_area(self.videowidget) self._volume_monitor = Gio.VolumeMonitor.get() self._volume_monitor.connect('mount-added', self.__mount_added_cb) self._volume_monitor.connect('mount-removed', self.__mount_removed_cb) if handle.object_id is None: # The activity was launched from scratch. We need to show # the Empty Widget self.playlist_widget.hide() emptypanel.show(self, 'activity-jukebox', _('No media'), _('Choose media files'), self.control.show_picker_cb) self.control.check_if_next_prev() Gdk.Screen.get_default().connect('size-changed', self._configure_cb)
class JukeboxActivity(activity.Activity): __gsignals__ = { 'playlist-finished': (GObject.SignalFlags.RUN_FIRST, None, []), } def __init__(self, handle): activity.Activity.__init__(self, handle) self.player = None self._alert = None self._playlist_jobject = None self.set_title(_('Jukebox Activity')) self.max_participants = 1 self._toolbar_box = ToolbarBox() activity_button = ActivityToolbarButton(self) activity_toolbar = activity_button.page self._toolbar_box.toolbar.insert(activity_button, 0) self.title_entry = activity_toolbar.title self._view_toolbar = ViewToolbar() self._view_toolbar.connect('go-fullscreen', self.__go_fullscreen_cb) self._view_toolbar.connect('toggle-playlist', self.__toggle_playlist_cb) view_toolbar_button = ToolbarButton( page=self._view_toolbar, icon_name='toolbar-view') self._view_toolbar.show() self._toolbar_box.toolbar.insert(view_toolbar_button, -1) view_toolbar_button.show() self._control_toolbar = Gtk.Toolbar() self._control_toolbar_button = ToolbarButton( page=self._control_toolbar, icon_name='media-playback-start') self._control_toolbar.show() self._toolbar_box.toolbar.insert(self._control_toolbar_button, -1) self._control_toolbar_button.hide() self.set_toolbar_box(self._toolbar_box) self._toolbar_box.show_all() self.connect('key_press_event', self.__key_press_event_cb) self.connect('playlist-finished', self.__playlist_finished_cb) # We want to be notified when the activity gets the focus or # loses it. When it is not active, we don't need to keep # reproducing the video self.connect('notify::active', self.__notify_active_cb) self._video_canvas = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL) self._playlist_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.playlist_widget = PlayList() self.playlist_widget.connect('play-index', self.__play_index_cb) self.playlist_widget.connect('missing-tracks', self.__missing_tracks_cb) self.playlist_widget.set_size_request( Gdk.Screen.width() * PLAYLIST_WIDTH_PROP, 0) self.playlist_widget.show() self._playlist_box.pack_start(self.playlist_widget, expand=True, fill=True, padding=0) self._playlist_toolbar = Gtk.Toolbar() move_up = ToolButton("go-up") move_up.set_tooltip(_("Move up")) move_up.connect("clicked", self._move_up_cb) self._playlist_toolbar.insert(move_up, 0) move_down = ToolButton("go-down") move_down.set_tooltip(_("Move down")) move_down.connect("clicked", self._move_down_cb) self._playlist_toolbar.insert(move_down, 1) self._playlist_box.pack_end(self._playlist_toolbar, False, False, 0) self._video_canvas.pack_start(self._playlist_box, False, False, 0) # Create the player just once logging.debug('Instantiating GstPlayer') self.player = GstPlayer() self.player.connect('eos', self.__player_eos_cb) self.player.connect('error', self.__player_error_cb) self.player.connect('play', self.__player_play_cb) self.control = Controls(self, self._toolbar_box.toolbar, self._control_toolbar) self._separator = Gtk.SeparatorToolItem() self._separator.props.draw = False self._separator.set_expand(True) self._separator.show() self._toolbar_box.toolbar.insert(self._separator, -1) self._stop = StopButton(self) self._toolbar_box.toolbar.insert(self._stop, -1) self._empty_widget = Gtk.Label(label="") self._empty_widget.show() self.videowidget = VideoWidget() self.set_canvas(self._video_canvas) self._init_view_area() self.show_all() # need hide the playlist by default self._playlist_box.hide() self._configure_cb() self.player.init_view_area(self.videowidget) self._volume_monitor = Gio.VolumeMonitor.get() self._volume_monitor.connect('mount-added', self.__mount_added_cb) self._volume_monitor.connect('mount-removed', self.__mount_removed_cb) if handle.object_id is None: # The activity was launched from scratch. We need to show # the Empty Widget self.playlist_widget.hide() emptypanel.show(self, 'activity-jukebox', _('No media'), _('Choose media files'), self.control.show_picker_cb) self.control.check_if_next_prev() Gdk.Screen.get_default().connect('size-changed', self._configure_cb) def _move_up_cb(self, button): self.playlist_widget.move_up() def _move_down_cb(self, button): self.playlist_widget.move_down() def _configure_cb(self, event=None): self._toolbar_box.toolbar.remove(self._stop) self._toolbar_box.toolbar.remove(self._separator) if Gdk.Screen.width() < Gdk.Screen.height(): self._control_toolbar_button.show() self._control_toolbar_button.set_expanded(True) self.control.update_layout(landscape=False) self._toolbar_box.toolbar.insert(self._separator, -1) else: self._control_toolbar_button.set_expanded(False) self._control_toolbar_button.hide() self.control.update_layout(landscape=True) self._toolbar_box.toolbar.insert(self._stop, -1) def __notify_active_cb(self, widget, event): """Sugar notify us that the activity is becoming active or inactive. When we are inactive, we stop the player if it is reproducing a video. """ logging.debug('JukeboxActivity notify::active signal received') if self.player.player.props.current_uri is not None and \ self.player.playing_video(): if not self.player.is_playing() and self.props.active: self.player.play() if self.player.is_playing() and not self.props.active: self.player.pause() def _init_view_area(self): """ Use a notebook with two pages, one empty an another with the videowidget """ self.view_area = Gtk.Notebook() self.view_area.set_show_tabs(False) self.view_area.append_page(self._empty_widget, None) self.view_area.append_page(self.videowidget, None) self._video_canvas.pack_end(self.view_area, expand=True, fill=True, padding=0) def _switch_canvas(self, show_video): """Show or hide the video visualization in the canvas. When hidden, the canvas is filled with an empty widget to ensure redrawing. """ if show_video: self.view_area.set_current_page(1) else: self.view_area.set_current_page(0) self._video_canvas.queue_draw() def __key_press_event_cb(self, widget, event): keyname = Gdk.keyval_name(event.keyval) logging.info("Keyname Press: %s, time: %s", keyname, event.time) if self.title_entry.has_focus(): return False if keyname == "space": self.control._button_clicked_cb(None) return True def __playlist_finished_cb(self, widget): self._switch_canvas(show_video=False) self._view_toolbar._show_playlist.set_active(True) self.unfullscreen() # Select the first stream to be played when Play button will # be pressed self.playlist_widget.set_current_playing(0) self.control.check_if_next_prev() def songchange(self, direction): current_playing = self.playlist_widget.get_current_playing() if direction == 'prev' and current_playing > 0: self.play_index(current_playing - 1) elif direction == 'next' and \ current_playing < len(self.playlist_widget._items) - 1: self.play_index(current_playing + 1) else: self.emit('playlist-finished') def play_index(self, index): # README: this line is no more necessary because of the # .playing_video() method # self._switch_canvas(show_video=True) self.playlist_widget.set_current_playing(index) path = self.playlist_widget._items[index]['path'] if self.playlist_widget.check_available_media(path): if self.playlist_widget.is_from_journal(path): path = self.playlist_widget.get_path_from_journal(path) self.control.check_if_next_prev() self.player.set_uri(path) self.player.play() else: self.songchange('next') def __play_index_cb(self, widget, index, path): # README: this line is no more necessary because of the # .playing_video() method # self._switch_canvas(show_video=True) self.playlist_widget.set_current_playing(index) if self.playlist_widget.is_from_journal(path): path = self.playlist_widget.get_path_from_journal(path) self.control.check_if_next_prev() self.player.set_uri(path) self.player.play() def __player_eos_cb(self, widget): self.songchange('next') def _show_error_alert(self, title, msg=None): self._alert = ErrorAlert() self._alert.props.title = title if msg is not None: self._alert.props.msg = msg self.add_alert(self._alert) self._alert.connect('response', self._alert_cancel_cb) self._alert.show() def __mount_added_cb(self, volume_monitor, device): logging.debug('Mountpoint added. Checking...') self.remove_alert(self._alert) self.playlist_widget.update() def __mount_removed_cb(self, volume_monitor, device): logging.debug('Mountpoint removed. Checking...') self.remove_alert(self._alert) self.playlist_widget.update() def __missing_tracks_cb(self, widget, tracks): self._show_missing_tracks_alert(tracks) def _show_missing_tracks_alert(self, tracks): self._alert = Alert() title = _('%s tracks not found.') % len(tracks) self._alert.props.title = title icon = Icon(icon_name='dialog-cancel') self._alert.add_button(Gtk.ResponseType.CANCEL, _('Dismiss'), icon) icon.show() icon = Icon(icon_name='dialog-ok') self._alert.add_button(Gtk.ResponseType.APPLY, _('Details'), icon) icon.show() self.add_alert(self._alert) self._alert.connect( 'response', self.__missing_tracks_alert_response_cb, tracks) def __missing_tracks_alert_response_cb(self, alert, response_id, tracks): if response_id == Gtk.ResponseType.APPLY: vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) vbox.props.valign = Gtk.Align.CENTER label = Gtk.Label(label='') label.set_markup(_('<b>Missing tracks</b>')) vbox.pack_start(label, False, False, 15) for track in tracks: label = Gtk.Label(label=track['path']) vbox.add(label) _missing_tracks = Gtk.ScrolledWindow() _missing_tracks.add_with_viewport(vbox) _missing_tracks.show_all() self.view_area.append_page(_missing_tracks, None) self.view_area.set_current_page(2) self.remove_alert(alert) def _alert_cancel_cb(self, alert, response_id): self.remove_alert(alert) def __player_play_cb(self, widget): # Do not show the visualization widget if we are playing just # an audio stream def callback(): if self.player.playing_video(): self._switch_canvas(True) else: self._switch_canvas(False) return False # HACK: we need a timeout here because gstreamer returns # n-video = 0 if we call it immediately GObject.timeout_add(1000, callback) def __player_error_cb(self, widget, message, detail): self.player.stop() self.control.set_disabled() logging.error('ERROR MESSAGE: %s', message) logging.error('ERROR DETAIL: %s', detail) file_path = self.playlist_widget._items[ self.playlist_widget.get_current_playing()]['path'] mimetype = mime.get_for_file(file_path) title = _('Error') msg = _('This "%s" file can\'t be played') % mimetype self._switch_canvas(False) self._show_error_alert(title, msg) def can_close(self): # We need to put the Gst.State in NULL so gstreamer can # cleanup the pipeline self.player.stop() return True def read_file(self, file_path): """Load a file from the datastore on activity start.""" logging.debug('JukeBoxAtivity.read_file: %s', file_path) title = self.metadata['title'] self.playlist_widget.load_file(file_path, title) self._view_toolbar._show_playlist.set_active(True) def write_file(self, file_path): def write_playlist_to_file(file_path): """Open the file at file_path and write the playlist. It is saved in audio/x-mpegurl format. """ list_file = open(file_path, 'w') for uri in self.playlist_widget._items: list_file.write('#EXTINF:%s\n' % uri['title']) list_file.write('%s\n' % uri['path']) list_file.close() if not self.metadata['mime_type']: self.metadata['mime_type'] = 'audio/x-mpegurl' if self.metadata['mime_type'] == 'audio/x-mpegurl': write_playlist_to_file(file_path) else: if self._playlist_jobject is None: self._playlist_jobject = \ self.playlist_widget.create_playlist_jobject() # Add the playlist to the playlist jobject description. # This is only done if the activity was not started from a # playlist or from scratch: description = '' for uri in self.playlist_widget._items: description += '%s\n' % uri['title'] self._playlist_jobject.metadata['description'] = description write_playlist_to_file(self._playlist_jobject.file_path) datastore.write(self._playlist_jobject) def __go_fullscreen_cb(self, toolbar): self.fullscreen() def __toggle_playlist_cb(self, toolbar): if self._view_toolbar._show_playlist.get_active(): self._playlist_box.show_all() else: self._playlist_box.hide() self._video_canvas.queue_draw()
def __init__(self, parent, title): wx.Frame.__init__(self, parent, title=title) # Splitters and Panels self.controls_map_splitter = wx.SplitterWindow(self) self.controls_map_splitter.SetMinimumPaneSize(300) controls_panel = wx.Panel(self.controls_map_splitter) map_panel = wx.Panel(self.controls_map_splitter) self.graphs_messages_splitter = wx.SplitterWindow(controls_panel) self.graphs_messages_splitter.SetMinimumPaneSize(50) graphs_panel = wx.Panel(self.graphs_messages_splitter) messages_panel = wx.Panel(self.graphs_messages_splitter) # World graphic self._graphics = worldmap.WorldMap(map_panel) self.graphics_sizer = wx.BoxSizer(wx.VERTICAL) self.graphics_sizer.Add(self._graphics, 1, wx.EXPAND) map_panel.SetSizerAndFit(self.graphics_sizer) # Controls panel self.controls = Controls(controls_panel, (300, 250), self) # Info panel self.info = Info(controls_panel, (300, 250)) # Graph canvas self.graphs = graphs.Graphs(graphs_panel, (300, 300)) # Messages panel self.messages = Messages(messages_panel, (600, 200)) self.interface_sizer = wx.BoxSizer(wx.VERTICAL) self.controls_info_sizer = wx.BoxSizer(wx.HORIZONTAL) self.controls_info_sizer.Add(self.info, 0, wx.EXPAND) self.controls_info_sizer.Add((20, -1), proportion=0) # Padding self.controls_info_sizer.Add(self.controls, 1, wx.EXPAND) self.messages_sizer = wx.BoxSizer(wx.VERTICAL) self.messages_sizer.Add(self.messages, 1, wx.EXPAND) messages_panel.SetSizerAndFit(self.messages_sizer) self.graphs_sizer = wx.BoxSizer(wx.VERTICAL) self.graphs_sizer.Add(self.graphs, 1, wx.EXPAND) graphs_panel.SetSizerAndFit(self.graphs_sizer) self.interface_sizer.Add(self.controls_info_sizer, 0, wx.EXPAND) self.interface_sizer.Add(self.graphs_messages_splitter, 1, wx.EXPAND) controls_panel.SetSizerAndFit(self.interface_sizer) self.graphs_messages_splitter.SplitHorizontally( messages_panel, graphs_panel ) self.controls_map_splitter.SplitVertically(controls_panel, map_panel) # Set up event handler for any worker thread results EVT_RESULT(self, self.OnResult) EVT_STOP(self, self.OnStop) # Set up close event so timer is properly stopped wx.EVT_CLOSE(self, self.OnClose) self.reset_gui() self.Show()
if(not os.path.exists("maps/%d-%d-%d.png" % (zoom,i,j))): page = urllib2.urlopen("http://a.tile.openstreetmap.org/%d/%d/%d.png" % (zoom,i,j)) file = open("maps/%d-%d-%d.png" % (zoom,i,j),"wb") data = page.read() file.write(data) file.flush() file.close() images.append(ImageTk.PhotoImage(file="maps/%d-%d-%d.png" % (zoom,i,j))) canvas.create_image((i - tile_ref[0] + r + 1) * 256,(j - tile_ref[1] + r + 1) * 256,image=images[-1]) print (float(i - tile_ref[0] + r) / ((r *2) +1 ) * 100) helicopter = HelicopterSprite(canvas,"images/helicopter/red/helicopter",(r*256)+256+250,(r*256)+256+250,0,60) controls = Controls(top) event = controls.get_event() canvas.xview_moveto(0.5) canvas.yview_moveto(0.5) prev_time = time.time() while(play): event = controls.get_event() while(event != None): helicopter.process_event(event) if(event == 9): play = False
class Game(object): def __init__(self, verbose=False, path=path): self.levels = {} self.home = os.environ['HOME'] self.path = path if path else os.environ['PWD'] self.game = pygame.init() self.game_exit = False self.current_level = "0-0" self.levels_loaded = False self.main_character_loaded = False self.clock = pygame.time.Clock() self.verbose = verbose self.width = 0 self.height = 0 self.scalar = 70 self.screen = None self.controls = Controls(path=path) self.game_locations = {} def load_levels(self): print self.path for path, directory, levels in os.walk(self.path + "/assets/levels/"): for level in levels: match = re.match("(.*)\.lvl", level) if match: level_name = match.group(1) file_name = path + match.group(0) with open(file_name, "r") as level_content: self.levels[level_name] = Level(level_name, level_content.read( ), clock=self.clock, scalar=self.scalar, verbose=self.verbose) self.width = self.levels[level_name].block_width * self.scalar if self.levels[ level_name].block_width * self.scalar > self.width else self.width self.height = self.levels[level_name].block_height * self.scalar if self.levels[ level_name].block_height * self.scalar > self.height else self.height self.levels_loaded = True def log(self, message): pprint(message) if self.verbose else None def load_characters(self): self.main_character = Character( "dave", screen=self.screen, scalar=self.scalar, clock=self.clock) self.main_character_loaded = True def valid_level(self, level): return True if self.levels.get(level, False) else False def go_direction(self, vector, direction, limit1, limit2, oldlimit1, oldlimit2): vectors = self.current_level.split('-') vectors[vector] = str(int(vectors[vector]) + direction) new_level = vectors[0] + '-' + vectors[1] if self.valid_level(new_level): self.current_level = vectors[0] + '-' + vectors[1] self.main_character.log('entered ' + self.current_level) self.main_character.old_position[vector] = limit1 self.main_character.position[vector] = limit2 else: self.main_character.old_position[vector] = oldlimit1 self.main_character.position[vector] = oldlimit2 def go_right(self): self.go_direction(0, 1, -1, 0, self.levels[ self.current_level].block_width - 1, self.levels[self.current_level].block_width - 1) def go_left(self): self.go_direction(0, -1, self.levels[self.current_level].block_width, self.levels[ self.current_level].block_width - 1, 0, 0) def go_up(self): self.go_direction(1, 1, self.levels[self.current_level].block_height, self.levels[ self.current_level].block_height - 1, 0, 0) def go_down(self): self.go_direction(1, -1, -1, 0, self.levels[ self.current_level].block_height - 1, self.levels[self.current_level].block_height - 1) def save_screen(self): pygame.image.save(self.screen, self.home + '/current_screen.jpg') def main_loop(self): if not self.levels_loaded: self.load_levels() if not self.main_character_loaded: self.load_characters() count = 0 self.screen = pygame.display.set_mode((self.width, self.height), pygame.RESIZABLE) while not self.game_exit: try: self.main_character.blocks.remove(tuple(self.main_character.position)) except KeyError: pass events = pygame.event.get() self.last_level = self.current_level self.levels[self.current_level].draw_level() self.main_character.blocks = self.levels[self.current_level].blocks self.main_character.water_blocks = self.levels[ self.current_level].water_blocks self.controls.get_events(events, self.screen, self.levels[self.current_level], self.main_character) self.main_character.check_movement() self.main_character.draw_character() self.levels[self.current_level].draw_foreground() pygame.display.update() self.levels[self.current_level].slow_clock() self.clock.tick(60) if self.main_character.position[0] > self.levels[self.current_level].block_width - 1: self.go_right() if self.main_character.position[0] < 0: self.go_left() if self.main_character.position[1] < 0: self.go_up() if self.main_character.position[1] > self.levels[self.current_level].block_height - 1: self.go_down() self.main_character.blocks.add(tuple(self.main_character.position))
def run(): signals = { 'green': False, 'red': False, 'blue': False, 'stop': False, 'metal': False, 'maxTime': False, 'finish': False, 'path': '/home/pi/Filakov/', 'pltCnt': 1, 'imgCnt': 1 } start = time.time() # Make directory for the pictures directory = datetime.datetime.today().strftime('%Y-%m-%d_%H-%M-%S') signals['path'] += directory + '/' try: os.makedirs(signals['path']) except Exception as e: debug_print(str(e)) debug_print('Folder for pictures was not created. Aborting program...') return global output_file output_file = open(signals['path'] + 'log.txt', 'w', encoding='utf-8') C = Controls("/dev/ttyACM0", output_file) if not C.started: debug_print( "Controls of the motors are not started. Aborting program...") output_file.close() return cam = cv2.VideoCapture(0) time.sleep(1) if not cam.isOpened(): debug_print("Camera is not opened. Aborting program...") output_file.close() return # Run the process T_metal = threading.Thread(target=metalCheck, args=( C, signals, )) T_cam = threading.Thread(target=cameraLoop, args=( cam, signals, )) T_metal.start() T_cam.start() # Canvas down C.Move(3, 'M', 250, wait=True) C.Lights(1) # Camera calibration # C.Move(2, 'M', 180, wait = True) # calibrateCamera(C, signals) # if signals['stop']: # stopRoutine(C, signals) # return C.Move(2, 'M', 180, wait=True) # debug_print('Camera calibrated successfully.') # First iteration of plant imaging plantIter(C, cam, '-', signals) if signals['stop']: stopRoutine(C, signals) signals['finish'] = True T_cam.join() T_metal.join() output_file.close() return # Second iteration of plant imaging debug_print('Preparing plant imaging on the other side.') C.Move(2, 'M', -180, wait=True) plantIter(C, cam, '+', signals) if signals['stop']: stopRoutine(C, signals) signals['finish'] = True T_cam.join() T_metal.join() output_file.close() return # Finishing routine debug_print('Vertical motor returning to home position.') C.Move(1, 'H', wait=True) debug_print('Job done: ' + str(time.time() - start) + ' secs') signals['finish'] = True T_cam.join() T_metal.join() C.Lights(0) # Canvas up C.Move(3, 'M', -250, wait=True) C.Close() uploadCloudFolder(signals['path']) output_file.close() sendDoneMail(signals['path'] + 'log.txt')
class Window(wx.Frame): def __init__(self, parent, title): wx.Frame.__init__(self, parent, title=title) # Splitters and Panels self.controls_map_splitter = wx.SplitterWindow(self) self.controls_map_splitter.SetMinimumPaneSize(300) controls_panel = wx.Panel(self.controls_map_splitter) map_panel = wx.Panel(self.controls_map_splitter) self.graphs_messages_splitter = wx.SplitterWindow(controls_panel) self.graphs_messages_splitter.SetMinimumPaneSize(50) graphs_panel = wx.Panel(self.graphs_messages_splitter) messages_panel = wx.Panel(self.graphs_messages_splitter) # World graphic self._graphics = worldmap.WorldMap(map_panel) self.graphics_sizer = wx.BoxSizer(wx.VERTICAL) self.graphics_sizer.Add(self._graphics, 1, wx.EXPAND) map_panel.SetSizerAndFit(self.graphics_sizer) # Controls panel self.controls = Controls(controls_panel, (300, 250), self) # Info panel self.info = Info(controls_panel, (300, 250)) # Graph canvas self.graphs = graphs.Graphs(graphs_panel, (300, 300)) # Messages panel self.messages = Messages(messages_panel, (600, 200)) self.interface_sizer = wx.BoxSizer(wx.VERTICAL) self.controls_info_sizer = wx.BoxSizer(wx.HORIZONTAL) self.controls_info_sizer.Add(self.info, 0, wx.EXPAND) self.controls_info_sizer.Add((20, -1), proportion=0) # Padding self.controls_info_sizer.Add(self.controls, 1, wx.EXPAND) self.messages_sizer = wx.BoxSizer(wx.VERTICAL) self.messages_sizer.Add(self.messages, 1, wx.EXPAND) messages_panel.SetSizerAndFit(self.messages_sizer) self.graphs_sizer = wx.BoxSizer(wx.VERTICAL) self.graphs_sizer.Add(self.graphs, 1, wx.EXPAND) graphs_panel.SetSizerAndFit(self.graphs_sizer) self.interface_sizer.Add(self.controls_info_sizer, 0, wx.EXPAND) self.interface_sizer.Add(self.graphs_messages_splitter, 1, wx.EXPAND) controls_panel.SetSizerAndFit(self.interface_sizer) self.graphs_messages_splitter.SplitHorizontally( messages_panel, graphs_panel ) self.controls_map_splitter.SplitVertically(controls_panel, map_panel) # Set up event handler for any worker thread results EVT_RESULT(self, self.OnResult) EVT_STOP(self, self.OnStop) # Set up close event so timer is properly stopped wx.EVT_CLOSE(self, self.OnClose) self.reset_gui() self.Show() def reset_gui(self): self.controls.reset_buttons() self.messages.clear() self.graphs.reset_data() # Event Methods def OnStart(self, event): self.controls.set_buttons_ready() self._simulation = simulation.Simulation() self._simulation.setup_config(self.controls.get_config_filename()) self.simulation_info = self._simulation.initialize() if not self.simulation_info.interface_config.print_messages: self.messages.deactivate() self._graphics.num_max_complaints = \ self.simulation_info.num_max_complaints self.rounds = 0 self.steps = 0 self.next_phase = "COASTPLAN" self.prev_phase = None self.worker = None def run(self, rounds, steps): assert rounds >= 0, "Rounds has to be a positive integer." assert steps >= 0, "Steps has to be a positive integer." assert steps > 0 or rounds > 0, "Rounds or steps needs to be positive." self.controls.set_status(rounds, steps) self.controls.set_buttons_processing() self.rounds = rounds self.steps = steps if self.worker is None: self.prev_phase = self.next_phase self.info.set_current_phase(self.next_phase) self.worker = WorkerThread(self._simulation, self) def OnResult(self, event): if not event.source is self.worker: # ongoing simulation was aborted return self.worker = None self.simulation_info.map.grid = util.update_map( self.simulation_info.map.grid, event.result.map.grid ) self.next_phase = event.result.next_phase handle_statistics(self.graphs, event.result.round, event.result.data) self._graphics.set_map(self.simulation_info.map) if event.result.phase == "HEARING": self._graphics.add_votes(event.result.complaints) self._graphics.update() for m in event.result.messages: self.messages.add(str(m)) newr = self.prev_phase == "LEARNING" and self.next_phase == "COASTPLAN" if newr: self._graphics.reset_votes() if newr and self.rounds > 0: self.rounds -= 1 elif self.rounds == 0: self.steps -= 1 if self.rounds > 0 or self.steps > 0: self.run(self.rounds, self.steps) else: self.controls.set_buttons_ready() def OnStop(self, event): self.reset_gui() self._simulation = None self.worker = None self.simulation_info = None def OnClose(self, event): # TODO: Fix self.Destroy()
class game_system(object): """game system controls when objects in the system get updated""" objects = () controllers = () def __init__(self, window=None, objects=(), controllers=()): #Create a font for score self.font = font.load('Arial', 18) #pyglet.font.Text object to display the score self.score = font.Text(self.font, x = 10, y=10, color=(1, 1, 1, 1)) self.control = Controls(window) self.bind_objects(*objects) self.bind_controllers(*controllers) self.score_right = 0 self.score_left = 0 self.draw_score() self.height = window.width self.width = window.height #should this not be handled within the object? #map effects to different objects in the game effects_map = { "fire": None} def draw_score(self): self.score.text = ("left: %d right: %d") % (self.score_left, self.score_right) self.score.draw() def bind_controllers(self, *controllers): """Bind one or more controllers""" self.controllers += controllers def bind_objects(self, *objects): """Bind one or more objects""" self.control.bind_keys(objects) self.objects += objects def add(self, object): """Add an object to the list of objects that get traveresed when update is called""" self.objects += object def __iter__(self): """Iterate the particles in the group""" # Make a copy of the particle set in case the group is # modified during iteration return iter(set(self.objects))#used to be particles def __len__(self): """Return the number of particles in the group""" return len(self.objects) def send(self, message): #send the message to correct object for object in self.objects: if object.name == message.to: object.move(message.content) #Check to see if score has occured if message.to == "score": print "score message" self.update_score(message.content) def update_score(self, message): if message == "right:score": self.score_right += 1 if message == "left:score": self.score_left += 1 #draw the score self.draw_score() #reset ball because its gone outside of the screen for object in self.objects: if object.name =="ball": object.reset_ball(self.height/2, self.width/2) def update(self, time_delta): """Update all sprites in the system. time_delta is the time since the last update (in arbitrary time units). This method can be conveniently scheduled using the Pyglet scheduler method: pyglet.clock.schedule_interval """ self.control.update(self, time_delta) for object in self.objects: object.update(time_delta) #object.sprite.last_position = object.sprite.position #object.sprite.last_velocity = object.sprite.velocity #for group in self: for controller in self.controllers: controller(time_delta, self) def draw(self): """Draw all the sprites in the system using their renderers. This method is convenient to call from you Pyglet window's on_draw handler to redraw particles when needed. """ glPushAttrib(GL_ALL_ATTRIB_BITS) self.draw_score() for sprite in self: sprite.draw() glPopAttrib()