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()
34.204.174.110
34.204.174.110
34.204.174.110
 
November 9, 2013


Food Spring - Watermelon Stage

Getting the fruit as far as possible is the object of each level, collecting bigger, more valuable guns. The final result is determined by the size of the fruits' collection when the monkey arrives in North America and either survives or perishes in the fruits' attack.

Watermelon Peach
Pineapple Grapes