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)
