title: Add collison detection to enemy sprites?
body: <p>i'd like to add the same collision detection used by the player sprite to the enemy sprites or 'creeps' ive added all the relevant code I can see yet collisons are still not being detected and handled, please find below the class, I have no idea what is wrong currently, the list of walls to collide with is 'wall_list' </p>
  
  <pre><code>import pygame
  import pauseScreen as dm
  import re
  from pygame.sprite import Sprite
  from pygame import Rect, Color
  from random import randint, choice
  from vec2d import vec2d
  from simpleanimation import SimpleAnimation
  import displattxt
  black = (0,0,0)
  white = (255,255,255)
  blue = (0,0,255)
  green = (101,194,151)
  global currentEditTool
  currentEditTool = "Tree"
  global editMap
  
  
  editMap = False
  open('MapMaker.txt', 'w').close()
  def draw_background(screen, tile_img):
          screen.fill(black)
          img_rect = tile_img.get_rect()
          global rect
          rect = img_rect
  
          nrows = int(screen.get_height() / img_rect.height) + 1
          ncols = int(screen.get_width() / img_rect.width) + 1
  
          for y in range(nrows):
              for x in range(ncols):
                  img_rect.topleft = (x * img_rect.width,
                                      y * img_rect.height)
                  screen.blit(tile_img, img_rect)
  
  def changeTool():
          if currentEditTool == "Tree":
                  None
          elif currentEditTool == "Rock":
                  None
  
  def pauseGame():
          red   = 255,  0,  0
          green =   0,255,  0
          blue  =   0,  0,255  
          screen.fill(black)
          pygame.display.update()
          if editMap == False:
                  choose = dm.dumbmenu(screen, [
                                  'Resume',
                                  'Enable Map Editor',
                                  'Quit Game'], 64,64,None,32,1.4,green,red)
  
                  if choose == 0:
                          print("hi")
                  elif choose ==1:
                          global editMap
                          editMap = True
                  elif choose ==2:
                          print("bob")
                  elif choose ==3:
                          print("bob")
                  elif choose ==4:
                          print("bob")
                  else:
                          None      
          else:
                  choose = dm.dumbmenu(screen, [
                                  'Resume',
                                  'Disable Map Editor',
                                  'Quit Game'], 64,64,None,32,1.4,green,red)
  
                  if choose == 0:
                          print("Resume")
                  elif choose ==1:
                          print("Dis ME")
                          global editMap
                          editMap = False
                  elif choose ==2:
                          print("bob")
                  elif choose ==3:
                          print("bob")
                  elif choose ==4:
                          print("bob")
                  else:
                          None                   
  
  class Wall(pygame.sprite.Sprite):
      # Constructor function
      def __init__(self,x,y,width,height):
          pygame.sprite.Sprite.__init__(self)   
          self.image = pygame.Surface([width, height])
          self.image.fill(green)
          self.rect = self.image.get_rect()
          self.rect.y = y
          self.rect.x = x
  
  
  class insertTree(pygame.sprite.Sprite):
  
      def __init__(self,x,y,width,height, typ):
          pygame.sprite.Sprite.__init__(self)
          self.image = pygame.image.load("images/map/tree.png").convert()
          self.image.set_colorkey(white)
          self.rect = self.image.get_rect()
          self.rect.y = y
          self.rect.x = x
  
  class insertRock(pygame.sprite.Sprite):
  
      def __init__(self,x,y,width,height, typ):
          pygame.sprite.Sprite.__init__(self)
          self.image = pygame.image.load("images/map/rock.png").convert()
          self.image.set_colorkey(white)
          self.rect = self.image.get_rect()
          self.rect.y = y
          self.rect.x = x
  
  class Creep(pygame.sprite.Sprite):
      """ A creep sprite that bounces off walls and changes its
          direction from time to time.
      """
      change_x=0
      change_y=0
      def __init__(   
              self, screen, creep_image, explosion_images, 
              field, init_position, init_direction, speed):
          """ Create a new Creep.
  
              screen: 
                  The screen on which the creep lives (must be a 
                  pygame Surface object, such as pygame.display)
  
              creep_image: 
                  Image (surface) object for the creep
  
              explosion_images:
                  A list of image objects for the explosion 
                  animation.
  
              field:
                  A Rect specifying the 'playing field' boundaries.
                  The Creep will bounce off the 'walls' of this 
                  field.
  
              init_position:
                  A vec2d or a pair specifying the initial position
                  of the creep on the screen.
  
              init_direction:
                  A vec2d or a pair specifying the initial direction
                  of the creep. Must have an angle that is a 
                  multiple of 45 degres.
  
              speed: 
                  Creep speed, in pixels/millisecond (px/ms)
          """
          Sprite.__init__(self)
  
          self.screen = screen
          self.speed = speed
          self.field = field
          self.rect = creep_image.get_rect()
  
          # base_image holds the original image, positioned to
          # angle 0.
          # image will be rotated.
          #
          self.base_image = creep_image
          self.image = self.base_image
          self.explosion_images = explosion_images
  
          # A vector specifying the creep's position on the screen
          #
          self.pos = vec2d(init_position)
  
          # The direction is a normalized vector
          #
          self.direction = vec2d(init_direction).normalized()
  
          self.state = Creep.ALIVE
          self.health = 15
  
      def is_alive(self):
          return self.state in (Creep.ALIVE, Creep.EXPLODING)
  
      def changespeed(self,x,y):
          self.change_x+=x
          self.change_y+=y
  
      def update(self, time_passed, walls):
          """ Update the creep.
  
              time_passed:
                  The time passed (in ms) since the previous update.
          """
          if self.state == Creep.ALIVE:
              # Maybe it's time to change the direction ?
              #
              self._change_direction(time_passed)
  
              # 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()
              bounds_rect = self.field.inflate(
                              -self.image_w, -self.image_h)
  
              if self.pos.x &lt; bounds_rect.left:
                  self.pos.x = bounds_rect.left
                  self.direction.x *= -1
              elif self.pos.x &gt; bounds_rect.right:
                  self.pos.x = bounds_rect.right
                  self.direction.x *= -1
              elif self.pos.y &lt; bounds_rect.top:
                  self.pos.y = bounds_rect.top
                  self.direction.y *= -1
              elif self.pos.y &gt; bounds_rect.bottom:
                  self.pos.y = bounds_rect.bottom
                  self.direction.y *= -1
  
          # collision detection
          old_x=bounds_rect.left
          new_x=old_x+self.direction.x
          bounds_rect.left = new_x
  
          # hit a wall?
          collide = pygame.sprite.spritecollide(self, walls, False)
          if collide:
              # yes
              bounds_rect.left=old_x
  
          old_y=self.pos.y
          new_y=old_y+self.direction.y
          self.pos.y = new_y
  
          collide = pygame.sprite.spritecollide(self, walls, False)
          if collide:
              # yes
              self.pos.y=old_y
  
          elif self.state == Creep.EXPLODING:
              if self.explode_animation.active:
                  self.explode_animation.update(time_passed)
              else:
                  self.state = Creep.DEAD
                  self.kill()
  
          elif self.state == Creep.DEAD:
              pass
  
          #------------------ PRIVATE PARTS ------------------#
  
      # States the creep can be in.
      #
      # ALIVE: The creep is roaming around the screen
      # EXPLODING: 
      #   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 &gt; 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
              body?
          """
          img_point = point - vec2d(  
              int(self.pos.x - self.image_w / 2),
              int(self.pos.y - self.image_h / 2))
  
          try:
              pix = self.image.get_at(img_point)
              return pix[3] &gt; 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)
          """
          self.health = max(0, self.health - n)
          if self.health == 0:
              self._explode()
  
  
  
  
      def _explode(self):
          """ Starts the explosion animation that ends the Creep's
              life.
          """
          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
  
          remainingCreeps-=1
  
          if remainingCreeps == 0:
                  print("all dead")
  
      def draw(self):
          """ Blit the creep onto the screen that was provided in
              the constructor.
          """
          if self.state == Creep.ALIVE:
              # The creep image is placed at self.pos. To allow for 
              # smooth movement even when the creep rotates and the 
              # image size changes, its placement is always 
              # centered.
              #
              self.draw_rect = self.image.get_rect().move(
                  self.pos.x - self.image_w / 2, 
                  self.pos.y - self.image_h / 2)
              self.screen.blit(self.image, self.draw_rect)
  
              # The health bar is 15x4 px.
              #
              health_bar_x = self.pos.x - 7
              health_bar_y = self.pos.y - self.image_h / 2 - 6
              self.screen.fill(   Color('red'), 
                                  (health_bar_x, health_bar_y, 15, 4))
              self.screen.fill(   Color('green'), 
                                  (   health_bar_x, health_bar_y, 
                                      self.health, 4))
  
          elif self.state == Creep.EXPLODING:
              self.explode_animation.draw()
  
          elif self.state == Creep.DEAD:
              pass
  
      def mouse_click_event(self, pos):
          """ The mouse was clicked in pos.
          """
          if self._point_is_inside(vec2d(pos)):
              self._decrease_health(3)
  #begin new player
  
  class Player(pygame.sprite.Sprite):
  
      change_x=0
      change_y=0
      frame = 0
  
      def __init__(self,x,y):
  
          pygame.sprite.Sprite.__init__(self)
          # LOAD PLATER IMAGES
          # Set height, width
          self.images = []
          for i in range(1,17):
              img = pygame.image.load("images/player/" + str(i)+".png").convert() #player images
              img.set_colorkey(white)
              self.images.append(img)
          self.image = self.images[0]
          self.rect = self.image.get_rect()
          self.rect.y = y
          self.rect.x = x
          self.health = 15
          self.image_w, self.image_h = self.image.get_size()
          health_bar_x = self.rect.x - 7
          health_bar_y = self.rect.y - self.image_h / 2 - 6
          screen.fill(   Color('red'), 
                                  (health_bar_x, health_bar_y, 15, 4))
          screen.fill(   Color('green'), 
                                  (   health_bar_x, health_bar_y, 
                                      self.health, 4))
  
      def changespeed(self,x,y):
          self.change_x+=x
          self.change_y+=y
  
      def _decrease_health(self, n):
          """ Decrease my health by n (or to 0, if it's currently
              less than n)
          """
          self.health = max(0, self.health - n)
          if self.health == 0:
              self._explode()
  
      def update(self,walls):
          # collision detection
          old_x=self.rect.x
          new_x=old_x+self.change_x
          self.rect.x = new_x
  
          # hit a wall?
          collide = pygame.sprite.spritecollide(self, walls, False)
          if collide:
              # yes
              self.rect.x=old_x
  
          old_y=self.rect.y
          new_y=old_y+self.change_y
          self.rect.y = new_y
  
          collide = pygame.sprite.spritecollide(self, walls, False)
          if collide:
              # yes
              self.rect.y=old_y
  
  
          # right to left
          if self.change_x &lt; 0:
              self.frame += 1
              if self.frame &gt; 3*4:
                  self.frame = 0                 
              # Grab the image, divide by 4
              # every 4 frames. 
              self.image = self.images[self.frame//4]
  
          # Move left to right.
          # images 4...7 instead of 0...3.
          if self.change_x &gt; 0:
              self.frame += 1
              if self.frame &gt; 3*4:
                  self.frame = 0
              self.image = self.images[self.frame//4+4]
  
          if self.change_y &gt; 0:
              self.frame += 1
              if self.frame &gt; 3*4:
                  self.frame = 0
              self.image = self.images[self.frame//4+4+4]
  
          if self.change_y &lt; 0:
              self.frame += 1
              if self.frame &gt; 3*4:
                  self.frame = 0
              self.image = self.images[self.frame//4+4+4+4]
  
  
  score = 0
  # initialize pyGame
  pygame.init()
  
  # 800x600 sized screen
  global screen
  screen = pygame.display.set_mode([800, 600])
  screen.fill(black)
  #bg_tile_img = pygame.image.load('images/map/grass.png').convert_alpha()
  #draw_background(screen, bg_tile_img)
  #pygame.display.flip()
  # Set title
  pygame.display.set_caption('Test')
  
  #background = pygame.Surface(screen.get_size())
  #background = background.convert()
  #background.fill(black)
  
  # Create the player
  player = Player( 50,50 )
  player.rect.x=50
  player.rect.y=50
  movingsprites = pygame.sprite.RenderPlain()
  movingsprites.add(player)
  
  # Make the walls. (x_pos, y_pos, width, height)
  global wall_list
  wall_list=pygame.sprite.RenderPlain()
  wall=Wall(0,0,10,600) # left wall
  wall_list.add(wall)
  wall=Wall(10,0,790,10) # top wall
  wall_list.add(wall)
  #wall=Wall(10,200,100,10) # poke wall 
  wall_list.add(wall)
  wall=Wall(790,0,10,600) #(x,y,thickness, height)
  wall_list.add(wall)
  wall=Wall(10,590,790,10)  #(x,y,thickness, height)
  wall_list.add(wall)
  
  
  f = open('MapMaker.txt')
  num_lines = sum(1 for line in f)
  print(num_lines)
  lineCount = 0
  with open("MapMaker.txt") as infile:
      for line in infile:
         f = open('MapMaker.txt')
         print(line)
  
         coords = line.split(',')
         #print(coords[0])
         #print(coords[1])
         #print(coords[2])
         #print(coords[3])
         #print(coords[4])
         if "tree" in line:
            print("tree in")
            wall=insertTree(int(coords[0]),int(coords[1]), int(coords[2]),int(coords[3]),coords[4])
            wall_list.add(wall)
         elif "rock" in line:
            print("rock in")
            wall=insertRock(int(coords[0]),int(coords[1]), int(coords[2]),int(coords[3]),coords[4] )
            wall_list.add(wall)
  
  
  
  
  
  
  width = 20
  height = 540
  height = height - 48
  for i in range(0,23):
      width = width + 32
      name = insertTree(width,540,790,10,"tree")
      #wall_list.add(name)
      name = insertTree(width,height,690,10,"tree")
      #wall_list.add(name)
  
  
  CREEP_SPAWN_TIME = 200 # frames
  
  creep_spawn = CREEP_SPAWN_TIME
  
  clock = pygame.time.Clock()
  bg_tile_img = pygame.image.load('images/map/grass.png').convert()
  img_rect = bg_tile_img
  FIELD_RECT = Rect(50, 50, 700, 500)
  CREEP_FILENAMES = [
       'images/player/1.png', 
      'images/player/1.png', 
      'images/player/1.png']
  N_CREEPS = 3
  
  creep_images = [
      pygame.image.load(filename).convert_alpha() 
      for filename in CREEP_FILENAMES]
  explosion_img = pygame.image.load('images/map/tree.png').convert_alpha()
  explosion_images = [
      explosion_img, pygame.transform.rotate(explosion_img, 90)]
  
  creeps = pygame.sprite.RenderPlain()
  
  
  done = False
  #bg_tile_img = pygame.image.load('images/map/grass.png').convert()
  #draw_background(screen, bg_tile_img)
  
  totalCreeps = 0
  remainingCreeps = 3
  while done == False:
  
      creep_images = pygame.image.load("images/player/1.png").convert()
      creep_images.set_colorkey(white)
      draw_background(screen, bg_tile_img)
  
      if len(creeps) != N_CREEPS:
  
          if totalCreeps &lt; N_CREEPS:
                          totalCreeps = totalCreeps + 1
                          print(totalCreeps)
                          creeps.add(
                          Creep(  screen=screen,
                          creep_image=creep_images, 
                          explosion_images=explosion_images,
                          field=FIELD_RECT,
                          init_position=( randint(FIELD_RECT.left, 
                                                  FIELD_RECT.right), 
                                          randint(FIELD_RECT.top, 
                                                  FIELD_RECT.bottom)), 
                          init_direction=(choice([-1, 1]), 
                                          choice([-1, 1])),
                          speed=0.01))
  
      for creep in creeps:
  
                      creep.update(60,wall_list)
                      creep.draw()
  
  
  
      for event in pygame.event.get():
  
  
          if event.type == pygame.QUIT:
              done=True
  
          if event.type == pygame.KEYDOWN:
              if event.key == pygame.K_LEFT:
                  player.changespeed(-2,0)
                  creep.changespeed(-2,0)
              if event.key == pygame.K_RIGHT:
                  player.changespeed(2,0)
                  creep.changespeed(2,0)
              if event.key == pygame.K_UP:
                  player.changespeed(0,-2)
                  creep.changespeed(0,-2)
              if event.key == pygame.K_DOWN:
                  player.changespeed(0,2)
                  creep.changespeed(0,2)
              if event.key == pygame.K_ESCAPE:
                  pauseGame()
              if event.key == pygame.K_1:
                  global currentEditTool
                  currentEditTool = "Tree"
                  changeTool()
              if event.key == pygame.K_2:
                  global currentEditTool
                  currentEditTool = "Rock"
                  changeTool()
  
          if event.type == pygame.KEYUP:
              if event.key == pygame.K_LEFT:
                  player.changespeed(2,0)
                  creep.changespeed(2,0)
              if event.key == pygame.K_RIGHT:
                  player.changespeed(-2,0)
                  creep.changespeed(-2,0)
              if event.key == pygame.K_UP:
                  player.changespeed(0,2)
                  creep.changespeed(0,2)
              if event.key == pygame.K_DOWN:
                  player.changespeed(0,-2)
                  creep.changespeed(0,-2)
  
          if event.type == pygame.MOUSEBUTTONDOWN and pygame.mouse.get_pressed()[0]:
                  for creep in creeps:
                          creep.mouse_click_event(pygame.mouse.get_pos())
  
                  if editMap == True:
                      x,y = pygame.mouse.get_pos()
                      if currentEditTool == "Tree":
  
                          name = insertTree(x-10,y-25, 10 , 10, "tree")
                          wall_list.add(name)
                          wall_list.draw(screen)          
                          f = open('MapMaker.txt', "a+")
                          image = pygame.image.load("images/map/tree.png").convert()
                          screen.blit(image, (30,10))
                          pygame.display.flip()
                          f.write(str(x) + "," + str(y) + ",790,10, tree\n")
                          #f.write("wall=insertTree(" + str(x) + "," + str(y) + ",790,10)\nwall_list.add(wall)\n")
  
                      elif currentEditTool == "Rock":
  
                          name = insertRock(x-10,y-25, 10 , 10,"rock")
                          wall_list.add(name)
                          wall_list.draw(screen)
                          f = open('MapMaker.txt', "a+")
                          f.write(str(x) + "," + str(y) + ",790,10,rock\n")
                          #f.write("wall=insertRock(" + str(x) + "," + str(y) + ",790,10)\nwall_list.add(wall)\n")
  
  
                  else:
                      None
  
  
  
  
  
      #pygame.display.flip()  
      player.update(wall_list)
  
  
  
  
  
      movingsprites.draw(screen)
      wall_list.draw(screen)
      pygame.display.flip()
  
      clock.tick(60)
  
  pygame.quit()
  </code></pre>