def update(self):
     dt = pyglet.clock.tick()
     camera.update(dt)
     for window in pyglet.app.windows:
         window.switch_to()
         window.dispatch_events()
         window.dispatch_event('on_draw')
         window.flip()
示例#2
0
def update(dtime):
    for obj_uuid in loaded_world.objects:
        loaded_world.objects[obj_uuid]._update(dtime)
    camera.update(dtime)
    player._update(dtime)
    labels['fps'].text = f'FPS: {pyglet.clock.get_fps():.0f}'
    labels['scale'].text = f'scale: {camera.scale:.2f}'
    labels['x'].text = f'x: {player.x:.3f}'
    labels['y'].text = f'y: {player.y:.3f}'
示例#3
0
文件: game.py 项目: cravay/keggly
def update():
	player.update()
	current_screen.update()
	for enemy in current_screen.enemies:
		if player.rect.colliderect(enemy):
			load_screen(checkpoint[2])
			player.x = checkpoint[0]
			player.y = checkpoint[1]
	camera.update()
示例#4
0
def update_camera_information(sim_id: int = None,
                              target_x: float = None,
                              target_y: float = None,
                              target_z: float = None,
                              camera_x: float = None,
                              camera_y: float = None,
                              camera_z: float = None,
                              follow_mode: bool = None,
                              _connection=None):
    camera.update(sim_id=sim_id,
                  target_position=sims4.math.Vector3(target_x, target_y,
                                                     target_z),
                  camera_position=sims4.math.Vector3(camera_x, camera_y,
                                                     camera_z),
                  follow_mode=follow_mode)
示例#5
0
def update():
    global curCannonPrepareTime
    if enemyBase.update():
        worldObjManager.addObject(enemyCharacter.HammerOrk(1600, 100), 2)
        worldObjManager.addObject(enemyCharacter.AxeOrk(1600, 100), 2)
        worldObjManager.addObject(enemyCharacter.SwordOrk(1600, 100), 2)

    worldObjManager.update()
    camera.update()
    coin.update()
    spearRespawnButton.update()
    axeRespawnButton.update()
    swordRespawnButton.update()
    if curCannonPrepareTime >= 0.0:
        curCannonPrepareTime -= gameFramework.frameTime
示例#6
0
def update():
    global player, bg, player_ui

    collision.collide_check(player)
    player_ui.set_count(player)

    gfw.world.update()
    bg.speed = player.dx * 5

    p_draw_x, p_draw_y, left_gab, bottom_gab = camera.update(player)

    player.set_draw_pos((p_draw_x, p_draw_y))

    objects.LEFT_GAB = left_gab
    objects.BOTTOM_GAB = bottom_gab
    effect.LEFT_GAB = left_gab
    effect.BOTTOM_GAB = bottom_gab

    p_x, p_y = player.draw_pos
    for i in gfw.world.objects_at(gfw.layer.whip):
        i.pos = (p_x, p_y)

    if player.life == 0:
        main_bgm.stop()
    if player.death_time < 0:
        main_bgm.repeat_play()
        player.life = 4
        player.boom_count = 4
        player.rope_count = 4
        player.death_time = 8
        fade_out_sound.play()
        reset()

    fade_in_out()
 def update(self, source, target):
     for camera in self.cameras:
         camera.update(source, target)
示例#8
0
 def render(self):
     for camera in self.cameras:
         camera.update()
示例#9
0
def update():
    camera.update()
示例#10
0
            if e.key == pygame.K_UP:
                up = False
            elif e.key == pygame.K_DOWN:
                down = False
            elif e.key == pygame.K_RIGHT:
                right = False
            elif e.key == pygame.K_LEFT:
                left = False

    # clear/erase the last drawn sprites
    display.blit(background, (0, 0))
    # update all the sprites
    all.update()  #RenderUpdates

    hero.update(left, right, up, down, blocks)  # передвижение
    camera.update(hero)

    for e in all:
        # display.blit(e.image,[0,0])
        # display.blit(e.image,e.rect)
        display.blit(e.image, camera.apply(e))

    display.blit(hero.image, camera.apply(hero))

    if hero.weapon.visible:
        x0 = hero.rect.x + hero.rect.width / 2
        y0 = hero.rect.y - hero.rect.width / 2
        hero.weapon.update(x0, y0, blocks)
        display.blit(hero.weapon.image, camera.apply(hero.weapon))

    # dirty = all.draw(display)	#RenderUpdates
示例#11
0
#camerainit
camera = camera.Camera(screen, pixAr, walls)

# Event Loop
running = True

