from pygame.time import get_ticks

from lib.pgfw.pgfw.GameChild import GameChild

class Timer(GameChild):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.reset()
        self.limit = 300000

    def reset(self):
        self.elapsed = 0
        self.stop()

    def start(self):
        self.running = True
        self.last_ticks = get_ticks()

    def stop(self):
        self.running = False

    def get_remaining(self):
        return self.limit - self.elapsed

    def get_ratio_remaining(self):
        return float(self.get_remaining()) / self.limit

    def update(self):
        if self.running:
            ticks = get_ticks()
            self.elapsed += ticks - self.last_ticks
            self.last_ticks = ticks
            if self.elapsed >= self.limit:
                self.reset()
from pygame import Surface
from pygame.font import Font
from pygame.draw import line
from pygame.locals import *

from lib.pgfw.pgfw.Game import Game
from food_spring.Types import Types
from food_spring.gaia.Gaia import Gaia
from food_spring.Spanky import Spanky
from food_spring.introduction.Introduction import Introduction
from food_spring.Timer import Timer
from food_spring.title.Title import Title
from food_spring.level.Levels import Levels
from food_spring.home.Home import Home
from food_spring.Siphon import Siphon
from food_spring.gun.GunLibrary import GunLibrary

class FoodSpring(Game):

    def __init__(self):
        Game.__init__(self, type_declarations=Types())
        if self.check_command_line("-mute"):
            self.audio.mute()
        self.input.register_any_press_ignore(keys=[K_LALT, K_RALT, K_F4])
        self.activate()
        self.subscribe(self.respond)

    def respond(self, event):
        if self.delegate.compare(event, "reset-game"):
            for child in (self.home, self.timer):
                self.call("deactivate", child)
                self.call("reset", child)
            self.activate()

    def call(self, method, obj):
        if hasattr(obj, method):
            attribute = getattr(obj, method)
            if callable(attribute):
                attribute()

    def activate(self):
        self.home.activate()

    def set_children(self):
        Game.set_children(self)
        self.gaia = Gaia(self)
        self.spanky = Spanky(self)
        self.timer = Timer(self)
        self.gun_library = GunLibrary(self)
        self.siphon = Siphon(self)
        self.levels = Levels(self)
        self.home = Home(self)

    def update(self):
        self.timer.update()
        self.home.update()
        self.levels.update()
        self.draw_time()

    def draw_time(self):
        if self.check_command_line("-timer"):
            surface = Font(None, 18).render(str(self.timer.get_remaining() / 1000),
                                            False, (0, 0, 0),
                                            (255, 255, 255))
            self.get_display_surface().blit(surface, (0, 0))
from os.path import join
from glob import glob

from pygame import Surface
from pygame.image import load

from lib.pgfw.pgfw.Sprite import Sprite

class Spanky(Sprite):

    def __init__(self, parent):
        Sprite.__init__(self, parent)
        self.load_configuration()
        self.load_from_path(self.get_resource(self.root), True, False)
        self.set_framesets()
        self.set_frameset("jump")

    def load_configuration(self):
        config = self.get_configuration("spanky")
        self.root = config["path"]
        self.jump_order = config["jump-order"]
        self.jump_framerate = config["jump-framerate"]
        self.wag_order = config["wag-order"]
        self.wag_framerate = config["wag-framerate"]
        self.walk_order = config["walk-order"]
        self.walk_framerate = config["walk-framerate"]

    def set_framesets(self):
        for verb in ("jump", "wag", "walk"):
            self.add_frameset(getattr(self, verb + "_order"),
                              getattr(self, verb + "_framerate"), verb)
from os.path import join
from random import randint, randrange, choice
from math import sin, cos, radians, ceil
from collections import deque

from pygame import Surface, Rect, PixelArray
from pygame.image import load
from pygame.mask import from_surface
from pygame.draw import line, aaline
from pygame.transform import rotate
from pygame.locals import *

from lib.pgfw.pgfw.Animation import Animation
from lib.pgfw.pgfw.Sprite import Sprite
from lib.pgfw.pgfw.GameChild import GameChild

