def on_draw(self): self.clear() gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() (w, h) = self.get_size() gl.glScalef( float(min(w, h))/w, -float(min(w, h))/h, 1 ) gl.gluPerspective(45.0, 1, 0.1, 1000.0) gl.gluLookAt(0, 0, 2.4, 0, 0, 0, 0, 1, 0) global render_texture render_texture = self.texture for v in self.visions.values(): gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() v.iteration() buf = pyglet.image.get_buffer_manager().get_color_buffer() rawimage = buf.get_image_data() self.texture = rawimage.get_texture() clock.tick()
def run(self): try: self.window.set_visible() while not self.window.has_exit: self.window.dispatch_events() clock.tick() if self.world and not self.paused: self.world.tick(1/FPS_LIMIT) if self.world and hasattr(self.world, 'player'): player_position = self.world.player.chunks[0].body.position self.camera.x, self.camera.y = player_position self.camera.angle = atan2( player_position.x, player_position.y) self.camera.update() if self.renderer: aspect = ( self.window.width / self.window.height) self.renderer.draw(self.world, aspect) self.camera.hud_projection( (self.window.width, self.window.height)) self.fps_display.draw() self.window.flip() finally: self.dispose()
def test_sprite(self): w = pyglet.window.Window(width=320, height=320) image = Image2d.load(ball_png) ball = Sprite(0, 0, 64, 64, image) view = FlatView(0, 0, 320, 320, sprites=[ball]) w.push_handlers(view.camera) dx, dy = (10, 5) clock.set_fps_limit(30) while not w.has_exit: clock.tick() w.dispatch_events() # move, check bounds ball.x += dx; ball.y += dy if ball.left < 0: ball.left = 0; dx = -dx elif ball.right > w.width: ball.right = w.width; dx = -dx if ball.bottom < 0: ball.bottom = 0; dy = -dy elif ball.top > w.height: ball.top = w.height; dy = -dy # keep our focus in the middle of the window view.fx = w.width/2 view.fy = w.height/2 view.clear() view.draw() w.flip() w.close()
def test_sprite(self): w = pyglet.window.Window(width=320, height=320) image = Image2d.load(ball_png) ball1 = BouncySprite(0, 0, 64, 64, image, properties=dict(dx=10, dy=5)) ball2 = BouncySprite(288, 0, 64, 64, image, properties=dict(dx=-10, dy=5)) view = FlatView(0, 0, 320, 320, sprites=[ball1, ball2]) view.fx, view.fy = 160, 160 clock.set_fps_limit(60) e = TintEffect((0.5, 1, 0.5, 1)) while not w.has_exit: clock.tick() w.dispatch_events() ball1.update() ball2.update() if ball1.overlaps(ball2): if "overlap" not in ball2.properties: ball2.properties["overlap"] = e ball2.add_effect(e) elif "overlap" in ball2.properties: ball2.remove_effect(e) del ball2.properties["overlap"] view.clear() view.draw() w.flip() w.close()
def instructionScreen(windowSurface, WWIDTH, FRAMES, background_image, background_position): while True: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() windowSurface.blit(background_image, background_position) displayText(windowSurface, 128, WWIDTH / 2, 125, 'MEGA', RED) displayText(windowSurface, 128, WWIDTH / 2, 275, 'JUMP!', GREEN) displayText(windowSurface, 20, WWIDTH / 2, 400, 'Space to jump (+ down arrow for small jump, M for MegaJump)', GREEN) displayText(windowSurface, 20, WWIDTH / 2, 450, 'Left & Right arrows to move (+ up arrow to move faster)', GREEN) displayText(windowSurface, 20, WWIDTH / 2, 500, 'Q to quit, R to reset', GREEN) displayText(windowSurface, 20, WWIDTH / 2, 550, 'Only 1 MegaJump per game!', RED) displayText(windowSurface, 20, WWIDTH / 2, 600, 'Press ESC to return to main screen', GREEN) pygame.draw.circle(windowSurface, GOLD, (510, 550), 10, 0) if pygame.key.get_pressed()[K_ESCAPE]: return pygame.display.flip() clock.set_fps_limit(FRAMES) clock.tick()
def test_limit_fps(self): """ Test that the clock effectively limits the frames per second to 60 Hz when set to. Because the fps are bounded, we expect a small error (1%) from the expected value. """ ticks = 20 fps_limit = 60 expected_delta_time = ticks*1./fps_limit clock.set_fps_limit(fps_limit) t1 = time.time() # Initializes the timer state. clock.tick() for i in range(ticks): clock.tick() t2 = time.time() computed_time_delta = t2 - t1 self.assertAlmostEqual(computed_time_delta, expected_delta_time, delta=0.01*expected_delta_time)
def wait(ms): a = clock.get_fps() ct = 0 loopcount = (ms / 1000.0) * a while ct < loopcount: clock.tick() ct+=1
def main_loop(self): clock.set_fps_limit(self.update_fps) while not self.has_exit: self.dispatch_events() self.update_cells() self.draw_grid() clock.tick() self.flip()
def test_fps(self): clock.set_default(clock.Clock()) self.assertTrue(clock.get_fps() == 0) for i in range(10): time.sleep(0.2) clock.tick() result = clock.get_fps() self.assertTrue(abs(result - 5.0) < 0.05)
def on_draw(self): self.clear() # clearing buffer clock.tick() # ticking the clock # showing FPS self.fpstext.text = "fps: %d" % clock.get_fps() self.fpstext.draw() # flipping self.flip()
def test_tick(self): clock.set_default(clock.Clock()) result = clock.tick() self.assertTrue(result == 0) time.sleep(1) result_1 = clock.tick() time.sleep(1) result_2 = clock.tick() self.assertTrue(abs(result_1 - 1.0) < 0.05) self.assertTrue(abs(result_2 - 1.0) < 0.05)
def test_fps_limit(self): clock.set_default(clock.Clock()) clock.set_fps_limit(20) self.assertTrue(clock.get_fps() == 0) t1 = time.time() clock.tick() # One to get it going for i in range(20): clock.tick() t2 = time.time() self.assertTrue(abs((t2 - t1) - 1.) < 0.05)
def test_schedule_multiple(self): clock.set_default(clock.Clock()) clock.schedule(self.callback) clock.schedule(self.callback) self.callback_count = 0 clock.tick() self.assertTrue(self.callback_count == 2) clock.tick() self.assertTrue(self.callback_count == 4)
def test_unschedule(self): clock.set_default(clock.Clock()) clock.schedule(self.callback) result = clock.tick() self.assertTrue(result == self.callback_dt) self.callback_dt = None time.sleep(1) clock.unschedule(self.callback) result = clock.tick() self.assertTrue(self.callback_dt == None)
def main(): global target, step while not w.has_exit: clock.tick() w.clear() target.pos.x += step if abs(target.pos.x) >= 17: step *= -1 w.dispatch_events() context.render() w.flip()
def savedGameScreen(savedGames, windowSurface, WWIDTH, WHEIGHT, FRAMES, background_image, background_position): time.sleep(0.3) while True: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() windowSurface.blit(background_image, background_position) displayTextLJ(windowSurface, 36, 50, 50, 'Saved Games List', RED) displayTextLJ(windowSurface, 24, 50, 100, "Name", RED) displayTextLJ(windowSurface, 24, 200, 100, "Difficulty", RED) displayTextLJ(windowSurface, 24, 350, 100, "Platforms", RED) displayTextLJ(windowSurface, 24, 500, 100, "Record", RED) displayTextLJ(windowSurface, 20, 50, 550, 'Press number to select game or D plus number to delete game', RED) displayTextLJ(windowSurface, 20, 50, 600, 'Escape to return to previous screen', RED) count = 1 for game in savedGames: displayTextLJ(windowSurface, 20, 50, 100 + (count * 30), str(count) + ". " + game['name'], GREEN) displayTextLJ(windowSurface, 20, 200, 100 + (count * 30), game['difficulty'], GREEN) displayTextLJ(windowSurface, 20, 350, 100 + (count * 30), game['pnumber'], GREEN) if game['difficulty'] == "INSANE": displayTextLJ(windowSurface, 20, 500, 100 + (count * 30), "Score: " + game['score'], GREEN) else: displayTime(windowSurface, int(game['record']), 500, 100 + (count * 30), GREEN, 20, "True") count += 1 if not pygame.key.get_pressed()[ord('d')]: for i in range(len(savedGames)): if pygame.key.get_pressed()[ord(str(i+1))]: return savedGames[i], i if pygame.key.get_pressed()[ord('d')]: for i in range(len(savedGames)): if pygame.key.get_pressed()[ord(str(i+1))]: del savedGames[i] saveGames(windowSurface, WWIDTH, WHEIGHT, None, savedGames, None, "Delete") time.sleep(0.5) break if pygame.key.get_pressed()[K_ESCAPE]: return None, None pygame.display.flip() clock.set_fps_limit(FRAMES) clock.tick()
def mainLoop(self): while not self.win.has_exit: self.win.dispatch_events() self.world.tick() self.camera.worldProjection() self.world.draw() self.camera.hudProjection() self.hud.draw() clock.tick() self.win.flip()
def on_draw(self): self.clear() # clearing buffer clock.tick() # ticking the clock # showing FPS self.fpstext.text = "fps: %d" % clock.get_fps() self.fpstext.draw() self.spaceship.draw() for alien in self.aliens: alien.draw() # flipping self.flip()
def main_loop(self): clock.set_fps_limit(30) clock.schedule_interval(self.animate_bird, 0.01) while not self.has_exit: self.dispatch_events() self.clear() self.update() self.draw() #Tick the clock clock.tick() self.flip()
def run_test(self): clock.set_fps_limit(30) while not self.w.has_exit: clock.tick() self.w.dispatch_events() self.view.fx += (self.keyboard[key.RIGHT] - self.keyboard[key.LEFT]) * 5 self.view.fy += (self.keyboard[key.UP] - self.keyboard[key.DOWN]) * 5 if self.marker is not None: self.marker.x = self.view.fx self.marker.y = self.view.fy self.view.clear() self.view.draw() self.w.flip() self.w.close()
def main_loop(self): ft = font.load('Arial', 28) fps_text = font.Text(ft, y=10) while not self.has_exit: self.dispatch_events() self.update() self.draw() clock.tick() fps_text.text = "fps: %d" % clock.get_fps() fps_text.draw() self.flip()
def loop(self): try: clock.tick() while not self.has_exit: self.dispatch_events() dt = clock.tick() self.game.update(dt) self.draw() self.flip() except Exception, e: print "Error", e traceback.print_exc() self.close()
def mainLoop(self): ft = font.load('Arial', 28) fps_text = font.Text(ft, y=10) while not self.has_exit: self.dispatch_events() self.clear clock.tick() fps_text = ("fps: %d") % (clock.get_fps()) fps_text.draw() self.flip()
def main_loop(self): self.batch = pyglet.graphics.Batch() self.register_event_type('on_update') pyglet.clock.schedule(self.update_kytten) self.fps = pyglet.clock.ClockDisplay() self.generateMenu() while not self.has_exit: # main loop #self.push_handlers(self.on_mouse_release) self.clear() clock.tick() self.dispatch_events() self.batch.draw() self.drawSelectedCard() self.drawNewDeckList() self.fps.draw() self.flip() #flip to the other opengl buffer
def main(): clock.schedule(rabbyt.add_time) window.game_window = Window(width=SCREEN_WIDTH, height=SCREEN_HEIGHT) rabbyt.set_default_attribs() mower = Mower() bubble = RPMBubble() guage = Guage(mower) objs = [mower, guage, bubble] magicEventRegister(window.game_window, events, objs) while not window.game_window.has_exit: tick = clock.tick() window.game_window.dispatch_events() for obj in objs: obj.update(tick) events.ConsumeEventQueue() rabbyt.clear((1, 1, 1)) guage.draw() mower.draw() bubble.draw() window.game_window.flip()
def main(): win = pyglet.window.Window( width=800, height=600 ) anims = [] @win.event def on_key_press(symbol, modifiers): #print 'Flipping', anims for anim in anims: anim.flip() anims.append( Anim('subWalkNorm', 5) ) anims.append( BeerThrowAnim() ) while not win.has_exit: done = False clock.set_fps_limit(FRAMES_PER_SECOND) while not done: timeChange = clock.tick() win.dispatch_events() for anim in anims: anim.update( timeChange ) win.clear() if done or win.has_exit: break for anim in anims: anim.draw() win.flip()
def main(): global win clock.schedule(rabbyt.add_time) win = pyglet.window.Window(width=leaves.SCREEN_WIDTH, height=leaves.SCREEN_HEIGHT) window.set_window(win) rabbyt.set_default_attribs() garbage = GarbageCan() leafs = leaves.LeafGroup() leafs += [leaves.Leaf(), leaves.Leaf(), leaves.Leaf() ] for i in range(len(leafs)): leafs[i].logicalX = 260 + i*80 leafs[i].logicalY = 100 + i*60 leafs[i].logicalZ = 10 while not win.has_exit: tick = clock.tick() win.dispatch_events() leafs.update(tick) garbage.update(tick) events.ConsumeEventQueue() rabbyt.clear((1, 1, 1)) leafs.draw() garbage.draw() win.flip()
def run(self, initial_state=None): """ Run the experiment. """ # first clear and do a flip # glClear(GL_COLOR_BUFFER_BIT) self.window.on_draw(force=True) self.blocking_flip() # start the first state (that's this experiment) self.enter() # process events until done self._last_time = now() while not self.done and not self.window.has_exit: # record the time range self._new_time = now() time_err = (self._new_time - self._last_time) / 2.0 self.event_time = event_time(self._last_time + time_err, time_err) # process the events that occurred in that range self.window.dispatch_events() # handle all scheduled callbacks dt = clock.tick(poll=True) # put in sleeps if necessary if dt < 0.0001: # do a usleep for half a ms (might need to tweak) self.clock.sleep(500) # save the time self._last_time = self._new_time
def main(): global fps_display win = Window(width=800, height=600) clock.schedule(rabbyt.add_time) rabbyt.set_default_attribs() bg = Background() fps_display = clock.ClockDisplay() while not win.has_exit: tick = clock.tick() win.dispatch_events() bg.update(tick) rabbyt.clear((bg.color)) bg.draw() fps_display.draw() win.flip()
def main(): global win clock.schedule(rabbyt.add_time) win = Window(width=800, height=600) rabbyt.set_default_attribs() lawn = Lawn() wind = Wind() magicEventRegister(win, events, list(lawn)) while not win.has_exit: tick = clock.tick() win.dispatch_events() lawn.update(tick) wind.update(tick) events.ConsumeEventQueue() rabbyt.clear((1, 1, 1)) lawn.draw() win.flip()
def savedGameScreen(savedGames, windowSurface, WWIDTH, WHEIGHT, FRAMES, background_image, background_position): time.sleep(0.3) while True: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() windowSurface.blit(background_image, background_position) displayTextLJ(windowSurface, 36, 50, 50, 'Saved Games List', RED) displayTextLJ(windowSurface, 24, 50, 100, "Name", RED) displayTextLJ(windowSurface, 24, 200, 100, "Difficulty", RED) displayTextLJ(windowSurface, 24, 350, 100, "Platforms", RED) displayTextLJ(windowSurface, 24, 500, 100, "Record", RED) displayTextLJ( windowSurface, 20, 50, 550, 'Press number to select game or D plus number to delete game', RED) displayTextLJ(windowSurface, 20, 50, 600, 'Escape to return to previous screen', RED) count = 1 for game in savedGames: displayTextLJ(windowSurface, 20, 50, 100 + (count * 30), str(count) + ". " + game['name'], GREEN) displayTextLJ(windowSurface, 20, 200, 100 + (count * 30), game['difficulty'], GREEN) displayTextLJ(windowSurface, 20, 350, 100 + (count * 30), game['pnumber'], GREEN) if game['difficulty'] == "INSANE": displayTextLJ(windowSurface, 20, 500, 100 + (count * 30), "Score: " + game['score'], GREEN) else: displayTime(windowSurface, int(game['record']), 500, 100 + (count * 30), GREEN, 20, "True") count += 1 if not pygame.key.get_pressed()[ord('d')]: for i in range(len(savedGames)): if pygame.key.get_pressed()[ord(str(i + 1))]: return savedGames[i], i if pygame.key.get_pressed()[ord('d')]: for i in range(len(savedGames)): if pygame.key.get_pressed()[ord(str(i + 1))]: del savedGames[i] saveGames(windowSurface, WWIDTH, WHEIGHT, None, savedGames, None, "Delete") time.sleep(0.5) break if pygame.key.get_pressed()[K_ESCAPE]: return None, None pygame.display.flip() clock.set_fps_limit(FRAMES) clock.tick()
def play_human_record(callback=None): """ Play the environment using keyboard as a human. Returns: None """ # Start on the first world first_world = 'SuperMarioBros-1-1-v0' env = gym_super_mario_bros.make(first_world) observations = [] #For Storing observations # set the frame rate for pyglet clock.set_fps_limit(env.metadata['video.frames_per_second']) # ensure the observation space is a box of pixels assert isinstance(env.observation_space, gym.spaces.box.Box) # ensure the observation space is either B&W pixels or RGB Pixels obs_s = env.observation_space is_bw = len(obs_s.shape) == 2 is_rgb = len(obs_s.shape) == 3 and obs_s.shape[2] in [1, 3] assert is_bw or is_rgb # get the mapping of keyboard keys to actions in the environment if hasattr(env, 'get_keys_to_action'): keys_to_action = env.get_keys_to_action() elif hasattr(env.unwrapped, 'get_keys_to_action'): keys_to_action = env.unwrapped.get_keys_to_action() else: raise ValueError('env has no get_keys_to_action method') # create the image viewer from tkinter import Tk root = Tk() # Determining screen size height = root.winfo_screenheight() width = int(((height / 240) * 256)) viewer = ImageViewer( env.spec.id if env.spec is not None else env.__class__.__name__, #env.observation_space.shape[0], # height #env.observation_space.shape[1], # width height, width, monitor_keyboard=True, relevant_keys=set(sum(map(list, keys_to_action.keys()), []))) # create a done flag for the environment done = False state = env.reset() viewer.show(env.unwrapped.screen) # for keeping score score = 0 level_score = 1000 death_score = -100 cur_level_score = level_score min_score = 200 # start the main game loop finish = False start = None try: world = 1 stage = 1 stage_num = 0 steps = 0 start = time.time() # timestamp for start of game while True: # clock tick clock.tick() # reset if the environment is done if done: done = False if cur_level_score > min_score: cur_level_score += death_score # Go to new stage if flag/axe reached or time-limit is up if finish or steps >= time_limit: if finish: score += cur_level_score cur_level_score = level_score stage_num += 1 world, stage, new_world = stages.make_next_stage( world, stage, stage_num) env.close() env = gym_super_mario_bros.make(new_world) finish = False steps = 0 state = env.reset() viewer.show(env.unwrapped.screen) # unwrap the action based on pressed relevant keys action = keys_to_action.get(viewer.pressed_keys, _NOP) next_state, reward, done, info = env.step(action) steps += 1 if info['flag_get']: finish = True # Adding observation to list observations.append(action) viewer.show(env.unwrapped.screen) # pass the observation data through the callback if callback is not None: callback(state, action, reward, done, next_state) state = next_state # shutdown if the escape key is pressed if viewer.is_escape_pressed: break # shutdown if playtime is up now = time.time() if now - start > play_time: break except KeyboardInterrupt: pass end = time.time() #Storing the data data = {} data['obs'] = observations data['obs_n'] = len(observations) data['start_time'] = start data['stop_time'] = end data['score'] = score folder_path = './DATA/sessions/' if not os.path.exists(folder_path): os.makedirs(folder_path) path, dirs, files = next(os.walk(folder_path)) file_count = len(files) file_path = folder_path + 'session' + str(file_count) print('Saving observations to file') with open(file_path, 'w') as outfile: json.dump(data, outfile) viewer.close() env.close()
def run(xml_file): gui = GUI(window) loadxml.fromFile(gui, xml_file) if '--dump' in sys.argv: print('-' * 75) gui.dump() print('-' * 75) window.push_handlers(gui) gui.push_handlers(dragndrop.DragHandler('.draggable')) @gui.select('#press-me') def on_click(widget, *args): print('on_click', widget) return event.EVENT_HANDLED @gui.select('#enable-other') def on_click(widget, *args): w = gui.get('#press-me') w.setEnabled(not w.isEnabled()) return event.EVENT_HANDLED @gui.select('button, text-button') def on_click(widget, *args): print('DEBUG', widget, 'PRESSED') return event.EVENT_UNHANDLED @gui.select('.show-value') def on_change(widget, value): print('DEBUG', widget, 'VALUE CHANGED', repr(value)) return event.EVENT_UNHANDLED @gui.select('frame#menu-test', 'on_click') def on_menu(w, x, y, button, modifiers, click_count): if not widgets.PopupMenu.isActivatingClick(button, modifiers): return event.EVENT_UNHANDLED gui.get('#test-menu').expose((x, y)) return event.EVENT_HANDLED @gui.select('.hover') def on_element_enter(widget, *args): print('ENTER ELEMENT', widget.id) return event.EVENT_HANDLED @gui.select('.hover') def on_element_leave(widget, *args): print('LEAVE ELEMENT', widget.id) return event.EVENT_HANDLED @gui.select('.drawer-control') def on_click(widget, *args): id = widget.id.replace('drawer-control', 'test-drawer') gui.get('#' + id).toggle_state() return event.EVENT_HANDLED @gui.select('#question-dialog-test') def on_click(widget, *args): def f(*args): print('DIALOG SAYS', args) dialogs.Question(widget.getGUI(), 'Did this appear correctly?', callback=f).run() return event.EVENT_HANDLED @gui.select('#message-dialog-test') def on_click(widget, *args): def f(*args): print('DIALOG SAYS', args) dialogs.Message(widget.getGUI(), 'Hello, World!', callback=f).run() return event.EVENT_HANDLED @gui.select('#music-test') def on_click(widget, x, y, button, modifiers, click_count): if not button & mouse.RIGHT: return event.EVENT_UNHANDLED def load_music(file=None): if not file: return gui.get('#music-test').delete() m = widgets.Music(gui, file, id='music-test', playing=True) m.gainFocus() dialogs.FileOpen(gui, callback=load_music).run() return event.EVENT_HANDLED @gui.select('#movie-test') def on_click(widget, x, y, button, modifiers, click_count): if not button & mouse.RIGHT: return event.EVENT_UNHANDLED def load_movie(file=None): print('DIALOG SELECTION:', file) if not file: return gui.get('#movie-test').delete() m = widgets.Movie(gui, file, id='movie-test', playing=True) m.gainFocus() dialogs.FileOpen(gui, callback=load_movie).run() return event.EVENT_HANDLED @gui.select('#movie-test') def on_text(widget, text): if text == 'f': gui.get('#movie-test').video.pause() anim.Delayed(gui.get('#movie-test').video.play, duration=10) window.set_fullscreen() return event.EVENT_HANDLED @gui.select('.droppable') def on_drop(widget, x, y, button, modifiers, element): element.reparent(widget) widget.bgcolor = (1, 1, 1, 1) return event.EVENT_HANDLED @gui.select('.droppable') def on_drag_enter(widget, x, y, element): widget.bgcolor = (.8, 1, .8, 1) return event.EVENT_HANDLED @gui.select('.droppable') def on_drag_leave(widget, x, y, element): widget.bgcolor = (1, 1, 1, 1) return event.EVENT_HANDLED try: sample = gui.get('#xhtml-sample') except KeyError: sample = None if sample: @layout.select('#click-me') def on_mouse_press(element, x, y, button, modifiers): print('CLICK ON', element) return event.EVENT_HANDLED sample.label.push_handlers(on_mouse_press) if gui.has('.progress-me'): class Progress: progress = 0 direction = 1 def animate(self, dt): self.progress += dt * self.direction if self.progress > 5: self.progress = 5 self.direction = -1 elif self.progress < 0: self.progress = 0 self.direction = 1 for e in gui.get('.progress-me'): e.value = self.progress / 5. animate_progress = Progress().animate clock.schedule(animate_progress) my_escape.has_exit = False while not (window.has_exit or my_escape.has_exit): clock.tick() window.dispatch_events() media.dispatch_events() glClearColor(.2, .2, .2, 1) glClear(GL_COLOR_BUFFER_BIT) gui.draw() fps.draw() window.flip() if '--once' in sys.argv: window.close() sys.exit() if '--dump' in sys.argv: print('-' * 75) gui.dump() print('-' * 75) if gui.has('.progress-me'): clock.unschedule(animate_progress) # reset everything window.pop_handlers() gui.delete() window.set_size(800, 600) return window.has_exit
def run(self): """ Run the experiment. """ # create the window if self.fullscreen: self.window = ExpWindow(self, fullscreen=True, caption=self.name, vsync=self.pyglet_vsync, screen=self.screen) else: self.window = ExpWindow(self, *(self.resolution), fullscreen=self.fullscreen, caption=self.name, vsync=self.pyglet_vsync, screen=self.screen) # set the clear color self.window.set_clear_color(self._background_color) # set the mouse as desired #self.window.set_exclusive_mouse() self.window.set_mouse_visible(False) # some gl stuff (must look up to remember why we want them) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) # get flip interval self.flip_interval = self._calc_flip_interval() print "Monitor Flip Interval is %f (%f Hz)" % (self.flip_interval, 1. / self.flip_interval) # first clear and do a flip #glClear(GL_COLOR_BUFFER_BIT) self.window.on_draw(force=True) self.blocking_flip() # start the first state (that's this experiment) self.enter() # process events until done self._last_time = now() while not self.done and not self.window.has_exit: # record the time range self._new_time = now() time_err = (self._new_time - self._last_time) / 2. self.event_time = event_time(self._last_time + time_err, time_err) # process the events that occurred in that range self.window.dispatch_events() # handle all scheduled callbacks dt = clock.tick(poll=True) # put in sleeps if necessary if dt < .0001: # do a usleep for 1/4 of a ms (might need to tweak) self.clock.sleep(250) # save the time self._last_time = self._new_time # write out csv logs if desired if not self.nocsv: self.state_log_stream.flush() yaml2csv(self.state_log, os.path.splitext(self.state_log)[0] + '.csv') self.exp_log_stream.flush() yaml2csv(self.exp_log, os.path.splitext(self.exp_log)[0] + '.csv') # close the window and clean up self.window.close() self.window = None
def run(self): global _activeLevel global soundtrack _activeLevel = self self.done = False clock.set_fps_limit(60) win = window.window avSprite = AvatarSprite(self.avatar) self.avatar.feetPos = self.startLoc self.avatar.walkMask = self.walkMask self.avatar.triggerZones = self.triggerZones events.Fire('AvatarBirth', self.avatar) events.Fire('LevelStartedEvent', self) while not self.done: timeChange = clock.tick() #if soundtrack and self.sound: # print soundtrack # soundtrack.dispatch_events() events.ConsumeEventQueue() win.dispatch_events() if self.deathDelay: self.deathDelay -= timeChange if self.deathDelay <= 0: self.done = True if self.done or win.has_exit: player.strings = self.avatar.strings[:] events.Reset() break avSprite.update(timeChange) for miscSprite in self.miscSprites: miscSprite.update(timeChange) for enemySprite in self.enemySprites.values(): enemySprite.update(timeChange) for sprite in self.visualEffects.sprites: sprite.update(timeChange) win.clear() # find the combined height of the background images bgWidth = 0 bgHeight = 0 for bg in self.bgImages: bgWidth += bg.width bgHeight += bg.height offset = self.calcBGOffset(self.avatar.x, self.avatar.y, win.width, win.height, bgWidth, bgHeight) window.bgOffset[0] = offset[0] window.bgOffset[1] = offset[1] #self.bg.blit(*window.bgOffset) #[bg.blit(*window.bgOffset) for bg in self.bgImages] for count, bg in enumerate(self.bgImages): bg.blit(count * 1024 + window.bgOffset[0], window.bgOffset[1]) for miscSprite in self.miscSprites: miscSprite.draw() avSprite.draw() for enemySprite in self.enemySprites.values(): enemySprite.draw() for sprite in self.visualEffects.sprites: sprite.draw() #self.healthText.draw() self.healthBar.draw(self.avatar) self.energyBar.draw(self.avatar) if DEBUG: self.fpsText.text = "fps: %d" % clock.get_fps() self.fpsText.draw() if clock.get_fps() < 30: events.Fire('LowFPS30') win.flip() return self.getNextScene()
blood = [] def splatter(direction): for drop in range(0, randint(15, 20)): blood.append( Blood( euclid.Vector2(200, 200), direction + euclid.Vector2(randint(-2, 2), randint(-2, 2)))) @win.event def on_key_press(symbol, modifiers): if symbol == window.key.RIGHT: splatter(Blood.right) elif symbol == window.key.LEFT: splatter(Blood.left) while not win.has_exit: win.dispatch_events() tick = clock.tick() for drop in blood: drop.update(tick) if drop.lifetime < 0: blood.remove(drop) win.clear() [drop.draw() for drop in blood] win.flip()
sprites = list() numsprites = int(sys.argv[1]) for i in range(numsprites): x = random.randint(0, w.width - img.width) y = random.randint(0, w.height - img.height) s = BouncySprite(x, y, img.width, img.height, img) s.dx = random.randint(-10, 10) s.dy = random.randint(-10, 10) sprites.append(s) view = FlatView.from_window(w, sprites=sprites) view.fx, view.fy = w.width / 2, w.height / 2 t = 0 numframes = 0 while 1: if w.has_exit: print('FPS:', clock.get_fps()) print('us per sprite:', float(t) / (numsprites * numframes) * 1000000) break t += clock.tick() w.dispatch_events() for s in sprites: s.update() view.clear() view.draw() w.flip() numframes += 1 w.close()
def step_events(): win.dispatch_events() media.dispatch_events() clock.tick()
# create a pyglet window and set glOptions win = window.Window(width=500, height=500, vsync=False, resizable=True) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) # needed so that egi knows where to draw egi.InitWithPyglet(win) # prep the fps display fps_display = clock.ClockDisplay() # register key and mouse event handlers win.push_handlers(on_key_press) win.push_handlers(on_resize) # create a world for agents world = World(500, 500) # add one agent world.target = Target(world, 10, 10) world.shooter = Shooter(world, 10, 0.01) # unpause the world ready for movement world.paused = False while not win.has_exit: win.dispatch_events() glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # show nice FPS bottom right (default) delta = clock.tick() world.update(delta) world.render() fps_display.draw() # swap the double buffer win.flip()
w1 = Window(width=300, height=300) w1.switch_to() setup_scene() tree1 = Tree(n=10, r=True) w1.push_handlers(tree1) w2 = Window(width=300, height=300) w2.switch_to() setup_scene() tree2 = Tree(n=10, r=False) w2.push_handlers(tree2) n = 0 clock.set_fps_limit(30) while not (w1.has_exit or w2.has_exit): clock.tick() n += 1 # draw w1.switch_to() glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) w1.dispatch_events() tree1.draw() w1.flip() w2.switch_to() glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) w2.dispatch_events() tree2.draw() w2.flip()
def play(game='SonicTheHedgehog-Genesis', state='GreenHillZone.Act1', scenario='scenario', frame_jump=1): ''' :param game: game to load :param state: level to load :param scenario: scenario to load :return: ''' print('\n\tBACKSPACE : reset the level' '\n\tECHAP : End') jump = 0 env = retro.make(game=game, state=state, use_restricted_actions=retro.ACTIONS_ALL, scenario=scenario) obs = env.reset() win_width = 900 screen_height, screen_width = obs.shape[:2] win_height = win_width * screen_height // screen_width win = pyglet.window.Window(width=win_width, height=win_height, vsync=False) key_handler = pyglet.window.key.KeyStateHandler() win.push_handlers(key_handler) key_previous_states = {} pyglet.app.platform_event_loop.start() fps_display = pyglet.clock.ClockDisplay() clock.set_fps_limit(60) glEnable(GL_TEXTURE_2D) texture_id = GLuint(0) glGenTextures(1, ctypes.byref(texture_id)) glBindTexture(GL_TEXTURE_2D, texture_id) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, screen_width, screen_height, 0, GL_RGB, GL_UNSIGNED_BYTE, None) total_reward = 0.0 while not win.has_exit: win.dispatch_events() win.clear() keys_clicked = set() keys_pressed = set() for key_code, pressed in key_handler.items(): if pressed: keys_pressed.add(key_code) if not key_previous_states.get(key_code, False) and pressed: keys_clicked.add(key_code) key_previous_states[key_code] = pressed buttons_pressed = set() # End of the session if keycodes.ESCAPE in keys_pressed: pyglet.app.platform_event_loop.stop() return # Reset of the level and the recorded images and actions elif keycodes.BACKSPACE in keys_pressed: print('reset level') env.reset() inputs = { 'A': keycodes.Z in keys_pressed or ButtonCodes.A in buttons_pressed, 'B': keycodes.A in keys_pressed or ButtonCodes.B in buttons_pressed, 'C': keycodes.E in keys_pressed, 'X': keycodes.Q in keys_pressed or ButtonCodes.X in buttons_pressed, 'Y': keycodes.S in keys_pressed or ButtonCodes.Y in buttons_pressed, 'Z': keycodes.D in keys_pressed, 'UP': keycodes.UP in keys_pressed or ButtonCodes.D_UP in buttons_pressed, 'DOWN': keycodes.DOWN in keys_pressed or ButtonCodes.D_DOWN in buttons_pressed, 'LEFT': keycodes.LEFT in keys_pressed or ButtonCodes.D_LEFT in buttons_pressed, 'RIGHT': keycodes.RIGHT in keys_pressed or ButtonCodes.D_RIGHT in buttons_pressed, 'MODE': keycodes.TAB in keys_pressed or ButtonCodes.SELECT in buttons_pressed, 'START': keycodes.ENTER in keys_pressed or ButtonCodes.START in buttons_pressed, } if jump == 0: action = [inputs[b] for b in env.BUTTONS] last_action = action obs, rew, done, info = env.step(action) jump = frame_jump else: obs, rew, done, info = env.step(last_action) total_reward += rew print(total_reward) print(rew) jump -= 1 glBindTexture(GL_TEXTURE_2D, texture_id) video_buffer = ctypes.cast(obs.tobytes(), ctypes.POINTER(ctypes.c_short)) glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, obs.shape[1], obs.shape[0], GL_RGB, GL_UNSIGNED_BYTE, video_buffer) x = 0 y = 0 h = win.height w = win.width pyglet.graphics.draw(4, pyglet.gl.GL_QUADS, ('v2f', [x, y, x + w, y, x + w, y + h, x, y + h]), ('t2f', [0, 1, 1, 1, 1, 0, 0, 0]), ) fps_display.draw() win.flip() timeout = clock.get_sleep_time(False) pyglet.app.platform_event_loop.step(timeout) clock.tick() pyglet.app.platform_event_loop.stop()
def main(): w = window.Window(vsync=False, resizable=True) w.set_mouse_cursor(w.get_system_mouse_cursor('text')) @w.event def on_key_press(symbol, modifiers): if sys.platform == 'darwin': accel = key.MOD_COMMAND else: accel = key.MOD_CTRL if modifiers & accel: if symbol == key.B: toggle_style('bold') elif symbol == key.I: toggle_style('italic') elif symbol in (key.EQUAL, key.NUM_ADD): add_font_size(2) elif symbol in (key.MINUS, key.NUM_SUBTRACT): add_font_size(-2) if symbol == key.ESCAPE: w.has_exit = True def toggle_style(attribute): old = caret.get_style(attribute) if old == style.INDETERMINATE: value = True else: value = not old caret.set_style({attribute: value}) def add_font_size(size): old_size = caret.get_style('font_size') if old_size in (style.INDETERMINATE, None): old_size = 12 caret.set_style({'font_size': old_size + size}) def on_resize(width, height): text.x = border text.y = height - border text.width = width - border * 2 text.height = height - border * 2 caret._update() w.push_handlers(on_resize) if len(sys.argv) > 1: content = open(sys.argv[1]).read() else: content = resource.file('info.att').read() # Draw to this border so we can test clipping. border = 50 batch = graphics.Batch() doc = attributed(content) text = layout.IncrementalTextLayout(doc, w.width - border * 2, w.height - border * 2, multiline=True, batch=batch) caret = caret_module.Caret(text) caret.color = (0, 0, 0) caret.visible = True caret.position = 0 w.push_handlers(caret) fps = clock.ClockDisplay(font=font.load('', 10, dpi=96), color=(0, 0, 0, 1), interval=1., format='FPS: %(fps)d') fps.label.x = 2 fps.label.y = 15 stats_text = font.Text(font.load('', 10, dpi=96), '', x=2, y=2, color=(0, 0, 0, 1)) def update_stats(dt): states = list(batch.state_map.values()) usage = 0. blocks = 0 domains = 0 fragmentation = 0. free_space = 0. capacity = 0. for state in states: for domain in list(state.values()): domains += 1 free_space += domain.allocator.get_free_size() fragmentation += domain.allocator.get_fragmented_free_size() capacity += domain.allocator.capacity blocks += len(domain.allocator.starts) if free_space: fragmentation /= free_space else: fragmentation = 0. free_space /= capacity usage = 1. - free_space stats_text.text = \ 'States: %d Domains: %d Blocks: %d Usage: %d%% Fragmentation: %d%%' % \ (len(states), domains, blocks, usage * 100, fragmentation * 100) clock.schedule_interval(update_stats, 1) glClearColor(1, 1, 1, 1) glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE) while not w.has_exit: clock.tick() w.dispatch_events() w.clear() batch.draw() fps.draw() stats_text.draw() glPushAttrib(GL_CURRENT_BIT) glColor3f(0, 0, 0) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) glRectf(border - 2, border - 2, w.width - border + 4, w.height - border + 4) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) glPopAttrib() w.flip() main()
def update_stats(dt): np = len(streamers) usage = streamers[0].domain.allocator.get_usage() fragmentation = streamers[0].domain.allocator.get_fragmentation() blocks = len(streamers[0].domain.allocator.starts) stats_text.text = \ 'Streamers: %d Blocks: %d Usage: %d%% Fragmentation: %d%%' % \ (np, blocks, usage * 100, fragmentation * 100) clock.schedule_interval(update_stats, 1) fps_text = clock.ClockDisplay() while not win.has_exit: win.dispatch_events() dt = clock.tick() dt = min(dt, 0.05) update_streamers() for i in range(min(MAX_ADD_STREAMERS, MAX_STREAMERS - len(streamers))): add_streamers() win.clear() batch.draw() stats_text.draw() fps_text.draw() win.flip()
def test_first_tick_is_delta_zero(): """ Tests that the first tick is dt = 0. """ dt = clock.tick() assert dt == 0
from pyglet.window import Window from pyglet import clock from scene2d.textsprite import * from pyglet import font width, height = 640, 480 window = Window(width=width, height=height) arial = font.load('Arial', 500, bold=True) commander = TextSprite(arial, 'COMMANDER', color=(1, 1, 1, 0.5)) keen = TextSprite(arial, 'KEEN', color=(1, 1, 1, 0.5)) print dir(keen) commander.x = width keen.x = -keen.width commander.dx = -(commander.width + width) / 10 keen.dx = (keen.width + width) / 10 clock.set_fps_limit(30) while not window.has_exit: window.dispatch_events() time = clock.tick() glClear(GL_COLOR_BUFFER_BIT) for text in (commander, keen): glLoadIdentity() text.x += text.dx * time text.draw() window.flip()
def update(self): self.dt_count += clock.tick() if self.dt_count >= 0.025: self.dt_count = 0
def test_first_tick_is_delta_zero(self): """ Tests that the first tick is dt = 0. """ dt = clock.tick() self.assertTrue(dt == 0)
def generate_data(game='SonicTheHedgehog-Genesis', state='GreenHillZone.Act1', scenario='scenario', extension_name='', frame_jump=1, save_images=True, save_actions=True, fixed_record_size=False): ''' Play to Sonic and save the images and actions of the session in order to create data for neural networks trainings :param game: game to load :param state: level to load :param scenario: the scenario file :param extension_name: extension's name of the image arrays and actions that will be saved :param frame_jump: factor for not saving images ex :frame_jump = 1 : every image of the session is saved frame_jump = 3 : only 1/3 images are saved The last action is repeated during the jumped frames :return: Actions : Move Sonic : Directional arrows Z : Jump S : Down R : Save session (images + actions). The name of the save will end by extension_name + an index which is incremented every save. C : Cancel current recording (images + actions are cleaned) BackSpace : level reset (images + actions are cleaned) ''' print('\n\tBACKSPACE : reset level' '\n\tC : Cancel current recording' '\n\tR : Save current recording' '\n\tECHAP : End') jump = 0 # Level loading env = retro.make(game=game, state=state, use_restricted_actions=retro.ACTIONS_ALL, scenario=scenario) obs = env.reset() save_index = 1 win_width = 900 screen_height, screen_width = obs.shape[:2] win_height = win_width * screen_height // screen_width win = pyglet.window.Window(width=win_width, height=win_height, vsync=False) key_handler = pyglet.window.key.KeyStateHandler() win.push_handlers(key_handler) key_previous_states = {} pyglet.app.platform_event_loop.start() fps_display = pyglet.clock.ClockDisplay() clock.set_fps_limit(60) glEnable(GL_TEXTURE_2D) texture_id = GLuint(0) glGenTextures(1, ctypes.byref(texture_id)) glBindTexture(GL_TEXTURE_2D, texture_id) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, screen_width, screen_height, 0, GL_RGB, GL_UNSIGNED_BYTE, None) # Array of the session's images images = [] # Array of the session's actions actions = [] while not win.has_exit: win.dispatch_events() win.clear() keys_clicked = set() keys_pressed = set() for key_code, pressed in key_handler.items(): if pressed: keys_pressed.add(key_code) if not key_previous_states.get(key_code, False) and pressed: keys_clicked.add(key_code) key_previous_states[key_code] = pressed buttons_pressed = set() # End of the session if keycodes.ESCAPE in keys_pressed: pyglet.app.platform_event_loop.stop() return # Reset images and actions elif keycodes.C in keys_pressed: print('reset record') print(len(images)) images = [] actions = [] # Images and actions of the game session are saved elif fixed_record_size and len(images) == SEQ_LENGTH + 1: if save_images: images = np.array(images, dtype=np.uint8) np.save('./data/images/' + state + extension_name + str(save_index), images) print('Images saved at : ./data/images/' + state + extension_name + str(save_index)) if save_actions: actions = np.array(actions, dtype=np.bool) np.save('./data/actions/' + state + extension_name + str(save_index), actions) print('Actions saved at : ./data/actions/' + state + extension_name + str(save_index)) images = [] actions = [] save_index += 1 elif keycodes.R in keys_pressed: if save_images and len(images) > 10: images = np.array(images, dtype=np.uint8) np.save('./data/images/' + state + extension_name + str(save_index), images) print('Images saved at : ./data/images/' + state + extension_name + str(save_index)) if save_actions and len(actions) > 10: actions = np.array(actions, dtype=np.bool) np.save('./data/actions/' + state + extension_name + str(save_index), actions) print('Actions saved at : ./data/actions/' + state + extension_name + str(save_index)) images = [] actions = [] save_index += 1 # Reset of the level, actions and images elif keycodes.BACKSPACE in keys_pressed: print('level reset') env.reset() images = [] actions = [] inputs = { 'A': keycodes.Z in keys_pressed or ButtonCodes.A in buttons_pressed, 'B': keycodes.A in keys_pressed or ButtonCodes.B in buttons_pressed, 'C': keycodes.E in keys_pressed, 'X': keycodes.Q in keys_pressed or ButtonCodes.X in buttons_pressed, 'Y': keycodes.S in keys_pressed or ButtonCodes.Y in buttons_pressed, 'Z': keycodes.D in keys_pressed, 'UP': keycodes.UP in keys_pressed or ButtonCodes.D_UP in buttons_pressed, 'DOWN': keycodes.DOWN in keys_pressed or ButtonCodes.D_DOWN in buttons_pressed, 'LEFT': keycodes.LEFT in keys_pressed or ButtonCodes.D_LEFT in buttons_pressed, 'RIGHT': keycodes.RIGHT in keys_pressed or ButtonCodes.D_RIGHT in buttons_pressed, 'MODE': keycodes.TAB in keys_pressed or ButtonCodes.SELECT in buttons_pressed, 'START': keycodes.ENTER in keys_pressed or ButtonCodes.START in buttons_pressed, } if jump == 0: action = [inputs[b] for b in env.BUTTONS] last_action = action obs, rew, done, info = env.step(action) jump = frame_jump if save_images: images.append(obs) if save_actions: actions.append([inputs['A'], inputs['LEFT'], inputs['RIGHT'], inputs['DOWN']]) else: obs, rew, done, info = env.step(last_action) jump -= 1 glBindTexture(GL_TEXTURE_2D, texture_id) video_buffer = ctypes.cast(obs.tobytes(), ctypes.POINTER(ctypes.c_short)) glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, obs.shape[1], obs.shape[0], GL_RGB, GL_UNSIGNED_BYTE, video_buffer) x = 0 y = 0 h = win.height w = win.width pyglet.graphics.draw(4, pyglet.gl.GL_QUADS, ('v2f', [x, y, x + w, y, x + w, y + h, x, y + h]), ('t2f', [0, 1, 1, 1, 1, 0, 0, 0]), ) fps_display.draw() win.flip() timeout = clock.get_sleep_time(False) pyglet.app.platform_event_loop.step(timeout) clock.tick() pyglet.app.platform_event_loop.stop()