示例#1
0
    def test_collide_mask__opaque(self):
        # make some fully opaque sprites that will collide with masks.
        self.s1.image.fill((255,255,255,255))
        self.s2.image.fill((255,255,255,255))
        self.s3.image.fill((255,255,255,255))

        # masks should be autogenerated from image if they don't exist.
        self.assertEqual (
            sprite.spritecollide (
                self.s1, self.ag2, dokill = False,
                collided = sprite.collide_mask
            ),
            [self.s2]
        )

        self.s1.mask = pygame.mask.from_surface(self.s1.image)
        self.s2.mask = pygame.mask.from_surface(self.s2.image)
        self.s3.mask = pygame.mask.from_surface(self.s3.image)

        # with set masks.
        self.assertEqual (
            sprite.spritecollide (
                self.s1, self.ag2, dokill = False,
                collided = sprite.collide_mask
            ),
            [self.s2]
        )
示例#2
0
    def update(self, dt):
        self.player.update(dt)
        self.coins.update(dt)

        # lock player in bounds
        self.player.rect.clamp_ip(self.bounds)

        spritecollide(self.player, self.coins, True)
示例#3
0
    def update(self, dt):
        self.player.update(dt)
        self.cookies.update(dt)

        # lock player in bounds
        self.player.rect.clamp_ip(self.bounds)

        # collide player with coins
        spritecollide(self.player, self.cookies, True)
示例#4
0
    def update(self, time, player_group, platform_group):
        if self.KILL:
            self.explode()
        hit_players = PS.spritecollide(self, player_group, False)
        hit_platforms = PS.spritecollide(self, platform_group, False)

        if hit_players:
            for this_player in hit_players:
                self.react(this_player)

        if hit_platforms:
            for this_platform in hit_platforms:
                self.rect.centery = (this_platform.get_top() - self.rect.height/4)
示例#5
0
 def attack(self, player, playerX, playerY, playerFace, screen, bg):
 #this bg is enemy block group
 #collisions with the new weapon rect!
     score = 0
     collision_list = []
     if "r" in playerFace:
         self.rectrl.x = playerX
         self.rectrl.y = playerY
         self.rect = self.rectrl
     elif "l" in playerFace:
         self.rectrl.x = playerX
         self.rectrl.y = playerY
         self.rect = self.rectrl
     elif "u" in playerFace:
         self.rectud.x = playerX
         self.rectud.y = playerY
         self.rect = self.rectud
     elif "d" in playerFace:
         self.rectud.x = playerX
         self.rectud.y = playerY
         self.rect = self.rectud
     collisions = PS.spritecollide(self, bg, False)
     for collision in collisions:
         collision_list.append(collision)
     return collision_list # to be added to Player's score
示例#6
0
	def update(self, time, scene):
		self.floatX += self.speedX * time * GRENADE_SPEED
		self.floatY += self.speedY * time * GRENADE_SPEED
		self.rect.x = roundToInt(self.floatX)
		self.rect.y = roundToInt(self.floatY)

		self.timeToBoom -= time

		if self.timeToBoom <= 0:
			scene.bulletGroup.remove(self)
			scene.bulletGroup.add(Explosion(self.rect.x, self.rect.y))

			# Kill people!
			originalRect = self.rect.copy()
			self.rect.inflate_ip(80, 80)  # 80x80 area damage
			
			enemies_hit = sprite.spritecollide(self, scene.enemyGroup, False)

			for enemy in enemies_hit:
				# Friendly fire
				if self.creator.__class__.__name__ == enemy.__class__.__name__:
					continue
				enemy.receive_attack(self.atk)

			if sprite.collide_rect(self, scene.player):
				scene.player.receive_attack(self.atk)

			self.rect = originalRect  # Restore the real rect

		self.timeToStop -= time

		if self.timeToStop <= 0:
			self.speedX = 0
			self.speedY = 0
    def detect_collision(self):
        collisions = spritecollide(self.player, self.obstacle_group, True)

        for c in collisions:
            self.collision_strategy_factory.get_strategy(c).on_collision()
            self.obstacles.remove(c)
            c.kill()
示例#8
0
    def update(self):
        dt = self.clock.tick(FPS)

        # basic update
        self.player.update(dt)
        self.coins.update(dt)

        # check if the player is on the path
        onpath = spritecollide(self.player, self.level.path, False)
        self.player.on_path(onpath)

        # collide coins
        for coin in spritecollide(self.player, self.coins, True):
            self.score += 1

        self.cam.update(self.player.rect)
示例#9
0
 def update(self):
     BouncySprite.update(self)
     if sprite.spritecollide(self, self.game.monsters, True):
         self.kill()
     self.life -= 1
     if self.life <= 0:
         self.kill()
示例#10
0
	def kill_people(self, scene):
		hitted_players = sprite.spritecollide(self, scene.enemyGroup, False)
		# scene.bulletGroup.remove(self)
		for player in hitted_players:
			player.hit_by_bullet(self.atk)
			# A bullet should not be capable of going through an infinite amount of bodies
			scene.bulletGroup.remove(self)
示例#11
0
 def handle_collision(self, bg, m_back=False):
     if m_back:
         face_copy = self.face
         self.face = self.move_face
     collisions = PS.spritecollide(self, bg, False)
     if 'r' in self.face:
         for collision in collisions:
             if(self.rect.x +
                self.rect.width) >= collision.rect.left:
                 self.rect.x = collision.rect.left - self.rect.width
     elif 'l' in self.face:
         for collision in collisions:
             if (self.rect.x) <= (collision.rect.left +
                                  collision.rect.width):
                 self.rect.x = collision.rect.left + \
                     collision.rect.width
     elif 'd' in self.face:
         for collision in collisions:
             if(self.rect.y +
                self.rect.height) >= collision.rect.top:
                 self.rect.y = collision.rect.top - self.rect.height
     elif 'u' in self.face:
         for collision in collisions:
             if (self.rect.y <= (collision.rect.top +
                                 collision.rect.height)):
                 self.rect.y = collision.rect.top + \
                     collision.rect.height
     if m_back:
         self.face = face_copy
     return (collisions is None)
