#!/usr/bin/env python

from random import randint, random, choice, randrange, uniform
from math import sin, tan, radians, copysign, degrees, cos, asin
from os import mkdir, remove
from os.path import join, exists
from sys import argv
from glob import glob
from collections import deque
from itertools import chain

from pygame.locals import *
from pygame import Surface, Color, PixelArray
from pygame.font import Font
from pygame.mixer import Sound, Channel, get_num_channels
from pygame.draw import polygon, line, circle, aaline
from pygame.gfxdraw import aapolygon, aacircle, filled_circle
from pygame.image import load, save
from pygame.transform import rotate, smoothscale, rotozoom, scale, flip
from pygame.event import clear
from pygame.display import set_mode

from lib.pgfw.pgfw.Game import Game
from lib.pgfw.pgfw.GameChild import GameChild
from lib.pgfw.pgfw.Sprite import Sprite
from lib.pgfw.pgfw.Animation import Animation
from lib.pgfw.pgfw.Vector import Vector
from lib.pgfw.pgfw.extension import (get_distance, get_delta, place_in_rect,
                                     get_step, collide_line_with_rect)

class SoundEffect(GameChild, Sound):

    def __init__(self, parent, path, volume=1.0):
        GameChild.__init__(self, parent)
        Sound.__init__(self, path)
        self.display_surface = self.get_display_surface()
        self.set_volume(volume)

    def play(self, loops=0, maxtime=0, fade_ms=0, position=None, x=None):
        channel = Sound.play(self, loops, maxtime, fade_ms)
        if x is not None:
            position = float(x) / self.display_surface.get_width()
	if position is not None and channel is not None:
            channel.set_volume(*self.get_panning(position))
        return channel

    def get_panning(self, position):
        return 1 - max(0, ((position - .5) * 2)), \
               1 + min(0, ((position - .5) * 2))

# ===--------------------===
# )))) FISSION / FUSION ((((
# ===--------------------===

class iQue(Game, Sprite):

    GENERATE_FLAG = "-generate"
    FRAME_DIR = "frame/"

    def __init__(self):
        Game.__init__(self)
        Sprite.__init__(self, self, 1000)
        if self.check_command_line(self.GENERATE_FLAG):
            pixels = PixelArray(smoothscale(\
                load(self.get_resource("Untitled.png")).convert(), (500, 400)))
            if not exists(self.FRAME_DIR):
                mkdir(self.FRAME_DIR)
            for path in glob("%s/*.png" % self.FRAME_DIR):
                remove(path)
            for ii in xrange(int(argv[argv.index("-" + \
                                                 self.GENERATE_FLAG) + 1])):
                color = Color(0, 0, 0)
                for x in xrange(len(pixels)):
                    for y in xrange(len(pixels[0])):
                        h, s, l, a = Color(*Surface((0, 0)).\
                                           unmap_rgb(pixels[x][y])).hsla
                        color.hsla = int((h + (ii % 240)) % 360), int(s), 50,\
                                     100
                        pixels[x][y] = color
                        pixels[x - 138][y - (ii % 1024)] = pixels[\
                            x - (ii % 128)][y - (ii % 2)]
                print ii
                save(pixels.make_surface(), "%s/%04i.png" % (self.FRAME_DIR,
                                                             ii))
        for path in sorted(glob("%s/*.png" % self.FRAME_DIR)):
            self.add_frame(load(path).convert())
        self.location.topleft = -10, -10
        self.goal = Goal(self)
        self.calorie = Calorie(self)
        self.carrot = Carrot(self)
        self.subscribe(self.respond)
        self.reset()
        clear()

    def respond(self, event):
        if self.delegate.compare(event, "reset-game"):
            self.reset()

    def reset(self):
        self.calorie.reset()

    def update(self):
        Sprite.update(self)
        self.goal.update()
        self.carrot.update()
        self.calorie.update()


class Carrot(Sprite):

    SIZE = 60, 35
    MARGIN = 30

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.add_frame(smoothscale(load("Emparchment.png").convert_alpha(),
                                   self.SIZE))
        self.spawn()

    def spawn(self):
        place_in_rect(self.get_display_surface().get_rect(), self.location,
                      True, self.parent.goal.skull.location.inflate(\
                          [self.MARGIN] * 2))
        self.parent.calorie.find_carrot()


class Goal(GameChild):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.skull = Skull(self)
        self.shield = Shield(self)

    def update(self):
        self.skull.update()


class Skull(Sprite):

    MARGIN = 10

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.add_frame(load("Pencil.png").convert_alpha())
        self.location.bottomright = self.get_display_surface().get_rect().\
                                    move([-self.MARGIN] * 2).bottomright


class Shield(GameChild):

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


