Installation is a Pain

I actually had a chance to try installing the game on Windows today. Did not go very smoothly. To circumvent the problem I have once again updated installation instructions and separated instructions for Linux and Windows this time. I just included all the necessary installers in the Windows package. With Linux users, I trust their ability to use their package managers to get what they need. I have no idea about the Mac installation process. I'll get on top of that later.

So I guess the next thing I'll be doing with this project is to package it up better. For Windows users I will make use of py2exe and then create an installer that gets all the necessities. For Linux I will make rpm and deb packages, which I hope will cover most distributions. I'll have to figure out what's the Mac equivalent of these. That means I have to steal someone's Mac for a while...

In good news tonight, I think I just tackled one big design problem yesterday. I'll tell more about it when I'm ready to release the next version, which will be 1.10 to indicate an actual gameplay change.

Bug-fixed 1.02 release for Python

Ahem. The 1.02 is just a bug fix. The bug in question being no game over when hamsters die out. Oops. I also added high score saving into disk. The game now creates a hamstersdata folder under your home directory and stores high score list there. I am looking into more elegant options.

I updated all the download links. Get 1.02 Python release here.

Why Python?

There are at least three reasons. First of all, as those who have installed any XNA games know, XNA is needy. Installing a simple game like Hamsters and Plague takes a long time and lots of disk space unless its prerequisites already exist. While I still think that XNA is a really good framework for making games, the deployment issues does not make it viable for lightweight Windows games. I am planning to update the XNA version every now and then though, mostly because it allows for an easy Windows Phone 7 port. Anyway, PyGame, while also a little needy, needs a lot less. Oh and it runs on pretty much any operating system.

Secondly, I am more familiar with Python than I am with C#. This has the clear implication that I can prototype faster. It allows me to focus on design issues. It also allowed me to redesign parts of the code, especially the parts that were done in a hurry. This new code design makes it easier to test ideas. Of course, learning more about PyGame was also a bonus, since I have not really done any games with Python before. Now I know how. It also wasn't such a big project, maybe twenty hours or less.

The final reason is that I live in a technological stone age. At least when it comes to my computer. I run Kubuntu on an old PC. That means developing in Windows is kind of, well, impossible. Fortunately my computer has enough kick left in it to run Hamsters and Plague at least. The Python version of course. I have heard rumors that it's much easier to test your game if you can actually play it.

I guess that is all. With the port out of the way I can focus on making 1.02. I'm not sure yet how the game will develop but it will change. Wait and see!

Download Options and Installation

We have gone Python. I will write about the reasons soon but in the meanwhile, we are offering Hamsters and Plague for every platform that can run PyGame. Here are the installation instructions for Windows and Linux. It's still a bit of a hassle but I am working on improving the process. I am not sure how to install on Mac OS X, but I'd bet on the Linux route.

Windows:

1. Download this file, extract it to a folder where you want the game to be in.

2. Go to the folder and run the Python installer.

3. Run the PyGame installer.

4. Run the Setuptools installer.

5. To play double click hamsters.pyw

Linux (and OS X?):

1. Install Python (2.x)

2. Install SDL development library. Building PyGame needs this.

3. Install setuptools

4. Run this command:

easy_install http://enk.kapsi.fi/games/HamstersAndPlague-1.03.tar.gz

5. After the installation is done, type 'hamsters' to run the game.

Programming Post-Mortem

Writing this took a bit longer than expected. Probably something to do with the sudden trip to Hamburg. Fortunately I still remember most of the stuff pretty well. As with the design, this considers only the Global Game Jam part of the work.

Because it was my first game jam, I wanted to work with stuff I'm familiar with. XNA was my tool of choice (in retrospect, not a very good choice but more about that later) and I teamed up with Teemu because we both wanted to work with XNA and at that time no one else did. Of course it turned out we had four teams working with XNA in the end. Anyway, when we were still brainstorming game concepts I already kept in mind what I knew I was able to do. Inside my own head I discarded any ideas I was not sure how to do. I did this because I wanted zero implementation risks for our team and, again in retrospect, I think that was a good decision.

Hamsters and Plague is a grid-based game. I hadn't done a grid on XNA, but I had done one with PyGame earlier. We divided our programming tasks at the beginning to control logic (grid and user input) and game logic (hamster aging, copulation and plague spreading). Before actually doing much, I did my usual code planning: deciding which classes we will have and what their function will be. This was quite helpful, as it allowed us to work on different files most of the times, avoiding editing conflicts. Since I was more familiar with the grid stuff, I decided to take care of that.

For the record, my optimistic estimation for our implementation time (first playable version) was around four hours. We definitely took longer than that but we did have a playable game Saturday afternoon, and I think we were the first group to have that at our site. So yeah, when the instructions say 'scope for four hours production, because you will take longer than you think' they are right. We didn't use any kind of version control, which was not such a great decision as we basically had to discard Teemu's work from Friday evening because I decided to redesign much of the code on Saturday morning. Let it be noted though that I'm not fluent with version control systems, so using them might've added overhead.

Actually there weren't many problems with implementation of the game. Grid, controls, logic - it all came together in straightforward fashion. No mystery bugs. No banging head against the wall for many hours. I wish application development at my job always went as smoothly. I guess the biggest problem was that we wasted some time when there was not enough for both programmers to do. In the end this was good though as it gave me at least some time to focus on level design, although clearly not enough.

Although we had our working prototype quite early, we were still programming to the last minute. The 'trivial' stuff like screen overlays and such take surprisingly long time to implement, especially when it's the first time you actually care enough to polish the game properly. One bug that seriously affected the gameplay was left in the code - at one point it was intended behavior but when we changed the rules a bit, it made the game too easy. I fixed it later, by removing one line of code...

