from os import listdir
from os.path import join

from pygame.mixer import Channel, Sound, music, find_channel

from GameChild import *
from Input import *

class Audio(GameChild):

    current_channel = None
    paused = False
    muted = False

    def __init__(self, game):
        GameChild.__init__(self, game)
        self.delegate = self.get_delegate()
        self.load_fx()
        self.subscribe(self.respond)

    def load_fx(self):
        fx = {}
        if self.get_configuration().has_option("audio", "sfx-path"):
            root = self.get_resource("audio", "sfx-path")
            if root:
                for name in listdir(root):
                    fx[name.split(".")[0]] = Sound(join(root, name))
        self.fx = fx

    def respond(self, event):
        if self.delegate.compare(event, "mute"):
            self.mute()

    def mute(self):
        self.muted = True
        self.set_volume()

    def unmute(self):
        self.muted = False
        self.set_volume()

    def set_volume(self):
        volume = int(not self.muted)
        music.set_volume(volume)
        if self.current_channel:
            self.current_channel.set_volume(volume)

    def play_bgm(self, path, stream=False):
        self.stop_current_channel()
        if stream:
            music.load(path)
            music.play(-1)
        else:
            self.current_channel = Sound(path).play(-1)
        self.set_volume()

    def stop_current_channel(self):
        music.stop()
        if self.current_channel:
            self.current_channel.stop()
        self.current_channel = None
        self.paused = False

    def play_fx(self, name, panning=.5):
        if not self.muted:
            channel = find_channel(True)
            if panning != .5:
                offset = 1 - abs(panning - .5) * 2
                if panning < .5:
                    channel.set_volume(1, offset)
                else:
                    channel.set_volume(offset, 1)
            channel.play(self.fx[name])

    def pause(self):
        channel = self.current_channel
        paused = self.paused
        if paused:
            music.unpause()
            if channel:
                channel.unpause()
        else:
            music.pause()
            if channel:
                channel.pause()
        self.paused = not paused

    def is_bgm_playing(self):
        current = self.current_channel
        if current and current.get_sound():
            return True
        return music.get_busy()
import os
delattr(os, "link")

from dark_stew.pgfw.Setup import Setup

if __name__ == "__main__":
    Setup().setup()
from dark_stew.pgfw.SetupWin import SetupWin

if __name__ == "__main__":
    SetupWin().setup()
from math import sqrt
from random import choice

from pygame import Rect

from dark_stew.pgfw.GameChild import GameChild
from dark_stew.floor.Floor import Floor
from dark_stew.pool.Pools import Pools
from dark_stew.aphids.Aphids import Aphids

class World(GameChild, Rect):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.input = self.get_input()
        self.display_surface = self.get_display_surface()
        self.directions = 0, 1, 2, 3
        self.direction = self.directions[2]
        self.load_configuration()
        self.reset_active_directions()
        self.init_rect()
        self.pools = Pools(self)
        self.floor = Floor(self)
        self.aphids = Aphids(self)
        self.get_audio().play_bgm(self.get_resource("world", "audio-path"),
                                  True)
        self.scroll_to_random_intersection()

    def load_configuration(self):
        config = self.get_configuration("world")
        self.dimensions = config["dimensions"]
        self.walk_step = config["walk-step"]
        self.run_step = config["run-step"]

    def reset_active_directions(self):
        self.active_directions = [False, False, False, False]
        self.scroll_active = False

    def init_rect(self):
        Rect.__init__(self, (0, 0), self.dimensions)

    def scroll_to_random_intersection(self):
        pools = self.pools
        cx, cy = choice(pools).center
        step = pools.step / 2
        dx, dy = self.display_surface.get_rect().center
        self.shift(cx + dx + step, cy + dy + step)

    def get_corners(self):
        x, y = self.topleft
        w, h = self.size
        return (x, y), (x, y - h), (x + w, y - h), (x + w, y), (x + w, y + h), \
               (x, y + h), (x - w, y + h), (x - w, y), (x - w, y - h)

    def update(self):
        self.scroll()
        self.floor.draw()
        self.pools.update()
        self.aphids.update()

    def scroll(self):
        if not self.aphids.sitting and not self.parent.monsters.current:
            keys = self.input
            axes = keys.get_axes()
            self.scroll_active = True in axes.values()
            shift = self.shift
            step = self.walk_step
            if keys.is_command_active("run"):
                step = self.run_step
            active = self.active_directions
            up, right, down, left = self.directions
            if axes["up"]:
                shift(y=step)
                active[up] = True
                if not active[left] and not active[right]:
                    self.direction = up
            else:
                active[up] = False
            if axes["right"]:
                shift(x=-step)
                active[right] = True
                if not active[up] and not active[down]:
                    self.direction = right
            else:
                active[right] = False
            if axes["down"]:
                shift(y=-step)
                active[down] = True
                if not active[left] and not active[right]:
                    self.direction = down
            else:
                active[down] = False
            if axes["left"]:
                shift(x=step)
                active[left] = True
                if not active[up] and not active[down]:
                    self.direction = left
            else:
                active[left] = False

    def shift(self, x=0, y=0, collide=True):
        self.move_ip(x, y)
        if collide:
            self.collide_aphids(-x, -y)
        viewport = self.display_surface.get_rect()
        if self.left > viewport.w:
            self.right = self.left
        if self.top > viewport.h:
            self.bottom = self.top
        if self.right < 0:
            self.left = self.right
        if self.bottom < 0:
            self.top = self.bottom

    def collide_aphids(self, x, y):
        for dx, dy in self.get_corners():
            aphids = self.aphids.collision_rect.move(x - dx, y - dy)
            for pool in self.pools:
                if aphids.colliderect(pool.water.rect):
                    water = pool.water.rect
                    radius = water.w / 2.0
                    distance = sqrt((aphids.centerx - water.centerx) ** 2 + \
                                    (aphids.centery - water.centery) ** 2)
                    if distance < radius:
                        self.shift(x, y)
                        return
34.204.180.1
34.204.180.1
34.204.180.1
 
December 3, 2013

Where in the mind's prism does light shine, inward, outward, or backward, and where in a plane does it intersect, experientially and literally, while possessing itself in a dripping wet phantasm?


Fig 1.1 What happens after you turn on a video game and before it appears?

The taxonomy of fun contains the difference between gasps of desperation and exaltation, simultaneously identical and opposite; one inspires you to have sex, while the other to ejaculate perpetually. A destruction and its procession are effervescent, while free play is an inseminated shimmer hatching inside you. Unlikely to be resolved, however, in such a way, are the climaxes of transitions between isolated, consecutive game states.

You walk through a door or long-jump face first (your face, not Mario's) into a painting. A moment passes for eternity, viscerally fading from your ego, corpus, chakra, gaia, the basis of your soul. It happens when you kill too, and especially when you precisely maim or obliterate something. It's a reason to live, a replicating stasis.


Fig 1.2 Sequence in a video game

Video games are death reanimated. You recurse through the underworld toward an illusion. Everything in a decision and logic attaches permanently to your fingerprint. At the core, you use its energy to soar, comatose, back into the biosphere, possibly because the formal structure of a mind by human standards is useful in the next world.