Phobocore is a two-player hotseat game, where the aim is to capture all the planets onscreen by shooting them. It’s sort of a cross between Asteroids and Risk/Galcon, with a respectful nod to open field overhead shooters like Robotron, Bezerk or Gauntlet.

Download Phobocore (v.09 for Windows & Linux) [10.3 mb]

The experience of creating this game has been quite enlightening so far. It really got me thinking about aspects of game design I hadn’t thought deeply about. I threw around lots of ideas relating to ‘resources’ and ‘defenses’, particularly thinking about how RTSs like Starcraft require balance in play style between defense building, offensive maneuvers and resource gathering. Good players must multitask and proiritize to get the upperhand on their opponents. Key questions like “Should captured/neutral/enemy planets be solid objects or unhindering ?” occupied more than one dinner time conversation, bearing out all the ways these would changed the game. I had great fun testing the effect of different game rules, and how these changed the dynamics of the gameplay (with huge thanks to my long-suffering girlfriend for playtesting. The next best thing to writing an AI player ). If you are keen to fiddle with these game rules yourself, you can throw various flags in the phobocore.py sourcecode to test how these variations change the play style required to win.

I also spent considerable time tweaking things like fire rates and the “planets-held to ammo recharge rate” ratio to try and make the game somewhat fun. It works pretty well for players that are equally matched, but much like Galcon, once one player gets an edge, it can be hard to recover and things are over pretty quickly.

Big features I’d love to add in the future: an AI compurer player for single player mode, and maybe network play. I need to work on the collision detection, improve the graphics, add background music, and add a help screen / tutorial screen and slap on a license (probably GPL for code and Creative Commons for audiovisual assests).

Have fun & feedback is, as always, welcome !

Here’s the README.txt

┏━┓╻ ╻┏━┓┏┓ ┏━┓┏━╸┏━┓┏━┓┏━╸
┣━┛┣━┫┃ ┃┣┻┓┃ ┃┃  ┃ ┃┣┳┛┣╸
╹  ╹ ╹┗━┛┗━┛┗━┛┗━╸┗━┛╹┗╸┗━╸
Copyright Andrew Perry, 2008, 2009.

A two player hotseat game of screen domination.
It's pink vs. blue.
Boys vs. girls.

┃: GAMEPLAY :┃

Phobocore is a a simultaneous two player game. The goal is to capture
 as many planets as possible.
* You capture planets by shooting them - eventually they will turn to
  your colour.
* If you shoot a planet enough, it becomes locked to your colour -
  these planets cannot be re-captured by the enemy.
* The more planets you capture, the faster your ammo refills (orange
  bar). The more locked planets you hold, the more powerful your
  bullets become.
* You can fly through neural (white) or enemy planets. You cannot fly
  through your own planets.
* Shooting the enemy freezes them momentarily, however they also
  absorb your bullets for their own ammo store.
* Powerups occasionally appear - these give you more ammo, and can
  provide the vital edge you need to capture more planets than your
  opponent.
* The red bar goes up the more planets you lock. Once you have locked
  30 % of the planets on screen, you win.

┃: CONTROLS :┃

Player 1 (pink, left ammo bar): W,A,S,D and space
Player 2 (blue, right ammo bar): Arrow keys and right-CTRL

┃: OPTIONS :┃

Commandline options:

-f          run the game in full screen mode

┃:   TIPS   :┃

Early on, every bullet counts. Fire accurately and efficiently.

It may seem frustrating at first, since you can't shoot very fast.
Early in the game, aim to quickly but efficiently capture as many
planets as possible, and pick up powerups if you can. Don't waste
ammo locking too many planets early in the game - it's more about
quantity not quality at this stage. As you capture more planets,
your fire rate will go up.

Once you have a reasonable fire rate established, start focusing
on locking planets too. This will increase your bullet power,
meaning you can also capture/lock planets faster.

Take opportunities to steal any weak planets owned by your opponent
(the smaller ones) with a quick circular spray of bullets - this
will seriously impact on your opponents fire rate, frustrating
their efforts to capture/steal/lock more planets.

Try not to fence yourself in. Keep in mind that planets you capture
become blockades for you, but become open space for your opponent.
Rather than spraying a whole 360 degree circle of bullets to capture
all the planets in your vicinity, try doing 270 degree sweeps,
leaving yourself a exit small hole of neutral or enemy planets.

No related posts.