class Siphon(GameChild):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.time_filter = self.get_game().time_filter
        self.color_index = 0
        self.load_configuration()
        self.set_roots()
        self.cancel()
        self.set_nodesets()
        self.set_score()
        self.set_badges()

    def load_configuration(self):
        self.badge_size = 60, 44
        self.stem_width = 30
        self.set_colors()

    def set_colors(self):
        components = self.get_configuration("siphon", "root-colors")
        colors = self.colors = []
        for ii in xrange(0, len(components), 6):
            colors.append((components[ii:ii + 3], components[ii + 3:ii + 6]))

    def set_roots(self):
        roots = self.roots = Roots(self, Roots.HORIZONTAL)
        roots.add_initial(self.stem_width)
        roots.init_surfaces(Rect(0, 0, self.stem_width, self.badge_size[1]))

    def cancel(self):
        self.contracting = False
        self.releasing = False
        self.release_elapsed = 0
        self.angle_deviation = 0

    def set_nodesets(self):
        interpolator = self.get_game().interpolator
        self.release_nodeset = interpolator.get_nodeset("release")

    def set_score(self):
        self.score = [[0, 0, 0] for _ in xrange(5)]

    def set_badges(self):
        self.badges = [Badge(self.roots, ii, self.badge_size) for ii in \
                       xrange(5)]
        self.set_badge()

    def set_badge(self):
        points = self.get_points()
        for ii, score in enumerate((2000, 5000, 10000, 16000)):
            if points < score:
                break
        self.roots.set_badge(self.badges[ii])

    def get_points(self):
        points = 0
        bases = 100, 200, 400, 800, 1600
        for ii, level in enumerate(self.score):
            base = bases[ii]
            for jj in xrange(max(level)):
                points += base * ((level[0] > jj) + (level[1] > jj) + \
                                  (level[2] > jj))
                base *= .9
        return int(points)

    def set_level(self, index=0):
        self.cancel()
        self.level = self.parent.levels[index]
        self.planet_rect = self.level.planet.location
        self.color_index = index
        self.roots.place()
        for badge in self.badges:
            badge.place()
        self.roots.gradient.set_tiles()
        self.roots.gradient.set_frames()
        self.draw_nodes()

    def draw_nodes(self):
        roots = self.roots
        roots.clear_root_surface()
        for node in roots.get_initial():
            y = self.get_initial_y(node.id)
            end = node.length, y
            self.draw_line((0, y), end)
            self.draw_children(node, end)

    def get_initial_y(self, node_id):
        modifier = -1 if node_id % 2 else 1
        return self.roots.rect.h / 2 + modifier * 10 * ((node_id + 1) / 2)

    def draw_line(self, start, end, alpha=180):
        line(self.roots.root_surface, self.get_current_colors()[0], start, end,
             3)
        aaline(self.roots.root_surface, (255, 255, 255), start, end, 1)

    def get_current_colors(self):
        return self.colors[self.color_index]

    def draw_children(self, node, start, depth=1):
        for child in node.children:
            end = self.get_offset_point(start, child.angle, child.length, True,
                                        depth)
            self.draw_line(start, end)
            self.draw_children(child, end, depth + 1)

    def get_offset_point(self, start, angle, length, deviate=False, depth=1):
        if deviate:
            angle -= self.angle_deviation * (angle - .8 ** depth * angle)
        return int(round(start[0] + cos(radians(angle)) * length)), \
               int(round(start[1] + sin(radians(angle)) * length))

    def add(self, level):
        offset = 70
        length = [40, 52, 66, 84, 100][level]
        for _ in xrange(25):
            parent = self.get_random_parent()
            for _ in xrange(3):
                angle = randint(parent.angle - offset, parent.angle + offset)
                if abs(angle) < 87 and (not parent.children or
                                        abs(parent.children[0].angle - angle) >
                                        45):
                    end = self.get_offset_point(self.get_end(parent), angle,
                                                length)
                    if self.check_end(end):
                        self.increase_score(level)
                        roots = self.roots
                        roots.add(length, angle, parent)
                        self.resize_roots_rect(end)
                        self.roots.init_surfaces(roots.rect)
                        self.draw_nodes()
                        return True

    def get_random_parent(self):
        node = self.roots[randrange(0, self.roots.initial_count)]
        while node.children:
            if len(node.children) == 1:
                if randint(0, 1):
                    break
            node = choice(node.children)
        return node

    def get_end(self, node):
        path = [node]
        while node.parent is not None:
            path.append(node.parent)
            node = node.parent
        x, y = node.length, self.get_initial_y(path.pop().id)
        while path:
            node = path.pop()
            x, y = self.get_offset_point((x, y), node.angle, node.length)
        return x, y

    def check_end(self, end):
        roots = self.roots.rect
        planet = self.planet_rect
        offset = end[0] + roots.left - planet.left, \
                 end[1] + roots.top - planet.top
        if planet.move(-planet.left, -planet.top).collidepoint(offset):
            return self.level.planet.frames[0].get_at(offset)[3] == 255

    def increase_score(self, level):
        self.score[level][randint(0, 2)] += 1
        self.set_badge()

    def resize_roots_rect(self, end):
        roots = self.roots.rect
        if end[0] > roots.w:
            roots.w = end[0]
        if end[1] < 0:
            roots.inflate_ip(0, -end[1] * 2)
        elif end[1] > roots.h:
            roots.inflate_ip(0, (end[1] - roots.h) * 2)

    def contract(self):
        self.contracting = True
        self.releasing = False
        self.charge_elapsed = 0
        self.roots.gradient.reverse()

    def release(self):
        if self.contracting:
            self.contracting = False
            self.releasing = True
            self.release_elapsed = 0
            self.roots.gradient.reverse()

    def update(self):
        self.update_angle_deviation()
        if self.contracting or self.releasing:
            self.draw_nodes()
        self.roots.update()

    def update_angle_deviation(self):
        if self.contracting:
            self.angle_deviation = self.level.food.charge
        elif self.releasing:
            self.release_elapsed += self.time_filter.get_last_frame_duration()
            if self.release_elapsed > self.release_nodeset.get_length():
                self.releasing = False
                self.angle_deviation = 0
            else:
                self.angle_deviation = self.release_nodeset.get_y(
                    self.release_elapsed) * self.level.food.submitted_charge