So the take-away:

- When unsure, especially if it's your first jam, it's best to design a game you already know how to implement.

- Scope for four hours or less (in a 48 hour jam). Estimates without experience are really optimistic.

- In a project with multiple programmers, use version control or very careful code design to keep everyone working.

Hamsters and Plague presented in Casual Connect (8.2. - 10.2.)

A bit late with the news, but anyway: Hamsters and Plague was nominated in the Gamesauce Challenge together with nine other games. The winners were invited to present their game at Casual Connect Europe, Hamburg, Germany.

I'm supposed to write a report of the event for Gamesauce and the presentations from Thursday will also be uploaded sometime in the future. So for more information, just wait a bit longer.

New Version (1.01)

I have uploaded a new version of Hamsters and Plague.
Changelog:
- Old hamsters will now catch the plague if next to it, instead of dying. This makes the game a lot more challenging.
- Better level design. This also makes the game more challenging.
- The game now loops back to title screen from highscore when the player clicks with the mouse.

Download here

Note: I changed the start menu folder from RuttoPuput toHamsters and Plague. If you have the old version installed, you need to uninstall it manually before installing this new version.

Note2: I added a handy 'download latest version' link under ABOUT.

Design Post-Mortem

Here's my thoughts on how we fared with our 48 hour endeavor. My viewpoint is that of designer, programmer and I guess a bit of producer. I'll do design first because that was my primary task.

After hearing this year's theme and drawing complete blanks for a while (at least I did), a bunch of us decided to set up a brainstorming room for coming up with game ideas. I feel this was essential to our success and being able to bounce ideas around with others certainly improved them. The idea for Hamsters and Plague started forming from a combination of bunnies, copulation and game of life. Yes, our original idea had bunnies instead of hamsters. In its raw form the idea was this: the player forms pairs of bunnies and when they copulate, avoids spreading the population near bunnies killed by a plague. If you've read the present abstract, you will notice that the core idea remained the same.

The exact method of manipulating bunnies had not formed 100% clear in my mind yet so I left that one open to experimentation. When I started to think about how to prevent bunnies from breeding immediately after being spawned, I ultimately came up with the idea of having them grow up from babies to adults and eventually die away. This was all during Friday. At this point there were also tombstones in the design, left behind by dead bunnies. Tombstones would also vanish after a while. After this the design was not very lively, it stayed essentially the same with some changes made during development and initial testing. The project was called RuttoPuput when it started.

During development there were some slight changes. Like changing bunnies into hamsters. There are two problems with bunnies and squares: ears. The shape of the head with ears is too tall compared to its width. Well, no problem there, enter another animal that copulates like no tomorrow: hamsters. After thinking through some different manipulation techniques, I decided to try a 2x2 rotator first, and as we can see from the final game, it was a hole-in-one. At this point we decided that the player cannot move plague victims or tombstones. After trying this, the tombstones went flying straight out of the window, because they made the game almost impossible to play. So no graves for old hamsters, not even a moments peace - the new generation will mercilessly breed upon their remains.

Actually one of the latest things to decide was the game goal. There were several options: fill a number of tiles with hamsters, breed a number of babies in one cycle and finally, the one we ultimately selected after playtesting, survive a number of cycles. At first the cycles went by wicked fast (2 seconds) and plague destroyed the poor hamsters every time. We slowed them down to 5 seconds per cycle: enough to do some damage control, but certainly not enough to solve every problem at once. The player needs to identify the most critical spots and focus attention there. Another small tweak was in spawning: initially, we had a spawning sequence of male, female, male,... with doctor as last (tenth) in the sequence. This made the game a bit too predictable, so it was changed to random, retaining the distribution.

We also experimented with having some hamsters born as teens instead of babies to combat the "single generation tactic" (where all your hamsters would be of the same age, except the one cycle when some are old and others are babies). However, this made survival too random, and ultimately I decided to hinder that tactic with level design. I don't know if that's even the optimal tactic but it does make the population more manageable.

With all these changes the game started to suddenly become a bit too easy. Keeping the hamster population low was manageable and they got nowhere near the plague in our test level. Enter scoring! To promote risk-taking, I decided on an exponential scoring formula: number of babies each cycle, to the power of two. Finally, we had enough time to make multiple levels, so we could also make them game harder with level design. Unfortunately we did not have enough time to test these levels so much (I managed a couple of play-throughs for our nine levels), and the difficulty curve ended up rising a bit too slowly. Fortunately, it's a jam, and we're not supposed to have a fully polished game.

Overall, I must say it would've been really tough for us if the initial idea had not turned out to be as good as it did. Since I was doing programming and design, there was not that much time allocated for design what with all the small programming details. If the idea had turned out to be not-so-great, we would've either been stuck with it or made a game that would be far less complete than what we got now. On the other hand, doing design and programming has certain benefits: fast test cycles. If I wanted to try something, all I needed to do was to get into the code, tweak and run.

Lessons learned:

- Group brainstorming is good, don't let the competition aspect get in your way.

- It's really hard to design difficulty curves when you're the only one who can test majority of changes.

- Being designer-programmer has its pros and cons. Less time for design, but faster test cycles.

- Certain aspects of design will only emerge through prototyping, so prototype early, prototype often! That is, unless you are Reiner Knizia who apparently plays his games inside his head.

What's This?

Hamsters and Plague is our game project developed initially for Global Game Jam 2011 at Oulu, Finland. It's a tile-based puzzle game. The player's goal is to control breeding of hamsters in such a way that the size of each generation is as large as possible but at the same time avoid expanding the population near plague victims. Too many hamsters will lead to chaotic, out-of-control copulation so beware!

This blog is your information channel on what's going on with Hamsters and Plague after GGJ2011.