tabakrolletjie/enemies.py

   1 # Boyd, the friendly, misunderstood turnip loving, light hating space mould
   2
   3 import random
   4
   5 import pymunk
   6 import pymunk.pygame_util
   7 import pygame.draw
   8 import pygame.surface
   9 import pygame.display
  10
  11 import pygame.locals as pgl
  12
  13 from .constants import (SCREEN_SIZE, MOULD_CATEGORY, OBSTACLE_CATEGORY,
  14                         TURNIP_CATEGORY)
  15 from .loader import loader
  16 from .sound import sound
  17
  18 MOULD_FILTER = pymunk.ShapeFilter(
  19     mask=MOULD_CATEGORY | OBSTACLE_CATEGORY,
  20     categories=MOULD_CATEGORY)
  21
  22 EAT_TURNIP_FILTER = pymunk.ShapeFilter(mask=TURNIP_CATEGORY)
  23
  24
  25 class Mould(pymunk.Body):
  26     """A segment of Boyd"""
  27
  28     def __init__(self, gamestate, space, pos):
  29         super(Mould, self).__init__(0, 0, pymunk.Body.STATIC)
  30         self.position = pos
  31         self._shape = pymunk.Circle(self, 16)
  32         space.add(self, self._shape)
  33         self._shape.filter = MOULD_FILTER
  34         self._resistances = {}
  35         self._age = 0
  36         self._img = None
  37         self._health = 500
  38         self.has_eyeball = False
  39         self._eyeball = None
  40
  41     def pygame_pos(self, surface):
  42         """Convert to pygame coordinates and offset position so
  43            our position is the centre of the image."""
  44         # The odd sign combination is because of the pymunk / pygame
  45         # transform, but we do it this way to exploit Vec2d math magic
  46         return pymunk.pygame_util.to_pygame(self.position + (-16, 16), surface)
  47
  48     def get_image(self):
  49         if not self._img:
  50             name = random.choice(
  51                 ('mouldA.png', 'mouldB.png', 'mouldC.png'))
  52             size = "16" if self._age < 10 else "32" if self._age < 20 else "64"
  53             self._img = loader.load_image(size, name)
  54         return self._img
  55
  56     def get_eyeball(self):
  57         if not self._eyeball:
  58             name = random.choice(
  59                 ('eyeballA.png', 'eyeballB.png', 'eyeballC.png'))
  60             self._eyeball = loader.load_image("32", name)
  61         return self._eyeball
  62
  63     def tick(self, gamestate, space, moulds):
  64         """Grow and / or Die"""
  65
  66         self._age += 1
  67
  68         # we regain a health every tick, so we heal in the dark
  69         if self._health < 100:
  70             self._health += 1
  71
  72         refresh = False
  73
  74         if (self._age % 15) == 0 and len(moulds) < 1000:
  75             # Spawn a new child, if we can
  76             spawn = True
  77             choice = random.randint(0, 4)
  78             if choice == 0:
  79                 pos = self.position + (0, 24)
  80             elif choice == 1:
  81                 pos = self.position + (24, 0)
  82             elif choice == 2:
  83                 pos = self.position + (-24, 0)
  84             else:
  85                 pos = self.position + (0, -24)
  86             # check for bounds
  87             if pos[0] < 0 or pos[0] >= SCREEN_SIZE[0]:
  88                 spawn = False
  89             if pos[1] < 0 or pos[1] >= SCREEN_SIZE[1]:
  90                 spawn = False
  91             # Check for free space
  92             # We allow some overlap, hence not checking full radius
  93             query = space.point_query(pos, 8, MOULD_FILTER)
  94             if query:
  95                 # for x in query:
  96                 #     if not isinstance(x.shape.body, Mould):
  97                 #         print x.shape, x.shape.body
  98                 spawn = False
  99             if spawn:
 100                 child = Mould(gamestate, space, pos)
 101                 child._health = self._health
 102                 moulds.append(child)
 103                 refresh = True
 104                 if random.randint(0, 10) < 2:
 105                     sound.play_sound("mouth_pop_2a.ogg")
 106
 107         if self._age in (10, 20):
 108             # We grow in size
 109             refresh = True
 110             self._img = None  # invalidate cached image
 111
 112         if self._age > 20 and random.randint(0, 500) < 1:
 113             # Maybe we grow an eyeball
 114             self.has_eyeball = True
 115
 116         if self._age > 120:
 117             # We die of old age
 118             space.remove(self, self._shape)
 119             moulds.remove(self)
 120             refresh = True
 121         else:
 122             # Check for turnips we can eat
 123             # Note that we can only eat a tick after we spawn
 124             query = space.point_query(self.position, 16, EAT_TURNIP_FILTER)
 125             if query:
 126                 query[0].shape.body.turnip.eaten = True
 127         return refresh
 128
 129     def damage(self, light_color, intensity, space, moulds):
 130         """Take damage for light, adjusted for resistances."""
 131         self._health -= 3
 132         if self._health <= 0 and self._age <= 120:
 133             # We die of damage
 134             space.remove(self, self._shape)
 135             moulds.remove(self)
 136             return True
 137         return False
 138
 139
 140 class Boyd(object):
 141
 142     def __init__(self, gamestate, space):
 143         seed = Mould(gamestate, space, (350, 370))
 144         self._moulds = [seed]
 145         self._image = pygame.surface.Surface(SCREEN_SIZE)
 146         self._image = self._image.convert_alpha(pygame.display.get_surface())
 147         self._draw_moulds()
 148
 149     def _draw_moulds(self):
 150         self._image.fill((0, 0, 0, 0))
 151         for m in self._moulds:
 152             self._image.blit(m.get_image(),
 153                              m.pygame_pos(self._image), None,
 154                              0)
 155         for m in self._moulds:
 156             if m.has_eyeball:
 157                 self._image.blit(m.get_eyeball(), m.pygame_pos(self._image),
 158                                  None, 0)
 159
 160     def tick(self, gamestate, space, lights):
 161         redraw = False
 162         # Handle spawn events
 163         for mould in self._moulds[:]:
 164             # Handle updates
 165             if mould.tick(gamestate, space, self._moulds):
 166                 redraw = True
 167             # Check for damage
 168             lit_by = lights.light_query(mould._shape)
 169             for light in lit_by:
 170                 # Todo: extract colour and intensity from light
 171                 if mould.damage(None, None, space, self._moulds):
 172                     redraw = True
 173                     break  # we only die once
 174         if redraw:
 175             self._draw_moulds()
 176
 177     def render(self, surface):
 178         """Draw ourselves"""
 179         surface.blit(self._image, (0, 0), None, 0)