示例#12
0
    def execute(self):
        '''Controls the actor movement as a regular object under Newton's laws. Checks collisions with grounds'''
        actor=self.__parent
        self.velocity=self.velocity+(actor.steering_acceleration+PS_freefall.GRAVITY)*self.time_step
        
        self.position=self.position+self.velocity*self.time_step
        if self.i==4:
            for floor in spritecollide(actor, actor.get_level().floors, False):
                if not actor.crect.colliderect(floor.crect):
                    continue
                if -16<floor.crect.top-actor.crect.bottom<3 and self.velocity[1]>=0:
                    self.velocity[1]=0
                    actor.standing_on=floor
                    self.position[1]=floor.crect.top-actor.rect.height/2
                    self.__parent_PM.set_state(PS_walking)
                    continue
                
                elif -16<floor.crect.left-actor.crect.right<3 and self.velocity[0]>0:
                    self.velocity[0]=-self.velocity[0]
                elif -3<floor.crect.right-actor.crect.left<16 and self.velocity[0]<0:
                    self.velocity[0]=-self.velocity[0]
                elif -3<floor.crect.bottom-actor.crect.top<16 and self.velocity[1]<0:
                    self.velocity[1]=-self.velocity[1]
            self.i=0
        else: self.i+=1

        actor.set_position([self.position[0], self.position[1]])
示例#13
0
 def handle_player(self, player):
     player.sprites()[0].set_attacking_rect()
     collisions = PS.spritecollide(self, player, False)
     if(len(collisions) == 1 and isinstance(collisions[0], Player)):
         if(Globals.INVINCIBILITY_COUNT == 0):
             self.attacked_player = True
     player.sprites()[0].reset_attacking_rect()
示例#14
0
 def useportal(self):
     # check for portals
     portalbox = spritecollide(self,self.level.portal_list,False)
     if portalbox != []:
         return portalbox[0].destination
     else:
         return 0
示例#15
0
 def test_collide_circle__no_radius_set(self):
     # collide_circle with no radius set.
     self.assertEqual (
         sprite.spritecollide (
             self.s1, self.ag2, dokill = False, collided = sprite.collide_circle
         ),
         [self.s2]
     )
示例#16
0
 def test_spritecollide__collided_defaults_to_collide_rect(self):
     # collide_rect should behave the same as default.
     self.assertEqual (
         sprite.spritecollide (
             self.s1, self.ag2, dokill = False, collided = sprite.collide_rect
         ),
         [self.s2]
     )
示例#17
0
 def test_spritecollide__works_if_collided_cb_is_None(self):
     # Test that sprites collide without collided function.
     self.assertEqual (
         sprite.spritecollide (
             self.s1, self.ag2, dokill = False, collided = None
         ),
         [self.s2]
     )
示例#18
0
 def grounded(self):
     "Check for ground underneath players feet, if not found switch to falling state"
     tmp = self.player.rect
     self.player.rect = self.player.rect.move(0, 1)
     collides = spritecollide(self.player, level.tile_group, False)
     if not collides:
         self.fall()
         
     self.player.rect = tmp
示例#19
0
 def test_collide_rect_ratio__ratio_of_one_like_default(self):
     # collide_rect_ratio should behave the same as default at a 1.0 ratio.
     self.assertEqual (
         sprite.spritecollide (
             self.s1, self.ag2, dokill = False,
             collided = sprite.collide_rect_ratio(1.0)
         ),
         [self.s2]
     )
示例#20
0
    def detect_collision(self):
        if self.elements['ship'].sprite:
            self.ship_collides = spritecollideany(self.elements['ship'].sprite, self.elements['asteroids'])
            self.ship_catches = spritecollide(self.elements['ship'].sprite, self.elements['power-ups'], True)

        if groupcollide(self.elements['lasers'], self.elements['asteroids'], True, True):
            if randint(1, 20) == 1:
                self.newPU = True
            self.score_add(50)
示例#21
0
 def test_collide_circle_ratio__no_radius_and_ratio_of_one(self):
     # collide_circle_ratio with no radius set, at a 1.0 ratio.
     self.assertEqual (
         sprite.spritecollide (
             self.s1, self.ag2, dokill = False,
             collided = sprite.collide_circle_ratio(1.0)
         ),
         [self.s2]
     )
示例#22
0
 def jump(self):
     # call when 'jump' key pressed
     # first check if player is on a platform.
     self.rect.y += 2        
     harvest = spritecollide(self,self.level.platform_list,False)
     self.rect.y -= 2  
     # then 'jump' if not airborne
     if len(harvest) > 0 or self.rect.bottom >= WINH-self.rect.h:
         # jump
         self.dy = -10
示例#23
0
文件: level.py 项目: alecgoebel/div2
    def update(self, dt):
        self.player.update(dt)
        self.coins.update(dt)

        # lock player in bounds
        self.player.rect.clamp_ip(self.bounds)

        # collide player with coins
        for coin in spritecollide(self.player, self.coins, False):
            coin.collect(self.player)
示例#24
0
 def test_collide_circle_ratio__no_radius_and_ratio_of_twenty(self):
     # collide_circle_ratio with no radius set, at a 20.0 ratio.
     self.assert_ (
         unordered_equality (
             sprite.spritecollide (
                 self.s1, self.ag2, dokill = False,
                 collided = sprite.collide_circle_ratio(20.0)
             ),
             [self.s2, self.s3]
         )
     )
