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()
from ld25.pgfw.Setup import Setup

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

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

class Types(TypeDeclarations):

    additional_defaults = {
        
        "map": {

            "int": "magnitude"},

        "stamps": {

            "int": ["tile-size", "count", "resolution", "max-magnification",
                    "section-resolution"],
            
            "list": ["palette-0", "palette-1", "palette-2", "palette-3",
                     "palette-4", "palette-5", "palette-6", "palette-7",
                     "palette-8",],
            
            "float-list": "projection-vector"},

        "scale": {

            "int-list": ["bar-dimensions", "offset"],
            
            "list": ["prefixes", "colors"],
            
            "int": ["resolution", "segments", "font-size", "font-padding",
                    "bar-alpha", "stroke-size"]}

            };
from time import sleep

import pygame

from antidefense.pgfw.Game import Game
from antidefense.Types import Types
from antidefense.map.Map import Map

class Antidefense(Game):

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

    def set_children(self):
        Game.set_children(self)
        self.map = Map(self)

    def update(self):
        self.map.update()
        self.get_screen().fill((0, 0, 255), (153, 222, 60, 45))
from time import time
from random import choice

from pygame import Surface, Color

from antidefense.pgfw.GameChild import GameChild

class Layer(GameChild, Surface):

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

    def init_surface(self):
        Surface.__init__(self, self.parent.get_size())

    def randomize(self):
        w, h = self.get_size()
        parent = self.parent
        stamps = parent.stamps.get_stamps(parent.get_zoom_level())
        step = stamps[0].get_width()
        start = time()
        for y in range(0, h, step):
            for x in range(0, w, step):
                self.blit(choice(stamps), (x, y))
        print time() - start
from math import sqrt
from random import choice, randint

from pygame import Color, Surface

from antidefense.pgfw.GameChild import GameChild

class Stamps(GameChild, list):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.config = self.get_configuration("stamps")

    def reset(self):
        list.__init__(self, [])
        self.load_palette()
        self.populate()

    def load_palette(self):
        config = self.config
        resolution = config["section-resolution"]
        parent = self.parent
        w, h = parent.dimensions
        x, y = parent.target
        index = int(float(x) / w * resolution) + resolution * \
                int(float(y) / h * resolution)
        self.palette = map(Color, config["palette-" + str(index)])

    def populate(self):
        config = self.config
        resolution = config["resolution"]
        max_magnification = config["max-magnification"]
        magnification_step = float(max_magnification) / resolution
        magnification = 1
        for ii in range(resolution):
            self.append([])
            while len(self[ii]) < config["count"]:
                saturation = float(ii) / resolution
                self[ii].append(self.build_stamp(saturation,
                                                 int(magnification)))
            magnification += magnification_step

    def build_stamp(self, saturation, magnification):
        size = self.config["tile-size"] * magnification
        stamp = Surface((size, size))
        self.randomize_stamp(stamp, saturation, magnification)
        return stamp

    def randomize_stamp(self, stamp, saturation, magnification):
        w, h = stamp.get_size()
        for y in range(0, h, magnification):
            for x in range(0, w, magnification):
                stamp.fill(self.get_random_color(saturation),
                          (x, y, magnification, magnification))
            
    def get_random_color(self, saturation):
        color = choice(self.palette)
        pr, pg, pb = self.config["projection-vector"]
        r, g, b = color[0], color[1], color[2]
        p = sqrt(r ** 2 * pr + g ** 2 * pg + b ** 2 * pb)
        r = int(p + (r - p) * saturation)
        g = int(p + (g - p) * saturation)
        b = int(p + (b - p) * saturation)
        return self.convert_rgb(r, g, b)

    def convert_rgb(self, r, g, b):
        rgb = [hex(x)[2:].zfill(2) for x in (r, g, b)]
        return Color("#" + "".join(rgb))

    def get_stamps(self, zoom_level):
        return self[int((len(self) - 1) * zoom_level)]
54.224.108.238
54.224.108.238
54.224.108.238
 
June 7, 2018


↠ RSS Feed ↞