def train_model(args): data_loader = InputHandler(args.data_dir, args.batch_size, args.result_length) args.vocabulary_size = data_loader.vocabulary_size # Save the original files, so that we can load the model when sampling with open(os.path.join(args.snapshots_dir, CONFIGURATION_FILE), 'wb') as f: cPickle.dump(args, f) with open(os.path.join(args.snapshots_dir, WORDS_VOCABULARY_FILE), 'wb') as f: cPickle.dump((data_loader.words, data_loader.vocabulary), f) model = RNNModel(args.rnn_size, args.network_depth, args.batch_size, args.result_length, args.vocabulary_size, args.gradient) with tf.Session() as session: tf.initialize_all_variables().run() saver = tf.train.Saver(tf.all_variables()) for e in range(args.num_epochs): session.run(tf.assign(model.lr, args.training_rate * (args.decay_rate ** e))) data_loader.set_batch_pointer_to_zero() state = model.initial_state.eval() for b in range(data_loader.num_batches): x, y = data_loader.get_next_batch() feed = {model.input_data: x, model.targets: y, model.initial_state: state} train_loss, state, _ = session.run([model.cost, model.final_state, model.train_op], feed) if (e * data_loader.num_batches + b) % args.snapshot == 0 \ or (e==args.num_epochs-1 and b == data_loader.num_batches-1): # save for the last result snapshot_path = os.path.join(args.snapshots_dir, 'model.ckpt') saver.save(session, snapshot_path, global_step = e * data_loader.num_batches + b) print("Model snapshot was taken to {}".format(snapshot_path))
def __init__(self): GameState( ) # initialize the singleton before threading to avoid race conditions self.root = tk.Tk() self.windowManager = WindowManager() self.display = Display(self.root, self.windowManager) self.inputHandler = InputHandler(self.display.widget)
def main(argv: List): ih = InputHandler(join(dirname(__file__), argv[0])) ih.build_inputs() a = Aero(ih.seats) a.calc_seat_values() print(a.get_highest_seat_id()) print(a.get_missing_seat_id())
def run_program(self): """ Prompts a user with a various options until a user types 'exit'. """ commands = [ self.print_all_cards, self.print_cards_by_type, self.add_card, self.search_card, self.delete_card_by_id, self.delete_card_by_name, self.backup_card_list ] EXIT = "exit" want_to_exit = False while not want_to_exit: answer = input(f"\nWhat would you like to do?\n" f"\t1. Show all cards in the app\n" f"\t2. Show all cards of a specific type\n" f"\t3. Add a new card\n" f"\t4. Search for a card\n" f"\t5. Delete a card by ID\n" f"\t6. Delete a card by Name\n" f"\t7. Back up all cards in the app\n" f"Please select or type '{EXIT}' to exit: ") if answer == EXIT: print("\nBye!") want_to_exit = True else: try: InputHandler.validate_input(len(commands), answer) except ValueError: print("\nPlease type an integer!") except CommandNotFoundException as e: print(f"{e}") else: commands[int(answer) - 1]()
def give_options(self): """ Prompt the user with the choices. """ options = [ self.catalogue.display_available_items, self.catalogue.search, self.check_out, self.return_item, self.catalogue.add_item, self.catalogue.remove_item ] try: answer = input("-------------------------------\n" "(1) Display available items \n" "(2) Find an item by title\n" "(3) Check out an item\n" "(4) Return an item\n" "(5) Add an item\n" "(6) Remove an item\n" "Please select: \n") InputHandler.validate(len(options), answer) answer = int(answer) - 1 except ValueError: print("\n[Error] Please type an integer!") except CommandNotFoundException as e: print(f"{e}") else: if answer == 1: title = input("Enter the item title: ") options[answer](title) elif answer in [2, 3, 5]: call_number = input("Enter the call number of the item: ") options[answer](call_number) else: options[answer]()
def set_card_type(): """ Keeps prompting a user with a card type option until a user gives a valid answer, and returns the selected card type. :return: CardType """ card_types = {} count = 0 question = "\nWhich type of card would you like to add?\n" for type_ in CardType: card_types[count] = type_ count += 1 question += f"\t{count}. {type_.value}\n" question += "Please select a card type: " input_type = None while input_type is None: try: answer = input(question) InputHandler.validate_input(len(card_types), answer) except ValueError: print("\nPlease type an integer!") except CommandNotFoundException as e: print(f"{e}") else: input_type = card_types[int(answer) - 1] return input_type
def __init__(self): self.gui = GUI() self.input_handler = InputHandler(self.gui, let_the_nice_lady_speak=True) self.mic = sr.Microphone() self.recorder = sr.Recognizer() self.recorder.pause_threshold = 0.6 self.recorder.operation_timeout = 1 self.action_dict = {ENTER_VOICE_MOOD: self.listen_to_command_mode, EXIT_APP: self.close_app} time.sleep(1)
def __init__(self, size): """ :param size: tuple """ self.size = size self.running = True self.document = Document(self.size) self.screen_handler = ScreenHandler(self.size) self.input_handler = InputHandler() self.using_mode = 0 pygame.display.set_mode(size)
def main(): timer = Timer() pygame_clock = pygame.time.Clock() # Game loop looping = True while looping: # update phase game_globals.update(timer.update()) # display phase game_globals.draw() pygame.display.update() # event phase for event in pygame.event.get(): if event.type == pygame.QUIT: looping = False pygame.quit() sys.exit() elif event.type == pygame.KEYDOWN: InputHandler.parse_input(event.type, event.key, InputHandler.BEGAN) elif event.type == pygame.KEYUP: InputHandler.parse_input(event.type, event.key, InputHandler.ENDED) elif event.type == pygame.MOUSEBUTTONDOWN: InputHandler.parse_input(event.type, event.button, InputHandler.BEGAN) elif event.type == pygame.MOUSEBUTTONUP: InputHandler.parse_input(event.type, event.button, InputHandler.BEGAN) pygame_clock.tick(60)
def setUp(self): self.num_processes = 4 self.config = { 'hosts': [['localhost', 0, 0] for i in range(self.num_processes)], 'input': [], 'output': [], } self.inputs = [] self.outputs = [] self.input_handlers = [] self.storage_handlers = [] for i in range(self.num_processes): # set up pipes r, w = os.pipe() self.config['input'].append(os.fdopen(r, 'r')) self.inputs.append(os.fdopen(w, 'w')) r, w = os.pipe() self.config['output'].append(os.fdopen(w, 'w')) self.outputs.append(os.fdopen(r, 'r')) storage_handler = StorageHandler(i, [0.1, 0.1, 0.1], self.config) input_handler = InputHandler(i, storage_handler, self.config) self.input_handlers.append(input_handler) self.storage_handlers.append(storage_handler) self.handlers = self.input_handlers + self.storage_handlers for handler in self.handlers: handler.run() self.all_outputs += self.outputs self.all_inputs += self.inputs self.force_quit = False
def __init__(self): self.screen = Screen(640, 320) self.input_handler = InputHandler(self.screen) self.cpu = Cpu(self.screen, self.input_handler) self.loop()
def open_order_sheet(self): """ Aks users the name of the excel spreadsheet and read the spreadsheet. Iterate each row and process the order. """ file_path = input("Please enter the excel file name: ") InputHandler.validate_file(file_path) df = pd.read_excel(file_path).fillna(0) df.columns = [column.lower() for column in df.columns] df.rename(columns={'order number': 'order_number', 'style name': 'style', 'hidden zipper pockets': 'num_hidden_pockets', 'dry cleaning': 'dry_cleaning', 'indoor/outdoor': 'in_or_out', 'requires ironing': 'require_ironing'}, inplace=True) for _, row in df.iterrows(): self.process_next_order(row)
def process_next_order(self, row): """ Validate data and convert each row to an Order object and store it in the order_list dictionary as {Order Number: Order object} :param row: data frame row """ # Validate Integer types InputHandler.validate_int(row['order_number']) InputHandler.validate_int(row['count']) InputHandler.validate_int(row['num_hidden_pockets']) InputHandler.validate_int(row['buttons']) self.order_list[row['order_number']] = Order(**row.to_dict())
def __init__(self): self.input = InputHandler() self.state_manager = GameStateManager() self.hiscores = Hiscores(resources.get_hiscores(HISCORES_FILENAME)) self.logic_clock = Clock() self.render_clock = Clock() self.renderer = Thread(target=self.render_loop, args=()) self.renderer.daemon = True self.rendering = Lock() self.running = False self.screen = None self.canvas = None
def select_topping(): """ Prompt user with a topping list, and return the selected topping. :return: None or Topping object """ question = f"\nStep 2: Select your topping!\n{'-'*40}\n" i = 1 for topping in ToppingMenu.topping_list: question += f"{i}. {topping}\n" i += 1 question += f"{i}. Check Out\n{'-'*40}\nPlease select: " return InputHandler.prompt_menu(question, ToppingMenu.topping_list)
def select_cheese(): """ Prompt user with cheese list, and return the selected cheese. :return: Cheese object """ question = f"\nStep 1: Select your cheese!\n{'-'*40}\n" i = 1 for cheese in CheeseMenu.cheese_list: question += f"{i}. {cheese}\n" i += 1 question += f"{i}. Next\n{'-'*40}\nPlease select: " return InputHandler.prompt_menu(question, CheeseMenu.cheese_list)
class GameDriver: def __init__(self): GameState( ) # initialize singletons before threading to avoid race conditions AssetLoader() MusicPlayer() self.root = tk.Tk() self.windowManager = WindowManager() self.display = Display(self.root, self.windowManager) self.inputHandler = InputHandler(self.display.widget) def initAssets(self): AssetLoader().loadAssets() AssetLoader().loadSaves() AssetLoader().loadSettings() # send events for loaded settings if AssetLoader().getSettings() is not None: for setting in AssetLoader().getSettings(): GameState().onSettingChange(setting[0], setting[1]) else: MusicPlayer().playNext(AssetLoader().getMusicPath('title')) self.windowManager.load() GameState().unlockGameMode() def mainloop(self): # start off separate thread to load assets GameState().lockGameMode(GameMode.isLoading) t = threading.Thread(target=self.initAssets) t.daemon = True t.start() # run update-draw loop forever dt = 0.0 while True: try: time.sleep(max(Globals.Timestep - dt, 0.0)) timeElapsed = max(Globals.Timestep, dt) time1 = time.time() self.display.draw() keypresses = self.inputHandler.getKeyPresses() self.windowManager.update(timeElapsed, keypresses) self.root.update() time2 = time.time() dt = time2 - time1 except tk.TclError: # window was closed sys.exit() except SystemExit: break # thrown on main menu exit except: # some other exception occurred if Globals.IsDev: traceback.print_exc() sys.exit()
def __init__(self): verbose = False bluetooth = True fakeData = False setupTags = False self.usercount = 0 for arg in sys.argv: if arg == "--verbose": verbose = True if arg == "--no-bluetooth": bluetooth = False if arg == "--fake-data": fakeData = True if arg == "--setup": setupTags = True self.recipeHandler = RecipeHandler() # Input handler is a separate thread, needs to be started self.inputHandler = InputHandler(verbose, bluetooth, fakeData, setupTags, self, self.recipeHandler) self.inputHandler.start() # open the website in our default browser # webbrowser.open_new_tab("file://" + os.path.realpath("bistro.html")) # init the webserver which is necessary for handling user interactions from the dashboard self.webserver = WebServer(self.inputHandler) self.webserver.start() # setup the websocket server - port is 5678 on our local machine server = websockets.serve(self.bistro, '', 5678) # self.dashboard_server = websockets.serve(self.echo, '', 443) # tell the server to run forever asyncio.get_event_loop().run_until_complete(server) asyncio.get_event_loop().run_forever()
def add_item(self): """ Adds a new item to the catalogue if not exists yet. """ passed = False while not passed: try: print("Which item type would you like to add?") print("1. Book\n2. DVD\n3. Journal") answer = input("Enter your choice (1-3)") InputHandler.validate(len(self.item_factory_map), answer) item_factory = self.item_factory_map.get(int(answer)) item = item_factory().create_item() except ValueError: print("\n[Error] Please type an integer!") except CommandNotFoundException as e: print(f"{e}") else: passed = True if not self.item_exists(item.call_number): self.item_list[item.call_number] = item print(f"Item({item.call_number}) bas been added.") else: print("This call number already exists.")
def __init__(self): pygame.mixer.pre_init(44100,-16,2,2048) pygame.init() self.sounds=Sounds() self.input_handler = InputHandler() self.game_screen = GameScreen(self.TITLE,self.WIDTH,self.HEIGHT) self.miner=Miner(8,0) self.explosion=Explosion(-1,-1) self.game_screen.add_sprite(self.miner) self.game_screen.add_sprite(self.explosion) self.health = 100 self.clock=pygame.time.Clock() self.state=self.WAITING self.game_screen.display_opening()
class GameDriver: def __init__(self): self.root = tk.Tk() self.windowManager = WindowManager(Globals.NumCols, Globals.NumRows) self.display = Display(self.root, self.windowManager) self.inputHandler = InputHandler(self.display.getWidget()) def mainloop(self): while True: try: time.sleep(Globals.Timestep) # TODO only sleep Timestep - computation time keypresses = self.inputHandler.getKeyPresses() self.windowManager.update(Globals.Timestep, keypresses) self.display.draw() self.root.update() except tk.TclError: # window was closed sys.exit() except: # some other exception occurred if Globals.IsDev: traceback.print_exc() sys.exit()
def main(): if len(sys.argv) != 5: print('Usage: {} [process ID] [delay time 1] [delay time 2]' '[delay time 3]'.format(sys.argv[0])) exit(1) process_id = int(sys.argv[1]) delay_times = [float(time_str) for time_str in sys.argv[2:5]] storage_handler = StorageHandler(process_id, delay_times) input_handler = InputHandler(process_id, storage_handler) storage_handler.run() input_handler.run() storage_handler.join() input_handler.join()
#!/usr/bin/env python3 from input_handler import InputHandler if __name__ == "__main__": input_handler = InputHandler() input_handler.handle_input()
sock.bind(locaddr) print('\r\n\r\nTello Python3 Demo.\r\n') print( 'Tello: command takeoff land flip forward back left right \r\n up down cw ccw speed speed?\r\n' ) print('end -- quit demo.\r\n') #recvThread create #recvThread = threading.Thread(target=recv) #recvThread.start() controller = Controller(sock, command_address) ih = InputHandler(controller) camera_address = ('0.0.0.0', 11111) cam_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) """ while True: try: msg = input(""); if msg == '1': controller.takeoff() if msg == '2': controller.land()
class Bistro: # Bistro class handles web sockets and holds input handler def __init__(self): verbose = False bluetooth = True fakeData = False setupTags = False self.usercount = 0 for arg in sys.argv: if arg == "--verbose": verbose = True if arg == "--no-bluetooth": bluetooth = False if arg == "--fake-data": fakeData = True if arg == "--setup": setupTags = True self.recipeHandler = RecipeHandler() # Input handler is a separate thread, needs to be started self.inputHandler = InputHandler(verbose, bluetooth, fakeData, setupTags, self, self.recipeHandler) self.inputHandler.start() # open the website in our default browser # webbrowser.open_new_tab("file://" + os.path.realpath("bistro.html")) # init the webserver which is necessary for handling user interactions from the dashboard self.webserver = WebServer(self.inputHandler) self.webserver.start() # setup the websocket server - port is 5678 on our local machine server = websockets.serve(self.bistro, '', 5678) # self.dashboard_server = websockets.serve(self.echo, '', 443) # tell the server to run forever asyncio.get_event_loop().run_until_complete(server) asyncio.get_event_loop().run_forever() @asyncio.coroutine def register(self, websocket): USERS.add(websocket) # await asyncio.wait([user.send(self.inputHandler.getMessage()) for user in USERS]) # send current order out to new websocket message = self.inputHandler.assembleMessage(Action.INIT) yield from asyncio.wait([websocket.send(message)]) @asyncio.coroutine def unregister(self, websocket): USERS.remove(websocket) @asyncio.coroutine def sendMessage(self, message): print("Send message") if USERS: print("Sending message to users ", message) yield from asyncio.wait([user.send(message) for user in USERS]) print("message sent") # send message to both dashboard, front and back projection #TODO: do we still need that method? """@asyncio.coroutine def getMessage(self): if self.inputHandler.newMessage: return self.inputHandler.getMessage() else: return """ @asyncio.coroutine def bistro(self, websocket, path): # in case there's a new message coming from the input handler # we want to send it via web sockets to the browser yield from self.register(websocket) print("Connected to websocket") while True: message = yield from websocket.recv() json_msg = json.loads(message) # print(json_msg.action, " " , json_msg.meal, " ", json_msg.amount) if json_msg["action"] == "prepare_order": print(json_msg["meal"]) self.inputHandler.orderHandler.addMealPreparation( json_msg["meal"], json_msg["amount"]) elif json_msg["action"] == "refresh": print("refreshing projections...") action = Action.REFRESH response = {"action": action.value} print("response") print(response) resp = str(response).replace("'", '"') yield from self.sendMessage(resp)
def HandleRequest(self, byteRequest): ''' Handle request sent by client. Request is handled, then passed to SendMessage to send a reply with appropriate data to client, this step is blocking. Parameters: requestString (str): the reqeust string Returns: int: either ServerProgram.CONTINUE or ServerProgram.QUIT_PROGRAM ''' immediate = False request, data = self.SplitRequest(byteRequest) state = HandlerState.INVALID extraInfo = None if (type(self.currHandler) != DirectoryHandler or request != "TRANSFER") and data: data = data.decode(FORMAT) print( request, data if data and len(data) < 512 else (len(data) if data else '')) # FINISH request exits the current handler # EXIT request finishes the program if request == "FINISH": if self.currHandler: self.currHandler = None state = HandlerState.SUCCEEDED else: self.SendMessage("INVALID", None) elif request == "EXIT": self.currHandler = None self.SendMessage("SUCCEEDED", None) return ServerProgram.QUIT_PROGRAM # If no handler is currently active elif not self.currHandler: # SHUTDOWN and SCREENSHOT are immeditate handlers if request == "SHUTDOWN": self.currHandler = ShutdownHandler() immediate = True elif request == "SCREENSHOT": self.currHandler = ScreenHandler() immediate = True elif request == "INFO": self.currHandler = InfoHandler() immediate = True # The rest needs additional requests and looping else: immediate = False state = HandlerState.SUCCEEDED if request == "PROCESS": self.currHandler = ProcessHandler() elif request == "APPLICATION": self.currHandler = ApplicationHandler() elif request == "KEYLOG": self.currHandler = InputHandler(KEYLOG_FILE_PATH) elif request == "REGISTRY": self.currHandler = RegistryHandler() elif request == "DIRECTORY": self.currHandler = DirectoryHandler() elif request == "LIVESTREAM": self.currHandler = LivestreamHandler( self, self.serverSocket, ScreenHandler()) # Else let current handler handle request else: state, extraInfo = self.currHandler.Execute(request, data) if self.currHandler and immediate: state, extraInfo = self.currHandler.Execute("", data) self.currHandler = None immediate = False print( state, extraInfo if extraInfo and len(extraInfo) < 512 else (len(extraInfo) if extraInfo else '')) if request == "SHUTDOWN" and state == HandlerState.SUCCEEDED: self.SendMessage("SUCCEEDED", extraInfo) return ServerProgram.QUIT_PROGRAM if state == HandlerState.SUCCEEDED: self.SendMessage("SUCCEEDED", extraInfo) elif state == HandlerState.FAILED: self.SendMessage("FAILED", extraInfo) else: self.SendMessage("INVALID", extraInfo) return ServerProgram.CONTINUE_PROGRAM
def main(argv: List): ih = InputHandler(join(dirname(__file__), argv[0])) ih.build_inputs() cb = CoolBoy(ih.numerals) print(cb.part_a()) print(cb.part_b())
class Game: def __init__(self): self.input = InputHandler() self.state_manager = GameStateManager() self.hiscores = Hiscores(resources.get_hiscores(HISCORES_FILENAME)) self.logic_clock = Clock() self.render_clock = Clock() self.renderer = Thread(target=self.render_loop, args=()) self.renderer.daemon = True self.rendering = Lock() self.running = False self.screen = None self.canvas = None def start(self): # Set running to true self.running = True # Init the game self.init() # Start the renderer self.renderer.start() # Start running the game loop self.logic_loop() def stop(self): # Set running to false self.running = False def init(self): # Init mixer for sound specifications pygame.mixer.pre_init(frequency=44100, size=-16, channels=2, buffer=512) # Init pygame pygame.init() pygame.display.set_caption(GAME_TITLE) # Set screen size self.screen = pygame.display.set_mode((GAME_WIDTH * GAME_SCALE, GAME_HEIGHT * GAME_SCALE), pygame.DOUBLEBUF) # Set canvas size self.canvas = pygame.Surface((GAME_WIDTH, GAME_HEIGHT)).convert() # Init the Input handler self.input.init() # Change to play state self.state_manager.set_state(MenuState(self)) def render_loop(self): while self.running: # Tick the clock self.render_clock.tick(GAME_MAX_FPS) # Render game with self.rendering: self.render() def logic_loop(self): while self.running: # Let the clock do the math delta = self.logic_clock.tick(1000) # Catch events self.input.catch_events() # Update game self.update(delta) # Quit pygame pygame.quit() def update(self, delta): # Update input handler self.input.update() # Quit game if close is clicked if self.input.quit: self.stop() # Update the game with delta given from clock self.state_manager.update(delta) def render(self): # Clear screen self.canvas.fill((255, 255, 255)) # Render game state manager on canvas self.state_manager.render(self.canvas) # Scale the canvas to the screen scale_canvas = pygame.transform.scale(self.canvas, (self.screen.get_size())) # Blit canvas to screen self.screen.blit(scale_canvas, (0, 0)) # Render screen pygame.display.flip()
def test_get_coordinator_greatest(self): input_handler = InputHandler(0) #[115, 32, 900, 63, 736] for 0 to 4 coordinator_id = input_handler.get_coordinator(0, 1906) self.assertEqual(coordinator_id, 1)
def __init__(self, guessesNumber=5): self.guessesNumber = guessesNumber #With default value of 5 self.secretWord = self.pickSecretWord() self.lettersGuessed = [] #Initiate with no letters guessed self.avaiableLetters = string.ascii_lowercase #All the letters in lower case self.inputHandler = InputHandler(self) #Initiate input handler
class Game(object): TITLE = "Gold Rush!" WIDTH=680 HEIGHT=600 WAITING = 1 PLAYING = 2 FRAMES_PER_SECOND = 30 board=[] def __init__(self): pygame.mixer.pre_init(44100,-16,2,2048) pygame.init() self.sounds=Sounds() self.input_handler = InputHandler() self.game_screen = GameScreen(self.TITLE,self.WIDTH,self.HEIGHT) self.miner=Miner(8,0) self.explosion=Explosion(-1,-1) self.game_screen.add_sprite(self.miner) self.game_screen.add_sprite(self.explosion) self.health = 100 self.clock=pygame.time.Clock() self.state=self.WAITING self.game_screen.display_opening() def setup(self): self.gold=0 self.charges=10 self.cash=0 self.health=100 self.board=[] # top row of empty spaces self.board.append([' ']*20) self.board.append(['*']*20) for y in range(2,14): row=[] for x in range(20): c='*' if y>1 and random()<0.4: c=' ' if random()<0.5: c='0' else: c='1' row.append(c) self.board.append(row) self.miner.set_location(8,0) self.game_screen.setup() self.game_screen.set_board(self.board) self.game_screen.draw_board() def mainloop(self): deltat=self.clock.tick(self.FRAMES_PER_SECOND) running=True while running: self.input_handler.check() if self.input_handler.exit_action: running=False elif self.state == self.WAITING: if self.input_handler.key_press: self.setup() self.state=self.PLAYING else: self.game_screen.clear_sprites() if self.miner.can_move(): kpress=self.input_handler.arrow_press if kpress: dx=0 dy=0 if kpress == K_RIGHT: dx=1 elif kpress == K_LEFT: dx=-1 elif kpress == K_UP: dy=-1 elif kpress == K_DOWN: dy=1 if self.input_handler.space_press and (dx!=0 or dy!=0): self.do_explosion(dx,dy) tx=self.miner.x + dx ty=self.miner.y + dy if (dx!=0 or dy!=0) and (tx>=0 and tx<=19 and ty>=0 and ty<=13): o=self.board[ty][tx] if o in ' 01': self.miner.set_location(tx,ty) if o in '01': self.take_nugget(tx,ty) elif (dy==-1 and tx==17 and ty==-1 and self.gold!=0): self.cash_out() if self.charges==0: self.state=self.WAITING self.input_handler.reset() self.game_screen.display_gameover() if self.miner.y>0: self.health-=1 if self.health<0: self.health=0 self.game_screen.display_health(self.health) else: self.health+=1 if self.health>100: self.health=100 self.game_screen.display_health(self.health) self.game_screen.draw(deltat) pygame.quit() def do_explosion(self,dx,dy): bx=self.miner.x + dx by=self.miner.y + dy if bx>=0 and bx<20 and (by>0 or (by==0 and dy==1)) and by<14 and self.charges>0: self.explosion.explode(bx,by) self.charges-=1 self.board[by][bx]=' ' self.miner.add_delay(20) self.game_screen.clear_square(bx,by) self.game_screen.display_charges() self.sounds.play_boom() self.game_screen.display_charges(self.charges) for j in range(20): x=randint(0,19) y=randint(2,11) o=self.board[y][x] a=self.board[y-1][x] if o==' ' and a=='*': self.board[y][x]='*' self.game_screen.reset_square(x,y) def cash_out(self): self.cash+=self.gold*self.charges self.gold=0 self.sounds.play_kaching() self.game_screen.display_gold(self.gold) self.game_screen.display_cash(self.cash) self.sounds.play_yeehaw() def take_nugget(self,tx,ty): self.board[ty][tx]=' ' self.gold += 1 self.sounds.play_bell() self.game_screen.clear_square(tx,ty) self.game_screen.display_gold(self.gold)
def main(argv: List): ih = InputHandler(join(dirname(__file__), argv[0])) ih.build_inputs() s = Sleddie(ih.grid, ih.max_row, ih.max_base_col, SLOPES) s.calc_all_slope_tree_hits() print(s.slope_multiple)
from keyboard import KeyBoard from observable import Observable from observer import Observer from input_handler import InputHandler#Actor from view import View import curses if __name__ == '__main__': observable = Observable() screen = curses.initscr() curses.noecho() curses.cbreak() keyBoard = KeyBoard(screen) input_handler = InputHandler() view = View(screen) observable.register(input_handler) observable.register(view) while 1: try: observable.update_observers(c=keyBoard.get_ch()) except KeyboardInterrupt: curses.endwin() exit()
class Better_Soundhound: def __init__(self): self.gui = GUI() self.input_handler = InputHandler(self.gui, let_the_nice_lady_speak=True) self.mic = sr.Microphone() self.recorder = sr.Recognizer() self.recorder.pause_threshold = 0.6 self.recorder.operation_timeout = 1 self.action_dict = {ENTER_VOICE_MOOD: self.listen_to_command_mode, EXIT_APP: self.close_app} time.sleep(1) def listen_to_command_mode(self): # todo change icon self.input_handler.listen_for_command() # todo change icon for action def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): if self.gui.interaction_window_open(): self.gui.close_interaction_window() mute_all(mute=False) def show_start_screen_and_run_app(self): start_the_app = self.gui.open_greeting_window() time.sleep(1) if start_the_app: self.gui.open_interaction_window() self.gui.change_interaction_message(message="Initializing...") else: print("User clicked exit.") self.close_app() # [detected_face, detected_left_arm, detected_left_palm, detected_left_hold_it, detected_right_arm, detected_right_palm, detected_right_hold_it, stop] def run_app(self, show_detection_screen=False): # Open greeting window - when closed, will continue from this point in code. Blocking! self.show_start_screen_and_run_app() finished = False detection_generator = wait_for_gesture(verbose=True, show_detection_screen=show_detection_screen) while not finished: self.gui.change_interaction_message(message="Watching you.......", new_img_path=gui_handler.CAMERA_PATH) detections = next(detection_generator) action = self.action_from_detection(detections) if action is None: # if the detected gesture does not specify an action, skip it continue self.handle_action(action) # self.handle_action(action) # if something = exit app: # finished = True self.close_app() def action_from_detection(self, detections): # todo - add more!!! print(detections[7]) if detections[7]: return EXIT_APP elif (detections[3] or detections[6]) and not detections[7]: # only one sided hold it gesture return ENTER_VOICE_MOOD else: return None def handle_action(self, action): assert action in self.action_dict action = self.action_dict[action] print("About to initiate {}".format(action)) action() def close_app(self): print("User used exit app gesture, exiting.") mute_all(mute=False) exit()
class Main(object): """ Main class for 08b15. """ def __init__(self, size): """ :param size: tuple """ self.size = size self.running = True self.document = Document(self.size) self.screen_handler = ScreenHandler(self.size) self.input_handler = InputHandler() self.using_mode = 0 pygame.display.set_mode(size) def run(self): """ :return: None """ while self.running: for event in pygame.event.get(): if event.type == pygame.QUIT: self.running = False else: self.input_handler.catch(event, self.screen_handler, self.document, self) self.update_screen() def update_screen(self): """ :return: None """ self.screen_handler.draw_screen(self.document, self.using_mode) pygame.display.update() def save_screen(self): """ Saves screenshot into /screens :return: None """ path = 'screens/output_%s.png' % str( datetime.datetime.now())[:-7].replace(":", ",") save_screen = pygame.Surface( (self.screen_handler.size[0] * 2, self.screen_handler.size[1] * 2)) save_screen.blit(self.screen_handler.screen, (0, 0)) save_screen.blit( pygame.transform.flip(self.screen_handler.screen, 0, 1), (0, self.screen_handler.size[1])) save_screen.blit( pygame.transform.flip(self.screen_handler.screen, 1, 0), (self.screen_handler.size[0], 0)) save_screen.blit( pygame.transform.flip(self.screen_handler.screen, 1, 1), (self.screen_handler.size[0], self.screen_handler.size[1])) pygame.image.save(save_screen, path)
def process(self, path=False, vertices=False, indices=False, info= False): if path: vertices, element_dict, info = read_model(path) indices = element_dict["triangles"] print(f"Reading {path}") else: assert (type(vertices) ==np.ndarray and type(indices) ==np.ndarray), "Define path or both vertices and indices" pre_box = indices.size bounding_rect_vertices, bounding_rect_indices = bounding_box(vertices,indices) vertices = np.append(vertices,bounding_rect_vertices) indices = np.append(indices,bounding_rect_indices) vertex_normals = pyrr.vector3.generate_vertex_normals(vertices.reshape((-1,3)), indices.reshape((-1,3)), normalize_result=True).flatten() vertices_final = np.append(vertices,vertex_normals) # initializing glfw library if not glfw.init(): raise Exception("glfw can not be initialized!") # creating the window window = glfw.create_window(1280, 720, "My OpenGL window", None, None) input_handler = InputHandler(window) # check if window was created if not window: glfw.terminate() raise Exception("glfw window can not be created!") # set window's position glfw.set_window_pos(window, 400, 200) # set the callback function for window resize glfw.set_window_size_callback(window, self.window_resize) # make the context current glfw.make_context_current(window) as_points = vertices.reshape(-1, 3) barycenter = as_points.mean(axis=0) max_x, max_y, max_z = as_points.max(axis=0) min_x, min_y, min_z = as_points.min(axis=0) middle_point = np.array( [min_x + (max_x-min_x)/2, min_y + (max_y-min_y)/2, min_z + (max_z-min_z)/2]) shader = shader_loader.compile_shader("src/shaders/vert.vs", "src/shaders/frag.fs") # Vertex Buffer Object VBO = glGenBuffers(1) VA0 = glGenVertexArrays(1) glBindBuffer(GL_ARRAY_BUFFER, VBO) glBufferData(GL_ARRAY_BUFFER, vertices_final.nbytes, vertices_final, GL_STATIC_DRAW) #positions glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*4, ctypes.c_void_p(0)) glEnableVertexAttribArray(0) #normals glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3*4, ctypes.c_void_p(4*len(vertices))) glEnableVertexAttribArray(1) # Element Buffer Object EBO = glGenBuffers(1) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO) glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, indices, GL_STATIC_DRAW) glUseProgram(shader) glClearColor(0, 0.1, 0.1, 1) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glEnable(GL_DEPTH_TEST) ## Shader matrices model_loc = glGetUniformLocation(shader, "model") self.proj_loc = glGetUniformLocation(shader, "projection") view_loc = glGetUniformLocation(shader, "view") color_loc = glGetUniformLocation(shader,"color") transform_loc = glGetUniformLocation(shader, "transform") light_loc = glGetUniformLocation(shader, "light") window_height = glfw.get_window_size(window)[1] window_width = glfw.get_window_size(window)[0] projection = pyrr.matrix44.create_perspective_projection_matrix( fovy=45, aspect=window_width/window_height, near=0.1, far=100) #projection = pyrr.matrix44.create_orthogonal_projection_matrix(0,1280,0,720,-1000,1000) scale = pyrr.matrix44.create_from_scale(pyrr.Vector3([1]*3)) # eye pos , target, up view = pyrr.matrix44.create_look_at(pyrr.Vector3( [0, 0, 3]), pyrr.Vector3([0, 0, 0]), pyrr.Vector3([0, 1, 0])) proj_matrix = glGetUniformLocation(shader, "projection") initial_offset = middle_point translation = pyrr.matrix44.create_from_translation( pyrr.Vector3(-initial_offset)) ## Input rotation = pyrr.matrix44.create_from_axis_rotation(np.array([0, 1, 0]), 0) glfw.set_key_callback(window, input_handler.keyboard_handler) glfw.set_scroll_callback(window, input_handler.scroll_handler) glfw.set_mouse_button_callback(window, input_handler.mouse_handler) previous_displacement = np.zeros(2) rot_y = pyrr.Matrix44.from_y_rotation(0.8 * glfw.get_time() ) glUniformMatrix4fv(transform_loc, 1, GL_FALSE, rot_y) glEnable(GL_LIGHTING) glEnable(GL_COLOR_MATERIAL) while not glfw.window_should_close(window): glfw.poll_events() glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) if input_handler.right_key_pressed: current_cursor_position = glfw.get_cursor_pos(window) cursor_displacement = np.array(current_cursor_position) - np.array( input_handler.start_cursor_position) - previous_displacement input_handler.rotation_list[0] += input_handler.rotations_per_screen_hor * \ cursor_displacement[0]/window_width input_handler.rotation_list[1] += input_handler.rotations_per_screen_vert * \ cursor_displacement[1]/window_height previous_displacement = cursor_displacement rot_x = pyrr.Matrix44.from_x_rotation(input_handler.rotation_list[1]) rot_y = pyrr.Matrix44.from_y_rotation(input_handler.rotation_list[0]) rotation = pyrr.matrix44.multiply(rot_x, rot_y) view = pyrr.matrix44.create_look_at(pyrr.Vector3(input_handler.eye), pyrr.Vector3( input_handler.target), pyrr.Vector3(input_handler.up)) light = pyrr.matrix44.create_identity() glUniformMatrix4fv(light_loc, 1, GL_FALSE, light) model = pyrr.matrix44.multiply(scale, translation) model = pyrr.matrix44.multiply(model, rotation) glUniformMatrix4fv(model_loc, 1, GL_FALSE, model) glUniformMatrix4fv(view_loc, 1, GL_FALSE, view) glUniformMatrix4fv(proj_matrix, 1, GL_FALSE, projection) default_RGB = np.zeros(shape=(3,),dtype=np.float32) +1 color = pyrr.Vector3(default_RGB) glUniform3fv(color_loc,1,color) if input_handler.mode == "default": glDrawElements(GL_TRIANGLES, pre_box, GL_UNSIGNED_INT, None) elif input_handler.mode == "point_cloud": glDrawElements(GL_POINTS, pre_box, GL_UNSIGNED_INT, None) elif input_handler.mode=="wireframe": glEnable(GL_POLYGON_OFFSET_FILL) glPolygonOffset(1.0, 2) glDrawElements(GL_TRIANGLES, pre_box, GL_UNSIGNED_INT, None) RGB = np.zeros(shape=(3,),dtype=np.float32) color = pyrr.Vector3(RGB) glUniform3fv(color_loc,1,RGB) glDrawElements(GL_LINES, pre_box, GL_UNSIGNED_INT, None) elif input_handler.mode == "bounding_box": glDrawElements(GL_LINES, len(indices), GL_UNSIGNED_INT, None) else: raise Exception("Invalid Mode!") glfw.swap_buffers(window) # terminate glfw, free up allocated resources glfw.terminate()
def test_get_coordinator_mid2(self): input_handler = InputHandler(0) #[115, 32, 900, 63, 736] for 0 to 4 coordinator_id = input_handler.get_coordinator(0, 800) self.assertEqual(coordinator_id, 2)