示例#25
0
    def update(self, dt):
        self.player.update(dt)
        self.coins.update(dt)

        # lock player in bounds
        self.player.rect.clamp_ip(self.bounds)

        # collide player with coins
        if spritecollide(self.player, self.coins, True):
            self.coin_sfx.stop()
            self.coin_sfx.play()
示例#26
0
 def test_collide_rect_ratio__collides_all_at_ratio_of_twenty(self):
     # collide_rect_ratio should collide all at a 20.0 ratio.
     self.assert_ (
         unordered_equality (
             sprite.spritecollide (
                 self.s1, self.ag2, dokill = False,
                 collided = sprite.collide_rect_ratio(20.0)
             ),
             [self.s2, self.s3]
         )
     )
示例#27
0
    def update(self):
        dt = self.clock.tick(FPS)

        # basic update
        self.player.update(dt)
        self.coins.update(dt)

        # collide coins
        for coin in spritecollide(self.player, self.coins, True):
            self.score += 1

        self.cam.update(self.player.rect)
示例#28
0
 def update(self):
    self.player.update()
    self.npcgroup.update()
    if sprite.spritecollideany(self.player, self.walls):
       self.player._goback()
    for npc in sprite.groupcollide(self.npcgroup, self.walls, False, False):
       npc._goback()
    npcCollisions = sprite.spritecollide(self.player, self.npcgroup, False)
    if len(npcCollisions) > 0:
       self.prepareForBattle()
       npcCollisions[0].kill()
       return BattleEvent(self.player, npcCollisions[0])
    return None
示例#29
0
    def player_detection(self, player_group):
       	hit_players = PS.spritecollide(self, player_group, False)
	if hit_players:
		for this_player in hit_players:
                    self.vx = ENEMY_VELOCITY
                    #Enemy reactions to player contact can cause bugs
                    self.vx = HIT_VELOCITY
                    if self.get_rit() > this_player.get_rit():
                            self.moving_right = True
                    else:
                            self.moving_right = False
	else:
		self.vx = ENEMY_VELOCITY 
示例#30
0
 def moveup(self, image_counter, walls):
     wall_list = PS.spritecollide(self, walls, False)
     if self.direction != 'moveup':  # we just changed directions
         self.movepos = [0.0, 0.0]  # remove deceleration
         self.image_tracker = 0
         self.change_direction = True
     else:
         self.movepos[1] = -self.speed
     self.direction = "moveup"
     self.update_image(self.image_tracker*4+1, self.change_direction)
     self.moving = True
     self.action_rect.width = 64
     self.action_rect.height = 32
     self.action_rect.midbottom = self.rect.midtop
示例#31
0
 def collides_detect(self, x_vel, y_vel):
     if spritecollide(self, MOBS, False):
         self.rect.x += self.return_impulse if self.x_vel < 0 else -self.return_impulse
         self.x_vel = 0
         self.get_damage(10)
     for p in PLATFORMS:
         if collide_rect(self, p):
             if x_vel > 0:
                 self.rect.right = p.rect.left
                 self.x_vel = 0
             if x_vel < 0:
                 self.rect.left = p.rect.right
                 self.x_vel = 0
             if y_vel > 0:
                 self.rect.bottom = p.rect.top
                 self.on_ground = True
                 self.in_jump = False
                 self.y_vel = 0
             if y_vel < 0:
                 self.rect.top = p.rect.bottom
                 self.y_vel = 0
示例#32
0
 def moveUnit(unit, tryTurns):
     for dist in range(Ship.VELOCITY, 0, -1):
         for turn in tryTurns:
             unit.tryMove(dist, turn)
             collidePlanet = sp.spritecollideany(
                 unit, planets, sp.collide_circle)
             if collidePlanet is unit.destPlanet:
                 unit.destPlanet.arrival(self.team)
                 unit.kill()
                 return
             else:
                 pass
                 # moveUnit(unit, filtertryTurns)
                 # return
             if (len(
                     sp.spritecollide(unit, ships, False,
                                      Ship.collidedShip)) == 1
                     and not collidePlanet):
                 unit.doMove()
                 return
             else:
                 unit.unTryMove()
示例#33
0
    def boosters_manager(self, frame):
        """Метод - обработчик всех событий с бустерами в т.ч. столкновений"""
        hits = spritecollide(self.starship, self.boosters, False)
        for booster in hits:
            booster_type = booster.type
            if booster_type in self.boosters_timeouts:
                self.timed_booster_handler(booster_type)
            elif booster_type in self.weapons:
                self.weapons_handler(booster_type)
            elif booster_type in self.timed_abilities:
                self.booster_handlers[booster_type]("activate")
            booster.pickup_sound.play()
            booster.kill()

        for booster_type, timeout in self.boosters_timeouts.items():
            # Если бустер активен (timeout > 0), но активное время закончилось (time.time() > timeout)...
            if time.time() > timeout > 0:
                self.boosters_timeouts[
                    booster_type] = 0  # задаём время деактивации равным 0 (отключённое состояние)
                self.booster_handlers[booster_type](
                    "deactivate"
                )  # деактивируем бустер (возвращаем исходное поведение)
        for booster_type, weapon in self.weapons.items():
            if weapon.ammo <= 0:
                self.weapons[booster_type].ammo = 0
                self.booster_handlers[booster_type]("deactivate")
        for booster_type, ability in self.timed_abilities.items():
            status = self.timed_abilities[booster_type].active
            if ability.amount <= 0 and status:
                self.timed_abilities[booster_type].active = False
                self.timed_abilities[booster_type].amount = 0
                self.timed_abilities[booster_type].sound.stop()
            elif ability.amount > 0 and status:
                self.timed_abilities[booster_type].amount -= status

        if frame % BOOSTER_SPAWN_RATE == 0 and frame != 0:
            self.boosters.add(
                Booster())  # ...размещаем новый бустер на игровом поле
