Video Games

from pygame import Rect

from _send.pgfw.GameChild import GameChild
from _send.field.sideline.background.Background import Background

class Sideline(GameChild, Rect):

    def __init__(self, parent, is_lower=False):
        GameChild.__init__(self, parent)
        self.is_lower = is_lower
        self.proportion = self.get_configuration("sideline", "proportion")
        self.init_rect()
        self.background = Background(self)

    def init_rect(self):
        display_surface = self.get_display_surface()
        width = display_surface.get_width()
        height = display_surface.get_height() * self.proportion
        Rect.__init__(self, (0, 0, width, height))
        if self.is_lower:
            self.bottom = display_surface.get_rect().bottom

    def refresh(self):
        self.background.refresh()

    def update(self):
        self.background.update()

from pygame import Surface

from _send.pgfw.GameChild import GameChild

class Filter(GameChild, Surface):

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

    def paint(self):
        pass

from pygame.transform import flip
from pygame import Surface

from _send.pgfw.Sprite import Sprite

class Cloth(Sprite):

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.scroll_speed = self.get_configuration("cloth", "scroll-speed")

    def refresh(self):
        self.set_references()
        self.set_frames()

    def set_references(self):
        self.fields = self.parent.parent.parent
        self.tartans = self.get_game().tartans

    def set_frames(self):
        name = self.fields.get_current_field().name
        self.clear_frames()
        self.remove_locations()
        sideline = self.parent.parent
        tile = self.tartans[name]
        if tile.get_width() == 0:
            tile.generate(store=True)
        if sideline.is_lower:
            tile = flip(tile, False, True)
        frame_h = tile.get_height()
        while frame_h < sideline.h:
            frame_h += tile.get_height()
        frame = Surface((sideline.w, frame_h))
        for x in xrange(0, frame.get_width(), tile.get_width()):
            for y in xrange(0, frame.get_height(), tile.get_height()):
                frame.blit(tile, (x, y))
        self.add_frame(frame)
        if sideline.is_lower:
            self.location.bottomleft = sideline.bottomleft
            self.add_location(offset=(0, self.location.h))
        else:
            self.location.topleft = sideline.topleft
            self.add_location(offset=(0, -self.location.h))

    def update(self):
        sideline = self.parent.parent
        is_lower = sideline.is_lower
        self.move(dy=(self.scroll_speed, -self.scroll_speed)[is_lower])
        if is_lower and self.location.bottom < sideline.top:
            self.move(dy=self.location.h)
        elif not is_lower and self.location.top > sideline.bottom:
            self.move(dy=-self.location.h)
        ds = self.display_surface
        ds.set_clip(sideline)
        Sprite.update(self)
        ds.set_clip(None)

from _send.pgfw.GameChild import GameChild
from _send.field.sideline.background.Filter import Filter
from _send.field.sideline.background.Cloth import Cloth

class Background(GameChild):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.filter = Filter(self)
        self.cloth = Cloth(self)

    def refresh(self):
        self.cloth.refresh()

    def update(self):
        self.cloth.update()

from random import random

from pygame.mixer import Sound

from _send.pgfw.GameChild import GameChild

class Static(GameChild):

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

    def load_configuration(self):
        self.frequency = self.get_configuration("static", "frequency")
        self.sound = Sound(self.get_resource("static", "path"))
        self.sound.set_volume(self.get_configuration("static", "volume"))

    def update(self):
        if random() < self.frequency:
            self.play()

    def play(self):
        channel = self.sound.play()
        if channel:
            self.parent.set_random_panning(channel)

from random import random, choice

from pygame import Surface, Color
from pygame.font import Font
from pygame.mixer import Sound

from _send.pgfw.GameChild import GameChild
from _send.title.Static import Static
from _send.title.Track import Track
from _send.tartan.Tartan import Tartan, Stripe
from _send.Arrow import Arrow

