def tick(self, framerate=0):
"""Update the Clock.
This method should be called once per frame. It will compute how many
milliseconds have passed since the previous call.
If you pass the optional framerate argument the function will delay
to keep the game running slower than the given ticks per second. This
can be used to help limit the runtime speed of a game. By calling
clock.tick(40) once per frame, the program will never run at more
than 40 frames per second.
Usage:
tick(framerate=0)
Returns:
float (milliseconds)
"""
now = SDL_GetTicks()
self.raw_frametime = now - self.last
while len(self.last_frames) > 9:
self.last_frames.pop(0)
if framerate == 0:
self.last = now
self.last_frames.append(self.raw_frametime)
return self.raw_frametime
frame_duration = 1.0 / framerate * 1000
if self.raw_frametime < frame_duration:
wait(frame_duration - self.raw_frametime)
now = SDL_GetTicks()
self.frametime = now - self.last
self.last = now
self.last_frames.append(self.frametime)
return self.frametime
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 update(self):
if self.activated:
self.current_ticks = SDL_GetTicks()
self.current_ticks -= self.start_ticks
if self.current_ticks - self.previous_ticks >= self.interval:
self.previous_ticks = self.current_ticks
self.enabled = True
def handle_new_input(e: SDL_Event, axis_norm_value: int = 0) -> bool:
"""
Event handling for button press/hat movement/axis movement
Only needed when an new input is present
Returns True when 'event_queue' is modified with a new event
"""
dev_index = active_devices[event.jdevice.which][0]
if e.type == SDL_JOYBUTTONDOWN:
mapped_events = configs[dev_index].get_btn_event(
event.jbutton.button)
event_index = f'{dev_index}_btn{event.jbutton.button}'
elif e.type == SDL_JOYHATMOTION:
mapped_events = configs[dev_index].get_hat_event(
event.jhat.hat, event.jhat.value)
event_index = f'{dev_index}_hat{event.jhat.hat}'
elif e.type == SDL_JOYAXISMOTION and axis_norm_value != 0:
mapped_events = configs[dev_index].get_axis_event(
event.jaxis.axis, axis_norm_value)
event_index = f'{dev_index}_axis{event.jaxis.axis}'
if mapped_events is not None:
event_queue[event_index] = [mapped_events, 0, SDL_GetTicks()]
return True
return False
def wait(milliseconds):
"""Pause the program for an amount of time.
Will pause for a given number of milliseconds. This function sleeps the
process to share the processor with other programs. A program that waits
for even a few milliseconds will consume very little processor time.
Usage:
wait(milliseconds)
Returns:
int (the actual number of milliseconds used)
"""
start = SDL_GetTicks()
SDL_Delay(int(milliseconds))
return SDL_GetTicks() - start
def tick(self, framerate=0):
"""..."""
now = SDL_GetTicks()
self.raw_frametime = now - self.last
while len(self.last_frames) > 9:
self.last_frames.pop(0)
if framerate == 0:
self.last = now
self.last_frames.append(self.raw_frametime)
return self.raw_frametime
frame_duration = 1.0 / framerate * 1000
if self.raw_frametime < frame_duration:
delay(frame_duration - self.raw_frametime)
now = SDL_GetTicks()
self.frametime = now - self.last
self.last = now
self.last_frames.append(self.frametime)
return self.frametime
def now(self, unit=TK_MS): """Fetches the current time according to the tracker's internal clock. In TryLink simulation mode, this returns the time since the experiment was first launched. Args: unit (int, optional): The units in which the time should be returned. Can be either ``TK_S`` (seconds) or ``TK_MS`` (milliseconds). Defaults to milliseconds. Returns: float: The current tracker time in the specified time unit. """ time = float(SDL_GetTicks()) return time * 0.001 if unit == TK_S else time
def filter_active_events(event_queue: dict) -> list:
"""
Method to filter out the event if the event:
* fired once within the JS_POLL_DELAY_DEBOUNCE
* fired multiple times, last fire within JS_POLL_POLL_DELAY_DEFAULT
"""
current_time = SDL_GetTicks()
filtered_events = []
for e in event_queue:
if event_queue[e][0] is None:
continue
last_fire_time = event_queue[e][2]
repeat_count = event_queue[e][1]
if repeat_count == 0 or \
(repeat_count == 1 and current_time > (last_fire_time + JS_INIT_DELAY)) or \
(repeat_count > 1 and current_time > (last_fire_time + JS_REPEAT_DELAY)):
filtered_events.extend(event_queue[e][0])
event_queue[e][2] = current_time
event_queue[e][1] += 1
# remove any duplicate events from the list
return list(set(filtered_events))
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)
def __init__(self):
"""..."""
self.last = SDL_GetTicks()
self.last_frames = []
self.frametime = 0
self.raw_frametime = 0
def get_delta(t0):
"""..."""
return SDL_GetTicks() - t0
def get_time():
"""..."""
return SDL_GetTicks()
def wait(milliseconds):
"""..."""
start = SDL_GetTicks()
SDL_Delay(int(milliseconds))
return SDL_GetTicks() - start
def activate(self):
self.start_ticks = SDL_GetTicks()
self.activated = True
def activate(self):
""" Activates the timer """
self.start_ticks = SDL_GetTicks()
self.activated = True
def __init__(self):
"""Initialization."""
self.last = SDL_GetTicks()
self.last_frames = []
self.frametime = 0
self.raw_frametime = 0
def get_time():
"""Get the current time from SDL clock."""
return SDL_GetTicks()
def run(self):
game_input = Input()
speed_x, speed_y = 2, 1
player_pos = [0, 0]
motion_type = self.player.motion_type
facing = self.player.facing
running = True
last_update_time = SDL_GetTicks() # units.MS
while 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:
running = False
break
# Exit
if game_input.was_key_pressed(SDLK_ESCAPE):
running = False
# 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
motion_type = MotionType.WALKING
facing = Facing.RIGHT_UP
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
motion_type = MotionType.WALKING
facing = Facing.RIGHT_DOWN
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
motion_type = MotionType.WALKING
facing = Facing.LEFT_UP
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
motion_type = MotionType.WALKING
facing = Facing.LEFT_DOWN
elif game_input.is_key_held(SDLK_LEFT):
player_pos[0] += speed_x
motion_type = MotionType.WALKING
facing = Facing.LEFT
elif game_input.is_key_held(SDLK_RIGHT):
player_pos[0] -= speed_x
motion_type = MotionType.WALKING
facing = Facing.RIGHT
elif game_input.is_key_held(SDLK_UP):
player_pos[1] += speed_y
motion_type = MotionType.WALKING
facing = Facing.UP
elif game_input.is_key_held(SDLK_DOWN):
player_pos[1] -= speed_y
motion_type = MotionType.WALKING
facing = Facing.DOWN
elif game_input.was_key_pressed(SDLK_i):
self.player.toggle_inventory()
# Player Attack
elif game_input.is_key_held(SDLK_SPACE):
motion_type = MotionType.CASTING
# Nothing
else:
motion_type = MotionType.STANDING
current_time = SDL_GetTicks() # units.MS
elapsed_time = current_time - last_update_time # units.MS
self.update(player_pos, motion_type, facing,
min(elapsed_time, MAX_FRAME_TIME))
last_update_time = current_time
self.get_sprites()
self.renderer.process(self.world, self.sprites)
self.sprites.clear()
# 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)