while running:

    #pygame.time.delay(10)

    #exit
    for event in pygame.event.get():

        if event.type == pygame.QUIT:

            running = False

    #pixAr[10,10] = (255, 255, 255)
    screen.fill((255, 255, 255))

    player.update()
    Wall.drawWalls()
    camera.update(player.x, player.y, player.rotation)

    pygame.display.update()

# Done! Time to quit.

pygame.quit()
示例#12
0
def updateEverything():
    camera.update()
示例#13
0
def loop():
    import bge

    cont = bge.logic.getCurrentController()
    owner = cont.owner

    fps = bge.logic.getLogicTicRate()
    data = codyn.data.networks[owner.name]

    cam = bge.logic.getCurrentScene().active_camera
    record = (not cam is None and 'cdn_record' in cam and cam['cdn_record'])

    if not record:
        fps /= data.nt

    if not data.single_step:
        data.single_step_cnt = 0

    if data.single_step:
        data.single_step_cnt += 1

        if data.single_step_cnt / fps > 0.01:
            data.single_step_cnt = 0

            data.simulator.step()
            data.simulator.update()

        data.paused = True
        data.single_step = False

    if not data.paused:
        data.simulator.step(1.0 / fps)
        data.simulator.update()

    data.lbl_time.text = 'time: {:>6.3f}, {:>2.2f}x'.format(data.simulator.t, data.nt)

    if not cam is None:
        camera.update(cam)

    if key_pressed(bge.events.SPACEKEY, True):
        data.paused = not data.paused

    if key_pressed(bge.events.RIGHTARROWKEY):
        data.single_step = True

    if record:
        fname = '/tmp/snapshots/{0:05d}.png'.format(data.i)
        bge.render.makeScreenshot(fname)

        data.i += 1

    if key_pressed(bge.events.PADPLUSKEY, True):
        data.nt *= 2

    if key_pressed(bge.events.PADMINUS, True):
        data.nt /= 2

    if key_pressed(bge.events.RKEY):
        data.simulator.reset()
        data.simulator.update()

        data.paused = True
        data.single_step = False
        data.i = 0
示例#14
0
def run_level(level):
	player = level.player
	triggers = level.triggers
	entities = level.entities
	background_entities = level.background_entities
	camera = level.camera
	barbers = level.barbers

	while True:
		CLOCK.tick(FPS)

		key_presses = pygame.event.get(pygame.KEYDOWN)
		key_states = pygame.key.get_pressed()

		for event in pygame.event.get():
			if event.type == pygame.QUIT:
				return 'quit'

		if key_states[pygame.K_r]:
			return 'restart'

		if key_states[pygame.K_ESCAPE]:
			return 'quit'

		if player.life_lost == True:
			display_life_lost_screen()
			player.life_lost = False

		player.update(key_presses, key_states, level)
		player.mustache.update()
		camera.update(player)

		if player.dead == True:
			display_death_screen()
			return 'dead'

		if player.mustache_numb == 4 and player.completed == False:
			display_sequence_screens(SCREENS_COMPLETED)
			player.completed = True


		# draw the background
		for y in range(26):
			for x in range(20):
				SCREEN.blit(IMAGES['bg_wall'], (x * TILESIZE, y * TILESIZE))

		for entity in background_entities:
			entity.update()
			if entity.image.get_rect().colliderect(SCREEN.get_rect()):
				SCREEN.blit(entity.image, camera.apply(entity))

		for entity in triggers:
			SCREEN.blit(entity.image, camera.apply(entity))

		for barber in barbers:
			barber.update(level)

		for entity in entities:
			if entity.image.get_rect().colliderect(SCREEN.get_rect()):
				SCREEN.blit(entity.image, camera.apply(entity))
				SCREEN.blit(player.mustache.image, camera.apply(player))

		pygame.display.update()
示例#15
0
    if pressed_down:
        my_spaceship.move_back()
    if pressed_right:
        my_spaceship.move_right()
    if pressed_left:
        my_spaceship.move_left()
    if pressed_rotate_right:
        my_spaceship.rotate(True)
    if pressed_rotate_left:
        my_spaceship.rotate(False)

    # Draw background
    screen.fill(blue_color)
    ground = pygame.Rect(0, SCREEN_HEIGHT * .9, SCREEN_WIDTH,
                         SCREEN_HEIGHT * .1)
    pygame.draw.rect(screen, green_color, ground)
    # Draw spaceship
    hero_image_active = pygame.transform.rotate(hero_image_base,
                                                (my_spaceship.orientation))
    my_spaceship.update(SCREEN_WIDTH, SCREEN_HEIGHT * .9)
    camera.update(my_spaceship.rect)
    # Game display
    my_spaceship.render(screen)
    screen.blit(hero_image_active, (my_spaceship.x, my_spaceship.y))

    # update canvas in window
    pygame.display.update()
    clock.tick(60)

pygame.quit()