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
