--- /dev/null
+{
+ "config": {
+ "name": "Station Alpha",
+ "power": 100,
+ "seeds": 10
+ },
+ "obstacles": [
+ {
+ "type": "wall",
+ "vertices": [
+ [400, 400], [450, 400], [450, 450], [400, 450]
+ ]
+ },
+ {
+ "type": "wall",
+ "vertices": [
+ [800, 400], [850, 400], [850, 450], [800, 450]
+ ]
+ },
+ {
+ "type": "wall",
+ "vertices": [
+ [200, 350], [250, 350], [250, 400], [200, 400]
+ ]
+ }
+ ],
+ "lights": [
+ {
+ "type": "spotlight",
+ "colour": "red",
+ "position": [700, 500],
+ "direction": 90.0,
+ "spread": 45.0,
+ "radius_limits": [20, 400],
+ "intensity": 0.8
+ }
+ ]
+}
import pygame.surface
import pygame.display
-import pygame.locals as pgl
-
from .constants import (SCREEN_SIZE, MOULD_CATEGORY, OBSTACLE_CATEGORY,
TURNIP_CATEGORY)
from .loader import loader
query[0].shape.body.turnip.eaten = True
return refresh
- def damage(self, light_color, intensity, space, moulds):
+ def damage(self, light, space, moulds):
"""Take damage for light, adjusted for resistances."""
+ distance = light.position.get_distance(self.position)
+ if distance < (light.radius_limits[0] or 0.0):
+ return False
+ if distance > (light.radius_limits[1] or 50.0):
+ return False
self._health -= 3
if self._health <= 0 and self._age <= 120:
# We die of damage
class Boyd(object):
def __init__(self, gamestate, space):
- seed = Mould(gamestate, space, (350, 370))
+ seed = Mould(gamestate, space, (275, 300))
self._moulds = [seed]
self._image = pygame.surface.Surface(SCREEN_SIZE)
self._image = self._image.convert_alpha(pygame.display.get_surface())
lit_by = lights.light_query(mould._shape)
for light in lit_by:
# Todo: extract colour and intensity from light
- if mould.damage(None, None, space, self._moulds):
+ if mould.damage(light, space, self._moulds):
redraw = True
break # we only die once
if redraw:
""" Obstacles for light and space mould. """
+import pygame.locals as pgl
+
import pymunk
import pymunk.pygame_util
import pygame.draw
+import pygame.surface
-from .constants import OBSTACLE_CATEGORY
+from .constants import (SCREEN_SIZE, OBSTACLE_CATEGORY)
+from .loader import loader
OBSTACLE_FILTER = pymunk.ShapeFilter(categories=OBSTACLE_CATEGORY)
def __init__(self, vertices):
super(Wall, self).__init__()
self.shapes.append(pymunk.Poly(self.body, vertices))
+ self._image = None
+
+ def get_image(self):
+ if self._image is None:
+ self._image = pygame.surface.Surface(SCREEN_SIZE).convert_alpha()
+ self._image.fill((0,0,0,0))
+
+ for shape in self.shapes:
+ pygame_poly = [
+ pymunk.pygame_util.to_pygame(v, self._image) for v in
+ shape.get_vertices()]
+ pygame.draw.polygon(self._image, (255, 255, 255), pygame_poly)
+
+ wall_texture = loader.load_image("textures", "stone.png").convert_alpha()
+ self._image.blit(wall_texture, (0, 0), None, pgl.BLEND_RGBA_MULT)
+
+ return self._image
def render(self, surface):
- for shape in self.shapes:
- pygame_poly = [
- pymunk.pygame_util.to_pygame(v, surface) for v in
- shape.get_vertices()]
- pygame.draw.polygon(surface, (0, 0, 0), pygame_poly)
+ surface.blit(self.get_image(), (0, 0), None, 0)
--- /dev/null
+""" Menu scene. """
+
+import os
+
+import pygame.locals as pgl
+
+from .base import BaseScene
+from ..events import SceneChangeEvent
+from ..widgets import TextButton
+from ..loader import loader
+
+
+class LoadLevelScene(BaseScene):
+
+ def _list_stations(self):
+ station_path = loader.full_path("stations")
+ files = os.listdir(station_path)
+ result = []
+ for f in files:
+ name, ext = os.path.splitext(f)
+ if ext == '.json':
+ result.append((name, f))
+ result.sort()
+ return result
+
+ def enter(self, gamestate):
+ """Construct list of stations"""
+ height = 50
+ self._buttons = []
+ width = 30
+ for station, filename in self._list_stations():
+ pos = (width, height)
+ button = TextButton(station, (255, 255, 255), filename, pos)
+ if width < 400:
+ width += 350
+ else:
+ width = 30
+ height += button.get_height() + 20
+ self._buttons.append(button)
+
+ def render(self, surface, gamestate):
+ surface.fill((0, 128, 128))
+ for button in self._buttons:
+ button.render(surface)
+
+ def _get_pressed(self, ev):
+ for button in self._buttons:
+ if button.pressed(ev):
+ return button.name
+ return None
+
+ def _do_load(self, name, gamestate):
+ from .day import DayScene
+ print "Loading station", name
+ gamestate.load_station(name)
+ SceneChangeEvent.post(scene=DayScene())
+
+ def event(self, ev, gamestate):
+ if ev.type == pgl.KEYDOWN:
+ if ev.key == pgl.K_l:
+ self._do_load("station_alpha.json", gamestate)
+ elif ev.type == pgl.MOUSEBUTTONDOWN:
+ pressed = self._get_pressed(ev)
+ if pressed:
+ self._do_load(pressed, gamestate)
from .day import DayScene
SceneChangeEvent.post(scene=DayScene())
+ def _do_load_level(self):
+ from .load_level import LoadLevelScene
+ SceneChangeEvent.post(scene=LoadLevelScene())
+
def event(self, ev, gamestate):
if ev.type == pgl.KEYDOWN:
if ev.key in (pgl.K_q, pgl.K_ESCAPE):
elif ev.key == pgl.K_d:
self._do_day()
elif ev.key == pgl.K_l:
- print "Loading Station Alpha ..."
- gamestate.load_station("station-alpha.json")
+ self._do_load_level()
elif ev.type == pgl.MOUSEBUTTONDOWN:
pressed = self._get_pressed(ev)
if pressed == 'load level':
- print "Loading Station Alpha ..."
- gamestate.load_station("station-alpha.json")
+ self._do_load_level()
elif pressed == 'start game':
self._do_day()
elif pressed:
projects / tabakrolletjie.git / commitdiff