from glob import glob
from os.path import join

from pygame import Color, PixelArray
from pygame.image import load

from lib.pgfw.pgfw.GameChild import GameChild

class View(GameChild):

    MAX_ALPHA = 255

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.index = 0
        self.alpha = self.MAX_ALPHA
        self.frame_index = 1
        self.display_surface = self.get_display_surface()
        self.load_configuration()
        self.set_frames()

    def load_configuration(self):
        config = self.get_configuration("view")
        self.coordinates = config["coordinates"]
        self.root = config["path"]
        self.alpha_step = config["alpha-step"]

    def set_frames(self):
        frames = []
        for path in sorted(glob(join(self.get_resource(self.root), "[0-9]*"))):
            frames.append(load(path).convert())
        self.frames = frames

    def update(self):
        self.decrement_alpha()
        self.draw()

    def decrement_alpha(self):
        alpha = self.alpha - self.alpha_step
        if alpha <= 0:
            alpha = self.MAX_ALPHA
            self.get_previous_frame().set_alpha(alpha)
            self.increment_frame_index()
        self.get_previous_frame().set_alpha(alpha)
        self.alpha = alpha

    def get_current_frame(self):
        return self.frames[self.frame_index]

    def increment_frame_index(self):
        index = self.frame_index + 1
        if index >= len(self.frames):
            index = 0
        self.frame_index = index

    def draw(self):
        display_surface = self.display_surface
        coordinates = self.coordinates
        display_surface.blit(self.get_current_frame(), coordinates)
        display_surface.blit(self.get_previous_frame(), coordinates)

    def get_previous_frame(self):
        frames = self.frames
        index = self.frame_index - 1
        if index < 0:
            index = len(frames) - 1
        return frames[index]
from pygame import Rect

from lib.pgfw.pgfw.GameChild import GameChild

class Collection(GameChild, Rect):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.load_configuration()
        self.init_rect()

    def load_configuration(self):
        config = self.get_configuration("collection")
        self.coordinates = config["coordinates"]
        self.size = config["size"]

    def init_rect(self):
        Rect.__init__(self, self.coordinates, self.size)
from os.path import join
from glob import glob

from pygame import Surface
from pygame.image import load

from lib.pgfw.pgfw.GameChild import GameChild
from food_spring.gaia.Swapper import Swapper

class Gaia(GameChild):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.offset = self.get_configuration("gaia", "offset")
        self.set_images()
        self.swapper = Swapper(self)

    def set_images(self):
        images = []
        for path in sorted(glob(join(self.get_resource("gaia", "path"),
                                     "*.png"))):
            images.append(load(path).convert_alpha())
        self.images = images
from random import shuffle, choice

from pygame import Surface
from pygame.time import get_ticks
from pygame.locals import *

from lib.pgfw.pgfw.GameChild import GameChild
from lib.pgfw.pgfw.Sprite import Sprite

class Swapper(GameChild, Surface):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.load_configuration()
        self.init_surface()
        self.set_segments()

    def load_configuration(self):
        config = self.get_configuration("introduction")
        self.segment_count = config["segments"]
        self.transition_time = config["transition"]

    def init_surface(self):
        parent = self.parent
        offset = parent.offset
        line, spread  = parent.images
        Surface.__init__(self, (line.get_width(), line.get_height() + offset),
                         SRCALPHA)
        self.blit(line, (0, 0))
        self.blit(spread, (0, offset))
        rect = self.get_rect()
        rect.left = self.get_display_surface().get_width() / 2 - \
                    self.get_width() / 2
        self.rect = rect

    def set_segments(self):
        width, height = self.get_size()
        count = self.segment_count
        segment_width = width / count
        remainder = width % count
        x = 0
        segments = []
        for _ in xrange(count):
            adjusted_width = segment_width + (remainder > 0)
            segments.append(Segment(self, x, 0, adjusted_width, height))
            x += adjusted_width
            remainder -= 1
        self.segments = segments

    def swap(self, p, q):
        if isinstance(p, int):
            p, q = self.segments[p], self.segments[q]
        if not (p.moving() or q.moving()):
            p.set_destination(q.location.right)
            q.set_destination(p.location.right)

    def update(self):
        for segment in self.segments:
            segment.update()
        self.swap(choice(self.segments), choice(self.segments))


class Segment(Sprite):

    def __init__(self, parent, *args):
        Sprite.__init__(self, parent)
        self.add_frame(self.parent.subsurface(args).copy())
        self.location.topleft = args[0] + self.parent.rect.left, args[1]
        self.destination = self.location.right

    def moving(self):
        return self.destination != self.location.right

    def set_destination(self, right):
        self.destination = right
        self.distance = abs(self.location.right - right)
        self.last_ticks = get_ticks()

    def update(self):
        right = self.location.right
        destination = self.destination
        ticks = get_ticks()
        if self.moving():
            elapsed = float(ticks - self.last_ticks)
            step = int(self.distance * elapsed / self.parent.transition_time) \
                   or 1
            if destination < right:
                step = -step
            self.move(step)
            if abs(step) >= abs(self.location.right - destination):
                self.location.right = destination
        self.last_ticks = ticks
        Sprite.update(self)
35.172.223.30
35.172.223.30
35.172.223.30
 
September 30, 2015


Edge of Life is a form I made with Babycastles and Mouth Arcade for an event in New York called Internet Yami-ichi, a flea market of internet-ish goods. We set up our table to look like a doctor's office and pharmacy and offered free examinations and medication prescriptions, a system described by one person as "a whole pharmacy and medical industrial complex".

Diagnoses were based on responses to the form and observations by our doctor during a short examination. The examination typically involved bizarre questions, toy torpedoes being thrown at people and a plastic bucket over the patient's head. The form combined ideas from Myers-Briggs Type Indicators, Codex Seraphinianus and chain-mail personality tests that tell you which TV show character you are. In our waiting room, we had Lake of Roaches installed in a stuffed bat (GIRP bat). It was really fun!

The icons for the food pyramid are from Maple Story and the gun icons are from the dingbat font Outgunned. I'm also using Outgunned to generate the items in Food Spring.