from os import system, sep, walk, remove
from os.path import basename, join, exists
from shutil import copy, copytree, rmtree
from distutils.core import setup
from zipfile import ZipFile

import py2exe

from esp_hadouken.Setup import *

origIsSystemDLL = py2exe.build_exe.isSystemDLL
def isSystemDLL(pathname):
    if basename(pathname).lower() in ("libogg-0.dll", "sdl_ttf.dll"):
        return 0
    return origIsSystemDLL(pathname)
py2exe.build_exe.isSystemDLL = isSystemDLL

destination = "dist/win/"

setup(windows=[{"script": "esp-hado",
                "icon_resources": [(1, Setup.config["game-icon-path"])]
      options={"py2exe": {"packages": Setup.build_package_list(),
                          "dist_dir": destination}})

def ignore_files(src, names):
    ignored = []
    if src == "aud":
        ignored += ["uncompressed", "mod"]
    if src == "img":
        ignored += ["local"]
    return ignored

for path in ["config", "Basic.ttf", "hi-scores", "README", "changelog"]:
    copy(path, destination)

for path in ["aud", "img"]:
    folder = join(destination, path)
    if not exists(folder):
        copytree(path, folder, ignore=ignore_files)


def create_archive():
    title = Setup.translate_title() + "-" + Setup.config["game-version"] + "-win"
    archive_name = title + ".zip"
    archive = ZipFile(archive_name, "w")
    for root, dirs, names in walk(destination):
        for name in names:
            path = join(root, name)
            archive.write(path, path.replace(destination, title + sep))
    copy(archive_name, "dist")

from pygame import event, joystick as joy, key as keyboard
from pygame.locals import *

from GameChild import *

class Input(GameChild):

    command_event = USEREVENT + 7

    def __init__(self, game):
        GameChild.__init__(self, game)
        self.joystick = Joystick()

    def subscribe_to_events(self):
        self.subscribe_to(KEYDOWN, self.translate_key_press)
        self.subscribe_to(JOYBUTTONDOWN, self.translate_joy_button)
        self.subscribe_to(JOYAXISMOTION, self.translate_axis_motion)

    def suppress(self):
        self.suppressed = True

    def unsuppress(self):
        self.suppressed = False

    def build_key_map(self):
        key_map = {}
        for key, value in self.get_configuration().iteritems():
            group, command = key.split("-", 1)
            if group == "keys":
                key_map[command] = value
        self.key_map = key_map

    def translate_key_press(self, evt):
        if self.is_debug_mode():
            print "You pressed %i, suppressed => %s" % (evt.key, self.suppressed)
        if not self.suppressed:
            key = evt.key
            for command, keys in self.key_map.iteritems():
                if key in keys:

    def post_command(self, name):
        if self.is_debug_mode():
            print "Posting %s command with id %i" % (name, self.command_event), command=name))

    def translate_joy_button(self, evt):
        if not self.suppressed:
            button = evt.button
            config = self.get_configuration()
            code = self.command_event
            if button == config["joy-advance"]:
            if button == config["joy-pause"]:

    def translate_axis_motion(self, evt):
        if not self.suppressed:
            axis = evt.axis
            value = evt.value
            code = self.command_event
            if axis == 1:
                if value < 0:
                elif value > 0:
                if value > 0:
                elif value < 0:

    def is_command_active(self, command):
        if not self.suppressed:
            joystick = self.joystick
            if self.is_key_pressed(command):
                return True
            if command == "up":
                return joystick.is_direction_pressed(Joystick.up)
            elif command == "right":
                return joystick.is_direction_pressed(Joystick.right)
            elif command == "down":
                return joystick.is_direction_pressed(Joystick.down)
            elif command == "left":
                return joystick.is_direction_pressed(Joystick.left)
            return False

    def is_key_pressed(self, command):
        poll = keyboard.get_pressed()
        for key in self.key_map[command]:
            if poll[key]:
                return True

    def get_axes(self):
        axes = {}
        for direction in "up", "right", "down", "left":
            axes[direction] = self.is_command_active(direction)
        return axes

class Joystick:

    (up, right, down, left) = range(4)

    def __init__(self):
        js = None
        if joy.get_count() > 0:
            js = joy.Joystick(0)
        self.js = js

    def is_direction_pressed(self, direction):
        js = self.js
        if not js or direction > 4:
            return False
        if direction == 0:
            return js.get_axis(1) < 0
        elif direction == 1:
            return js.get_axis(0) > 0
        elif direction == 2:
            return js.get_axis(1) > 0
        elif direction == 3:
            return js.get_axis(0) < 0
from time import sleep

from pygame.locals import *

from esp_hadouken.pgfw.Configuration import TypeDeclarations
from esp_hadouken.pgfw.Game import Game
from esp_hadouken.Timer import Timer
from esp_hadouken.title.Title import Title
from esp_hadouken.overworld.Overworld import Overworld

class ESPHadouken(Game):

    def __init__(self):
        Game.__init__(self, type_declarations=Types())
        # self.get_audio().mute()
        # self.subscribe(self.inform)

    def inform(self, event):
        print event

    def set_children(self):
        self.timer = Timer(self)
        self.title = Title(self)
        self.overworld = Overworld(self)

    def update(self):

class Types(TypeDeclarations):

    additional_defaults = {

        "keys": {"list": ["up", "right", "down", "left"]},

        "title": {"int": ["prompt-size", "enemy-delay", "enemy-offset",
                          "toy-shift-delay", "turn-delay", "leave-delay",
                          "toy-turn-offset", "sky-arc-step",
                          "sky-arc-thickness", "sky-framerate",

                  "float": "enemy-speed",

                  "list": "mask-vector-colors",

                  "int-list": ["wood-position", "toy-position", "toy-offset",
                               "enemy-enter-framerate", "background-framerate",
                               "sky-color", "sky-arc-color"]},

        "main-menu": {"int": ["frame-count", "framerate", "option-width",

                      "int-list": ["size", "text-color",

                      "list": ["option-text", "select-fx"]},

        "toy": {"int": "framerate"},

        "overworld": {"int": ["toy-position", "wall-position", "dot-position"],

                      "int-list": ["wall-size", "wall-border"]},

        "dot": {"int": "frame-count",

                "int-list": ["framerate-range", "transparent-color"]},

        "engine": {"float": ["attack", "release", "deceleration",
                             "max-velocity", "initial-thrust",
                             "peak-acceleration", "peak-distance",
                             "max-negative-acceleration", "calibrator-step"]},

        "sprite": {"list": ["dark-palette", "light-palette"]}}
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.



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

↠ RSS Feed ↞