from os import mkdir, rename
from os.path import join, exists, dirname, basename
from time import strftime
from math import floor
from random import choice, random
from glob import glob

from pygame import Color, Rect, Surface
from pygame.font import Font
from pygame.image import load
from pygame.mixer import Sound
from pygame.event import clear
from pygame.locals import *

from _send.pgfw.GameChild import GameChild
from _send.pgfw.Animation import Animation
from _send.field.Field import Field
from _send.field.sideline.Sideline import Sideline
from _send.field.Charge import Charge
from _send.Send import SoundEffect

class Fields(Animation):

    def __init__(self, parent):
        Animation.__init__(self, parent)
        self.compare = self.get_delegate().compare
        self.load_configuration()
        self.subscribe(self.respond)
        self.set_sidelines()
        self.charge = Charge(self)
        self.life_meter = LifeMeter(self)
        self.score = Score(self)
        self.result = Result(self)
        music = self.music = []
        for path in sorted(glob(join(self.get_resource("fields", "music-path"),
                                     "[0-9]*"))):
            music.append(Sound(path))
        self.register(self.unsuppress_input)
        self.reset()
        self.read()

    def load_configuration(self):
        config = self.get_configuration("fields")
        self.palette_base = config["palette-base"]
        self.delimiter = config["delimiter"]
        self.fields_path = self.get_resource("fields", "path")
        self.backup_directory_name = self.\
                                     get_configuration("fields",
                                                       "backup-directory-name")

    def respond(self, event):
        if self.compare(event, "reset-game"):
            self.reset()
        elif self.compare(event, "raise-volume") or \
             self.compare(event, "lower-volume"):
            step = .1 * (-1 if event.command == "lower-volume" else 1)
            print step
            for sound in self.music:
                volume = sound.get_volume() + step
                print volume
                if volume < 0:
                    volume = 0
                elif volume > 1:
                    volume = 1
                sound.set_volume(volume)

    def reset(self):
        self.current_index = None
        for sound in self.music:
            sound.stop()
            sound.set_volume(self.get_configuration("fields",
                                                    "music-initial-volume"))
        self.music_index = None
        self.charge.reset()
        self.life_meter.reset()
        self.score.reset()
        self.result.reset()
        self.halt()
        self.suppressing_input = False
        self.loading = False

    def read(self, custom=False):
        path = self.custom_fields_path if custom else self.fields_path
        fields = self.fields = []
        index = {}
        for ii, line in enumerate(open(path)):
            name, parameters, background, foreground = \
                  map(str.strip, line.split(self.delimiter))
            ball, cup, speed, tartan_scale = parameters.split()
            background_color = self.parse_color(background)
            foreground_color = self.parse_color(foreground)
            fields.append(Field(self, name, float(ball), float(cup),
                                float(speed), float(tartan_scale),
                                background_color, foreground_color))
            index[name] = ii
        self.index = index

    def parse_color(self, color):
        return Color(*map(int, color.split(",")))

    def set_sidelines(self):
        self.sidelines = Sideline(self), Sideline(self, True)

    def get(self, name):
        return self.fields[self.get_index(name)]

    def get_index(self, name):
        return self.index[name]

    def get_current_field(self):
        if self.current_index is None:
            return
        return self.fields[self.current_index]

    def load(self, index=None, previous=False, suppress_title=False):
        if index is None:
            if not previous:
                index = self.get_next_index()
            else:
                index = self.get_previous_index()
        if not self.music[1].get_num_channels():
            self.music[1].play(-1)
        # if index / len(self.music) != self.music_index:
        #     if self.music_index is not None:
        #         self.music[self.music_index].fadeout(8000)
        #     self.music_index = index / len(self.music)
        #     self.music[self.music_index].play(-1, 0, 8000)
        current = self.get_current_field()
        if current:
            current.unload()
        self.fields[index].load(suppress_title)
        self.current_index = index
        for sideline in self.sidelines:
            sideline.refresh()
        self.charge.reset()
        self.loading = True

    def get_next_index(self):
        current = self.current_index
        if current is None:
            return 0
        if current == len(self.fields) - 1:
            return current
        return current + 1

    def get_previous_index(self):
        current = self.current_index
        if current is None or current == 0:
            return 0
        return current - 1

    def unsuppress_input(self):
        self.suppressing_input = False

    def write(self):
        fields_path = self.fields_path
        backup_directory_path = join(dirname(fields_path),
                                     self.backup_directory_name)
        if not exists(backup_directory_path):
            mkdir(backup_directory_path)
        rename(fields_path, join(backup_directory_path,
                                 "%s.%s" % (basename(fields_path),
                                            strftime("%Y%m%d%H%M%S"))))
        output = open(fields_path, "w")
        for field in self.fields:
            output.write("%s\n" % field)

    def update(self):
        current = self.get_current_field()
        if current:
            if self.suppressing_input and not self.is_playing(check_all=True):
                self.play(self.unsuppress_input, delay=500, play_once=True)
            current.update()
            for sideline in self.sidelines:
                sideline.update()
            self.charge.update()
            self.life_meter.update()
            self.score.update()
            self.result.update()
            if self.loading:
                self.loading = False
                self.suppressing_input = True
                clear()
        Animation.update(self)