示例#34
0
    def organizar_ordem_de_sprites(self):
        for item in spritecollide(self.hero.hitbox, EntidadesGroup, False):
            if item == self.hero:
                continue
            if self.hero.rect.bottom <= item.rect.bottom - 4:
                lista_sprites = EntidadesGroup.sprites()
                EntidadesGroup.empty()

                heroi_index = lista_sprites.index(self.hero)
                lista_sprites.remove(item)
                lista_sprites.insert(heroi_index + 1, item)

                EntidadesGroup.add(lista_sprites)
                break

            if self.hero.rect.bottom >= item.rect.bottom - 4:
                lista_sprites = EntidadesGroup.sprites()
                EntidadesGroup.empty()

                heroi_index = lista_sprites.index(self.hero)
                lista_sprites.remove(item)
                lista_sprites.insert(heroi_index - 1, item)

                EntidadesGroup.add(lista_sprites)
示例#35
0
 def update(self, ticks: int):
     """
     Updates game state with timing information provided by PyGame
     @param ticks: number of milliseconds passed since pygame.init() was called
     (obtained with pygame.time.get_ticks())
     @return: None
     """
     self.bear.update(ticks)
     self.bear.clamp(self.world.rect)
     self.camera.move_to(self.bear.position)
     self.camera.clamp(self.world.rect)
     collide_list = spritecollide(self.bear, self.berry_group, True)
     for _ in collide_list:
         self.score += 1
         self.remaining = len(self.berry_group)
         if self.remaining == 0:
             self.running = False
     if self.running:
         self.timer = ticks
         self.text.set_text(
             "Collected: {0}. Remaining: {1}. Elapsed time: {2:.1f} s".format(self.score, self.remaining, self.timer / 1000.0))
     else:
         self.text.set_text(
             "You collected all berries in {0:.1f} seconds".format(self.timer / 1000.0))
示例#36
0
    def update(self, shell_list=None):
        random_move = self.directions[random.randint(0, 7)]
        if random_move:
            self._rotate(random_move)

        self._move()

        #Keep the AI on the screen
        if self.rect.left <= 0:
            self._rotate('right')
        elif self.rect.right >= 1024:
            self._rotate('left')
        if self.rect.top <= 0:
            self._rotate('left')
        elif self.rect.bottom >= 768:
            self._rotate('left')

        self.turret.update(self.rect.center, self.rotationCounter)

        if spritecollide(self, shell_list, 'true'):
            self._die()
        #Draw AI tank on screen
        self.screen.blit(self.image, self.rect)
        self.turret.shells.update()
示例#37
0
    def colision_check(self):
        for bloco in spritecollide(self.hitbox, colisionsGroup, False):
            if self.hitbox.rect.bottom - bloco.rect.top == 2:
                self.hitbox.rect.bottom = bloco.rect.top
                self.pos_y = [False, True]
                self.pos_x = [True, True]

            if bloco.rect.bottom - self.hitbox.rect.top == 2:
                self.hitbox.rect.top = bloco.rect.bottom
                self.pos_y = [True, False]
                self.pos_x = [True, True]

            if self.hitbox.rect.right - bloco.rect.left == 2:
                self.hitbox.rect.right = bloco.rect.left
                self.pos_x = [False, True]
                self.pos_y = [True, True]

            if bloco.rect.right - self.hitbox.rect.left == 2:
                self.hitbox.rect.left = bloco.rect.right
                self.pos_x = [True, False]
                self.pos_y = [True, True]

            self.rect.x = self.hitbox.rect.x - 8
            self.rect.y = self.hitbox.rect.y - 16
示例#38
0
    def collision_with_hurdle(self):
        """Returns if Mario has collision with hurdles on map."""

        if sprite.spritecollide(self, HURDLES_GROUP, dokill=False):
            return True
        return False
示例#39
0
 def test_spritecollide__works_if_collided_cb_is_None(self):
     # Test that sprites collide without collided function.
     self.assertEqual(
         sprite.spritecollide(self.s1, self.ag2, dokill=False, collided=None),
         [self.s2],
     )
示例#40
0
    def update(self):
        self.rect.y += self.dy

        for _ in spritecollide(self, self.borders, False):
            self.rect.y -= self.dy
            self.stop()
示例#41
0
 def is_resolved(self) -> bool:
     return any(
         spritecollide(sprite, self._zone_group, False)
         for sprite in self._entering_group)
示例#42
0
文件: board.py 项目: adalbas/sfgame
 def filter_single_collision(self, single):
     sprite.spritecollide(single, self, True)
示例#43
0
 def test_spritecollide__works_if_collided_cb_not_passed(self):
     # Should also work when collided function isn't passed at all.
     self.assertEqual(sprite.spritecollide(self.s1, self.ag2, dokill=False),
                      [self.s2])
示例#44
0
     if spritecollideany(player, gp_walls):
         player.move(1, 0)
     else:
         player_mv = True
 elif evt.key == K_RIGHT:
     player.move(1, 0)
     if spritecollideany(player, gp_walls):
         player.move(-1, 0)
     else:
         player_mv = True
 if player_mv:  # le joueur se déplace
     # We test the collision between the player and an object of
     # the game board. In the case of a collision, sp contains the
     # sprite of the object and is removed from the group
     # gp_items_onboard
     sp = spritecollide(player, gp_items_onboard, True)
     if sp:
         # According to the value of sp, we add the object
         # recovered by the player in the border
         if sp[0] == sp_eth:
             items_collected.set_item(ETHER)
         elif sp[0] == sp_tub:
             items_collected.set_item(TUBE)
         elif sp[0] == sp_syr:
             items_collected.set_item(SYRINGE)
     # test of the collision between the player and the guardian
     if collide_rect(player, guard):
         game = False
         pg.font.init()
         ft = pg.font.Font(pg.font.get_default_font(), 100)
         if len(items_collected.items_found) == 3:
