def animateTileChange(tilesToFlip, tileColor, additionalTile): # Draw the additional tile that was just laid down. (Otherwise we'd # have to completely redraw the board & the board info.) if tileColor == WHITE_TILE: additionalTileColor = WHITE else: additionalTileColor = BLACK additionalTileX, additionalTileY = translateBoardToPixelCoord(additionalTile[0], additionalTile[1]) sdlgfx.filledCircleRGBA(REN.renderer, additionalTileX, additionalTileY, SPACESIZE//2 - 4, *additionalTileColor) REN.present() for rgbValues in range(0, 255, int(ANIMATIONSPEED * 2.55)): for event in ext.get_events(): if event.type == SDL_QUIT: shutdown() elif event.type == SDL_KEYUP: sc = event.key.keysym.scancode if sc == SDL_SCANCODE_ESCAPE: shutdown() if rgbValues > 255: rgbValues = 255 elif rgbValues < 0: rgbValues = 0 if tileColor == WHITE_TILE: color = (rgbValues, rgbValues, rgbValues, 255) # rgbValues goes from 0 to 255 elif tileColor == BLACK_TILE: color = (255 - rgbValues, 255 - rgbValues, 255 - rgbValues, 255) # rgbValues goes from 255 to 0 for x, y in tilesToFlip: centerx, centery = translateBoardToPixelCoord(x, y) sdlgfx.filledCircleRGBA(REN.renderer, centerx, centery, SPACESIZE//2 - 4, *color) REN.present() SDL_Delay(1000//FPS)
def run(): WIDTH = 1600 HEIGHT = 1200 THICKNESS = 10 LENGTH = 100 RADIUS = 20 sdlext.init() window = sdlext.Window("the PG", size=(WIDTH, HEIGHT)) window.show() world = sdlext.World() spriterenderer = SoftwareRenderer(window) world.add_system(spriterenderer) factory = sdlext.SpriteFactory(sdlext.SOFTWARE) sp_paddle1 = factory.from_color(WHITE, (THICKNESS, LENGTH)) sp_paddle2 = factory.from_color(WHITE, (THICKNESS, LENGTH)) player1 = Player(world, sp_paddle1, 0, HEIGHT//2 - LENGTH//2) player2 = Player(world, sp_paddle2, WIDTH - THICKNESS, HEIGHT//2 - LENGTH//2) sp_ball = factory.from_color(WHITE, size=(RADIUS, RADIUS)) movement = MovementSystem(0, 0, WIDTH, HEIGHT) world.add_system(movement) ball = Ball(world, sp_ball, WIDTH//2 - THICKNESS//2, HEIGHT//2 - RADIUS//2) ball.velocity.vx = 3 running = True while running: events = sdlext.get_events() for event in events: if event.type == sdl2.SDL_QUIT: running = False break world.process() return 0
def run(linefile): sdl2ext.init() for line in linefile: l = line.split() if len(l) == 0: pass elif l[0] == "pixels": xpix = int(l[1]) ypix = int(l[2]) window = sdl2ext.Window("Pixel Access", size=(xpix, ypix)) window.show() renderer = sdl2ext.Renderer(window) running = True while running: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break with Timer() as t: grid = draw.dofile(linefile) print "=> elasped grid: %s s" % t.secs with Timer() as t: draw_pixels(renderer, xpix, ypix, grid) print "=> elasped render: %s s" % t.secs window.refresh() sdl2ext.quit() return 0
def checkEvents(self): for event in sdle.get_events(): if event.type == sdl.SDL_QUIT: self.running = False break if event.type == sdl.SDL_KEYDOWN: self.keys[event.key.keysym.sym] = True if event.type == sdl.SDL_KEYUP: self.keys[event.key.keysym.sym] = False if self.keyDown(sdl.SDLK_DOWN): s = self.entities['test'].sprite() self.entities['test'].yspeed = self.entities['test'].yspeed + 0.5 if self.keyDown(sdl.SDLK_UP): s = self.entities['test'].sprite() self.entities['test'].yspeed = self.entities['test'].yspeed - 0.5 if self.keyDown(sdl.SDLK_RIGHT): s = self.entities['test'].sprite() self.entities['test'].xspeed = self.entities['test'].xspeed + 0.5 if self.keyDown(sdl.SDLK_LEFT): s = self.entities['test'].sprite() self.entities['test'].xspeed = self.entities['test'].xspeed - 0.5
def __init__(self, naki_pattern, textbox_manager, world): self.naki_pattern = naki_pattern self.textbox_manager = textbox_manager self.world = world self.button_names = list() self.buttons = list() for pattern in naki_pattern: self.textbox_manager.make_button(pattern) self.button_names.append(pattern) self.buttons.append(self.textbox_manager.entity_dict[pattern]) self.world.process() while True: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break elif event.type == SDL_MOUSEBUTTONDOWN: for i, button in enumerate(self.buttons): if sprite_mouse_overlap(button.sprite, event.button): self.command = button.textbox.name break else: self.command = None for button_name in self.button_names: self.textbox_manager.del_button(button_name) world.process() return SDL_Delay(10) world.process()
def process_input(self): """Process buffered input and dispatch resulting events.""" events = sdl_ext.get_events() for evt in events: if evt.type in {sdl.SDL_KEYUP}: key_event = evt.key send_event(KeyPressEvent(key_event.keysym.sym)) elif evt.type in {sdl.SDL_MOUSEMOTION}: mouse_motion = evt.motion send_event(MouseMoveEvent(mouse_motion.x, mouse_motion.y)) elif evt.type in {sdl.SDL_MOUSEBUTTONDOWN, sdl.SDL_MOUSEBUTTONUP}: mouse_event = evt.button if mouse_event.button == sdl.SDL_BUTTON_LEFT: button = MouseClickEvent.Button.left elif mouse_event.button == sdl.SDL_BUTTON_RIGHT: button = MouseClickEvent.Button.right else: button = MouseClickEvent.Button.unknown if evt.type == sdl.SDL_MOUSEBUTTONDOWN: state = MouseClickEvent.State.down else: state = MouseClickEvent.State.up send_event( MouseClickEvent(mouse_event.x, mouse_event.y, button, state))
def process_input(self): """Process buffered input and dispatch resulting events.""" events = sdl_ext.get_events() for evt in events: if evt.type in {sdl.SDL_KEYUP}: key_event = evt.key send_event(KeyPressEvent(key_event.keysym.sym)) elif evt.type in {sdl.SDL_MOUSEMOTION}: mouse_motion = evt.motion send_event(MouseMoveEvent(mouse_motion.x, mouse_motion.y)) elif evt.type in {sdl.SDL_MOUSEBUTTONDOWN, sdl.SDL_MOUSEBUTTONUP}: mouse_event = evt.button if mouse_event.button == sdl.SDL_BUTTON_LEFT: button = MouseClickEvent.Button.left elif mouse_event.button == sdl.SDL_BUTTON_RIGHT: button = MouseClickEvent.Button.right else: button = MouseClickEvent.Button.unknown if evt.type == sdl.SDL_MOUSEBUTTONDOWN: state = MouseClickEvent.State.down else: state = MouseClickEvent.State.up send_event(MouseClickEvent( mouse_event.x, mouse_event.y, button, state))
def run(linefile): sdl2ext.init() for line in linefile: l = line.split() if len(l) == 0: pass elif l[0] == "pixels": xpix = int(l[1]) ypix = int(l[2]) window = sdl2ext.Window("Pixel Access", size=(xpix, ypix)) window.show() windowsurface = window.get_surface() running = True while running: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break grid = draw.dofile(linefile) draw_pixels(windowsurface, xpix, ypix, grid) window.refresh() sdl2ext.quit() return 0 '''
def pump(return_events=False): """Pumps the SDL2 event queue and appends its contents to the EventManager log. The SDL2 event queue contains SDL_Event objects representing keypresses, mouse movements, mouse clicks, and other input events that have occured since last check. Pumping the SDL2 event queue clears its contents, so be careful of calling it (or functions that call it implicitly) multiple times in the same loop, as it may result in unexpected problems watching for input (e.g if you have two functions checking for mouse clicks within two different boundaries and both call pump(), the second one will only return True if a click within that boundary occurred within the sub-millisecond interval between the first and second functions.) To avoid these problems, you can manually fetch the queue once per loop and pass its contents to each of the functions in the loop inspecting user input. Args: return_events (bool): If true, returns the contents of the SDL2 event queue. Returns: A list of SDL_Event objects, if return_events=True. Otherwise, the return value is None. """ SDL_PumpEvents() if return_events: return get_events()
def poll(self): key_get = self._key_conversions.get mouse_button_get = self._mouse_conversions.get window_height = conf.get_resolution()[1] for event in sdl2_ext.get_events(): if event.type == sdl2.SDL_QUIT: raise SystemExit elif event.type == sdl2.SDL_KEYDOWN: self.process_key_down(key_get(event.key.keysym.sym)) elif event.type == sdl2.SDL_KEYUP: self.process_key_up(key_get(event.key.keysym.sym)) elif event.type == sdl2.SDL_MOUSEMOTION: event = event.motion x = event.x y = window_height - event.y self.process_mouse_motion((x, y)) elif event.type == sdl2.SDL_MOUSEBUTTONUP: event = event.button x = event.x y = window_height - event.y button = mouse_button_get(event.button) self.process_mouse_button_up(button, (x, y)) elif event.type == sdl2.SDL_MOUSEBUTTONDOWN: event = event.button x = event.x y = window_height - event.y button = mouse_button_get(event.button) self.process_mouse_button_down(button, (x, y)) self.process_long_press() self.process_mouse_longpress()
def hora_check_phase(player): if player.hand.hora_flag( player.hand.contents, player.hand.hand[-1], False ) and \ player.naki_status in [None,'kan']: print("You Tsumo?") self.textbox_manager.make_button('tsumo') while True: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False return elif event.type == SDL_MOUSEBUTTONDOWN: if sprite_mouse_overlap(self.textbox_manager.entity_dict['tsumo'].sprite, event.button): player.hand.agarihai = player.hand.tsumohai #TODO:上がりはいが-1の時はこれでいいのか。いつ起こる。とりあえずここで止める if player.hand.agarihai == -1: input() player.hand.agarihai = player.hand.hand[0] hora_process(player) self.textbox_manager.del_button('tsumo') return True else: self.textbox_manager.del_button('tsumo') return False else: return False
def run(): # init sdl and get window up sdl2ext.init() window = sdl2ext.Window("Traction Edge RL", size=(800, 600)) window.show() #create hardware accelerated context for drawing on context = sdl2ext.RenderContext(window, index=-1, flags=SDL_RENDERER_ACCELERATED) #create our custom renderer with the context renderer = systems.Renderer(context) # init world world = sdl2ext.World() world.add_system(renderer) # create our sprites factory = sdl2ext.SpriteFactory(sprite_type=sdl2ext.TEXTURE, renderer=context) sp_player = factory.from_color(WHITE, size=(32,32)) #create player player = entities.Creature(world, sp_player, 100, 400) #main loop running = True while running: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break SDL_Delay(10) world.process() return
def run(): # You know those from the helloworld.py example. # Initialize the video subsystem, create a window and make it visible. sdl2ext.init() TTF_Init() window = sdl2ext.Window("2D drawing primitives", size=(800, 600)) window.show() # As in colorpalettes.py, explicitly acquire the window's surface to # draw on. windowsurface = window.get_surface() fps = FPS(windowsurface) # We implement the functionality as it was done in colorpalettes.py and # utilise a mapping table to look up the function to be executed, together # with the arguments they should receive functions = ((draw_lines, (windowsurface, 800, 600)), (draw_rects, (windowsurface, 800, 600))) # A storage variable for the function we are currently on, so that we know # which function to execute next. curindex = 0 draw_lines(windowsurface, 800, 600) textSurface = TTF_RenderText_Shaded(font, repr(SDL_GetPerformanceFrequency()), SDL_Color(255, 255, 255), SDL_Color(40, 90, 120)) # The event loop is nearly the same as we used in colorpalettes.py. If you # do not know, what happens here, take a look at colorpalettes.py for a # detailled description. running = True while running: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break if event.type == SDL_MOUSEBUTTONDOWN: curindex += 1 if curindex >= len(functions): curindex = 0 # In contrast to colorpalettes.py, our mapping table consists # of functions and their arguments. Thus, we get the currently # requested function and argument tuple and execute the # function with the arguments. func, args = functions[curindex] func(*args) break textSurface = TTF_RenderText_Shaded( font, "FPS: " + str(SDL_GetPerformanceFrequency()), SDL_Color(255, 255, 255), SDL_Color(40, 90, 120)) SDL_BlitSurface(textSurface, None, windowsurface, None) window.refresh() TTF_Quit() sdl2ext.quit() return 0
def run(): sdl2ext.init() window = sdl2ext.Window("The Pong Game", size=(800, 600)) window.show() if "-hardware" in sys.argv: print("Using hardware acceleration") renderer = sdl2ext.RenderContext(window) factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer) else: print("Using software rendering") factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE) # Create the paddles - we want white ones. To keep it easy enough for us, # we create a set of surfaces that can be used for Texture- and # Software-based sprites. sp_paddle1 = factory.from_color(WHITE, size=(20, 100)) sp_paddle2 = factory.from_color(WHITE, size=(20, 100)) sp_ball = factory.from_color(WHITE, size=(20, 20)) world = World() movement = MovementSystem(0, 0, 800, 600) collision = CollisionSystem(0, 0, 800, 600) aicontroller = TrackingAIController(0, 600) if factory.sprite_type == sdl2ext.SOFTWARE: spriterenderer = SoftwareRenderer(window) else: spriterenderer = TextureRenderer(renderer) world.add_system(aicontroller) world.add_system(movement) world.add_system(collision) world.add_system(spriterenderer) player1 = Player(world, sp_paddle1, 0, 250) player2 = Player(world, sp_paddle2, 780, 250, True) ball = Ball(world, sp_ball, 390, 290) ball.velocity.vx = -BALL_SPEED collision.ball = ball aicontroller.ball = ball running = True while running: for event in sdl2ext.get_events(): if event.type == sdlevents.SDL_QUIT: running = False break if event.type == sdlevents.SDL_KEYDOWN: if event.key.keysym.sym == sdlkc.SDLK_UP: player1.velocity.vy = -PADDLE_SPEED elif event.key.keysym.sym == sdlkc.SDLK_DOWN: player1.velocity.vy = PADDLE_SPEED elif event.type == sdlevents.SDL_KEYUP: if event.key.keysym.sym in (sdlkc.SDLK_UP, sdlkc.SDLK_DOWN): player1.velocity.vy = 0 sdltimer.SDL_Delay(10) world.process()
def run(): # You know those from the helloworld.py example. # Initialize the video subsystem, create a window and make it visible. sdl2ext.init() TTF_Init() window = sdl2ext.Window("2D drawing primitives", size=(800, 600)) window.show() # As in colorpalettes.py, explicitly acquire the window's surface to # draw on. windowsurface = window.get_surface() fps = FPS(windowsurface) # We implement the functionality as it was done in colorpalettes.py and # utilise a mapping table to look up the function to be executed, together # with the arguments they should receive functions = ((draw_lines, (windowsurface, 800, 600)), (draw_rects, (windowsurface, 800, 600)) ) # A storage variable for the function we are currently on, so that we know # which function to execute next. curindex = 0 draw_lines(windowsurface, 800, 600) textSurface = TTF_RenderText_Shaded(font, repr(SDL_GetPerformanceFrequency()), SDL_Color(255, 255, 255), SDL_Color(40, 90, 120)) # The event loop is nearly the same as we used in colorpalettes.py. If you # do not know, what happens here, take a look at colorpalettes.py for a # detailled description. running = True while running: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break if event.type == SDL_MOUSEBUTTONDOWN: curindex += 1 if curindex >= len(functions): curindex = 0 # In contrast to colorpalettes.py, our mapping table consists # of functions and their arguments. Thus, we get the currently # requested function and argument tuple and execute the # function with the arguments. func, args = functions[curindex] func(*args) break textSurface = TTF_RenderText_Shaded(font,"FPS: " + str(SDL_GetPerformanceFrequency()), SDL_Color(255, 255, 255), SDL_Color(40, 90, 120)) SDL_BlitSurface(textSurface, None, windowsurface, None) window.refresh() TTF_Quit() sdl2ext.quit() return 0
def handle_input(self) -> None: events = get_events() for event in events: if event.type == SDL_QUIT: self.inputs[Input.QUIT] = True elif event.type == SDL_KEYDOWN: self.inputs[to_input(event.key.keysym.sym)] = True elif event.type == SDL_KEYUP: self.inputs[to_input(event.key.keysym.sym)] = False
def checkForKeyPress(): for event in ext.get_events(): if event.type == SDL_QUIT: shutdown() elif event.type == SDL_KEYUP: sc = event.key.keysym.scancode if sc == SDL_SCANCODE_ESCAPE: shutdown() return event.key.keysym.scancode
def loop(self, id): # processa eventos events = sdlx.get_events() for ev in events: if ev.type == sdl.SDL_QUIT: self.close(id) return # atualiza os fps e tela self.conexões[id].update()
def process_input(self): events = get_events() for evt in events: if evt.type == sdl.SDL_KEYDOWN: self.events.append(KeyEvent( evt.key.keysym.sym, KeyEvent.State.down)) elif evt.type == sdl.SDL_KEYUP: self.events.append(KeyEvent( evt.key.keysym.sym, KeyEvent.State.up))
def run(self): """Main loop of the state.""" delta = self.clock.tick() while self.running: delta = self.clock.tick() for event in ext.get_events(): self.handle_event(event) self.update(delta) self.draw()
def run(): # print sdl2ext.get_image_formats() # return sdl2ext.init() window = sdl2ext.Window("The Pong Game", size=(800, 600)) window.show() world = sdl2ext.World() factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE) sp_ball = factory.from_color(WHITE, size=(20, 20)) sp_paddle1 = factory.from_color(WHITE, size=(20, 100)) sp_paddle2 = factory.from_color(WHITE, size=(20, 100)) movement = MovementSystem(0, 0, 800, 600) collision = CollisionSystem(0, 0, 800, 600, 390, 290) aicontroller = TrackingAIController(0, 600) spriterenderer = SoftwareRenderer(window) world.add_system(aicontroller) world.add_system(movement) world.add_system(collision) world.add_system(spriterenderer) player1 = Player(world, sp_paddle1, 0, 250) player2 = Player(world, sp_paddle2, 780, 250, True) ball = Ball(world, sp_ball, 390, 290) ball.velocity.vx = -3 collision.ball = ball aicontroller.ball = ball collision.player1 = player1 collision.player2 = player2 running = True while running: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break if event.type == SDL_KEYDOWN: if event.key.keysym.sym == SDLK_UP: player1.velocity.vy = -3 elif event.key.keysym.sym == SDLK_DOWN: player1.velocity.vy = 3 elif event.type == SDL_KEYUP: if event.key.keysym.sym in (SDLK_UP, SDLK_DOWN): player1.velocity.vy = 0 SDL_Delay(10) world.process() return 0
def start(self): if not self.initialize(): sys.exit(-1) while self.running: events = sdlx.get_events() for event in events: self.process_event(event) self.render() self.cleanup() sys.exit(0)
def run(self): menu_input = Input() last_update_time = SDL_GetTicks() # units.MS while self.running: start_time = SDL_GetTicks() # units.MS menu_input.begin_new_frame() menu_events = get_events() for event in menu_events: if event.type == SDL_KEYDOWN: menu_input.key_down_event(event) elif event.type == SDL_KEYUP: menu_input.key_up_event(event) elif event.type == SDL_QUIT: self.running = False break # Exit if menu_input.was_key_pressed(SDLK_ESCAPE): self.running = False # Move the cursor elif menu_input.was_key_pressed(SDLK_UP): if self.cursor_position != 0: self.cursor_position -= 1 elif menu_input.was_key_pressed(SDLK_DOWN): if self.cursor_position != 4: self.cursor_position += 1 # Select option elif menu_input.was_key_pressed(SDLK_RETURN): self.running = False if self.cursor_position == 0: self.launch_game() current_time = SDL_GetTicks() # units.MS elapsed_time = current_time - last_update_time # units.MS self.update(min(elapsed_time, MAX_FRAME_TIME)) last_update_time = current_time self.renderer.process(self.world, self.sprites) # This loop lasts 1/60th of a second, or 1000/60th ms ms_per_frame = 1000 // FPS # units.MS elapsed_time = SDL_GetTicks() - start_time # units.MS if elapsed_time < ms_per_frame: SDL_Delay(ms_per_frame - elapsed_time)
def gui_trash_parse(self, player): self.reach = False self.kan = False self.state = True self.button_names = [] if not player.reach and \ player.hand.mensen: self.textbox_manager.make_button('reach') self.button_names.append('reach') if 4 in player.hand.contents: self.textbox_manager.make_button('kan') self.button_names.append('kan') self.world.process() while True: events = sdl2ext.get_events() if (player.reach and\ self.hai == player.hand.tsumohai) or \ ((not player.reach)and\ self.number != None): for button_name in self.button_names: self.textbox_manager.del_button(button_name) self.world.process() break for event in events: if event.type == SDL_QUIT: running = False break elif event.type == SDL_MOUSEMOTION: for hai in player.hand.entities: if hai.sprite.y < player.hand_pos[1] - 30: continue elif sprite_mouse_overlap(hai.sprite, event.motion): hai.velocity.vy = -1 else: hai.velocity.vy = 1 elif event.type == SDL_MOUSEBUTTONDOWN: for i, hai in enumerate(player.hand.entities): if sprite_mouse_overlap(hai.sprite, event.button): self.hai = hai.hai self.hai_entity = hai self.number = self.hai.number #TODO:カンとリーチどっちもできてしまう for button_name in self.button_names: if sprite_mouse_overlap(self.textbox_manager.entity_dict[button_name].sprite, event.button): if button_name == 'reach': self.reach = not self.reach elif button_name == 'kan': self.kan = not self.kan SDL_Delay(10) self.world.process()
def test_get_events_issue_6(self): sdl2ext.init() SDL_FlushEvent(SDL_FIRSTEVENT, SDL_LASTEVENT) for x in range(12): event = SDL_Event() event.type = SDL_USEREVENT + x event.user = SDL_UserEvent(type=event.type, timestamp=0, windowID=0, code=0) SDL_PushEvent(event) results = sdl2ext.get_events() for idx, r in enumerate(results): self.assertEqual(idx, r.type - SDL_USEREVENT)
def update(self) -> None: self.events.clear() for event in get_events(): if event.type == SDL_MOUSEBUTTONDOWN: self.events.append((event.button.x, event.button.y)) elif event.type == SDL_QUIT: quit() self.renderer.present() # Presenting renderer self.renderer.clear(color=(0, 0, 0, 255)) # Clearing renderer self.refresh() # Refreshing window
def test_get_events(self): sdl2ext.init() SDL_FlushEvent(SDL_FIRSTEVENT, SDL_LASTEVENT) for x in range(10): event = SDL_Event() event.type = SDL_USEREVENT + 1 event.user = SDL_UserEvent(type=event.type, timestamp=0, windowID=0, code=0) SDL_PushEvent(event) results = sdl2ext.get_events() self.assertEqual(len(results), 10) for ev in results: self.assertEqual(ev.type, (SDL_USEREVENT + 1))
def run(): # You know those from the helloworld.py example. # Initialize the video subsystem, create a window and make it visible. sdl2ext.init() window = sdl2ext.Window("sdlgfx drawing examples", size=(800, 600)) window.show() # Create a rendering context for the window. The sdlgfx module requires it. context = sdl2ext.RenderContext(window) # We implement the functionality as it was done in colorpalettes.py and # utilise a mapping table to look up the function to be executed, together # with the arguments they should receive functions = ((draw_lines, (context, 800, 600)), (draw_circles, (context, 800, 600)), (draw_ellipsis, (context, 800, 600)), (draw_rects, (context, 800, 600)), (draw_trigons, (context, 800, 600)), (draw_polygons, (context, 800, 600)), (draw_mixed, (context, 800, 600)) ) # A storage variable for the function we are currently on, so that we know # which function to execute next. curindex = 0 draw_lines(context, 800, 600) # The event loop is nearly the same as we used in colorpalettes.py. If you # do not know, what happens here, take a look at colorpalettes.py for a # detailed description. running = True while running: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break if event.type == SDL_MOUSEBUTTONDOWN: curindex += 1 if curindex >= len(functions): curindex = 0 # In contrast to colorpalettes.py, our mapping table consists # of functions and their arguments. Thus, we get the currently # requested function and argument tuple and execute the # function with the arguments. func, args = functions[curindex] func(*args) break context.present() sdl2ext.quit() return 0
def run(): sdl2ext.init() sdlttf.TTF_Init(SDL_INIT_EVERYTHING) font = sdlttf.TTF_OpenFont(str.encode("himalaya.ttf"), 300) flags = SDL_WINDOW_SHOWN color = sdlttf.SDL_Color(255, 255, 255, 255) tibstring = 'བསྐྱོངས་' sdlstr = (ctypes.c_uint16 * len(tibstring))(*map(ord, tibstring)) window = SDL_CreateWindow(b'TTF TEST', SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, flags) renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC) # message = sdlttf.TTF_RenderUTF8_Blended(font, # str.encode(tibstring), # color) message = sdlttf.TTF_RenderUNICODE_Blended( font, sdlstr, color) tex = SDL_CreateTextureFromSurface(renderer, message) dst = SDL_Rect(0, 0, 640, 480) SDL_RenderCopy(renderer, tex, None, dst) SDL_ShowWindow(window) running = True while running: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break SDL_RenderPresent(renderer) return 0
def start(self): """ Main application loop """ if sdl.SDL_Init(sdl.SDL_INIT_EVERYTHING) < 0: return False sdl.SDL_GL_SetAttribute(sdl.SDL_GL_DOUBLEBUFFER, 1) self.window = sdl.SDL_CreateWindow(self.cfg.window.title, sdl.SDL_WINDOWPOS_CENTERED, sdl.SDL_WINDOWPOS_CENTERED, self.cfg.window.width, self.cfg.window.height, WND_FLAGS ) if not self.window: return False if not self.initialize(): # Log error instead # sys.stderr.write(msg.viz_gl_init_fail+msg.newline) sys.exit(1) while self.running: frameStart = sdl.SDL_GetTicks() events = sdlx.get_events() for event in events: self.process_event(event) eventsEnd = sdl.SDL_GetTicks() self.frameStats.inputSum += eventsEnd - frameStart # Simulate if self.runSimulation: self.sim.step() simEnd = sdl.SDL_GetTicks() self.frameStats.simulationSum += simEnd - eventsEnd self.renderer.render(self.window, self.userController) renderEnd = sdl.SDL_GetTicks() self.frameStats.renderSum += renderEnd - simEnd # Agents calculations # (a1, a2, ...) agentsEnd = sdl.SDL_GetTicks() self.frameStats.agentSum += agentsEnd - renderEnd # Calculate compensation for the frame rate self.frameStats.count += 1 frameDuration = agentsEnd - frameStart self.frameStats.totalSum += frameDuration delay = int(self.targetFrameDuration - frameDuration) self.frameStats.delaySum += delay if frameDuration < self.targetFrameDuration: sdl.SDL_Delay(delay) self.cleanup() sys.exit(0)
def run(): # You know those from the helloworld.py example. # Initialize the video subsystem, create a window and make it visible. sdl2ext.init() window = sdl2ext.Window("Pixel Access", size=(800, 600)) window.show() # As in colorpalettes.py, explicitly acquire the window's surface to # draw on. windowsurface = window.get_surface() # We implement the functionality as it was done in colorpalettes.py and # utilise a mapping table to look up the function to be executed, together # with the arguments they should receive functions = ( (draw_horizontal_stripes, (windowsurface, 300, 500, 200, 400)), (draw_vertical_stripes, (windowsurface, 300, 500, 200, 400)), ) # A storage variable for the function we are currently on, so that we know # which function to execute next. curindex = 0 draw_horizontal_stripes(windowsurface, 300, 500, 200, 400) # The event loop is nearly the same as we used in colorpalettes.py. If you # do not know, what happens here, take a look at colorpalettes.py for a # detailled description. running = True while running: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break if event.type == SDL_MOUSEBUTTONDOWN: curindex += 1 if curindex >= len(functions): curindex = 0 # In contrast to colorpalettes.py, our mapping table consists # of functions and their arguments. Thus, we get the currently # requested function and argument tuple and execute the # function with the arguments. func, args = functions[curindex] func(*args) break window.refresh() sdl2ext.quit() return 0
def process_frame(joystick, tx, get_ship, args): for event in SDLE.get_events(): if event.type == SDL.SDL_QUIT: exit(0) process_yaw(joystick, tx, get_ship) if args.enable_pitch: process_pitch(joystick, tx, get_ship) if args.enable_warp: process_warp(joystick, tx, get_ship) process_thrust(joystick, tx, get_ship) process_main_screen(joystick, tx, get_ship) process_shields(joystick, tx, get_ship) process_red_alert(joystick, tx, get_ship) process_reverse(joystick, tx, get_ship) process_dock_rq(joystick, tx, get_ship) time.sleep(1 / 15)
def fullfun(self): self.__clear() for _ in fun(self): i = sdl2.SDL_GetTicks() self.build_maze() self.__rendersprite() events = sdl.get_events() for e in events: if e.type == sdl2.SDL_QUIT: return False self.__present() self.__clear() i = sdl2.SDL_GetTicks() - i if i < (1000 // 500): sdl2.SDL_Delay(1000 // 500 - i) return True
def __update_sdl(cls): events = sdl2ext.get_events() for event in events: if event.type == SDL_WINDOWEVENT: for key, window in list(cls.windows.items()): if SDL_GetWindowID( window.sdl_window.window) == event.window.windowID: if event.window.event == SDL_WINDOWEVENT_CLOSE: SDL_HideWindow(window.sdl_window.window) del cls.windows[key] cls.closed_windows.add(key) if event.window.event == SDL_WINDOWEVENT_RESIZED: window._resize(event.window.data1, event.window.data2) window.update(window.last_data) break
def test_get_events_issue_6(self): try: sdl2ext.init() except sdl2ext.SDLError: raise unittest.SkipTest('Video subsystem not supported') SDL_FlushEvent(SDL_FIRSTEVENT, SDL_LASTEVENT) for x in range(12): event = SDL_Event() event.type = SDL_USEREVENT + x event.user = SDL_UserEvent(type=event.type, timestamp=0, windowID=0, code=0) SDL_PushEvent(event) results = sdl2ext.get_events() for idx, r in enumerate(results): self.assertEqual(idx, r.type - SDL_USEREVENT)
def test_get_events(self): try: sdl2ext.init() except sdl2ext.SDLError: raise unittest.SkipTest('Video subsystem not supported') SDL_FlushEvent(SDL_FIRSTEVENT, SDL_LASTEVENT) for x in range(10): event = SDL_Event() event.type = SDL_USEREVENT + 1 event.user = SDL_UserEvent(type=event.type, timestamp=0, windowID=0, code=0) SDL_PushEvent(event) results = sdl2ext.get_events() self.assertEqual(len(results), 10) for ev in results: self.assertEqual(ev.type, (SDL_USEREVENT + 1))
def main(): global state newstate = np.copy(state) width = 600 height = 600 sdl2ext.init() window = sdl2ext.Window('GRIDLEARN', size=(width, height)) window.show() surface = window.get_surface() running = True begin_tick = begin_time = time.monotonic() mousedown = False while running: now = time.monotonic() elapsed = now - begin_time events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break elif event.type == SDL_KEYDOWN: if event.key.keysym.sym == 27: running = False break elif event.key.keysym.sym == 113: state[:] = 0 elif event.type == SDL_MOUSEBUTTONDOWN: mousedown = True elif event.type == SDL_MOUSEBUTTONUP: mousedown = False elif mousedown and event.type == SDL_MOUSEMOTION: print(dir(event.button)) x, y = event.button.x, event.button.y idx = int(x / width * W) idy = int(y / height * H) state[idy, idx] = 1 break if now - begin_tick > 0.1: begin_tick = now newstate = update(state, newstate, weights, 0.1) newstate, state = state, newstate draw(surface, width, height) window.refresh() sdl2ext.quit()
def make_score_board(window = None, yaku_list = ['rinshan', 'pinfu'], fusu = 20, hansu = 2 , tensu = 2000): if window == None: sdl2ext.init() window = sdl2ext.Window("The Pong Game", size=(800, 600)) window.show() img = print_yaku_list(yaku_list) window_surface = window.get_surface() surface = pilSurface(img) sdl2ext.fill(window_surface, sdl2ext.Color(0, 0, 0 )) rect_tes1 = rect.SDL_Rect(0, 0, 320, 500) rect_tes2 = rect.SDL_Rect(25, 0, 800, 600) SDL_BlitSurface(surface,rect_tes1,window_surface,rect_tes2) SDL_UpdateWindowSurface(window.window) rect_tes1 = rect.SDL_Rect(0, 0, 800, 600) rect_tes2 = rect.SDL_Rect(25, 550, 800, 600) img = PIL.Image.new("RGBA", (500, 35)) if hansu >= 0: text_hansu = str(hansu) + '飜 ' if hansu >= 13: text_hansu = '数え役満 ' if hansu >= 100: text_hansu = '役満 ' text = str(fusu) + '符 ' + text_hansu + str(tensu) + '点' draw_text(img, text, 0, 0) surface = pilSurface(img) SDL_BlitSurface(surface, rect_tes1, window_surface, rect_tes2) SDL_UpdateWindowSurface(window.window) while True: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break elif event.type == SDL_MOUSEBUTTONDOWN: return
def run(): sdl2ext.init() window = sdl2ext.Window("Pong Game", size=(1280, 720)) window.show() world = sdl2ext.World() collision = CollisionSystem(0, 0, 1280, 720) movement = MovementSystem(0, 0, 1280, 720) spriterenderer = SoftwareRenderer(window) world.add_system(movement) world.add_system(collision) world.add_system(spriterenderer) factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE) sp_paddle1 = factory.from_color(WHITE, size=(20, 100)) sp_paddle2 = factory.from_color(WHITE, size=(20, 100)) sp_ball = factory.from_color(WHITE, size=(20, 20)) player1 = Player(world, sp_paddle1, 0, 250) player2 = Player(world, sp_paddle2, 1255, 250) ball = Ball(world, sp_ball, 300, 290) collision.ball = ball ball.velocity.vx = -3 running = True while running: events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break if event.type == SDL_KEYDOWN: if event.key.keysym.sym == SDLK_UP: player1.velocity.vy = -3 elif event.key.keysym.sym == SDLK_DOWN: player1.velocity.vy = 3 elif event.type == SDL_KEYUP: if event.key.keysym.sym in (SDLK_UP, SDLK_DOWN): player1.velocity.vy = 0 SDL_Delay(10) world.process() return 0
def run(self): sdl2ext.init() window = sdl2ext.Window("Robot Sandbox", size=(640, 480)) window.show() spriteRender = SoftwareRenderer(window) self.world.add_system(spriteRender) running = True while running: events = sdl2ext.get_events() for event in events: #pdb.set_trace() if event.type == SDL_QUIT: runnig = False break self.world.process() window.refresh() return 0
def draw(window, robot): events = sdl.get_events() for event in events: if event.type == sdl2.SDL_QUIT: running = False break surface = window.get_surface() sdl.fill(surface, sdl.Color(0, 0, 0)) #Drawing the walls sdl.line(surface, sdl.Color(255, 255, 255), (-meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, 0, -meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, WINDOW_SIZE[1], meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, 0, meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, WINDOW_SIZE[1])) draw_robot(surface, robot) window.refresh()
def run(self): """Perform startup procedures and enter the mainloop. """ # Only run if not already running. if not self.running: self.running = True # Execute the init function of the init script if present. if not self.path["init.py"]: self.log.msg("WARNING", "Driftwood", "init.py missing, nothing will happen") else: self.script.call("init.py", "init") # Escape key pauses the engine. self.input.register(self.keycode.SDLK_ESCAPE, self.__handle_pause) # This is the mainloop. while self.running: # Process SDL events. sdlevents = sdl2ext.get_events() for event in sdlevents: if event.type == SDL_QUIT: # Stop running. self.running = False elif event.type == SDL_KEYDOWN: # Pass a keydown to the Input Manager. self.input._key_down(event.key.keysym.sym) elif event.type == SDL_KEYUP: # Pass a keyup to the Input Manager. self.input._key_up(event.key.keysym.sym) elif event.type == SDL_WINDOWEVENT and event.window.event == SDL_WINDOWEVENT_EXPOSED: self.window.refresh() # Process tick callbacks. self.tick.tick() print("Shutting down...") return 0
def run_simulation(name, path, maze, continuous=False): '''run a simulation of sprite going through the maze parameters: name : name of the algorithm to be displayed on window path : the path returned by the algorithm startstate : the starting state of the maze data : the maze matrix (containing 0s and 1s) continuos : True if click is not necessary for next move else False''' startstate, data = maze.startstate, maze.data w, r = initiation(name, data) run = True way = iter(path) w.show() s = Simulation(r, *startstate, data) nextitem = True while True: events = sdl.get_events() for e in events: if e.type == sdl2.SDL_QUIT: run = False break elif e.type == sdl2.SDL_MOUSEBUTTONDOWN or e.type == sdl2.SDL_KEYDOWN: nextitem = True if not run: break if nextitem: try: direction = next(way) except StopIteration: run = False break if direction == "end": nextitem = False elif direction == "start": pass else: run = ACTION[direction](s) if not continuous: nextitem = False w.hide()
def run(): sdl2ext.init() # init window window = sdl2ext.Window("tri", size=(screenwidth, screenheight), flags=SDL_WINDOW_OPENGL | SDL_WINDOW_FULLSCREEN_DESKTOP) window.show() # init renderer and generator worldrenderer = WorldRenderer(window) trigen = TriGenerator() # init world world = TriWorld() world.add_system(worldrenderer) world.add_system(trigen) # hide cursor SDL_ShowCursor(SDL_DISABLE) running = True while running: start = SDL_GetTicks() # main loop party time events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break world.process() # try and do 60fps elapsed = (SDL_GetTicks() - start) / 1000.0 delay = 16.6 - elapsed if delay > 0: SDL_Delay(int(delay)) SDL_ShowCursor(SDL_ENABLE) return 0
def enterPlayerTile(): # Draws the text and handles the mouse click events for letting # the player choose which color they want to be. Returns # [WHITE_TILE, BLACK_TILE] if the player chooses to be White, # [BLACK_TILE, WHITE_TILE] if Black. # Create the text. text_spr = SPRITE_FACTORY.from_text('Do you want to be white or black?', color=TEXTCOLOR, bg_color=TEXTBGCOLOR1) center_sprite(text_spr, WINDOWWIDTH//2, WINDOWHEIGHT//2) white_spr = SPRITE_FACTORY.from_text('White', color=TEXTCOLOR, bg_color=TEXTBGCOLOR1) center_sprite(white_spr, WINDOWWIDTH//2 - 60, WINDOWHEIGHT//2 + 40) black_spr = SPRITE_FACTORY.from_text('Black', color=TEXTCOLOR, bg_color=TEXTBGCOLOR1) center_sprite(black_spr, WINDOWWIDTH//2 + 60, WINDOWHEIGHT//2 + 40) while True: # Keep looping until the player has clicked on a color. for event in ext.get_events(): # event handling loop if event.type == SDL_QUIT: shutdown() elif event.type == SDL_KEYUP: sc = event.key.keysym.scancode if sc == SDL_SCANCODE_ESCAPE: shutdown() elif event.type == SDL_MOUSEBUTTONUP: pt = SDL_Point(event.button.x, event.button.y) print(pt) if rect.SDL_PointInRect(pt, get_spr_rect(white_spr)): return [WHITE_TILE, BLACK_TILE] elif rect.SDL_PointInRect(pt, get_spr_rect(black_spr)): return [BLACK_TILE, WHITE_TILE] # Draw the screen. SPRITE_RENDERER.render([text_spr, white_spr, black_spr]) REN.present() SDL_Delay(1000//FPS)
def main(): sdl2ext.init() TTF_Init() window = sdl2ext.Window("Text display", size=(800, 600)) window.show() renderer = sdl2ext.RenderContext(window) factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer) world = sdl2ext.World() fps = FPSCounter(world, renderer=renderer) spriteRenderer = factory.create_sprite_renderer() fpsController = FPSController() world.add_system(fpsController) world.add_system(spriteRenderer) running = True while running: for event in sdl2ext.get_events(): if event.type == sdlevents.SDL_QUIT: running = False break elif event.type == sdlevents.SDL_USEREVENT: entity = cast(event.user.data1, POINTER(py_object)).contents.value entity.textsprite.text = "FPS: " + str(entity.fps.counter) entity.fps.counter = 0 renderer.clear() world.process() TTF_Quit() sdl2ext.quit() return 0
def runGame(): # Plays a single game of reversi each time this function is called. # Reset the board and game. mainBoard = getNewBoard() resetBoard(mainBoard) showHints = False turn = random.choice(['computer', 'player']) # Draw the starting board and ask the player what color they want. drawBoard(mainBoard) playerTile, computerTile = enterPlayerTile() # Make the sprite and Rect objects for the "New Game" and "Hints" buttons newGame = SPRITE_FACTORY.from_text("New Game", color=TEXTCOLOR, bg_color=TEXTBGCOLOR2) newGame.position = (WINDOWWIDTH - 8 - newGame.size[0], 10) newGameRect = get_spr_rect(newGame) hints = SPRITE_FACTORY.from_text("Hints", color= TEXTCOLOR, bg_color=TEXTBGCOLOR2) hints.position = (WINDOWWIDTH - 8 - hints.size[0], 40) hintsRect = get_spr_rect(hints) while True: # main game loop # Keep looping for player and computer's turns. if turn == 'player': # Player's turn: if getValidMoves(mainBoard, playerTile) == []: # If it's the player's turn but they # can't move, then end the game. break movexy = None while movexy == None: # Keep looping until the player clicks on a valid space. # Determine which board data structure to use for display. if showHints: boardToDraw = getBoardWithValidMoves(mainBoard, playerTile) else: boardToDraw = mainBoard for event in ext.get_events(): if event.type == SDL_QUIT: shutdown() elif event.type == SDL_KEYUP: sc = event.key.keysym.scancode if sc == SDL_SCANCODE_ESCAPE: shutdown() elif event.type == SDL_MOUSEBUTTONUP: # Handle mouse click events mousex, mousey = event.button.x, event.button.y if rect.SDL_PointInRect(SDL_Point(mousex, mousey), newGameRect): # Start a new game return True elif rect.SDL_PointInRect(SDL_Point(mousex, mousey), hintsRect): # Toggle hints mode showHints = not showHints # movexy is set to a two-item tuple XY coordinate, or None value movexy = getSpaceClicked(mousex, mousey) if movexy != None and not isValidMove(mainBoard, playerTile, movexy[0], movexy[1]): movexy = None # Draw the game board. drawBoard(boardToDraw) drawInfo(boardToDraw, playerTile, computerTile, turn) # Draw the "New Game" and "Hints" buttons. SPRITE_RENDERER.render([newGame, hints]) SDL_Delay(1000//FPS) #TODO REN.present() # Make the move and end the turn. makeMove(mainBoard, playerTile, movexy[0], movexy[1], True) if getValidMoves(mainBoard, computerTile) != []: # Only set for the computer's turn if it can make a move. turn = 'computer' else: # Computer's turn: if getValidMoves(mainBoard, computerTile) == []: # If it was set to be the computer's turn but # they can't move, then end the game. break # Draw the board. drawBoard(mainBoard) drawInfo(mainBoard, playerTile, computerTile, turn) # Draw the "New Game" and "Hints" buttons. SPRITE_RENDERER.render([newGame, hints]) # Make it look like the computer is thinking by pausing a bit. pauseUntil = SDL_GetTicks() + random.randint(5, 15) * 100 while SDL_GetTicks() < pauseUntil: REN.present() # Make the move and end the turn. x, y = getComputerMove(mainBoard, computerTile) makeMove(mainBoard, computerTile, x, y, True) if getValidMoves(mainBoard, playerTile) != []: # Only set for the player's turn if they can make a move. turn = 'player' # Display the final score. drawBoard(mainBoard) scores = getScoreOfBoard(mainBoard) # Determine the text of the message to display. if scores[playerTile] > scores[computerTile]: text = 'You beat the computer by %s points! Congratulations!' % \ (scores[playerTile] - scores[computerTile]) elif scores[playerTile] < scores[computerTile]: text = 'You lost. The computer beat you by %s points.' % \ (scores[computerTile] - scores[playerTile]) else: text = 'The game was a tie!' result_spr = SPRITE_FACTORY.from_text(text, color=TEXTCOLOR, bg_color=TEXTBGCOLOR1) center_sprite(result_spr, WINDOWWIDTH//2, WINDOWHEIGHT//2) # Display the "Play again?" text with Yes and No buttons. play_again_spr = SPRITE_FACTORY.from_text('Play again?', color=TEXTCOLOR, bg_color=TEXTBGCOLOR1) center_sprite(play_again_spr, WINDOWWIDTH//2, WINDOWHEIGHT//2 + 50) # Make "Yes" button. yes_spr = SPRITE_FACTORY.from_text('Yes', color=TEXTCOLOR, bg_color=TEXTBGCOLOR1) center_sprite(yespr, WINDOWWIDTH//2 - 60, WINDOWHEIGHT//2 + 90) yes_rect = get_spr_rect(yes_spr) # Make "No" button. no_spr = SPRITE_FACTORY.from_text('No', color=TEXTCOLOR, bg_color=TEXTBGCOLOR1) center_sprite(no_spr, WINDOWWIDTH//2 + 60, WINDOWHEIGHT//2 + 90) no_rect = get_spr_rect(no_spr) while True: # Process events until the user clicks on Yes or No. for event in ext.get_events(): # event handling loop if event.type == SDL_QUIT: shutdown() elif event.type == SDL_KEYUP: sc = event.key.keysym.scancode if sc == SDL_SCANCODE_ESCAPE: shutdown() elif event.type == MOUSEBUTTONUP: pt = SDL_Point(event.button.x, event.button.y) if rect.SDL_PointInRect(pt, yes_rect): return True elif rect.SDL_PointInRect(pt, no_rect): return False SPRITE_RENDERER.render([result_spr, play_again_spr, yes_spr, nospr]) REN.present() SDL_Delay(1000//FPS)
def queueSDLEvents(self): events = sdl2ext.get_events() newEvents = dict() for event in events: self.evtMngr.queueEvent(E_SDL_EVENT, event.type, event)
def runGame(): #setup variables for start of game board = getBlankBoard() lastMoveDownTime = SDL_GetTicks() lastMoveSidewaysTime = lastMoveDownTime lastFallTime = lastMoveDownTime score = 0 level, fallFreq = calculateLevelAndFallFreq(score) fallingPiece = None nextPiece = getNewPiece() keylen = ctypes.c_int() kybd_st = SDL_GetKeyboardState(ctypes.byref(keylen)) while True: starttime = SDL_GetTicks() if fallingPiece == None: fallingPiece = nextPiece nextPiece = getNewPiece() lastFallTime = SDL_GetTicks() if not isValidPos(board, fallingPiece): return for event in ext.get_events(): if event.type == SDL_QUIT: shutdown() elif event.type == SDL_KEYUP: sc = event.key.keysym.scancode if sc == SDL_SCANCODE_ESCAPE: shutdown() elif sc == SDL_SCANCODE_P: #Pausing the game REN.clear(BGCOLOR) sdlmixer.Mix_PauseMusic() showTextScreen("Paused") # pause till keypress sdlmixer.Mix_ResumeMusic() tmp = SDL_GetTicks() #reseting these is necessary though lastFallTime might help them a bit starttime = tmp lastMoveDownTime = tmp lastMoveSidewaysTime = tmp lastFallTime = tmp #rotate elif sc == SDL_SCANCODE_UP or sc == SDL_SCANCODE_W: fallingPiece['rotation'] = (fallingPiece['rotation'] + 1) % len(PIECES[fallingPiece['shape']]) if not isValidPos(board, fallingPiece): fallingPiece['rotation'] = (fallingPiece['rotation'] - 1) % len(PIECES[fallingPiece['shape']]) #rotate other way elif sc == SDL_SCANCODE_Q: fallingPiece['rotation'] = (fallingPiece['rotation'] - 1) % len(PIECES[fallingPiece['shape']]) if not isValidPos(board, fallingPiece): fallingPiece['rotation'] = (fallingPiece['rotation'] + 1) % len(PIECES[fallingPiece['shape']]) # move piece all the way down elif sc == SDL_SCANCODE_SPACE: for i in range(1, BOARDHEIGHT): if not isValidPos(board, fallingPiece, adj_y=i): break fallingPiece['y'] += i-1 if is_moving_left(kybd_st) or is_moving_right(kybd_st) and SDL_GetTicks() - lastMoveSidewaysTime > MOVESIDEWAYSFREQ: if is_moving_left(kybd_st) and isValidPos(board, fallingPiece, adj_x=-1): fallingPiece['x'] -= 1 elif is_moving_right(kybd_st) and isValidPos(board, fallingPiece, adj_x=1): fallingPiece['x'] += 1 lastMoveSidewaysTime = SDL_GetTicks() if is_moving_down(kybd_st) and SDL_GetTicks() - lastMoveDownTime > MOVEDOWNFREQ and isValidPos(board, fallingPiece, adj_y=1): fallingPiece['y'] += 1 lastMoveDownTime = SDL_GetTicks() # let piece fall if it's time to fall if SDL_GetTicks() - lastFallTime > fallFreq: # see if piece has landed if not isValidPos(board, fallingPiece, adj_y=1): print(fallingPiece) addToBoard(board, fallingPiece) score += removeCompleteLines(board) level, fallFreq = calculateLevelAndFallFreq(score) fallingPiece = None else: fallingPiece['y'] += 1 lastFallTime = SDL_GetTicks() #replace all these calls with variable set at top of loop? #draw everything REN.clear(BGCOLOR) #REN.fill((0,0,WINDOWWIDTH,WINDOWHEIGHT), BGCOLOR) #REN.fill((XMARGIN - 3, 0, (BOARDWIDTH * BOXSIZE) + 8, WINDOWHEIGHT), BGCOLOR) drawBoard(board) if fallingPiece: drawPiece(fallingPiece) drawStatus(score, level, nextPiece) REN.present() SDL_Delay(1000//FPS - ((SDL_GetTicks()-starttime)))
with open("figure.json", "r") as ff: figure = json.loads(ff.read()) figure["points"] = np.array(figure["points"]) print(figure["points"]) figure["points"] -= np.mean(figure["points"], axis=0) print(figure["points"]) figure["points"] = np.hstack( (figure["points"], np.ones((figure["points"].shape[0], 1)))) print(figure["points"]) figure["AB"] = np.array(figure["AB"]) sdl2e.init() window = sdl2e.Window("...", size=(WIDTH, HEIGHT)) window.show() draw(window, transform(world, figure["points"]), figure["polygons"]) running = True while running: events = sdl2e.get_events() for event in events: if event.type == sdl2.SDL_QUIT: running = False break if event.type == sdl2.SDL_KEYDOWN: if handle_key(window, event.key.keysym.sym): draw(window, transform(world, figure["points"]), figure["polygons"]) sdl2e.quit()
def runGame(): #setup variables for start of game board = getBlankBoard() lastMoveDownTime = SDL_GetTicks() lastMoveSidewaysTime = lastMoveDownTime lastFallTime = lastMoveDownTime score = 0 level, fallFreq = calculateLevelAndFallFreq(score) fallingPiece = None nextPiece = getNewPiece() keylen = ctypes.c_int() kybd_st = SDL_GetKeyboardState(ctypes.byref(keylen)) while True: starttime = SDL_GetTicks() if fallingPiece == None: fallingPiece = nextPiece nextPiece = getNewPiece() lastFallTime = SDL_GetTicks() if not isValidPos(board, fallingPiece): return for event in ext.get_events(): if event.type == SDL_QUIT: shutdown() elif event.type == SDL_KEYUP: sc = event.key.keysym.scancode if sc == SDL_SCANCODE_ESCAPE: shutdown() elif sc == SDL_SCANCODE_P: #Pausing the game REN.clear(BGCOLOR) sdlmixer.Mix_PauseMusic() showTextScreen("Paused") # pause till keypress sdlmixer.Mix_ResumeMusic() tmp = SDL_GetTicks() #reseting these is necessary though lastFallTime might help them a bit starttime = tmp lastMoveDownTime = tmp lastMoveSidewaysTime = tmp lastFallTime = tmp #rotate elif sc == SDL_SCANCODE_UP or sc == SDL_SCANCODE_W: fallingPiece['rotation'] = ( fallingPiece['rotation'] + 1) % len( PIECES[fallingPiece['shape']]) if not isValidPos(board, fallingPiece): fallingPiece['rotation'] = ( fallingPiece['rotation'] - 1) % len( PIECES[fallingPiece['shape']]) #rotate other way elif sc == SDL_SCANCODE_Q: fallingPiece['rotation'] = ( fallingPiece['rotation'] - 1) % len( PIECES[fallingPiece['shape']]) if not isValidPos(board, fallingPiece): fallingPiece['rotation'] = ( fallingPiece['rotation'] + 1) % len( PIECES[fallingPiece['shape']]) # move piece all the way down elif sc == SDL_SCANCODE_SPACE: for i in range(1, BOARDHEIGHT): if not isValidPos(board, fallingPiece, adj_y=i): break fallingPiece['y'] += i - 1 if is_moving_left(kybd_st) or is_moving_right( kybd_st ) and SDL_GetTicks() - lastMoveSidewaysTime > MOVESIDEWAYSFREQ: if is_moving_left(kybd_st) and isValidPos( board, fallingPiece, adj_x=-1): fallingPiece['x'] -= 1 elif is_moving_right(kybd_st) and isValidPos( board, fallingPiece, adj_x=1): fallingPiece['x'] += 1 lastMoveSidewaysTime = SDL_GetTicks() if is_moving_down(kybd_st) and SDL_GetTicks( ) - lastMoveDownTime > MOVEDOWNFREQ and isValidPos( board, fallingPiece, adj_y=1): fallingPiece['y'] += 1 lastMoveDownTime = SDL_GetTicks() # let piece fall if it's time to fall if SDL_GetTicks() - lastFallTime > fallFreq: # see if piece has landed if not isValidPos(board, fallingPiece, adj_y=1): print(fallingPiece) addToBoard(board, fallingPiece) score += removeCompleteLines(board) level, fallFreq = calculateLevelAndFallFreq(score) fallingPiece = None else: fallingPiece['y'] += 1 lastFallTime = SDL_GetTicks( ) #replace all these calls with variable set at top of loop? #draw everything REN.clear(BGCOLOR) #REN.fill((0,0,WINDOWWIDTH,WINDOWHEIGHT), BGCOLOR) #REN.fill((XMARGIN - 3, 0, (BOARDWIDTH * BOXSIZE) + 8, WINDOWHEIGHT), BGCOLOR) drawBoard(board) if fallingPiece: drawPiece(fallingPiece) drawStatus(score, level, nextPiece) REN.present() SDL_Delay(1000 // FPS - ((SDL_GetTicks() - starttime)))
def game_board(self, board, player_one, player_two, player_types, ai_difficulty=None): from player_data import PlayerData pd=PlayerData() if 'AI' in player_types: from ai import AI ai=AI() if 'AI: Easy' in [player_one,player_two]: ai.difficulty=0 elif 'AI: Medium' in [player_one,player_two]: ai.difficulty=1 elif 'AI: Hard' in [player_one,player_two]: ai.difficulty=2 sdl2ext.init() window = sdl2ext.Window("c4o5x5", size=(320, 420)) window.show() factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE) spriterenderer = factory.create_sprite_render_system(window) moves = 0 running = True updated_p1 = False updated_p2 = False while running: if moves % 2 == 0: this_player = player_one that_player = player_two if player_types[0]=='AI': mode='AI' player_graphic="ai.bmp" else: mode='Human' player_graphic = "player_one.bmp" if moves % 2 == 1: this_player = player_two that_player = player_one if player_types[1]=='AI': mode='AI' player_graphic="ai.bmp" else: mode='Human' player_graphic = "player_two.bmp" for x in range(5): for y in range(5): if board.marks[x][y] is None: spriterenderer.render(factory.from_image(self.RESOURCES.get_path("tile.bmp")),x*64,y*64) if board.marks[x][y] == player_one: spriterenderer.render(factory.from_image(self.RESOURCES.get_path("tile_o.bmp")),x*64,y*64) if board.marks[x][y] == player_two: spriterenderer.render(factory.from_image(self.RESOURCES.get_path("tile_x.bmp")),x*64,y*64) if board.check_winning_positions() != (False,False): winning_player = board.check_winning_positions()[0] if winning_player == player_one: winning_graphic = 'player_one_wins.bmp' if player_one != 'Guest' and not updated_p1: player=pd.load_player(player_one) pd.update_player(player_one,player.wins+1,player.losses) updated_p1 = True if player_two != 'Guest' and not updated_p2: player=pd.load_player(player_two) pd.update_player(player_two,player.wins,player.losses+1) updated_p2=True elif winning_player == player_two: winning_graphic = 'player_two_wins.bmp' if player_one != 'Guest' and not updated_p2: player=pd.load_player(player_two) pd.update_player(player_two,player.wins+1,player.losses) updated_p2=True if player_two != 'Guest' and not updated_p1: player=pd.load_player(player_one) pd.update_player(player_one,player.wins,player.losses+1) updated_p1=True spriterenderer.render(factory.from_image(self.RESOURCES.get_path(winning_graphic)),0,(x+1)*64) events = sdl2ext.get_events() for event in events: if event.type == SDL_MOUSEBUTTONDOWN: running = False SDL_Delay(1000) break elif moves == 25: winning_graphic = "tie_game.bmp" spriterenderer.render(factory.from_image(self.RESOURCES.get_path(winning_graphic)),0,(x+1)*64) events = sdl2ext.get_events() for event in events: if event.type == SDL_MOUSEBUTTONDOWN: running = False break elif mode == 'Human': spriterenderer.render(factory.from_image(self.RESOURCES.get_path(player_graphic)),0,(x+1)*64) events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break elif event.type == SDL_MOUSEBUTTONDOWN: x_pos = int(event.button.x/64) y_pos = int(event.button.y/64) if x_pos <= 4 and y_pos <= 4 and board.marks[x_pos][y_pos] is None: board.marks[x_pos][y_pos]=this_player moves = moves + 1 elif mode=='AI': move = ai.make_move(board,this_player,that_player) moves = moves + 1 board.update_position(move[0],move[1],this_player) for x in range(5): for y in range(5): if board.marks[x][y] is None: spriterenderer.render(factory.from_image(self.RESOURCES.get_path("tile.bmp")),x*64,y*64) if board.marks[x][y] == player_one: spriterenderer.render(factory.from_image(self.RESOURCES.get_path("tile_o.bmp")),x*64,y*64) if board.marks[x][y] == player_two: spriterenderer.render(factory.from_image(self.RESOURCES.get_path("tile_x.bmp")),x*64,y*64) spriterenderer.render(factory.from_image(self.RESOURCES.get_path(player_graphic)),0,(x+1)*64) SDL_Delay(500) events = sdl2ext.get_events() for event in events: if event.type == SDL_QUIT: running = False break else: pass else: raise Exception SDL_Delay(10) sdl2ext.quit()
def run(): # Initialize PySDL2 stuff ext.init() window = ext.Window(title="Esper PySDL2 example", size=RESOLUTION) renderer = ext.Renderer(target=window) window.show() # Initialize Esper world, and create a "player" Entity with a few Components. world = esper.World() player = world.create_entity() world.add_component(player, Velocity(x=0, y=0)) world.add_component(player, Renderable(texture=texture_from_image(renderer, "redsquare.png"), width=64, height=64, posx=100, posy=100)) # Another motionless Entity: enemy = world.create_entity() world.add_component(enemy, Renderable(texture=texture_from_image(renderer, "bluesquare.png"), width=64, height=64, posx=400, posy=250)) # Create some Processor instances, and asign them to be processed. render_processor = RenderProcessor(renderer=renderer) movement_processor = MovementProcessor(minx=0, maxx=RESOLUTION[0], miny=0, maxy=RESOLUTION[1]) world.add_processor(render_processor) world.add_processor(movement_processor) # A simple main loop running = True while running: start_time = SDL_GetTicks() for event in ext.get_events(): if event.type == SDL_QUIT: running = False break if event.type == SDL_KEYDOWN: if event.key.keysym.sym == SDLK_UP: # Here is a way to directly access a specific Entity's Velocity # Component's attribute (y) without making a temporary variable. world.component_for_entity(player, Velocity).y = -3 elif event.key.keysym.sym == SDLK_DOWN: # For clarity, here is an alternate way in which a temporary variable # is created and modified. The previous way above is recommended instead. player_velocity_component = world.component_for_entity(player, Velocity) player_velocity_component.y = 3 elif event.key.keysym.sym == SDLK_LEFT: world.component_for_entity(player, Velocity).x = -3 elif event.key.keysym.sym == SDLK_RIGHT: world.component_for_entity(player, Velocity).x = 3 elif event.key.keysym.sym == SDLK_ESCAPE: running = False break elif event.type == SDL_KEYUP: if event.key.keysym.sym in (SDLK_UP, SDLK_DOWN): world.component_for_entity(player, Velocity).y = 0 if event.key.keysym.sym in (SDLK_LEFT, SDLK_RIGHT): world.component_for_entity(player, Velocity).x = 0 # A single call to world.process() will update all Processors: world.process() # A crude FPS limiter for about 60fps current_time = SDL_GetTicks() sleep_time = int(start_time + 16.667 - current_time) if sleep_time > 0: SDL_Delay(sleep_time)
def run(self): game_input = Input() speed_x, speed_y = 2, 1 player_pos = [-100, -100] # motion_type = self.player_motion_type # facing = self.player_facing self.running = True last_update_time = SDL_GetTicks() # units.MS while self.running: start_time = SDL_GetTicks() # units.MS game_input.begin_new_frame() game_events = get_events() for event in game_events: if event.type == SDL_KEYDOWN: game_input.key_down_event(event) elif event.type == SDL_KEYUP: game_input.key_up_event(event) elif event.type == SDL_QUIT: self.running = False break if not self.running: self.clear() break # Exit if game_input.was_key_pressed(SDLK_ESCAPE): self.clear() self.running = False break # Player movement if game_input.is_key_held(SDLK_RIGHT) and game_input.is_key_held( SDLK_UP): player_pos[0] -= speed_x player_pos[1] += speed_y self.player.velocity.vx = speed_x self.player.velocity.vy = -speed_y self.player.facing.set("right_up") self.player.motiontype.set("walking") elif game_input.is_key_held(SDLK_RIGHT) and game_input.is_key_held( SDLK_DOWN): player_pos[0] -= speed_x player_pos[1] -= speed_y self.player.velocity.vx = speed_x self.player.velocity.vy = speed_y self.player.facing.set("right_down") self.player.motiontype.set("walking") elif game_input.is_key_held(SDLK_LEFT) and game_input.is_key_held( SDLK_UP): player_pos[0] += speed_x player_pos[1] += speed_y self.player.velocity.vx = -speed_x self.player.velocity.vy = -speed_y self.player.facing.set("left_up") self.player.motiontype.set("walking") elif game_input.is_key_held(SDLK_LEFT) and game_input.is_key_held( SDLK_DOWN): player_pos[0] += speed_x player_pos[1] -= speed_y self.player.velocity.vx = -speed_x self.player.velocity.vy = speed_y self.player.facing.set("left_down") self.player.motiontype.set("walking") elif game_input.is_key_held(SDLK_LEFT): player_pos[0] += speed_x self.player.velocity.vx = -speed_x self.player.facing.set("left") self.player.motiontype.set("walking") elif game_input.is_key_held(SDLK_RIGHT): player_pos[0] -= speed_x self.player.velocity.vx = speed_x self.player.facing.set("right") self.player.motiontype.set("walking") elif game_input.is_key_held(SDLK_UP): player_pos[1] += speed_y self.player.velocity.vy = -speed_y self.player.facing.set("up") self.player.motiontype.set("walking") elif game_input.is_key_held(SDLK_DOWN): player_pos[1] -= speed_y self.player.velocity.vy = speed_y self.player.facing.set("down") self.player.motiontype.set("walking") # elif game_input.was_key_pressed(SDLK_i): # self.player.toggle_inventory() # Player Attack elif game_input.is_key_held(SDLK_SPACE): pass # motion_type = MotionType.CASTING # Nothing else: self.player.velocity.vx = 0 self.player.velocity.vy = 0 self.player.motiontype.set("standing") current_time = SDL_GetTicks() # units.MS elapsed_time = current_time - last_update_time # units.MS last_update_time = current_time self.world.process() # This loop lasts 1/60th of a second, or 1000/60th ms ms_per_frame = 1000 // FPS # units.MS elapsed_time = SDL_GetTicks() - start_time # units.MS if elapsed_time < ms_per_frame: SDL_Delay(ms_per_frame - elapsed_time)