class LifeMeter(GameChild, Rect):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.display_surface = self.get_display_surface()
        self.heart = load(self.get_resource("life-meter", "heart-path")).\
                     convert()
        self.miss = load(self.get_resource("life-meter", "miss-path")).\
                    convert()
        self.initial_lives = self.get_configuration("life-meter",
                                                    "initial-lives")
        self.max_lives = self.get_configuration("life-meter", "max-lives")
        Rect.__init__(self, 0, 0, self.heart.get_width() * self.max_lives,
                      self.heart.get_height())
        self.center = parent.sidelines[1].center
        self.reset()

    def reset(self):
        self.lives = self.initial_lives

    def remove_life(self):
        self.lives -= 1

    def add_life(self):
        if self.lives < self.max_lives:
            self.lives += 1

    def update(self):
        for ii, x in enumerate(xrange(0, self.w, self.w / self.max_lives)):
            image = self.heart if ii < self.lives else self.miss
            self.display_surface.blit(image, self.move(x, 0))


class Score(GameChild):

    def __init__(self, parent):
        GameChild.__init__(self, parent)
        self.display_surface = self.get_display_surface()
        font = self.font = Font(self.get_resource("display", "font-path"), 24)
        self.high_score = 0
        path = self.get_resource("score", "path")
        if path is not None:
            for line in open(path):
                if int(line) > self.high_score:
                    self.high_score = int(line)
        self.set_high_score_surface()
        self.reset()

    def set_high_score_surface(self):
        font = Font(self.get_resource("display", "font-path"), 10)
        top = font.render("best", True, (221, 172, 227), (255, 255, 255))
        bottom = font.render(str(self.high_score), True, (170, 132, 208),
                             (255, 255, 255))
        tr, br = top.get_rect(), bottom.get_rect()
        surface = self.high_score_surface = Surface((max(tr.w, br.w) + 4,
                                                     tr.h + br.h))
        surface.fill((255, 255, 255))
        rect = self.high_score_rect = surface.get_rect()
        tr.midtop = rect.midtop
        surface.blit(top, tr)
        br.midbottom = rect.midbottom
        surface.blit(bottom, br)
        rect.bottomright = self.display_surface.get_rect().bottomright

    def reset(self):
        self.score = 0
        self.set_surface()

    def increase(self, amount):
        self.score += amount
        self.set_surface()
        if self.score > self.high_score:
            self.high_score = self.score
            self.set_high_score_surface()

    def set_surface(self):
        text = str(self.score)
        font = self.font
        width, height = font.size(text)
        text_surface = Surface((width + 4, height), SRCALPHA)
        text_surface.blit(font.render(text, True, (255, 255, 0)), (0, 0))
        text_surface.blit(font.render(text, True, (0, 255, 0)), (4, 0))
        background = (255, 255, 255)
        text_surface.blit(font.render(text, True, (0, 0, 255)), (2, 0))
        text_rect = text_surface.get_rect()
        surface = self.surface = Surface(text_rect.inflate(12, 2).size,
                                         SRCALPHA)
        surface.fill(background)
        rect = self.rect = surface.get_rect()
        text_rect.center = rect.center
        rect.center = self.parent.sidelines[0].center
        surface.blit(text_surface, text_rect)

    def update(self):
        self.display_surface.blit(self.surface, self.rect)
        self.display_surface.blit(self.high_score_surface, self.high_score_rect)


