Пример #1
0
def update(dt):
    global time_left, gameover
    time_left -= dt
    time_display.text = "%d seconds remaining" % (time_left)

    if not gameover and time_left <= 0:
        gameover_display.text = "Gameover, press ENTER to restart"
        gameover = True
        #return
    elif not gameover and player.getBody().getPosition()[0] > 3600:
        gameover_display.text = "You won! Press ENTER to play again"
        gameover = True

    player.update()
 
    # Position everything but try to keep player in the middle of the screen
    player_pos = player.body.getPosition()[0:2]
    player_offset = (window.width / 2 - player_pos[0],
                     window.height / 2 - player_pos[1])
    window_offset = [0, 0]
    if player_offset[0] > 0:
        window_offset[0] = player_offset[0]
    elif player_offset[0] < -(background.image.width - window.width):
        window_offset[0] = (background.image.width - window.width +
                            player_offset[0])

    if player_offset[1] > 0:
        window_offset[1] = player_offset[1]
    elif player_offset[1] < -(background.image.height - window.height):
        window_offset[1] = (background.image.height - window.height +
                            player_offset[1])

    object_offset = (player_offset[0] - window_offset[0],
                     player_offset[1] - window_offset[1])

    player.sprite.x, player.sprite.y = (window.width / 2 - window_offset[0],
                                        window.height / 2 - window_offset[1])
    background.position = object_offset

    # Convert world positions to screen positions
    for physics in level_physics:
        physics.update()
        physics.getSprite().position = get_window_position(physics.getPosition(),
                                                           object_offset)

    for overlay in level_overlays:
        overlay.getSprite().position = get_window_position(
            overlay.position, object_offset)

    # Physics
    global physics_dt

    physics_dt += dt
    # ODE recomends constant world steps to stop jitter
    while physics_dt > PHYSICS_STEP:
        space.collide(None, near_callback)
        world.step(PHYSICS_STEP)
        contactgroup.empty()

        physics_dt -= PHYSICS_STEP
Пример #2
0
def update():
    dt = clock.tick(settings.fps) / 1000  # in seconds

    camera.main.update(dt)

    physics.update()

    for entity in EntityManager.entities:
        entity.update(dt)

    if settings.debug:
        print(1 / dt, " FPS")
Пример #3
0
    frame_count = 0

    # SUBPROBLEM 4: uncomment the code below.
    # preallocate locks for objects
    locks_ptr = preallocate_locks(num_balls)

    num_to_record = 100
    num_recorded = 0
    list_of_fps = []


    while True: # so we can do a quantitative comparison
        with Timer() as t:
            update(positions, velocities, grid,
                   radius, grid_spacing, locks_ptr,
                   physics_step)

        # udpate our estimate of how fast the simulator runs
        physics_step = 0.9 * physics_step + 0.1 * t.interval
        total_time += t.interval

        frame_count += 1

        ball_indices = np.arange(num_balls)

        if total_time > anim_step:
            animator.update(positions)
            fps = frame_count / total_time
            list_of_fps.append(fps)
            print("{} simulation frames per second".format(fps))
Пример #4
0
    animator = Animator(positions, radius * 2)

    # simulation/animation time variablees
    physics_step = 1.0 / 100  # estimate of real-time performance of simulation
    anim_step = 1.0 / 30  # FPS
    total_time = 0

    frame_count = 0

    # SUBPROBLEM 4: uncomment the code below.
    # preallocate locks for objects
    locks_ptr = preallocate_locks(num_balls)

    while True:
        with Timer() as t:
            update(positions, velocities, grid, radius, grid_size, locks_ptr,
                   physics_step)

        # udpate our estimate of how fast the simulator runs
        physics_step = 0.9 * physics_step + 0.1 * t.interval
        total_time += t.interval

        frame_count += 1
        if total_time > anim_step:
            animator.update(positions)
            print("{} simulation frames per second".format(frame_count /
                                                           total_time))
            frame_count = 0
            total_time = 0
            # SUBPROBLEM 3: sort objects by location.  Be sure to update the
            # grid if objects' indices change!  Also be sure to sort the
            # velocities with their object positions!
Пример #5
0
 def update(self):
     physics.update(self.bodies)
     self.do_collisions()