def run(): boxes = [Box(sdl2.SDL_Rect(0, int(1080 * 0.8 / 2) - 50, 100, 100))] last_tick = sdl2.SDL_GetTicks() while App.running: for box in boxes: box.update() for window in App.windows: renderer = window["renderer"] sdl2.SDL_SetRenderDrawColor(renderer, 30, 30, 30, 255) sdl2.SDL_RenderClear(renderer) for box in boxes: box.render() for window in App.windows: renderer = window["renderer"] sdl2.SDL_RenderPresent(renderer) Events.handle_events() current_tick = sdl2.SDL_GetTicks() last_tick = last_tick + App.FRAME_DURATION delay = last_tick - current_tick sdl2.SDL_Delay(int(max(0, delay)))
def loop(window, renderer, inputfoo, renderfoo, choke_ms = 100): while True: loopstart = sdl2.SDL_GetTicks() while True: event = sdl2.SDL_Event() rv = sdl2.SDL_PollEvent(ctypes.byref(event)) if rv == 0: break elif event.type == sdl2.SDL_QUIT: return elif event.type == sdl2.SDL_KEYUP: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: if inputfoo(): return elif event.type == sdl2.SDL_WINDOWEVENT: if event.window.event == sdl2.SDL_WINDOWEVENT_RESIZED: sz = Size2(event.window.data1, event.window.data2) sdl2.SDL_GetWindowSize(window, ctypes.byref(w_w), ctypes.byref(w_h)) elif sdl2.SDL_WINDOWEVENT_CLOSE: inputfoo() else: continue print(event.window.event) elif event.type == sdl2.SDL_MOUSEBUTTONDOWN: inputfoo() elapsed = sdl2.SDL_GetTicks() - loopstart if choke_ms > elapsed: sdl2.SDL_Delay(choke_ms - elapsed) renderfoo(window, renderer)
def update(self) -> None: sequence = self.sequences[self.current_animation_playing] frame_interval = 1000.0 / sequence.sample_rate if (sdl2.SDL_GetTicks() - self.last_frame_change) >= frame_interval: self.finished = sequence.next_frame() self.last_frame_change = sdl2.SDL_GetTicks()
def random_movement(self): # Shopper is already doing a random movement if self.pacing or self.pausing: return # Only decide every random movement interval if Shopper.random_movement_interval > sdl2.SDL_GetTicks()\ - self.random_movement_start: return # Randomly generate probability # Do not pause if picking up item from shelf or if at entrance/exit random_int = random.randrange(0, 100) if random_int < Shopper.pausing_probability and not self.at_item\ and not self.at_entrance and not self.at_exit: self.pausing = True self.random_movement_start = sdl2.SDL_GetTicks() # Randomly generate pausing time self.pausing_time = random.randrange(Shopper.max_pausing_time / 4, Shopper.max_pausing_time) # Only pace if the shopper is at an aislse or in the center elif random_int < Shopper.pacing_probability\ and (self.at_aisle or self.at_center): self.pacing = True self.random_movement_start = sdl2.SDL_GetTicks() # Randomly generate pacing distance self.pacing_distance = random.randrange( 0, Shopper.max_pacing_distance) self.reverse_velocity()
def pause(self): if self.pausing_time < sdl2.SDL_GetTicks()\ - self.random_movement_start: self.pausing = False else: self.x_velocity = 0 self.y_velocity = 0 self.look_to_side() self.last_moved = sdl2.SDL_GetTicks()
def update(self) -> None: pos = self.container.position keys = sdl(sdl2.SDL_GetKeyboardState(None)) if keys[sdl2.SDL_SCANCODE_SPACE] == 1: if (sdl2.SDL_GetTicks() - self.last_shot) >= self.cooldown: # Player has two turrets self.shoot(pos.x + 25, pos.y - 20) self.shoot(pos.x - 25, pos.y - 20) self.last_shot = sdl2.SDL_GetTicks()
def generate_shoppers(self, entities, textures, store): if store.time_before_next_npc_generation < sdl2.SDL_GetTicks()\ - store.last_npc_generated: entities.add_character(CharacterType.SHOPPER, store.entrance_x, store.entrance_y - Civilian.default_height, 'Shopper', textures) # Determine next time to generate shopper, within bounds store.time_before_next_npc_generation = random.randrange( 3000, 18000) # ms store.last_npc_generated = sdl2.SDL_GetTicks()
def handle_collision(self, player): # Set player's most recent shopping cart player.shopping_cart = self # If player is not running, do not push cart if not player.running: Item.handle_collision(self, player) return # Time since last move: ms time_elapsed = sdl2.SDL_GetTicks() - self.last_moved # Reset time elapsed if the player has not touched the # shopping cart recently if time_elapsed > 250: time_elapsed = 0 not_touched_recently = True else: not_touched_recently = False # Calculate shopping cart angle based on the player's velocity # Align with player's location if the player player has not # touched the cart recently if player.x_velocity > 0 and player.y_velocity == 0: # going right self.angle = 0.0 if not_touched_recently: self.x = player.x + player.width self.y = player.y elif player.x_velocity < 0 and player.y_velocity == 0: # going left self.angle = 180.0 if not_touched_recently: self.x = player.x - self.width self.y = player.y elif player.y_velocity > 0 and player.x_velocity == 0: # going down self.angle = 90.0 if not_touched_recently: self.x = player.x self.y = player.y + player.height elif player.y_velocity < 0 and player.x_velocity == 0: # going up self.angle = 270.0 if not_touched_recently: self.x = player.x self.y = player.y - self.height # Similar to MovableEntity.update_position() self.x += player.x_velocity * time_elapsed / 1000.0 self.y += player.y_velocity * time_elapsed / 1000.0 self.last_moved = sdl2.SDL_GetTicks()
def handle_interaction(self, player, messages): if not self.check_action_interval(): return self.last_interaction = sdl2.SDL_GetTicks() if sdl2.SDL_GetTicks() - self.last_pet > Pet.pet_interval: player.morale += Pet.petting_morale_boost self.last_pet = sdl2.SDL_GetTicks() messages.append('Morale increased from petting '\ + self.name.lower()) # Pet ability needs to cooldown else: messages.append('Already performed this action recently') return
def update_position(self): time_elapsed = sdl2.SDL_GetTicks() - self.last_moved self.x += self.x_velocity * time_elapsed / 1000.0 self.y += self.y_velocity * time_elapsed / 1000.0 # Update pacing self.pacing_distance -= abs(self.x_velocity * time_elapsed / 1000.0) self.pacing_distance -= abs(self.y_velocity * time_elapsed / 1000.0) if self.movement_blocked: self.x -= self.x_velocity * time_elapsed / 1000.0 self.y -= self.y_velocity * time_elapsed / 1000.0 self.movement_blocked = False self.last_moved = sdl2.SDL_GetTicks()
def init(self, hide_window): self._ticks = sdl2.SDL_GetTicks() # Should be less... https://wiki.libsdl.org/SDL_Init sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) self._window = sdl2.SDL_CreateWindow(b"PyBoy", sdl2.SDL_WINDOWPOS_CENTERED, sdl2.SDL_WINDOWPOS_CENTERED, self._scaledresolution[0], self._scaledresolution[1], sdl2.SDL_WINDOW_RESIZABLE) self._sdlrenderer = sdl2.SDL_CreateRenderer( self._window, -1, sdl2.SDL_RENDERER_ACCELERATED) self._sdltexturebuffer = sdl2.SDL_CreateTexture( self._sdlrenderer, sdl2.SDL_PIXELFORMAT_RGBA32, sdl2.SDL_TEXTUREACCESS_STATIC, COLS, ROWS) self.blank_screen() if hide_window: sdl2.SDL_HideWindow(self._window) else: sdl2.SDL_ShowWindow(self._window)
def onLoop(self): # get elapsed time t = sdl2.SDL_GetTicks() self.deltaTime = t - self.frames[-1] if not self.paused: # update time of particle system self.system.update(self.deltaTime * 0.001) # normalize 1.0 as 1[sec] # rendering self.onRender() # time logging self.frames.append(t) while self.frames[-1] - self.frames[0] > 1000 and len(self.frames) > 2: self.frames.pop(0) # update text self.nbParticles = "NB PARTICLES : " + str( self.system.getNbParticles()) fps = ((len(self.frames) - 1) * 1000.0) // (self.frames[-1] - self.frames[0]) self.fps = "FPS : " + str(fps) if notext and t - self.lasttime >= 1000: # output informations to console print(self.fps, ',', self.nbParticles, ',', self.strSmoke) self.lasttime = t
def remove_expired_messages(self): for message in self.messages: if MessageStack.message_duration < sdl2.SDL_GetTicks()\ - message.time: self.messages.remove(message) # Only removes one message each frame return
def _on_axes_throttle_delay_expired_event(self, event): if sdl2.SDL_GetTicks() < self._next_axes_tick: if self.warnings_enabled: print('Axes throttling delay expiration event pre-empted.', file=sys.stderr) return self._on_axes_motion()
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 handle_interaction(self, player, messages, game_time=0): if not self.check_action_interval(): return self.last_interaction = sdl2.SDL_GetTicks() # Allow the player to checkout just one item if they are holding it if player.shopping_cart == None or player.shopping_cart.items.size == 0: if player.item_being_carried == None: messages.append(SelfCheckout.unsuccessful_message_no_items) return else: player.item_being_carried.purchase_single_item( player, messages) return # Player checking out shopping cart total_cost = player.shopping_cart.total_cost if player.money < total_cost: messages.append(SelfCheckout.unsuccessful_message_money) return if player.backpack.size + player.shopping_cart.items.size\ > player.backpack.capacity: messages.append(SelfCheckout.unsuccessful_message_space) return # Transfer shopping cart items to player's backpack player.money -= total_cost player.shopping_cart.items.transfer(player.backpack) player.shopping_cart.total_cost = 0 messages.append('Checked out cart: -$' + str(int(total_cost))) messages.append('Backpack contents: ' + str(player.backpack))
def onLoop(self): # get elapsed time t = sdl2.SDL_GetTicks() self.deltaTime = t - self.frames[-1] if not self.paused: # create new particle system with SPACE key if self.spacePressed >= 0.0: self.spacePressed += self.deltaTime if self.spacePressed >= 1000.0: position = spk.Vector3D(spk.random(-2.0, 2.0), spk.random(-2.0, 2.0), spk.random(-2.0, 2.0)) self.explosions.append(self.explosion.clone(position)) self.spacePressed = 0.0 # calclate camera position and distances with each explosion # so draw in the order: far -> near cosX = math.cos(self.angleX * math.pi / 180.0) sinX = math.sin(self.angleX * math.pi / 180.0) cosY = math.cos(self.angleY * math.pi / 180.0) sinY = math.sin(self.angleY * math.pi / 180.0) cz = self.camPosZ campos = spk.Vector3D(-cosX * sinY * cz, sinX * cz, cosX * cosY * cz) def compareDist(explosion): return -spk.getSqrDist(explosion.system.getWorldTransformPos(), campos) self.explosions.sort(key=compareDist) explosions = [] for explosion in self.explosions: # update time of particle system alive = explosion.system.update(self.deltaTime * 0.001) if alive: explosions.append(explosion) else: pass # remove dead systems from self.systems self.explosions = explosions # rendering self.onRender() # time logging self.frames.append(t) while self.frames[-1] - self.frames[0] > 1000 and len(self.frames) > 2: self.frames.pop(0) # update text nbParticles = sum([s.system.getNbParticles() for s in self.explosions]) self.nbParticles = "NB PARTICLES : " + str(nbParticles) fps = ((len(self.frames) - 1) * 1000.0) // (self.frames[-1] - self.frames[0]) self.fps = "FPS : " + str(fps) if notext and t - self.lasttime >= 1000: # output informations to console print(self.fps, ',', self.nbParticles) self.lasttime = t
def run(self): run, update_img, update_view, update_frame = self.poll_events() if (run and self.playing and sdl2.SDL_GetTicks() - self.last_update > 1000 / self.fps): self.update_filtered_image() self.last_update = sdl2.SDL_GetTicks() self.update_screen() else: if update_img: self.update_filtered_image(update_frame_count=update_frame) if update_view: self.update_screen() delay = 10 sdl2.SDL_Delay(delay) return run
def update(self): time = sdl2.SDL_GetTicks() / 1000 if not self._paused: self.frametime = time - self._prev_time self.time += self.frametime self._prev_time = time
def __init__(self, width, height): self.width = width self.height = height # init SDL sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_DOUBLEBUFFER, 1) self.window = sdl2.SDL_CreateWindow( b"SPARK(&pyspk) Fireworks Demo", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, width, height, sdl2.SDL_WINDOW_SHOWN | sdl2.SDL_WINDOW_OPENGL) sdl2.SDL_CaptureMouse(True) # init OpenGL self.context = sdl2.SDL_GL_CreateContext(self.window) sdl2.SDL_GL_SetSwapInterval(0) gl.glClearColor(0.0, 0.0, 0.0, 1.0) surface = sdl2.SDL_GetWindowSurface(self.window) gl.glViewport(0, 0, surface.contents.w, surface.contents.h) # load Textures texture = loadTexture(b'res/flare.bmp', gl.GL_ALPHA, gl.GL_REPEAT) # init FTGL if not notext: font = FTGL.TextureFont('res/font.ttf') font.FaceSize(24) self.font = font # init SPARK(pyspk) # random seed initialization spk.setRandomSeed(int(time.time())) # step configuration spk.System.setClampStep(True, 0.1) # clamp the step to 100 ms spk.System.useAdaptiveStep(0.001, 0.01) # use an adaptive step from 1ms to 10ms (1000fps to 100fps) # the base system self.basesystem = BaseSystem(self.height, texture) print('SPARK FACTORY AFTER INIT :') spk.Factory.getInstance().traceAll() # init Variables self.running = True self.paused = False self.deltaTime = 0 self.step = 0 self.text = 2 self.renderValue = 0 self.angleY = 0.0 self.camPosZ = 5.0 self.spacePressed = -1.0 self.systems = [] self.nbParticles = '' self.fps = '' self.frames = [sdl2.SDL_GetTicks()-1] self.lasttime = self.frames[-1]
def main(): global rend if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: print(sdl2.SDL_GetError()) return 0 x, y = 0, 0 # window = sdl2.ext.Window("ekkek", 600,600, sdl2.SDL_WINDOW_OPENGL) window = sdl2.SDL_CreateWindow(TITLE, sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, 600, 600, sdl2.SDL_WINDOW_OPENGL) context = sdl2.SDL_GL_CreateContext(window) rend = Renderer() time = sdl2.SDL_GetTicks() prev_time = sdl2.SDL_GetTicks() frame_time = 0 e = ioproc(sdl2.SDL_Event()) dt = 1000. / 60. #while sdl2.SDL_WaitEvent(ctypes.byref(sdl2.SDL_QUIT)): while e.checkEvents(): # time = sdl2.SDL_GetTicks() # frame_time = time - prev_time # prev_time = time # while sdl2.SDL_PollEvent(ctypes.byref(e)) !=0: # if(e.type == sdl2.SDL_QUIT): # running = False time += dt frame_time = time - sdl2.SDL_GetTicks() if (frame_time <= 0): frame_time = 1 tms.sleep(frame_time / 1000.) # update shit here # ... rend.doShit() rend.draw() sdl2.SDL_GL_SwapWindow(window) # rend.unload() #Unload assimp imports sdl2.SDL_GL_DeleteContext(context) sdl2.SDL_Quit()
def __init__(self, container: "entities.Entity", sequences: Dict[str, Sequence], default_sequence: str): self.container = container self.sequences = sequences self.last_frame_change = sdl2.SDL_GetTicks() self.finished = False # Key used to index into self.sequences dictionary self.current_animation_playing = default_sequence
def handle_interaction(self, player, messages, game_time=0): if not self.check_action_interval(): return self.last_interaction = sdl2.SDL_GetTicks() if player.use_supply(SupplyType.SOAP, 1): messages.append(Sink.successful_message) else: messages.append(Sink.unsuccessful_message)
def process_inputs(self): io = imgui.get_io() s_w = ctypes.pointer(ctypes.c_int(0)) s_h = ctypes.pointer(ctypes.c_int(0)) sdl2.SDL_GetWindowSize(self.window, s_w, s_h) w = s_w.contents.value h = s_h.contents.value f_w = ctypes.pointer(ctypes.c_int(0)) f_h = ctypes.pointer(ctypes.c_int(0)) sdl2.SDL_GL_GetDrawableSize(self.window, f_w, f_h) f_w = f_w.contents.value f_h = f_h.contents.value io.display_size = w, h io.display_fb_scale = compute_fb_scale((w, h), (f_w, f_h)) current_time = sdl2.SDL_GetTicks() / 1000.0 if self._gui_time: # print("1") self.io.delta_time = current_time - self._gui_time else: # print("2") self.io.delta_time = 1. / 60. if self.io.delta_time == 0.0: self.io.delta_time = 1. / 60. # print("") # print(f"{self.io.delta_time:.32f}") # print(f"{current_time:.32f}") # if self._gui_time: # print(f"{self._gui_time:.32f}") self._gui_time = current_time mx = ctypes.pointer(ctypes.c_int(0)) my = ctypes.pointer(ctypes.c_int(0)) mouse_mask = sdl2.SDL_GetMouseState(mx, my) if sdl2.SDL_GetWindowFlags(self.window) & sdl2.SDL_WINDOW_MOUSE_FOCUS: io.mouse_pos = mx.contents.value, my.contents.value else: io.mouse_pos = -1, -1 io.mouse_down[0] = self._mouse_pressed[0] or ( mouse_mask & sdl2.SDL_BUTTON(sdl2.SDL_BUTTON_LEFT)) != 0 io.mouse_down[1] = self._mouse_pressed[1] or ( mouse_mask & sdl2.SDL_BUTTON(sdl2.SDL_BUTTON_RIGHT)) != 0 io.mouse_down[2] = self._mouse_pressed[2] or ( mouse_mask & sdl2.SDL_BUTTON(sdl2.SDL_BUTTON_MIDDLE)) != 0 self._mouse_pressed = [False, False, False] io.mouse_wheel = self._mouse_wheel self._mouse_wheel = 0
def onLoop(self): # get elapsed time t = sdl2.SDL_GetTicks() self.deltaTime = t - self.frames[-1] if not self.paused: # update emitters angle = self.totalTime * 2.0 * math.pi / 15000.0 sinA = math.sin(angle) cosA = math.cos(angle) sinB = math.sin(angle * 10.0) for i in range(5): self.emitters[i].setForce(1.8 + 1.8 * sinB, 2.1 + 2.1 * sinB) if self.highGraphics: self.emitters[i].setFlow((self.flow[i] * 0.5) + (self.flow[i] * 0.5) * sinB) else: self.emitters[i].setFlow((self.flowLow[i] * 0.5) + (self.flowLow[i] * 0.5) * sinB) self.emitters[1].setDirection( spk.Vector3D(cosA - sinA, 3.0, sinA + cosA)) self.emitters[2].setDirection( spk.Vector3D(-cosA + sinA, 3.0, -sinA - cosA)) self.emitters[3].setDirection( spk.Vector3D(-cosA - sinA, 3.0, -sinA + cosA)) self.emitters[4].setDirection( spk.Vector3D(cosA + sinA, 3.0, sinA - cosA)) # update time of particle system self.system.update(self.deltaTime * 0.001) # normalize 1.0 as 1[sec] self.totalTime += self.deltaTime # rendering self.onRender() # time logging self.frames.append(t) while self.frames[-1] - self.frames[0] > 1000 and len(self.frames) > 2: self.frames.pop(0) # update text self.nbParticles = "NB PARTICLES : " + str( self.system.getNbParticles()) fps = ((len(self.frames) - 1) * 1000.0) // (self.frames[-1] - self.frames[0]) self.fps = "FPS : " + str(fps) if notext and t - self.lasttime >= 1000: # output informations to console print(self.fps, ',', self.nbParticles, ',', self.getGraphicsString()) self.lasttime = t
def handle_interaction(self, player, messages, game_time=0): if not self.check_action_interval(): return self.last_interaction = sdl2.SDL_GetTicks() if game_time > Computer.start_time: player.working = True messages.append(Computer.successful_message) else: messages.append(Computer.unsuccessful_message_time)
def handle_interaction(self, player, messages, game_time=0): if not self.check_action_interval(): return self.last_interaction = sdl2.SDL_GetTicks() if player.use_supply(SupplyType.FOOD, 1): player.morale += Kitchen.eating_morale_boost player.consumption.additional_meals_eaten += 1 messages.append(Kitchen.successful_message) else: messages.append(Kitchen.unsuccessful_message)
def handle_backspace(self): """...""" ticks = sdl2.SDL_GetTicks() if ticks - self.delete_timer > self.delete_speed: self.delete_timer = ticks try: self.buffer.pop() except IndexError: pass else: self.create_text()
def handle_interaction(self, player, messages, game_time=0): if not self.check_action_interval(): return if self.being_carried: player.item_being_carried = None self.being_carried = False else: player.item_being_carried = self self.being_carried = True self.last_interaction = sdl2.SDL_GetTicks()
def __init__(self, x, y, width, height, texture, type, name, interaction_message, speed): MovableEntity.__init__(self, x, y, width, height, texture, speed) self.type = type self.name = name self.interaction_message = interaction_message # Last time the player interacted with the character: ms self.last_interaction = sdl2.SDL_GetTicks() # If true, the controller will remove this entity from the game self.removed = False