class Roots(GameChild, list):

    HORIZONTAL, VERTICAL = range(2)

    def __init__(self, parent, orientation):
        GameChild.__init__(self, parent)
        self.display_surface = self.get_display_surface()
        self.orientation = orientation
        self.gradient = Gradient(self, 200)

    def add(self, length, angle, parent=None):
        self.append(Node(len(self), length, angle, parent))
        if parent is not None:
           parent.add_child(self[-1])

    def add_initial(self, length):
        count = self.initial_count = 5
        for ii in xrange(count):
            self.add(length, 0)

    def get_initial(self):
        return self[:self.initial_count]

    def init_surfaces(self, rect):
        surface = self.surface = Surface(rect.size)
        surface.set_colorkey((0, 0, 0))
        self.root_surface = Surface(rect.size)
        self.rect = rect
        self.gradient.set_frames()

    def set_badge(self, badge):
        self.badge = badge

    def clear_root_surface(self):
        self.root_surface.fill((0, 0, 0))

    def place(self):
        base = self.parent.level.planet.location
        self.rect.midleft = base.left - self.parent.stem_width + 2, \
                            base.centery

    def update(self):
        self.badge.update()
        self.gradient.update()
        self.surface.blit(self.root_surface, (0, 0), None, BLEND_MIN)
        self.display_surface.blit(self.surface, self.rect)


class Node:

    def __init__(self, id, length, angle, parent=None):
        self.id, self.length, self.angle, self.parent = id, length, angle, \
                                                        parent
        self.children = []

    def add_child(self, child):
        self.children.append(child)


class Gradient(Sprite):

    def __init__(self, parent, framerate):
        Sprite.__init__(self, parent, framerate)
        self.set_tiles()

    def set_tiles(self):
        tile_rect = Rect(0, 0, 16, 16)
        colors = self.get_colors()
        tiles = self.tiles = []
        segment_count = len(colors)
        segment_width = int(ceil(float(tile_rect.w) / segment_count))
        for _ in xrange(segment_count):
            frame = Surface(tile_rect.size)
            x = 0
            for color in colors:
                frame.fill(color, (x, 0, segment_width, tile_rect.h))
                x += segment_width
            colors.rotate()
            if self.parent.orientation == Roots.VERTICAL:
                frame = rotate(frame, 90)
            tiles.append(frame)

    def get_colors(self):
        count = 8
        base_color = Color(*self.parent.parent.get_current_colors()[1])
        bh, bs, bl, ba = base_color.hsla
        bs_step = (100 - bs) / float(count - 1)
        bl_step = (100 - bl) / float(count - 1)
        colors = deque()
        for _ in xrange(count):
            color = Color(0, 0, 0)
            color.hsla = map(int, (bh, min(100, bs), min(100, bl), ba))
            colors.append(color)
            bs += bs_step
            bl += bl_step
        return colors

    def set_frames(self):
        self.display_surface = self.parent.surface
        index = 0 if not self.frames else \
                self.get_current_frameset().get_current_id()
        self.clear_frames()
        rect = self.parent.rect
        surface = Surface(rect.size)
        if self.parent.orientation == Roots.VERTICAL:
            surface = rotate(surface, 90)
            rect = surface.get_rect()
        for tile in self.tiles:
            frame = surface.copy()
            for x in xrange(0, rect.w, tile.get_width()):
                for y in xrange(0, rect.h, tile.get_height()):
                    frame.blit(tile, (x, y))
            self.add_frame(frame)
        for _ in xrange(index):
            self.shift_frame()