示例#45
0
    def run(self):
        framesSinceLastEnemyShot = 0
        lastMove = "right"

        while not self.done:

            #Keyboard press and exit events
            for event in pygame.event.get():
                if event.type == QUIT:
                    exit()

            #Keyboard hold
            keys = pygame.key.get_pressed()
            if keys[K_LEFT] or keys[K_a]:
                if (not self.player.touchingLeftBorder()):
                    self.player.setSpeed((-1, 0))
            if keys[K_RIGHT] or keys[K_d]:
                if (not self.player.touchingRightBorder()):
                    self.player.setSpeed((1, 0))
            if keys[K_SPACE]:
                if (self.player.attempt_shoot(self.CLOCK)):
                    playSoundPlayerShot()
            self.player.do()

            #Checking if monsters can be moved
            canMoveLeft = canMoveRight = True
            for monster in self.monsters:
                if (monster.touchingLeftBorder()):
                    lastMove = "left"
                    canMoveLeft = False
                if (monster.touchingRightBorder()):
                    lastMove = "right"
                    canMoveRight = False

            if (canMoveRight and lastMove == "left"):
                monsSpeed = (1, 0)
            elif (canMoveLeft and lastMove == "right"):
                monsSpeed = (-1, 0)
            else:
                monsSpeed = (0, 0)

            for monster in self.monsters:
                monster.setSpeed(monsSpeed)
                monster.do()

            #Player-Shot collision with monster
            collided = groupcollide(self.player.shots, self.monsters, True,
                                    False)
            for key, values in collided.items():
                for value in values:
                    value.life -= self.player.damage
                    if value.life <= 0:
                        self.player.score += value.value
                    collision_pos = value.getPosition()
                    self.temp_effects.append(
                        TempEffect("hit_blue", "effects", collision_pos))

            #Monsters-Shots collision with player
            for monster in self.monsters:
                collided = spritecollide(self.player, monster.shots, True)
                if (len(collided)):
                    self.player.life -= monster.damage
                    collision_pos = self.player.getPosition()
                    self.temp_effects.append(
                        TempEffect("hit_blue", "effects", collision_pos))

            #Select random enemy to shot and control time between shots
            indexMonShooting = randint(0, len(self.monsters))
            if((framesSinceLastEnemyShot > 30 and len(self.monsters) > 4) or \
            (framesSinceLastEnemyShot > 60)):
                for i, monster in enumerate(self.monsters):
                    if (i == indexMonShooting):
                        monster.shoot()
                        framesSinceLastEnemyShot = 0
            else:
                framesSinceLastEnemyShot += 1

            if self.player.life <= 0:
                self.done = True

                text = "You lost!  Score: " + str(self.player.score)
                self.showText(text)
                playSoundDeath()
            elif len(self.monsters) <= 0:
                self.done = True

            #Updating and rendering objects
            self.renderObjects()

            self.CLOCK.tick(self.FPS)

        if (len(self.monsters) <= 0):
            if (self.key < MAX_STAGE):
                self.done = False
                self.key += 1
                self.start()
            else:
                text = "You won!  Score: " + str(self.player.score)
                self.showText(text)
                pygame.time.delay(2000)
 def collide(self, group, doKill=False, collided=None):
     return sprite.spritecollide(self, group, doKill, collided)
示例#47
0
    def __dispatch_collisions(self):
        collision_results = {
            'group': {},
            'sprite': {},
            'foreach_sprite': {},
        }
        for (collision, args) in self.__collisions['group'].items():
            collision_results['group'][collision] = groupcollide(*args)

        for (collision, args) in self.__collisions['sprite'].items():
            collision_results['sprite'][collision] = spritecollide(*args)

        for (collision, args) in self.__collisions['foreach_sprite'].items():
            arg_list = list(args)
            sprite_list = arg_list[0]
            for sprite in sprite_list:
                arg_list[0] = sprite
                args = tuple(arg_list)
                collision_results['foreach_sprite'][sprite] = spritecollide(
                    *args)

        for bullet in self.__entities.player_bullets:
            collision_result = spritecollide(bullet,
                                             self.__scene_elements.iron_group,
                                             bullet.enhanced, None)
            if collision_result:
                bullet.kill()

        for player_tank in self.__entities.player_tanks:
            for food in self.__entities.foods:
                collision_result = collide_rect(player_tank, food)
                if collision_result:
                    self.__dispatch_food_effect(food, player_tank)

        # --我方子弹撞敌方坦克
        for tank in self.__entities.enemy_tanks:
            if collision_results['foreach_sprite'][tank]:
                if tank.food:
                    self.__entities.add(tank.food)
                    tank.clear_food()
                if tank.decrease_level():
                    self.__play_sound('bang')
                    self.__total_enemy_num -= 1

        # --敌方子弹撞我方坦克
        for tank in self.__entities.player_tanks:
            if collision_results['foreach_sprite'][tank]:
                if tank.protected:
                    self.__play_sound('blast')
                else:
                    if tank.decrease_level():
                        self.__play_sound('bang')
                    if tank.health < 0:
                        self.__entities.remove(tank)

        if collision_results['sprite'][
                'PlayerBulletWithHome'] or collision_results['sprite'][
                    'EnemyBulletWithHome']:
            self.__is_win_flag = False
            self.__has_next_loop = False
            self.__play_sound('bang')
            self.__home.destroyed = True

        if collision_results['group']['PlayerTankWithTree']:
            self.__play_sound('hit')
