After writing about a few of my older projects, here's a more current one: A
motor being controlled by an Arduino board.
This one's a little prototype for my client
xyz high precision. It's the first step in a larger project
that is currently still ongoing.
This project uses the
Arduino Motor Shield, mounted
on top of a
This was my first embedded development project since university and the first
Arduino project I ever did. Arduino was a real breeze to get into. The
documentation made it easy to get started, and everything just worked as it was
I've been having a few more problems since then with the more complex project
that followed this prototype, but at least for quick, simple projects Arduino is
a very good fit and I can't recommend it enough.
And finally, the last installment in my series about projects from late 2012
that I never manged to write about before: The
facilityboss Windows Installer.
facilityboss is a versatile platform for -among other
things- facility management. My task was to create a Windows installer for its
core runtime and integrate that into the existing
Hudson-based continous integration infrastructure, so
it could be built automatically on every change.
The technology I used for this was NSIS, a tool
for building Windows installers. NSIS is definitely one of the weirdest tools I
have ever used. Don't get me wrong, it works and it's quite good at doing its
job. It even works on Linux, allowing you to create Windows builds on Linux
But the NSIS scripting language is seriously strange. It doesn't offer most of
anything you would expect from a scripting language. Function arguments? Local
variables? Nope, no luck. Basic control structures like if-else or loops? Not
included in the language, but you can include an external library that
implements those as macros. Baffling to the modern mind, but I guess it's good
enough for what it does, especially once you get the hang of it.
Once again, quite the interesting project. I even learned from it
how to build Debian packages.
Another project I worked on in November of 2012 was developing a library for
calculating the contact angle of a
drop of water from a processed picture of said drop. This was a client project
for xyz high precision.
So what's a contact angle? Basically, a drop of water looks different depending
on what kind of surface it sits on. Here's an example
The library's API is basically a single function that takes a processed picture
containing the outline of a drop, such as this:
The output is simply the contact angle calculated from the picture.
I really learned a lot from this. I hadn't written any image processing code
before, so it was all really interesting. This was compounded by the fact that
this was my first (and only) time writing in Visual Basic.
There were quite a few challenges in handling the different input data sets. For
example, the picture above might be misinterpreted as showing a drop with a high
contact angle, but actually the lower part of the picture is a remnant of the
drop's reflection on the surface and the contact angle is quite low. The
code had to recognize cases like this.
The core of the library's code is a combination of
Moore neighborhood countour tracing
and looking for sharp edges along the traced contour (which naturally can't be
part of the drop). The rest consists mostly of straight-forward linear algebra.
Of course, figuring out that this was the winning combination wasn't that easy,
so it took a while to get this right.
As with a lot of my projects, I haven't really had the chance to use what I
learned in another project since then. Too bad, since image processing is very
interesting and can be quite a lot of fun.
In November of 2012, I added some features to
mindmaps, an open source mind mapping
application originally written by David Richard. That
work was sponsored by my client
I added the following features to mindmaps:
- A way to modify the width of of the lines leading to a node.
- A text field that can be used to attach a note to each node.
- An additional storage method: Mindmaps can be saved to/loaded from a server
- The ability to attach URLs to nodes. There are actually several configurable
modes for doing this (one allowing for one URL, another allowing for multiple).
This was quite an interesting project for me, since I hadn't worked with such a
mostly been game-related: simulating logic, drawing stuff to a canvas,
multiplayer with node.js/socket.io,
stuff like that).
The project was especially educational because of the well thought-out codebase
I was working with. It gave me quite a few ideas about how to do UIs with
find the time (or the paying client) to do something like this again in the near
If you're interested, my modifications can be found at my
GitHub fork of mindmaps.
I'd like to talk about an old project of mine that I somehow never got around to
blog about: Colored Squares.
Colored Squares is a little game that I did for the #bbg game creation
challenge 6. The theme was "Puzzle".
Although the game is very simple -all you do is stack a bunch of colored
squares- it is maybe the most successful of my prototypes. There was zero
response when I posted it to Kongregate, but after I posted
it on Facebook, a lot of my friends played it and told me they enjoyed it. I
think that's because of all my prototypes it's the most accessible and complete
Although I can see the appeal, I don't like it that much myself. Playing it
doesn't really require a lot of thought and I don't think you can get much out
of it besides a few moments of distraction.
There's an interesting lesson to learn here though: Accessibility and polish are
just as important as an interesting core mechanic.
I used to blog on http://blog.hannobraun.com/.
I've decided to move my blogging activities to this website, for mostly
As you can see, I've migrated some of the old articles from my old blog to this
one. Since this was a manual migration, I've decided to leave the articles that
no longer have any relevance.
Please let me know if you find any errors (like broken links) in
the migrated articles.
Do you want to build a Windows installer on Debian using
NSIS, but need the
special "large strings"
Well, you're in luck, because I've had the same problem before you and created
the Debian packages you need.
I've created a small game prototype last week: Missile Miner.
It's a game that's obviously inspired by Asteroids, but with a different goal:
You are a miner who mines asteroids for fun and profit. The native aliens don't
Play it here:
Source code is available here:
Obviously it's not finished: The aliens shoot missiles that don't do anything
besides following you and it could use some polish. Hopefully I'll find some
time to work on it more in the near future.
I've recently started working on Orbital Invaders, an improved sequel for
World War. I thought that the general idea was interesting and could be
developed into a great game. Maybe that's right, maybe not. What I do know now
is that the prototype I've built is no fun at all. Since I don't see any ways to
make the core mechanic fun, I'm cancelling the project.
I've uploaded the prototype's source code to GitHub:
You can also play it online, if you're interested:
Instructions for playing: Drag the mouse to place satellites in orbit. Use the
mouse wheel to dilate time for a satellite, to make it follow its orbit faster
or slower. Satellites will shoot aliens if they're near, so make sure they don't
Do you think it was the right decision to cancel this project or is there a way
to salvage the design? Let me know in the comments.
About two weeks ago, I
took part in Ludum
Dare #23, the 48-hour game creation challenge. Despite all odds, I managed
to finish a game, Tiny World War. I decided to upload it to
Kongregate, a portal for web-based games,
and see how that goes.
Kongregate is a popular portal where people play mostly Flash games. It's very
easy to submit your own games to Kongregate, and since I heard that they're very
good at generating revenue from those games I had wanted to try them out for a
I didn't expect the game to do well there. It's unpolished and not very
accessible. My motivation for doing this was mostly information gathering:
Getting some first-hand data on how many people play a new game on Kongregate
and what kind of revenue I can expect from that.
Two player version
The game was originally built for two players, both sitting at the same
keyboard. This is of course a big hurdle for players since they'll probably not
have a friend with them when playing games on Kongregate.
Unsurprisingly, the game didn't do very well. As of today, it has been played
404 times. This has generated a total ad revenue of $0.75. My share is 40% of
Not enough people have rated the game, so it is still under judgement. This
means the average rating is not yet published and the game still shows up in
Kongregate's "Under Judgement" list.
The only feedback the two player version generated was a comment expressing the
wish to be able to play the game against the computer. I hadn't considered this
before because I thought of it as not feasible. But the comment got me thinking
and the next day I hacked together an AI for the game out of nothing but cheap
tricks and some random numbers.
I released the resulting singleplayer edition as a new game on Kongregate. Of
course this version had the same flaws as the original one, but at least it
could be played without a friend in the room. As a result, the game generated
much more plays and quite a bit of feedback. As of today, the game has been
played 1391 times. This generated a total ad revenue of $2.62. Again, I get a
share of 40% ($1.35).
The feedback generally fell into one of the following categories:
- "Interesting concept": Quite a few people seemed to actually like it, which
honestly surprised me. I expected this to be a throwaway experiment to get some
insights into Kongregate.
- "I don't get it": No surprises here.
- "It doesn't work": Until I discovered
Sauce Labs a few days ago, I really wasn't
set up to test with any browsers except Chrome and Firefox on Linux. This really
showed, and a lot of people couldn't play the game due to bugs that only
surfaced on a few browsers.
- "Too easy": As I implied, the AI runs mostly on good will and duct tape. This,
combined with the fact that the game's balancing is a bit off anyway, makes it
really easy to win every game once you know how.
I tried to be as responsive as I could, answering comments, fixing bugs and
making simple improvements.
The game came out of judgement with a score of about 2.5 of 5 stars. Enough to
make the 2.0 cutoff (games with a rating of lower than 2.0 are basically hidden
from Kongregate and are unlikely to see a lot of traffic). This is not good but
definitely better than I expected.
Ad revenue doesn't seem to be a good model to earn a living off games, which is
pretty much what I expected. It might be okay, if I could crank out a decent
game every few days (which I think is possible, but damn hard), but I don't
think that's a way to get rich (wait, you're telling me indie game development
in general is not a way to get rich?).
Publishing a game on Kongregate is pretty much how I expected it to be: You get
some initial plays by showing up in the "under judgement" list and once you get
your rating, further exposure depends on the quality of that rating. I'm looking
forward to uploading more games to see how they compare.
The only non-positive thing I can say about Kongregate is that they don't offer
a lot in the way of analytics. Since I didn't collect any myself, I don't really
have a lot of data beyond what I talked about in this article.
One thing I found interesting: Not a single person complained about the
graphics, which are not very good (I did them myself). Maybe that just didn't
come up because the game's other flaws were too glaring or maybe people on
Kongregate are very tolerant when it comes to that. We'll see how that goes in
Since you read this far, I guess you have some interest in me and this humble
start into my indie game dev adventure. I'll definitely release more games,
maybe even a polished sequel to Tiny World War. If you want to hear about it,
feel free to subscribe to my blog or
follow me on Twitter.
I've taken part in the fifth #bbg game creation challenge. Last time I couldn't
finish, but this time I got something done. My entry is called Ludus and it's a
game about gladiators.
You can play the game using
Google Chrome or check out the
source code on GitHub. I recommend you check out the
for info on the game.
I'm a bit ambivalent about the result. On the one hand it's nice to have
finished something, on the other hand I could really have used more time to
iterate on the game play. Doing the user interface took forever though, so I had
to do most of the actual game logic in the last two hours.
But it was definitely a worthwhile experience. I haven't created a mouse-focused
game UI like that before and there was a lot to be learned here. I've also made
about a million (actually, more like 12) notes about things to improve in
noop, most of which
I expect to implement this week or maybe next.
I don't know yet, but maybe I'll polish the game a bit and release it on
Kongregate. I'll keep you updated.
Last weekend, I took part in Ludum Dare #23.
Ludum Dare is a 48-hour game development contest. This time, over a thousand
games were made for the contest alone. The Ludum Dare Jam, which runs a day
longer than the contest and has more relaxed rules, is still ongoing as I'm
writing this, so there's more on the way.
Gathering at the Spielmeister offices
There was a real-world gathering at the
Spielmeister offices here in Darmstadt
(where I live). Since writing games is usually more enjoyable with others and
there was free beer to be had, attending this gathering was pretty much a
The gathering started Friday evening. Since the contest didn't start until 3am
that night, there was some time for setting up our gear and getting to know each
other. I worked at Spielmeister in the past and know the guys there pretty well,
but there were some participants I had never met before. My plan was to take it
easy, go home early and come back Saturday morning to start working on the game.
I think it's pretty safe to say that I drank a bit too much of the free
Spielmeister beer, after which nothing would do but go out and enjoy Darmstadt's
exciting nightlife (Darmstadt residents can decide for themselves if I'm being
ironic). Fortunately other local indie
devs agreed and shared in my Friday-night adventure.
After that, Saturday was pretty much ruined. I was way too tired, didn't get a
lot done and spent too much time trying to solve problems that weren't really
relevant to the situation at hand. Fortunately I got in a good night's sleep and
came back well-rested on Sunday.
Time was scarce, but I managed to turn things around and finish an actual game.
Tiny World War
The theme for the contest was "tiny world". I bounced around several vague
ideas, but in the end couldn't resist the temptation of working on a game based
on orbital mechanics yet again.
My game's called Tiny World War.
Go check it
I think it turned out to be an interesting game, which unfortunately suffers
from its inaccessibility. I also couldn't get a lot of playtesting in, which
probably didn't help. If you played the gravity levels in
Osmos, I guess you can find
your way around.
All things considered, I'm pretty happy with how it turned out.
Last week, I released
noop, a small HTML5 game framework which I used for this contest. I'm very
happy with the results. The basic approach of using a light-weight entity system
without much magic behind it worked very well.
As was to be expected, I ran up against some limitations. I was pleasantly
surprised about how easy this was to solve, however: I just copied the modules
I was having problems with, made some modifications and changed the module's
name. The other (unchanged) modules didn't care and kept on working without any
Since I didn't even put that much effort into making the framework's modules so
loosely coupled, I feel that this validates the kind-of-procedural (but actually
data-oriented design) approach I took with the framework.
Coming up next
I plan to use noop again soon(-ish) for the current
#bgg challenge 5
which ends in mid-May. I've also got some other projects in the works which
might or might not see the light of day any time soon. Whatever it will turn out
to be, more stuff is coming up, and you will read about it here.
wrote a recap of the event at
I've been working on a HTML5-based browser game for a while. Since I want to
re-use some of that game's code for Ludum
Dare, the monthly #bbg challenge and
possibly other contests, I've decided to extract the useful stuff into a
framework and release it to the public.
Check it out here:
If you have any questions, feedback or other comments, feel free to post them
here on this blog.
Here's a new game prototype!
It's an implementation of
Conway's Game of
I created this yesterday within a few hours, so it's pretty basic (still a lot
of fun, however). Maybe I'll add some more features soon. I haven't made up my
Important: I've tested this in Chrome 10/11 only. If you have
problems running it, try using the newest version of your browser. If it still
won't run, please let me know!
I didn't get a prototype done last week, but I did one the week before. It's
basically the extension of
previous prototype. I finished that one in about 7 hours and took 5 more
hours to refine the underlying technology.
The original idea was to let the player start a rocket from a planet into orbit,
but again, I didn't get that far. I started with a rocket in space and got
carried away working on the underlying framework, that is starting to develop
out of these prototypes.
But who cares, I'm happy with it, it was fun, so I can count this as a full
success. Take a look at the
source code or check out the
prototype. You can control the rocket with the cursor keys: Use left and
right to change direction, up to accelerate.
My original idea was simple:
- The player shoots a projectile at a target in space.
- Between the player and the target are some gravity wells.
- Consequently, the player has to take gravity into account when aiming.
My goal was to finish this project in less than 10 hours. I didn't get as far as
I hoped in that time, but I'm still happy with the result. I managed to get the
than I expected.
I also implemented a simple
entity system for this game. I'm pretty sure I'll use this in future
projects and extend it further.
But enough talk. You can check out the source code at
GitHub or watch a
live version of the
prototype (won't work without a current version of Chrome, Firefox, Opera