Game Development Stack Exchange is a question and answer site for professional and independent game developers. It's 100% free, no registration required.

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

bassically im trying to add collision detection to the sprite below, using the following:

self.rect = bounds_rect

                collide = pygame.sprite.spritecollide(self, wall_list, False)

                if collide:
            # yes


However it seems that when the collide is triggered it continuously prints 'collide' over and over when instead i want them to simply not be able to walk through the object, any help?

def update(self, time_passed):
        """ Update the creep.

                The time passed (in ms) since the previous update.
        if self.state == Creep.ALIVE:
            # Maybe it's time to change the direction ?

            # Make the creep point in the correct direction.
            # Since our direction vector is in screen coordinates 
            # (i.e. right bottom is 1, 1), and rotate() rotates 
            # counter-clockwise, the angle must be inverted to 
            # work correctly.
            self.image = pygame.transform.rotate(
                self.base_image, -self.direction.angle)

            # Compute and apply the displacement to the position 
            # vector. The displacement is a vector, having the angle
            # of self.direction (which is normalized to not affect
            # the magnitude of the displacement)
            displacement = vec2d(    
                self.direction.x * self.speed * time_passed,
                self.direction.y * self.speed * time_passed)

            self.pos += displacement

            # When the image is rotated, its size is changed.
            # We must take the size into account for detecting 
            # collisions with the walls.
            self.image_w, self.image_h = self.image.get_size()
            global bounds_rect
            bounds_rect = self.field.inflate(
                            -self.image_w, -self.image_h)

            if self.pos.x < bounds_rect.left:
                self.pos.x = bounds_rect.left
                self.direction.x *= -1
            elif self.pos.x > bounds_rect.right:
                self.pos.x = bounds_rect.right
                self.direction.x *= -1
            elif self.pos.y <
                self.pos.y =
                self.direction.y *= -1
            elif self.pos.y > bounds_rect.bottom:
                self.pos.y = bounds_rect.bottom
                self.direction.y *= -1

            self.rect = bounds_rect

            collide = pygame.sprite.spritecollide(self, wall_list, False)

            if collide:
        # yes


        elif self.state == Creep.EXPLODING:
                self.state = Creep.DEAD

        elif self.state == Creep.DEAD:

        #------------------ PRIVATE PARTS ------------------#

    # States the creep can be in.
    # ALIVE: The creep is roaming around the screen
    #   The creep is now exploding, just a moment before dying.
    # DEAD: The creep is dead and inactive
    (ALIVE, EXPLODING, DEAD) = range(3)

    _counter = 0

    def _change_direction(self, time_passed):
        """ Turn by 45 degrees in a random direction once per
            0.4 to 0.5 seconds.
        self._counter += time_passed
        if self._counter > randint(400, 500):
            self.direction.rotate(45 * randint(-1, 1))
            self._counter = 0

    def _point_is_inside(self, point):
        """ Is the point (given as a vec2d) inside our creep's
        img_point = point - vec2d(  
            int(self.pos.x - self.image_w / 2),
            int(self.pos.y - self.image_h / 2))

            pix = self.image.get_at(img_point)
            return pix[3] > 0
        except IndexError:
            return False

    def _decrease_health(self, n):
        """ Decrease my health by n (or to 0, if it's currently
            less than n)
        """ = max(0, - n)
        if == 0:

    def _explode(self):
        """ Starts the explosion animation that ends the Creep's
        self.state = Creep.EXPLODING
        pos = ( self.pos.x - self.explosion_images[0].get_width() / 2,
                self.pos.y - self.explosion_images[0].get_height() / 2)
        self.explode_animation = SimpleAnimation(
            self.screen, pos, self.explosion_images,
            100, 300)
        global remainingCreeps


        if remainingCreeps == 0:
                print("all dead")
share|improve this question
up vote 1 down vote accepted

When the collision happens you need to do something to resolve it, for example, stop the motion of the offending sprite, and probably move it back a small step, else it will continue to collide in every loop through your update.

share|improve this answer
Well currently im just printing 'collide' but it seems as SOON as it collides it prints it out over and over indefinatly 0.0 – xBroak Dec 2 '12 at 12:32
That's because you're not doing anything to make it stop colliding, so it'll print it again every time you call update. – Donnie Dec 3 '12 at 18:01

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.