示例#48
0
    def move(self, keys):
        self.acc_x = 0
        if self.rectangle.bottom + self.velocity_Y < SCREEN_HEIGHT:
            self.acc_y = GRAVITY
        else:
            self.velocity_Y = 0
            self.acc_y = 0
            self.rectangle.bottom = SCREEN_HEIGHT

        if keys[pygame.K_d]:
            self.acc_x = 1.5
            self.directionX = DIRECTION_RIGHT
        elif keys[pygame.K_a]:
            self.acc_x = -1.5
            self.directionX = DIRECTION_LEFT

        if keys[pygame.K_w]:
            self.playerSprite.rect.y += 1
            hits = self.playerSprite.rect.midbottom[1] > SCREEN_HEIGHT
            self.playerSprite.rect.y -= 1
            if hits or self.platformCollision:
                self.velocity_Y = -30

        self.velocity_X += self.acc_x
        self.velocity_Y += self.acc_y

        if abs(self.velocity_X) > 0.5:
            if self.velocity_X > 0:
                self.velocity_X -= self.velocity_X * FRICTION
            elif self.velocity_X < 0:
                self.velocity_X += abs(self.velocity_X) * FRICTION

            if self.velocity_X > 0 or (
                    self.velocity_X < 0
                    and self.rectangle.left + self.velocity_X > 0):
                self.rectangle.x += self.velocity_X
                platformXCollide = spritecollide(self.playerSprite,
                                                 self.platformSpriteGroup,
                                                 False)
                if platformXCollide and self.velocity_X > 0:  # Ruch w prawo
                    self.velocity_X = 0
                    self.playerSprite.rect.right = platformXCollide[
                        0].rect.left - 1

                elif platformXCollide and self.velocity_X < 0:  #Ruch w lewo
                    self.velocity_X = 0
                    self.playerSprite.rect.left = platformXCollide[
                        0].rect.right + 1

                if self.velocity_X > 0 and self.rectangle.left > SCREEN_WIDTH:
                    self.rectangle.right = 0

        if abs(self.velocity_Y) > 0.5:
            if self.velocity_Y > 0:
                self.velocity_Y -= self.velocity_Y * FRICTION
            elif self.velocity_Y < 0:
                self.velocity_Y += abs(self.velocity_Y) * FRICTION

            self.rectangle.y += self.velocity_Y
            collidePlatformY = spritecollide(self.playerSprite,
                                             self.platformSpriteGroup, False)
            if collidePlatformY and self.velocity_Y < 0:
                self.velocity_Y = 0
                self.playerSprite.rect.top = collidePlatformY[0].rect.bottom + 1

        for bullet in self.bulletSpriteGroup:
            bullet.updateBullet()
示例#49
0
    def _compute_reward(self):
        """compute the reward for moving on the map
        """
        #  logg = getMyLogger(f"c.{__class__.__name__}._compute_reward")
        #  logg.debug(f"Start _compute_reward")

        # compute collision car/road
        #  start = timer()
        hits = spritecollide(self.racer_car, self.racer_map, dokill=False)
        #  end = timer()
        #  logg.debug(f"Time for sprite collisions {end-start:.6f} s")

        #  logg.debug(f"hitting {hits}")
        hit_directions = []
        hit_sid = []
        for segment in hits:
            #  logg.debug(f"hit segment with id {segment.s_id}")
            hit_directions.append(self.racer_map.seg_info[segment.s_id][0])
            hit_sid.append(segment.s_id)

        # out of the map
        if len(hit_directions) == 0:
            return 0, True

        # if it is in the map, check that is moving
        if self.racer_car.speed < 0.0001:
            return -1, False

        # too many hits, your road is weird, cap them at 2 segments
        elif len(hit_directions) > 2:
            #  logg.warn(f"Too many segments hit")
            hit_directions = hit_directions[:2]
            hit_sid = hit_sid[:2]

        # now hit_directions is either 1 or 2 elements long
        if len(hit_directions) == 1:
            mean_direction = hit_directions[0]
        else:
            # 135   90  45    140   95  50    130   85  40
            # 180       0     185       5     175       -5
            # 225   270 315   230   275 320   220   265 310
            # 270, 0 have mean 315 = (270+0+360)/2
            # 270, 180 have mean 225 = (270+180)/2
            # 0, 90 have mean 45 = (0+90)/2
            if abs(hit_directions[0] - hit_directions[1]) > 180:
                mean_direction = (sum(hit_directions) + 360) / 2
                if mean_direction >= 360:
                    mean_direction -= 360
            else:
                mean_direction = sum(hit_directions) / 2

        error = self.racer_car.direction - mean_direction
        if error < 0:
            error += 360
        if error > 180:
            error = 360 - error
        #  logg.debug(f"direction {self.racer_car.direction} has error of {error:.4f}")

        # error goes from 0 (good) to 180 (bad)
        reward = 90 - error
        # MAYBE a sigmoid-like shape

        # scale it from -1 to 1
        reward /= 90

        # make it proportional to speed squared
        reward *= self.racer_car.speed * self.racer_car.speed

        return reward, False