Download: maximalist (maximalist_0.12_miniLD5.zip, 4.6 Mb, md5: 68ada72418f029f9d7f5e81ca4792863)

(see below for the README)

Gameplay video

[youtube i8gTYMhBjv8]

You may wonder why the fullscreen resolution seems strange (800×480). Well, if you owned an Asus EeePC 4G Surf (701), you may not wonder so much.

Libraries used:

• Pygame
• Rabbyt (including the pygame_font.py font rendering code)
• My (alpha) simplemenu library

Tools used:

• The Gimp
• Sfxr (DrPetter saves the day, yet again)
• Audacity
• oggenc

I used a scanner to ‘photograph’ various items around the house (including myself) to provide source images for further manipulation.

Assests:

• “Squealer” font by Ray Larabie
• A scan of my face
• A carved wooden ‘skull’ box on my desk
• Some hand drawn sprites (exit and glowstick)
• Me screaming into the microphone

All in all, I had a fun, relaxed weekend making this game. I’ve got to remember to relax a little more during Ludum Dare competitions, it really seems to help.

The README

Installation, playing

On Windows, run maximalist.exe .

On Linux or other platforms, run:
$ python maximalist.py

Dependancies (Linux or other only):
Python (2.5 +) ( http://www.python.org .. you probably already have it)
Pygame 1.7.1 ( http://www.pygame.org )
Rabbyt 0.8.2 ( http://matthewmarshall.org/projects/rabbyt/ )

(hint for Debian/Ubuntu: $ sudo apt-get install python-pygame python-setuptools; sudo easy_install Rabbyt==0.8.2 )

Backstory

You are venturing into a dungeon or something. You think.
Actually, to be honest, you don’t know how you got here or
what you are doing here. All you do know is that there’s
something nasty lurking in the dark. The big bag of glowsticks
slung over you shoulder is your only friend.
All you want to do is Exit. And keep Exiting, until it’s safe.

Gameplay

There are 25 levels. Using a glowstick costs 5 points. Exiting a level gets you 10.
Getting your brains chomped by a nasty halves your score.
Try to get the highest score you can.

Controls

Move the mouse. Click the mouse buttons.

No related posts.

simplemenu-alpha0.tar.bz2

Requires pygame and rabbyt. It’s under the MIT license. I’m regarding this as alpha, since it’s incomplete and poorly tested, (although I am using successfully it in a small game already).

simplemenu, as it’s unimaginative name suggests, is a simple set of classes to automatically lay out a vertical column of ‘buttons’ on the screen, with click and rollover effects. Like the about simplest sort of GUI you could imagine. I made it because I felt like I needed a quick and brainless way to make simple “Start”, “Options”, “Quit” menus at the title screen of games, and during a Ludum Dare 48 hour competition, you don’t want to have to mess around with the details of things like this.

There is nothing I’d call game logic in the classes. There is demo code under “if __name__ == ‘__main__’:” … again this is what I would call ‘functional documentation’, not useful game logic. It’s all still quite ugly.

No related posts.

No related posts.

You can download it here [Mondrian_by_pansapiens_LD11.zip] (Windows and Linux compatible).

More details later. Right now, I have to sleeeeeeeep.

= Mondrian =
A game based on the visual art of Piet Mondrian.
Copyright Andrew Perry (pansapiens), 2008.
Licensed under the GPL version 3 (http://www.gnu.org/licenses/gpl.html).

Created for Ludum Dare 11 – Minimalism (18 – 20th April, 2008).

= Installation =
Unzip the package, run mondrian.exe (Windows) or mondrian.py (Linux & other platforms).

Usage: mondrian.py [options]

Options:
-h, –help show this help message and exit
-r, –random Play a randomly generated level
-e, –editor Launch in level editing mode

Dependancies (only required on Linux, or when running from source):
Python (2.5), Pygame (1.8), Rabbyt (0.8.1), PyOpenGL.

= Gameplay =

Goal: Clear the play area (aka Mondrian painting) to achieve pure white minimalism.
Click on the black beams with the mouse pointer to make then vanish.
Coloured squares expand when not in contact with a beam.
Squares of the same colour vanish when they contact.
Square of opposite colour do not vanish when they come in contact.

= Controls (game mode) =

Click with the mouse pointer.
Press ‘r‘ to restart the current level.

= Controls (level editor) =
Objects are inserted at the current position of the mouse pointer. Otherwise, gameplay is the same.

Up/down key – insert vertical beam
Left/right key – insert horizontal beam
z – insert red square
x – insert yellow square
c – insert blue square
v – insert grey square
s – save level to file “saved.pickle” in the working directory
l – load level from file “saved.pickle”
backspace, del – clear all objects from the level

= Some legalese =

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see .

No related posts.

Obviously, the first thing to do is install Python and all the required dependencies (eg Pygame, etc) on a Windows box (or Virtual Machine) and make sure your game will actually run. If it won’t run, you may need to tweak your Python to be more cross-platform. For simple games this mostly boils down to making sure all the sys and os module calls that use file paths use os.path to manipulate the path strings, rather than string concatenation. Paths in Linux use a forward slash “/”, paths in Windows use a backslash “\”, and some other platform may do something else; os.path deals with all this for you. I went through this process with shoodar (v0.11) and got it running under Windows with all the dependencies installed (eg Pygame, PyOpenGL, Rabbyt 0.81).

Now comes the ‘fun’ part – building the executable (and collecting associated dll’s and data files) for your game. There are a few tools for doing this on Windows:

Freeze

Comes with Python, but I didn’t test it.

cx_Freeze

cx_Freeze — I got this working to create a Windows distribution of shoodar after a bit of playing around. One advantage is that it doesn’t require a dedicated distutils script like py2exe. A downside is that it seems to generate lots of files in addition to the executable, and doesn’t automatically know to copy over data directories containing sprites & sounds, etc. You need to remember to do that part manually.

I downloaded the Windows installer for cx_Freeze (cx_Freeze-4.0b1.win32-py2.5.exe) and installed it. I unzipped the shoodar source into a folder called shoodar. In the shoodar source directory, I created a folder called dist. Then, at the Windows command prompt, in the shoodar folder, I typed:

c:\Python25\Scripts\freeze --install-dir dist shoodar.py

I then copied the shoodar\data folder into the dist folder.

The brand spanking new shoodar.exe executable was in the dist folder. It ran, and appears to function correctly.

py2exe, with PyMikes PySetup.py

py2exe — seems to be the most popular choice among Pygamers. There are a few wrapper scripts floating around at pygame.org.

The py2exe tutorial gives a nice example of how it’s done using a simple distutils setup.py script. I used py2exe with PyMike’s PySetup.py script. The PySetup.py script is a distutils setup.py script on steroids, tailored for packaging up Pygame games. It also worked for packaging shoodar, which also uses Rabbyt 0.81 (and hence PyOpenGL) without any special tricks.

I edited the obvious stuff at the top of the PySetup.py script in the shoodar directory (This included adding data, the directory which contains shoodars sprite files, to the extra_data list. I set dest_folder to the empty directory dist. I also added pygame.locals to the extra_modules list, but I probably didn’t need to. I left icon_file empty, since I don’t have an icon yet).

In the shoodar folder at the command prompt, running:

c:\Python25\python.exe PySetup.py

did the trick. Py2exe doesn’t generate nearly as many files as cx_Freeze … not that it’s really a big deal, but it looks less overwhelming in the file manager.

I had one problem with some (apparently) Linux specific code .. the use of os.path.dirname(__file__) which I changed to os.getcwd(). It’s worth noting that even after fixing this bug, py2exe builds failed until I removed the build (generated by py2exe) and dist directories and started with a clean slate. So, I’d suggest removing the build directory and the dest_folder between py2exe build attempts.

Next episode: Wrapping up the distribution in an executable Windows installer package (or How to make an evil “next”->”next”->”next”->”Finish” Windows installer for a Python game).

No related posts.

Over at scienceoss.com theres a nice post about profiling functions using “timeit” within IPython. Essentially, in IPython, you can run:

timeit my_slightly_sluggish_function(x, y)

timeit maybe_a_faster_function(x, y)

and get average execution time values over many replicates of each function call, like:

100000 loops, best of 3: 8.9 µs per loop

100000 loops, best of 3: 4.9 µs per loop

Interesting how programming for games and programming for scientific number crunching often have the same requirements and boil down to using similar techniques.

No related posts.

As tempting as is it to reinvent the wheel and write my own IF interpretor in Python, I figured it was likely that others had already done this grunt work for me. After a bit of Googling, so far Python Universe Builder (PUB) looks like the best option. Hopefully this will save me from the grue.

No related posts.

No nice installers and stuff yet, but the README in the archive gives some instructions for getting it running under Debain flavours of Linux.

No related posts.