class Calorie(Sprite):

    SIZE = 71, 88
    SPAWN_MARGIN = 30
    FETCH_DELAY = 1000
    SPEED = 7
    CARROT_BOX_SHRINK = -20, -10
    PROJECTION_LENGTH = 2000
    SPIN_RANGE = -1.2, 1.2
    NORTH, EAST, SOUTH, WEST = range(4)

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.step = (0, 0)
        self.shot_speed_nodeset = self.get_game().interpolator.\
                                  get_nodeset("shot-speed")
        self.add_frames()
        self.shadow = load("Gallery.png").convert_alpha()
        self.register(self.fetch_carrot, self.barf)

    def add_frames(self):
        morph_paths = glob(join(self.get_resource("morph"), "*.png"))
        base = load("Calorie.png").convert_alpha()
        self.add_frame(base)
        self.add_frameset(0, name="facing-right")
        self.add_frame(flip(base, True, False))
        self.add_frameset(1, name="facing-left")
        self.set_frameset(randint(1, 2))
        for path in sorted():
            self.add_frame(load(path).convert_alpha())
            self.add_frameset(xrange(2, len(self.frames)), name="shooting")

    def reset(self):
        self.shot_count = 0
        self.clear_aim()
        place_in_rect(self.get_display_surface().get_rect(), self.location,
                      True, self.parent.goal.skull.location.inflate(\
                          [self.SPAWN_MARGIN] * 2))

    def clear_aim(self):
        self.collisions = []
        self.steps = []

    def find_carrot(self):
        self.play(self.fetch_carrot, delay=self.FETCH_DELAY, play_once=True)

    def fetch_carrot(self):
        step = self.step = get_step(self.location.midbottom,
                                    self.parent.carrot.location.center,
                                    self.SPEED)
        if step[0] < 0:
            self.set_frameset("facing-left")
        else:
            self.set_frameset("facing-right")

    def aim(self):
        angles = deque(xrange(360))
        angles.rotate(randrange(0, len(angles)))
        magnitude = self.shot_speed_nodeset.get_y(self.shot_count)
        bounds = self.get_display_surface().get_rect()
        spin = uniform(*self.SPIN_RANGE)
        best_wc, best_c, best_s = None, [], []
        for angle in angles:
            collides, wall_count, collisions, steps = self.project(angle, spin,
                                                                   magnitude,
                                                                   bounds)
            if collides and wall_count >= best_wc and \
                   len(steps) >= len(best_s) and len(collisions) <= \
                   len(best_c) + 1:
                best_wc = wall_count
                best_c = collisions
                best_s = steps
        self.steps = best_s
        self.collisions = best_c
        self.shot_count += 1
        self.set_frameset("shooting")
        self.play(self.barf, delay=3000, play_once=True)

    def project(self, angle, spin, magnitude, bounds):
        traveled = 0
        projection = Vector(*self.get_game().carrot.location.center)
        collides = False
        steps = []
        collisions = []
        walls = [False] * 4
        while traveled < self.PROJECTION_LENGTH:
            delta = get_delta(angle, magnitude)
            projection += delta
            angle += spin
            if steps and collide_line_with_rect(self.get_game().goal.skull.\
                                                location, steps[-1],
                                                projection):
                collides = True
                break
            if projection[0] < bounds.left or projection[0] > bounds.right or \
                   projection[1] < bounds.top or projection[1] > bounds.bottom:
                if projection[0] < bounds.left:
                    projection[0] += 2 * (bounds.left - projection[0])
                    wall_angle = 0
                    walls[self.WEST] = True
                elif projection[0] > bounds.right:
                    projection[0] += 2 * (bounds.right - projection[0])
                    wall_angle = 0
                    walls[self.EAST] = True
                if projection[1] < bounds.top:
                    projection[1] += 2 * (bounds.top - projection[1])
                    wall_angle = 180
                    walls[self.NORTH] = True
                elif projection[1] > bounds.bottom:
                    projection[1] += 2 * (bounds.bottom - projection[1])
                    wall_angle = 180
                    walls[self.SOUTH] = True
                collisions.append(map(int, projection))
                angle = wall_angle - angle
            steps.append(tuple(projection))
            traveled += magnitude
        wall_count = 0
        for wall in walls:
            if wall:
                wall_count += 1
        return collides, wall_count, collisions, steps

    def barf(self):
        self.get_game().carrot.spawn()
        self.clear_aim()

    def update(self):
        self.get_game().time_filter.open()
        ds = self.get_display_surface()
        for ii in xrange(1, len(self.steps)):
            line(ds, (0, 0, 0), self.steps[ii - 1], self.steps[ii], 5)
            line(ds, (128, 128, 128), self.steps[ii - 1], self.steps[ii], 3)
            line(ds, (0, 255, 255), self.steps[ii - 1], self.steps[ii])
        for ii, collision in enumerate(self.collisions):
            font = Font(None, 20)
            surface = font.render(str(ii), False, (0, 0, 255))
            circle(ds, (255, 255, 255), collision, 20)
            ds.blit(surface, collision)
        if self.step != (0, 0):
            if self.parent.carrot.location.inflate(self.CARROT_BOX_SHRINK).\
                   collidepoint(self.location.midbottom - ):
                self.step = (0, 0)
                self.get_game().time_filter.close()
                self.aim()
            else:
                self.move(*self.step)
        Sprite.update(self)


if __name__ == "__main__":
    iQue().run()
34.203.28.212
34.203.28.212
34.203.28.212
 
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.


↠ RSS Feed ↞