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 ball_cup.pgfw.Setup import Setup

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

if __name__ == "__main__":
    SetupWin().setup()
from _send.pgfw.Configuration import TypeDeclarations

class Types(TypeDeclarations):

    additional_defaults = {

        "display": {"path": "font-path"},

        "tartan": {"path": "path",

                   "float": "ratio-to-ball",

                   "int": ["thread-size", "sample-size"]},

        "title": {"path": ["channel-audio", "stream-audio"],

                  "float": ["pan-frequency", "lead-volume", "beat-volume"],

                  "int": ["arrow-overlap", "arrow-count", "arrow-saturation"],

                  "int-list": ["arrow-size", "arrow-hue", "background-offset"]},

        "arrow": {"int": "frame-count"},

        "static": {"path": "path",

                   "float": ["frequency", "volume"]},

        "fields": {"path": ["default-path", "custom-path"],

                   "list": "palette-base",

                   "float": "music-initial-volume"},

        "sideline": {"float": "proportion"},

        "cloth": {"float": "scroll-speed"},

        "ball": {"int-list": "base-velocity-range",

                 "int": "base-size",

                 "float": "base-deceleration"},

        "charge": {"int": ["peak-time", "margin"],

                   "int-list": ["transparent-color", "size-limits"],

                   "list": "colors"},

        "cup": {"int-list": ["color", "size-range"],

                "float": "size-range",

                "int": ["margin-vertical", "margin-right"]},

        "result": {"list": ["text", "colors"],

                   "int": ["margin", "font-size", "framerate"],

                   "float": "main-color-probability"},

        "scoreboard": {"int": ["height", "margin-top", "score-segment-width",
                               "score-border-width"],

                       "int-list": "score-border-color"},

        "life-meter": {"int": ["initial-lives", "max-lives"],

                       "path": ["heart-path", "miss-path"]},

        "score": {"path": "path"}

        }
from pygame.mixer import Sound

class SoundEffect(Sound):

    def __init__(self, path, volume):
        Sound.__init__(self, path)
        self.set_volume(volume)

from _send.pgfw.Game import Game
from _send.Types import Types
from _send.field.Fields import Fields
from _send.tartan.Tartans import Tartans
from _send.title.Title import Title
from _send.Editor import Editor

class Send(Game):

    def __init__(self):
        Game.__init__(self, type_declarations=Types())
        self.title.activate()

    def draw_sample_tiles(self):
        from pygame import Surface
        from pygame.image import save
        for name, tartan in self.tartans.iteritems():
            surface = Surface((100, 100))
            tile = tartan.generate(.2)
            for x in xrange(0, surface.get_width(), tile.get_width()):
                for y in xrange(0, surface.get_height(), tile.get_height()):
                    surface.blit(tile, (x, y))
            save(surface, "/tmp/%s.png" % \
                 tartan.get_filesystem_formatted_name())

    def set_children(self):
        Game.set_children(self)
        self.fields = Fields(self)
        self.tartans = Tartans(self)
        self.title = Title(self)
        if self.check_command_line(self.get_configuration("editor", "flag")):
            self.editor = Editor(self)

    def update(self):
        self.title.update()
        self.fields.update()
3.237.66.86
3.237.66.86
3.237.66.86
 
January 28, 2014


E F F L U E N C E