I've moved to a new website. This website won't be updated any longer in any significant way.

This is not a game yet, but it is about missiles, so the name is at least half-correct.

Missile Game is an experiment. I'm interested in the idea of a space-based multiplayer strategy game, where the player takes control of a space ship. I imagine the user interface to be some kind of simplistic radar screen (inspired by Galactica's DRADIS screens), so that's what I tried to create.
The result is this demo, which I optimistically call Missile Game 0.1.

The download: MissileGame-0.1.zip
The code: http://github.com/hbraun/MissileGame/tree/master

Explanation:
At the center of the screen is the symbol for your own spaceship. Some kilometers away, missiles are spawned in regular intervals, which then proceed to fly towards your ship. Once these missiles have a certain distance to your ship, defensive missiles will be launched to intercept them.
The only thing the player can do right now is to zoom in and out using the mouse's scroll-wheel.

This was built using Piccolo2D and Scalable Dynamics 0.2. The code is horrible in some places, but it serves its purpose.

I don't know yet how this will develop further. For now I have other plans, but I may pick this up later and turn it into a real game.

Here's a new version of Scalable Dynamics, my 2D game physics library written in Scala. Some work has gone into it, but changes are mostly cosmetic.

Most important changes:
* Scalable dynamics is now abbreviated sd, not ScD. The package name changed accordingly.
* Some classes have been extracted into sub-packages (e.g. math, collision). This is a work in progress.

The download: ScalableDynamics-0.2.zip
The code: http://github.com/hbraun/ScalableDynamics/tree/master

Please note that I moved the code repository to GitHub. The old repo.or.cz repository will no longer be updated.

Here's something small I've played around with today while at university. I thought I'd publish it before I forget about it.

From the README:
The functional finite-sate machine library (short: ffsmlib) is a small library for modelling finite-state machines. It is written in Scala (http://scala-lang.org/).
ffsmlib is mainly a toy without any real applications right now.

The code: http://github.com/hbraun/ffsmlib/tree/master
The download: ffsmlib-0.1.zip

This is a source-only release. If you want to use it for something, I suggest just copy the files into your project.

Update: Updated the URL of the code repository.

At the end of a very productive week I present to you a new version of Kong.

The download: Kong-0.3.zip
The requirement: A working Java installation.
The instructions: W/S keys for player 1, Up/Down keys for player 2.
The code: http://repo.or.cz/w/kong.git

Not much has changed from a player perspective, but things are completely different under the hood. I replaced Phys2D with my own physics library, Scalable Dynamics. This fixes the tunneling effects (when the ball would escape from the screen boundaries and disappear for a while) that plagued version 0.2.

I expect improved versions to appear in the future. I have some ideas that could make Kong into an interesting game.
Additionally, Kong is the ideal testbed for my Scalable Dynamics library. I plan to grow them together, by making use of new ScD features in the next Kong versions.

Scalable Dynamics (short: ScD) is a 2D physics library. It is called Scalable Dynamics because it's written in Scala, the Scalable Language, not because it's scalable (it's not, at least not this early version).

I cannot overstate enough that this is the first version with only the most basic features:
* Rigid bodies
* Linear movement
* Applying forces and impulses to bodies
* Supported body shapes: circles and line segments
* Continuous collision detection between all supported shapes except between line segments

It's released under the Open Source Apache license 2.0. The license doesn't restrict usage in any way and is also very liberal in regard to modifying the library.

But enough talk.
The download: ScalableDynamics-0.1.zip
The code: http://repo.or.cz/w/scd.git

I expect to extend this in the future as I need more features for my own games.

Update: I made a mistake in the feature description. Collisions between line segments are actually not supported. I have updated the article.

PiccoInput is a small library written in Scala that handles events from the Piccolo2D scene graph and allows you to poll for pressed keys from your main loop. So instead of implementing an interface which handles input events, you just register PiccoInput's KeyHandler with Piccolo and just ask the KeyHandler every frame if the key you're interested in is pressed.

Nothing special, but convenient if you're developing games with Piccolo2D and Scala.

The download: PiccoInput-0.1.zip
The code: http://repo.or.cz/w/piccoinput.git

This is open source software under the Apache license 2.0. If you're just using this library, this license will restrict you in no way.

Documentation is available (and quite extensive), but currently only in the form of source code comments. Maybe the day will come when I'll figure out how to use scaladoc, but that day is not today.

I've written a small utility (in Scala) that can count the lines of code of a Scala project. It's not perfect, but it's intelligent enough (in most cases) to distinguish code lines from comment lines.

Download: ScCount-0.1.zip
Instructions: Give it some (or none, it defaults to ".") files or directories. Directories will be searched recursively, all Scala source files will be counted.

The distribution package is a bit rough. I haven't included the Scala library jar-file, because it seemed somewhat silly to ship some megabytes worth of library with such a tiny script.
I figure if you want this, you know how to start a Scala application from a jar anyway.

I know, it took a while, but here they are: My pictures from 0x10h three.

An official report has yet to appear. I'll post here if something shows up.

From the department of "I don't want to do any real work" comes Kong 0.2, the next version of my legendary Pong clone.

The download: Kong-0.2.zip
The requirement: A working Java installation.
The instructions: W/S keys for player 1, Up/Down keys for player 2.
The code: http://repo.or.cz/w/kong.git

This is a complete rewrite and aside from the color palette and general Pong gameplay, it hasn't got much to do with Pong 0.1. It's built with Scala using the Piccolo2D scene graph and Phys2D for physics.

It has a few problems, but it's playable. An improved version may or may not appear sooner or later.