示例#50
0
    def update(self):

        if not self.start_tick is None:
            currentTime = get_ticks()
            if self.hp > 0:
                if (currentTime - self.start_tick) / 1000 > 1:
                    self.unhurtful = False
                    # Revert back
                    self._updateSprite()
            else:
                if (currentTime - self.start_tick) / 1000 > 5:
                    self.dead = False
                    initialLocations = [(968, 300), (968, 400), (280, 400),
                                        (968, 250), (280, 250)]
                    self.image = load(os.getcwd() + '/img/sprite-' +
                                      self.spriteName + '/' + self.spriteName +
                                      '-r1.png')
                    initialLocation = initialLocations[randint(0, 4)]
                    self.rect.x, self.rect.y = initialLocation
                    self.weapon.rect.x, self.weapon.rect.y = self.rect.x, self.rect.y
                    self.hp = 100
                else:
                    self.image = load(os.getcwd() + '/img/sprite-' +
                                      self.spriteName + '/d.png')
                    self.weapon.rect.right = self.rect.left
                    self.dead = True
                    return
        self._updateSprite()
        self.calc_grav()
        if self.rect.right > 1440:
            self.rect.right = 1440
        if self.rect.left < 0:
            self.rect.left = 0
        move = self._sliding()
        if move > 4:
            move = 4
        elif move < -4:
            move = -4
        self.rect.x += move
        self.weapon.update()
        self.weapon.rect.y = self.rect.y + 50
        if self.direction == 1:
            self.weapon.rect.x = self.rect.x + 20
        elif self.direction == -1:
            self.weapon.rect.x = self.rect.x - 30
        self.weapon.rect.x += move
        self.weapon.update()

        weakLayer_list = spritecollide(self, self.weakLayer, False)
        for each in weakLayer_list:
            if self.ySpeed > 0:
                self.rect.bottom = each.rect.top
            elif self.ySpeed < 0:
                self.rect.top = each.rect.bottom
            self.ySpeed = 0

        block_hit_list = spritecollide(self, self.platforms, False)
        self._preventMoving(block_hit_list)

        self.rect.y += self.ySpeed
        block_hit_list = spritecollide(self, self.platforms, False)
        for block in block_hit_list:
            if self.ySpeed > 0:
                self.rect.bottom = block.rect.top
            elif self.ySpeed < 0:
                self.rect.top = block.rect.bottom
            self.ySpeed = 0

        sticks_hit_list = spritecollide(self, self.sticks, False)
        if len(sticks_hit_list) > 0:
            if self.unhurtful == False:
                self.start_tick = get_ticks()
                self._updateSprite()
                self.hp -= 10
                self.hit_sound.play()
                if self.hp <= 0:
                    #death
                    self.death_sound.play()
                else:
                    self.unhurtful = True

        bullet_hit_list = spritecollide(self, self.bulletList, False)
        for each in bullet_hit_list:
            if self.unhurtful == False:
                self.start_tick = get_ticks()
                self._updateSprite()
                if isinstance(each, shotgunShell):
                    self.hp -= 40
                else:
                    self.hp -= 20
                self.hit_sound.play()
                if self.hp <= 0:
                    #death
                    self.death_sound.play()
                else:
                    self.unhurtful = True

        elevator_hit_list = spritecollide(self, self.elevator, False)
        for each in elevator_hit_list:
            if self.rect.bottom > each.rect.top:
                self.ySpeed = each.speed

        giantSpike_hit_list = spritecollide(self, self.giantSpike, False)
        for each in giantSpike_hit_list:
            if each.rect.bottom >= self.rect.top and self.unhurtful == False:
                self.start_tick = get_ticks()
                self._updateSprite()
                self.hp -= 90
                self.hit_sound.play()
                if self.hp <= 0:
                    #Dead
                    self.death_sound.play()
                else:
                    self.unhurtful = True
示例#51
0
 def collide_detect(self):
     if spritecollide(self, BULLETS, True):
         self.hp -= BULLET_DAMAGE
示例#52
0
    def collision_with_gap(self):
        """Returns if Mario has collision with gaps on map."""

        if sprite.spritecollide(self, GAP_GROUP, dokill=False):
            return True
        return False
示例#53
0
    def collision_with_object(self):
        """Returns if Mario has collision with objects on map."""

        if sprite.spritecollide(self, OBJECT_GROUP, dokill=False):
            return True
        return False
