from lib.pgfw.pgfw.Sprite import Sprite

class StaticEnvironment(Sprite):

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.load_from_path(self.get_resource("home",
                                              "static-environment-path"),
                            True)
from pygame import mixer
from pygame.image import load

from lib.pgfw.pgfw.GameChild import GameChild
from food_spring.home.View import View
from food_spring.home.StaticEnvironment import StaticEnvironment
from food_spring.home.Foods import Foods
from food_spring.home.collection.Collection import Collection

class Home(GameChild):

    any_press_ignored = ["left", "right"]

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.display_surface = self.get_display_surface()
        self.input = self.get_input()
        self.compare = self.get_delegate().compare
        self.audio = self.get_audio()
        self.audio_path = self.get_resource("home", "audio")
        self.static_environment = StaticEnvironment(self)
        self.view = View(self)
        self.foods = Foods(self)
        self.collection = Collection(self)
        self.reset()
        self.deactivate()

    def deactivate(self):
        self.active = False
        self.input.unregister_any_press_ignore(*self.any_press_ignored)
        self.audio.stop_current_channel()
        mixer.quit()
        mixer.init(self.stored_frequency)

    def reset(self):
        self.foods.reset()
        self.store_frequency()

    def store_frequency(self):
        self.stored_frequency = mixer.get_init()[0]

    def activate(self):
        self.active = True
        self.input.register_any_press_ignore(*self.any_press_ignored)
        self.foods.activate()
        self.start_audio()

    def start_audio(self):
        self.store_frequency()
        mixer.quit()
        mixer.init(int(self.parent.timer.get_ratio_remaining() * \
                       self.stored_frequency))
        self.audio.play_bgm(self.audio_path)

    def update(self):
        if self.active:
            self.view.update()
            self.static_environment.update()
            self.foods.update()
from pygame import Rect

from lib.pgfw.pgfw.GameChild import GameChild

class Foods(GameChild, list):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.active_index = 0
        self.display_surface = self.get_display_surface()
        self.compare = self.get_delegate().compare
        self.bounds = self.get_display_surface().get_rect()
        self.load_configuration()
        self.set_foods()
        self.set_tv_rect()
        self.reset()
        self.subscribe(self.respond)

    def load_configuration(self):
        config = self.get_configuration("home")
        self.inactive_x = config["food-inactive-x"]
        self.inactive_y = config["food-inactive-y"]
        self.active_y = config["food-active-y"]
        self.margin = config["food-margin"]
        self.step = config["food-step"]
        self.tv_edge = config["tv-edge"]

    def set_foods(self):
        levels = self.get_game().levels
        for ii in range(len(levels)):
            self.append(levels[ii].food)

    def set_tv_rect(self):
        self.tv_rect = Rect(0, 0, self.tv_edge,
                            self.display_surface.get_height())

    def swap_in(self, index):
        self.store(self.get_active())
        self.active_index = index
        self.step_forward()

    def step_forward(self):
        self.get_active().location.bottomleft = self.get_x(self.active_index), \
                                                self.active_y

    def get_x(self, index):
        x = self.inactive_x
        for ii in range(index):
            x += self[ii].location.w + self.margin
        return x

    def respond(self, event):
        if self.parent.active:
            if self.compare(event, "left"):
                self.moving[0] = True
            elif self.compare(event, "left", True):
                self.moving[0] = False
            elif self.compare(event, "right"):
                self.moving[1] = True
            elif self.compare(event, "right", True):
                self.moving[1] = False
            elif self.compare(event, "any"):
                self.do()

    def do(self):
        rect = self.get_active().location
        if not self.collide_other():
            if rect.colliderect(self.tv_rect):
                self.stop_moving()
                self.store_location()
                self.parent.deactivate()
                self.get_game().levels.activate(self.active_index)
            elif rect.colliderect(self.parent.collection):
                pass

    def stop_moving(self):
        self.moving = [False, False]

    def collide_other(self):
        active = self.get_active()
        rect = active.location
        clip = None
        closest = None
        for food in self:
            if active != food and rect.colliderect(food):
                if not clip or rect.clip(food).w > clip.w:
                    clip = rect.clip(food)
                    closest = food
        if closest:
            self.swap_in(self.index(closest))
            return True

    def store_location(self):
        self.stored_location = self.get_active().location.topleft

    def reset(self):
        for food in self:
            self.store(food)
        self.swap_in(0)
        self.stop_moving()
        self.store_location()

    def activate(self):
        for food in self:
            if self.index(food) != self.active_index:
                self.store(food)
        self.get_active().location.topleft = self.stored_location

    def store(self, food):
        index = self.index(food)
        self[index].location.bottomleft = self.get_x(index), self.inactive_y

    def update(self):
        active = self.get_active()
        if True in self.moving:
            if self.moving[0]:
                active.move(-self.step)
            if self.moving[1]:
                active.move(self.step)
            self.wrap()
        for food in self:
            if self.index(food) != self.active_index:
                food.update()
        active.update()

    def get_active(self):
        return self[self.active_index]

    def wrap(self):
        rect = self.get_active().location
        bounds = self.bounds
        if rect.left > bounds.right:
            rect.right = bounds.left
        elif rect.right < bounds.left:
            rect.left = bounds.right
18.97.14.81
18.97.14.81
18.97.14.81
 
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.