class Badge(Animation):

    def __init__(self, parent, level, size):
        Animation.__init__(self, parent)
        self.level = level
        self.rect = Rect((0, 0), size)
        self.display_surface = self.get_display_surface()
        self.background_color = Color(255, 222, 222)
        self.set_background()
        self.set_guns()
        self.register(self.shift)
        self.play(self.shift, 120)

    def set_background(self):
        width = 1
        rect = self.rect
        surface = Surface(rect.size)
        colors = (0, 0, 0), (255, 255, 255)
        for ii, x in enumerate(xrange(0, rect.w, width)):
            surface.fill(colors[ii % 2], (x, 0, width, rect.h))
        self.background = surface
        self.surface = Surface(surface.get_size())

    def set_guns(self):
        width = 0
        margin = 5
        images = []
        for guns in self.parent.parent.parent.gun_library:
            image = guns[self.level].frames[0].copy()
            mask = from_surface(image)
            pixels = PixelArray(image)
            for x in xrange(len(pixels)):
                for y in xrange(len(pixels[0])):
                    if mask.get_at((x, y)):
                        pixels[x][y] = (0, 0, 0)
                    else:
                        pixels[x][y] = (255, 255, 255)
            del pixels
            width += image.get_width() + margin
            images.append(image)
        self.img = images[0]
        surface = Surface((width, self.rect.h))
        surface.fill((255, 255, 255))
        x = 0
        for image in images:
            rect = image.get_rect()
            rect.midleft = x, self.rect.h / 2
            if self.level == 0:
                rect.centery += 3
            surface.blit(image, rect)
            x += image.get_width() + margin
        self.gun_surface = surface
        self.gun_rect = surface.get_rect()
        self.gun_rect.right = self.rect.w

    def shift(self):
        rect = self.gun_rect
        rect.move_ip(2, 0)
        if rect.left >= rect.w:
            rect.left -= rect.w

    def place(self):
        if self.parent.orientation == Roots.HORIZONTAL:
            self.rect.midright = self.parent.rect.midleft
        else:
            self.rect.midtop = self.parent.rect.midbottom

    def update(self):
        Animation.update(self)
        gr = self.gun_rect
        self.surface.fill(self.background_color)
        self.background.set_colorkey((255, 255, 255))
        self.surface.blit(self.background, (0, 0))
        self.surface.blit(self.gun_surface, gr, None, BLEND_MIN)
        self.surface.blit(self.gun_surface, gr.move(-gr.w, 0), None, BLEND_MIN)
        self.display_surface.blit(self.surface, self.rect)
        h, s, v, a = self.background_color.hsva
        h += 2
        if h > 360:
            h -= 360
        self.background_color.hsva = h, s, v, a
216.73.216.78
216.73.216.78
216.73.216.78
 
August 12, 2013

I've been researching tartan/plaid recently for decoration in my updated version of Ball & Cup, now called Send. I want to create the atmosphere of a sports event, so I plan on drawing tartan patterns at the vertical edges of the screen as backgrounds for areas where spectator ants generate based on player performance. I figured I would make my own patterns, but after browsing tartans available in the official register, I decided to use existing ones instead.

I made a list of the tartans that had what I thought were interesting titles and chose 30 to base the game's levels on. I sequenced them, using their titles to form a loose narrative related to the concept of sending. Here are three tartans in the sequence (levels 6, 7 and 8) generated by an algorithm I inferred by looking at examples that reads a tartan specification and draws its pattern using a simple dithering technique to blend the color stripes.


Acadia


Eve


Spice Apple

It would be wasting an opportunity if I didn't animate the tartans, so I'm thinking about animations for them. One effect I want to try is making them look like water washing over the area where the ants are spectating. I've also recorded some music for the game. Here are the loops for the game over and high scores screens.

Game Over

High Scores