from pygame.image import load

from dark_stew.pgfw.Sprite import Sprite

class Clouds(Sprite):

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.dx = -self.get_configuration("clouds", "speed")
        self.load_from_path(self.get_resource("clouds", "path"), True)

    def update(self):
        self.move(self.dx)
        Sprite.update(self)

    def draw(self):
        rect = self.rect
        offset = rect.left + rect.w
        self.display_surface.blit(self.get_current_frame(), rect)
        Sprite.draw(self)
from dark_stew.pgfw.Game import Game
from dark_stew.pgfw.Configuration import TypeDeclarations
from dark_stew.World import World
from dark_stew.monster.Monsters import Monsters

class DarkStew(Game):

    def __init__(self):
        Game.__init__(self, type_declarations=Types())

    def set_children(self):
        Game.set_children(self)
        self.world = World(self)
        self.monsters = Monsters(self)

    def update(self):
        self.world.update()
        self.monsters.update()


class Types(TypeDeclarations):

    additional_defaults = {

        "joy": {"int": ["run", "action"]},

        "world": {"int-list": "dimensions",

                  "int": ["walk-step", "run-step"],

                  "path": "audio-path"},

        "floor": {"path": ["tile-path", "film-path"],

                  "int": "film-opacity"},

        "water": {"float-list": "speed",

                  "path": "tile-path",

                  "int-list": ["color", "opacity"]},

        "pool": {"int": ["framerate", "padding"],

                 "path": ["water-path", "ring-path", "led-path"]},

        "stool": {"path": "path",

                  "float-list": ["angles", "offsets"]},

        "led": {"path": "path",

                "float": ["angle", "offset"]},

        "aphids": {"path": ["path", "animation-path", "moving-path",
                            "standing-path", "sitting-path", "back-path",
                            "front-path", "side-path", "rod-path", "line-path"],

                   "int": ["rest-framerate", "walk-framerate", "run-framerate"],

                   "int-list": "collision-rect",

                   "float": ["initial-chance", "chance-increase"]},

        "monsters": {"path": "path",

                     "int": ["shadow-offset", "shadow-alpha"]},

        }
from pygame import Surface
from pygame.image import load
from pygame.draw import circle
from pygame.locals import *

from dark_stew.pgfw.GameChild import GameChild

class Floor(GameChild, Surface):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.display_surface = self.get_display_surface()
        self.input = self.get_input()
        self.load_configuration()
        self.init_surface()
        self.paint()
        self.add_film()

    def load_configuration(self):
        config = self.get_configuration("floor")
        self.tile_path = self.get_resource("floor", "tile-path")
        self.film_path = self.get_resource("floor", "film-path")
        self.film_opacity = config["film-opacity"]

    def init_surface(self):
        Surface.__init__(self, self.parent.size)

    def paint(self):
        tile = load(self.tile_path)
        self.fill_tile(tile)

    def fill_tile(self, tile, blend=0):
        for x in xrange(0, self.get_width(), tile.get_width()):
            for y in xrange(0, self.get_height(), tile.get_height()):
                self.blit(tile, (x, y), None, blend)

    def add_film(self):
        tile = load(self.film_path).convert_alpha()
        tile.set_alpha(self.film_opacity)
        self.fill_tile(tile, BLEND_ADD)

    def add_holes(self):
        for pool in self.parent.pools:
            self.fill(self.transparent_color, pool)

    def draw(self):
        surface = self.display_surface
        for corner in self.parent.get_corners():
            surface.blit(self, corner)
from pygame import Surface
from pygame.image import load

from dark_stew.pgfw.GameChild import GameChild

class Monster(GameChild):

    def __init__(self, parent, path):
        GameChild.__init__(self, parent)
        self.path = path
        self.display_surface = self.get_display_surface()
        self.set_image()
        self.set_shadow()

    def set_image(self):
        image = load(self.path).convert()
        rect = image.get_rect()
        rect.center = self.display_surface.get_rect().center
        offset = self.parent.shadow_offset / 2
        rect.move_ip(-offset, -offset)
        self.image = image
        self.image_rect = rect

    def set_shadow(self):
        shadow = Surface(self.image.get_size())
        parent = self.parent
        shadow.fill(parent.shadow_color)
        rect = shadow.get_rect()
        rect.center = self.display_surface.get_rect().center
        offset = parent.shadow_offset / 2
        rect.move_ip(offset, offset)
        shadow.set_alpha(parent.shadow_alpha)
        self.shadow = shadow
        self.shadow_rect = rect

    def draw(self):
        surface = self.display_surface
        surface.blit(self.shadow, self.shadow_rect)
        surface.blit(self.image, self.image_rect)
from os import listdir
from os.path import join
from random import choice

from pygame import Color

from dark_stew.pgfw.GameChild import GameChild
from dark_stew.monster.Monster import Monster

class Monsters(GameChild, list):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.current = None
        self.delegate = self.get_delegate()
        self.load_configuration()
        self.add_monsters()

    def load_configuration(self):
        config = self.get_configuration("monsters")
        self.shadow_color = Color(config["shadow-color"])
        self.shadow_offset = config["shadow-offset"]
        self.shadow_alpha = config["shadow-alpha"]
        self.path = self.get_resource("monsters", "path")

    def add_monsters(self):
        root = self.path
        for path in [join(root, name) for name in sorted(listdir(root))]:
            self.append(Monster(self, path))

    def open_random(self):
        self.current = choice(self)

    def close(self):
        self.current = None

    def update(self):
        if self.current:
            self.current.draw()
44.223.39.67
44.223.39.67
44.223.39.67
 
June 6, 2016