class Title(GameChild):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.display_surface = self.get_display_surface()
        self.compare = self.get_delegate().compare
        self.fields = self.get_game().fields
        self.load_tracks()
        self.static = Static(self)
        self.set_backgrounds()
        self.set_current_background()
        self.deactivate()
        self.subscribe(self.respond)
        self.arrow = Arrow(self, (150, 39), (120, 280), 100, 12, 4, Arrow.RIGHT)
        self.arrow.location.center = self.display_surface.get_rect().center

    def load_tracks(self):
        get_resource = self.get_resource
        config = self.get_configuration("title")
        self.lead_track = Track(self, get_resource("title", "lead-audio"),
                                config["lead-volume"])
        self.beat_track = Track(self, get_resource("title", "beat-audio"),
                                config["beat-volume"])
        self.audio = Sound(get_resource("title", "audio"))

    def set_backgrounds(self):
        backgrounds = self.backgrounds = []
        for palette in self.get_configuration("title", "palette").split("/"):
            tartan = Tartan(self)
            tartan.sett = []
            tartan.palette = {}
            tartan.thread_size = 4
            tartan.sett_width = 0
            tartan.asymmetric = False
            for ii, entry in enumerate(palette.split(",")):
                color, ratio = entry.split()
                width = int(round(float(ratio) * 2))
                tartan.sett_width += width
                tartan.sett.append(Stripe(ii, width))
                tartan.palette[ii] = Color("#%sFF" % color)
            tartan.generate(1, True)
            ox, oy = self.get_configuration("title", "background-offset")
            backgrounds.append(Surface(self.display_surface.get_size()))
            for x in xrange(ox, backgrounds[-1].get_width(),
                            tartan.get_width()):
                for y in xrange(oy, backgrounds[-1].get_height(),
                                tartan.get_height()):
                    backgrounds[-1].blit(tartan, (x, y))

    def set_current_background(self):
        self.current_background = choice(self.backgrounds)

    def deactivate(self):
        self.audio.stop()
        self.active = False

    def respond(self, event):
        compare = self.compare
        if self.active and compare(event, "advance"):
            self.deactivate()
            self.fields.load()
        elif compare(event, "reset-game"):
            self.deactivate()
            self.set_current_background()
            self.activate()

    def activate(self):
        # self.lead_track.play()
        # self.beat_track.play()
        self.active = True
        self.audio.play(-1)

    def update(self):
        if self.active:
            self.lead_track.update()
            self.beat_track.update()
            # self.static.update()
            if random() < .35:
                self.set_current_background()
            self.display_surface.blit(self.current_background, (0, 0))
            self.arrow.update()

    def set_random_panning(self, channel):
        offset = (random() - .5) * 2
        if offset < 0:
            volume = 1, 1 + offset
        else:
            volume = 1 - offset, 1
        channel.set_volume(*volume)

18.222.20.32

September 13, 2013♦

from array import array
from time import sleep

import pygame
from pygame.mixer import Sound, get_init, pre_init

class Note(Sound):

    def __init__(self, frequency, volume=.1):
        self.frequency = frequency
        Sound.__init__(self, self.build_samples())
        self.set_volume(volume)

    def build_samples(self):
        period = int(round(get_init()[0] / self.frequency))
        samples = array("h", [0] * period)
        amplitude = 2 ** (abs(get_init()[1]) - 1) - 1
        for time in xrange(period):
            if time < period / 2:
                samples[time] = amplitude
            else:
                samples[time] = -amplitude
        return samples

if __name__ == "__main__":
    pre_init(44100, -16, 1, 1024)
    pygame.init()
    Note(440).play(-1)
    sleep(5)

This program generates and plays a 440 Hz tone for 5 seconds. It can be extended to generate the spectrum of notes with a frequency table or the frequency formula. Because the rewards in Send are idealized ocean waves, they can also be represented as tones. Each level has a tone in its goal and a tone based on where the player's disc lands. Both play at the end of a level, sounding harmonic for a close shot and discordant for a near miss. The game can dynamically create these tones using the program as a basis.

I'm also building an algorithmically generated song: Silk Routes (Scissored). Here is an example of how it sounds so far.

↠ RSS Feed ↞