class Result(Animation):

    def __init__(self, parent):
        Animation.__init__(self, parent, self.render)
        self.register(self.render,
                      self.get_configuration("result", "framerate"))
        self.delegate = self.get_game().delegate
        self.display_surface = self.get_display_surface()
        self.subscribe(self.respond)
        config = self.get_configuration("result")
        regions = self.regions = config["text"]
        portholes = self.portholes = {}
        for path in glob(join(self.get_resource("result", "porthole-path"),
                              "*")):
            portholes[basename(path).split(".")[0].upper()] = load(path).\
                                                              convert_alpha()
        self.font = Font(self.get_resource("display", "font-path"),
                         config["font-size"])
        self.main_color_probability = config["main-color-probability"]
        text_colors = self.text_colors = {}
        for ii, color in enumerate(config["colors"]):
            text_colors[regions[ii]] = Color(color + "FF")
        self.success_audio = SoundEffect(self.get_resource("result",
                                                           "success-audio"), .2)
        self.miss_audio = SoundEffect(self.get_resource("result", "miss-audio"),
                                      1.0)
        self.next_level_audio = SoundEffect(self.\
                                            get_resource("result",
                                                         "next-level-audio"),
                                            .1)
        self.reset()

    def respond(self, event):
        if self.is_playing() and self.delegate.compare(event, "any"):
            if self.success:
                self.parent.load()
                self.next_level_audio.play()
            else:
                if self.parent.life_meter.lives > 0:
                    self.parent.load(self.parent.current_index,
                                     suppress_title=True)
                else:
                    path = self.get_resource("score", "path")
                    if path is None:
                        path = join(\
                            self.get_configuration("setup",
                                                   "resource-search-path")[0],
                            self.get_configuration("score", "path"))
                    open(path, "a").write(str(self.parent.score.score) + "\n")
                    self.parent.score.reset()
                    self.parent.life_meter.reset()
                    self.parent.load(0)
            self.reset()

    def reset(self):
        self.halt()

    def render(self):
        font = self.font
        region = self.regions[self.region_index]
        color = self.text_colors[region]
        if self.region_index > 0 and random() > self.main_color_probability:
            colors = self.text_colors.copy()
            colors.pop(self.regions[0])
            colors.pop(region)
            color = choice(colors.values())
        text = font.render(region, True, color, (255, 255, 255))
        tr = text.get_rect()
        surface = self.text_surface = Surface((tr.w + 50, tr.h + 10), SRCALPHA)
        surface.fill((255, 255, 255))
        rect = self.text_rect = surface.get_rect()
        tr.center = rect.center
        surface.blit(text, tr)
        rect.center = self.display_surface.get_rect().center

    def evaluate(self):
        field = self.parent.get_current_field()
        ball, cup = field.ball, field.cup
        if not ball.rect.colliderect(cup.location):
            self.parent.life_meter.remove_life()
            self.set_region(0)
            self.success = False
            if self.parent.life_meter.lives > 0:
                self.miss_audio.play()
            else:
                self.miss_audio.play(-1)
                self.miss_audio.fadeout(2600)
        else:
            distance = max(abs(ball.location.centerx - cup.location.centerx),
                           abs(ball.location.centery - cup.location.centery))
            ratio = 1 - float(distance) / (cup.location.w / 2 + \
                                           ball.location.w / 2 + 1)
            index = int(floor(len(self.regions[1:]) * ratio))
            self.parent.score.increase((self.parent.current_index + 1) * \
                                       (index + 1))
            self.set_region(index + 1)
            self.success = True
            self.success_audio.play()
            fields = self.parent
            level_index = fields.current_index
            if level_index != len(fields.index) - 1 and level_index % 5 == 4:
                fields.life_meter.add_life()
        self.play()

    def set_region(self, index):
        self.region_index = index
        surface = self.porthole_surface = self.portholes[self.regions[\
            self.region_index]]
        rect = self.porthole_rect = surface.get_rect()
        rect.center = self.display_surface.get_rect().center

    def update(self):
        if self.is_playing():
            Animation.update(self)
            self.display_surface.blit(self.porthole_surface, self.porthole_rect)
            self.display_surface.blit(self.text_surface, self.text_rect)
34.236.192.4
34.236.192.4
34.236.192.4
 
June 29, 2013

A few weeks ago, for Fishing Jam, I made a fishing simulation from what was originally designed to be a time attack arcade game. In the program, Dark Stew, the player controls Aphids, an anthropod who fishes for aquatic creatures living in nine pools of black water.



Fishing means waiting by the pool with the line in. The longer you wait before pulling the line out, the more likely a creature will appear. Aside from walking, it's the only interaction in the game. The creatures are drawings of things you maybe could find underwater in a dream.

The background music is a mix of clips from licensed to share songs on the Free Music Archive. Particularly, Seed64 is an album I used a lot of songs from. The full list of music credits is in the game's README file.

I'm still planning to use the original design in a future version. There would be a reaction-based mini game for catching fish, and the goal would be to catch as many fish as possible within the time limit. I also want to add details and obstacles to the background, which is now a little boring, being a plain, tiled, white floor.

If you want to look at all the drawings or hear the music in the context of the program, there are Windows and source versions available. The source should work on any system with Python and Pygame. If it doesn't, bug reports are much appreciated. Comments are also welcome :)

Dark Stew: Windows, Pygame Source

I wrote in my last post that I would be working on an old prototype about searching a cloud for organisms for Fishing Jam. I decided to wait a while before developing that game, tentatively titled Xenographic Barrier. Its main interactive element is a first-person scope/flashlight, so I'd like to make a Wii version of it.

I'm about to start working on a complete version of Ball & Cup. If I make anything interesting for it, I'll post something. There are a lot of other things I want to write about, like game analyses, my new GP2X and arcades in Korea, and there's still music to release. Lots of fun stuff coming!