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