示例#54
0
def run_racer_main(args):
    """mainloop of the game

    adapted from https://www.pygame.org/docs/tut/chimp.py.html
    and https://www.pygame.org/docs/tut/ChimpLineByLine.html
    """
    logg = logging.getLogger(f"c.{__name__}.run_racer_main")

    template_images = args.template_images
    fps = args.fps

    pygame.init()
    # size is (int, int) tuple
    field_size = (900, 900)
    # unpack the field size for clarity
    field_wid, field_hei = field_size
    sidebar_size = (300, field_hei)
    sidebar_wid, sidebar_hei = sidebar_size
    total_size = (field_wid + sidebar_wid, field_hei)

    screen = pygame.display.set_mode(total_size)
    pygame.display.set_caption("Racer")

    # Create The playing field
    field = pygame.Surface(field_size)
    # convert() changes the pixel format
    # https://www.pygame.org/docs/ref/surface.html#pygame.Surface.convert
    field = field.convert()
    #  field.fill((250, 250, 250))
    field.fill((0, 0, 0))

    # Put Text On The field, Centered
    if not pygame.font:
        logg.error("You need fonts to put text on the screen")

    # create a new Font object (from a file if you want)
    font = pygame.font.Font(None, 36)

    # draw the field on the screen
    screen.blit(field, (0, 0))

    # create the sidebar
    sidebar = pygame.Surface(sidebar_size)
    sidebar = sidebar.convert()
    sidebar.fill((80, 80, 80))

    # render() draws the text on a Surface
    text_title = font.render("Drive safely", 1, (255, 255, 255))
    # somewhere here there is a nice drawing of rect pos
    # https://dr0id.bitbucket.io/legacy/pygame_tutorial01.html
    # the pos is relative to the surface you blit to
    textpos_title = text_title.get_rect(centerx=sidebar_wid / 2)

    # draw the text on the sidebar
    sidebar.blit(text_title, textpos_title)

    val_delta = 50
    speed_text_hei = 200
    text_speed = font.render("Speed:", 1, (255, 255, 255))
    textpos_speed = text_speed.get_rect(center=(sidebar_wid / 2,
                                                speed_text_hei))
    sidebar.blit(text_speed, textpos_speed)
    speed_val_hei = speed_text_hei + val_delta

    direction_text_hei = 300
    text_direction = font.render("Direction:", 1, (255, 255, 255))
    textpos_direction = text_direction.get_rect(center=(sidebar_wid / 2,
                                                        direction_text_hei))
    sidebar.blit(text_direction, textpos_direction)
    direction_val_hei = direction_text_hei + val_delta

    # draw the sidebar on the screen
    screen.blit(sidebar, (field_wid, 0))

    # update the display (linked with screen)
    pygame.display.flip()

    # Prepare Game Objects
    clock = pygame.time.Clock()

    #  racer = RacerCar(template_images, field_wid // 2, field_hei // 2)
    racer = RacerCar(template_images, 100, 100)

    rmap = RacerMap(field_wid, field_hei)
    # draw map on the field, it is static, so there is no need to redraw it every time
    rmap.draw(field)

    # draw the map first, the car on top
    #  allsprites = pygame.sprite.RenderPlain((rmap, racer))
    allsprites = pygame.sprite.RenderPlain((racer))

    # Main Loop
    going = True
    while going:
        clock.tick(fps)
        logg.debug(f"    New frame")

        # Handle Input Events
        # https://stackoverflow.com/a/22099654
        for event in pygame.event.get():
            logg.debug(f"Handling event {event}")
            if event.type == pygame.QUIT:
                going = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    going = False
            logg.debug(f"Done handling")

        keys = pygame.key.get_pressed()
        if keys[pygame.K_d]:
            racer.step("right")
        elif keys[pygame.K_a]:
            racer.step("left")
        elif keys[pygame.K_w]:
            racer.step("up")
        elif keys[pygame.K_x]:
            racer.step("down")
        elif keys[pygame.K_q]:
            racer.step("upleft")
        elif keys[pygame.K_e]:
            racer.step("upright")
        elif keys[pygame.K_z]:
            racer.step("downleft")
        elif keys[pygame.K_c]:
            racer.step("downright")
        else:
            racer.step("nop")

        # manually update the racer, pass the action in step
        #  allsprites.update()

        hits = spritecollide(racer, rmap, dokill=False)
        logg.debug(f"hitting {hits}")
        hit_directions = []
        hit_sid = []
        for segment in hits:
            logg.debug(f"hit segment with id {segment.sid}")
            hit_directions.append(rmap.seg_info[segment.sid][0])
            hit_sid.append(segment.sid)
        racer._compute_reward(hit_directions, hit_sid)

        # Draw Everything again, every frame
        # the field already has the road drawn
        screen.blit(field, (0, 0))

        # draw all moving sprites (the car) on the screen
        allsprites.draw(screen)
        # if you draw on the field you can easily leave a track
        #  allsprites.draw(field)

        # draw the sidebar template
        screen.blit(sidebar, (field_wid, 0))
        # draw the updated numbers

        pygame.display.flip()

    pygame.quit()
示例#55
0
 def handle_collisions(self, group):
     return PS.spritecollide(self, group, False)
示例#56
0
 def handle_enemies(self):
     collisions = PS.spritecollide(self, self.enemy_list, False)
     if len(collisions) > 0:
         self.projectile_attack_enemy = True
     for collision in collisions:
         self.enemies_attacked.append(collision)
示例#57
0
 def game_over(self):
     if spritecollide(self.player, self.zombies, False) and self.updated:
         self.game.game_over = True
示例#58
0
 def handle_player(self, player):
     collisions = PS.spritecollide(self, player, False)
     if (len(collisions) == 1 and collisions[0].enemy_ID == -1):
         if (Globals.INVINCIBILITY_COUNT == 0):
             self.attacked_player = True
示例#59
0
 def handle_collision(self, bg):
     collisions = PS.spritecollide(self, bg, False)
     #if collide, disappear
     if (pass_through == 0):
         if (len(collisions) > 0):
             self.kill()
示例#60
0
    def handle_collisions(self, tilemap, entities=None, **kwargs):
        if tilemap:
            collisions = []

            for x in tilemap:
                if x.collides:
                    collisions += spritecollide(self, x, False)

            self.blocked_top = False
            self.blocked_bottom = False
            self.blocked_right = False
            self.blocked_left = False

            newrect = self.rect.move(self.x_velocity, self.y_velocity)

            if collisions:
                for tile in collisions:
                    self.on_tile_collide(tile, entities, **kwargs)
                    if collision.top(
                            newrect, tile.rect
                    ):  # Moving down; Hit the top side of the wall
                        self.y_velocity = 0
                        self.y_acceleration = 0
                        self.rect.bottom = tile.rect.top

                        self.blocked_bottom = True

                    # For gravity
                    if collision.top(self.rect.move(0, 5), tile.rect):
                        self.jumping = False
                        self.falling = False
                        self.blocked_bottom = True
                    else:
                        self.falling = True

                    if collision.bottom(
                            newrect, tile.rect
                    ):  # Moving up; Hit the bottom side of the wall
                        self.y_velocity = 0
                        self.y_acceleration = 0
                        self.jumping = False

                        if self.rect.top < tile.rect.bottom:
                            self.rect.top = tile.rect.bottom

                        self.blocked_top = True

                    if collision.left(
                            newrect, tile.rect
                    ):  # Moving right; Hit the left side of the wall
                        self.x_velocity = 0
                        self.x_acceleration = 0

                        if self.rect.right > tile.rect.left:
                            self.rect.right = tile.rect.left

                        self.blocked_right = True

                    if collision.right(
                            newrect, tile.rect
                    ):  # Moving left; Hit the right side of the wall
                        self.x_velocity = 0
                        self.x_acceleration = 0

                        if self.rect.left < tile.rect.right:
                            self.rect.left = tile.rect.right

                        self.blocked_left = True