So I was playing and I missed a jump and I fell. And then Nikki kept falling and falling and falling. I was wondering when she would stop falling and declare me dead. And then I realized, "this is Haskell, she will fall forever."
I realize this isn't related to the game, but I found it entertaining that the Haskell bindings to Chipmunk, the 2D physics engine is called .... (waitforit) Hipmunk.
Very glad that someone's trying to make a game in Haskell that goes beyond a weekend hacking project. That said, on my OS X system, the arrow keys didn't work. A common complaint about Haskell is that doing "game-like" stuff (updating game state, bullet positions, ai, etc.) is hard. I don't think that's necessarily true, but this game is going to need some basic testing if it's going to do anything to dispel the notion.
> A common complaint about Haskell is that doing "game-like" stuff
I doubt some user-input issue on the Mac, in the alpha release, is to do with difficulties in the correct design for updating shared state, in a purely functional way... (they're probably using STM anyway (I would)).
> Don't hestitate to report any bugs that you experience to the bugtracker!
I looked at the source - they are using Hipmunk for the physics engine, a Haskell binding to Chipmunk (a physics library in C) to store state like object positions. Things like updating positions of objects occur in the IO monad.
The UI is done using a custom Qt Haskell binding, and it looks like the key mapping to key translation is hard-coded - possibly the cause of key problems on Mac if they key codes are different to what it is expecting.
> difficulties in the correct design for updating shared state, in a purely functional way
can you elaborate on the right way? i think the choice to write a game in a functional language is interesting, because games are inherently about managing state, and functional languages are all about not using state.
At least Haskell orients towards shared-state concurrency, where the state is the thin layer of communication between many stateless threads, using mechanisms like transactional memory to manage the shared resource.
