LambdaHack: my party-based roguelike (engine) in Haskell

[Bandobras]

Announcing LambdaHack, my party-based roguelike (engine) in Haskell and Allure of the Stars, the Sci-fi game. Released with Linux, OSX and Windows binaries, a version playable straight in the browser and source code. Follow the links for newest versions. Contributions welcome!

https://github.com/LambdaHack/Lambda...eleases/latest


Version v0.4.101.0, aka 'Officially fun' is out!

- the game is now officially fun to play
- introduce unique boss monsters and unique artifact items
- add animals that heal the player
- let AI gang up, attempt stealth and react to player aggressiveness
- spawn actors fast and close to the enemy
- spawn actors less and less often on a given level, but with growing depth
- prefer weapons with effects, if recharged
- make the bracing melee bonus additive, not multiplicative
- let explosions buffet actors around
- make braced actors immune to translocation effects
- use mouse for movement, actor selection, aiming
- don't run straight with selected actors, but go-to cross-hair with them
- speed up default frame rate, slow down projectiles visually
- rework item manipulation UI
- you can pick up many items at once and it costs only one turn
- allow actors to apply and project from the shared stash
- reverse messages shown in player diary
- display actor organs and stats
- split highscore tables wrt game modes
- move score calculation formula to content
- don't keep the default/example config file commented out; was misleading
- I was naughty again and changed v0.5.0.0 of LambdaHack content API slightly one last time

[Narvius]

I will spend many days and nights reading the source.

[Bandobras]

Originally Posted by Narvius

I will spend many days and nights reading the source.

Haha, well met, old buddy from UnAngband days. Please feel free to comment (e.g., here), ask questions and, of course, contribute (e.g., defining your own crazy game with the engine is a great start).

[Narvius]

Alright, so I started delving into the source. The sample implementations for Client and Server really help, though one thing that I've been wondering about those: Your CliImplementation is a newtype wrapper around a small monad stack. Have you thought about making the client type in general be a monad transformer as well? Then you can just type alias one single monad transformer stack and have all the default MonadState functionality for free.

I would code it up myself quick, but I don't yet feel comfortable enough with the codebase, and I don't know where you rely on MonadStateRead/MonadStateWrite.

[Edit]
Ah, upon closer inspection, the plethora of MonadClient* instances would make this a bit harder, since they need access to what's on the inside. Nevermind, then. :'D

[Bandobras]

Originally Posted by Narvius

The sample implementations for Client and Server really help

Yep. They are 'sample', but they should actually be enough for a lot of crazy games. I suppose one would extend the main engine code rather than add an extra state component to CliState and then transform the extra state in some external code. But the generality helped me ensure via types that engine doesn't depend on the concrete representation of the state data underneath. [Edit: and on the fact, that there's the IO monad underneath.]

Your CliImplementation is a newtype wrapper around a small monad stack.

Yep, and a very similar stack for SerImplementation.

the plethora of MonadClient* instances

Yep, I use those and the read-write and read-only monad a lot to ensure clients can't modify the main game State they share with the server, etc. (Actually, they can modify it, but only in the little bit of code (Atomic*) where they update the shared state based on messages sent by the server. Also, only restricted bits of the the state are shared based on what clients' actors can see, etc.) [Edit: I also use it to make sure only tiny bits of the client code can send/receive messages from the server, etc.]

[Edit: this is described in https://github.com/LambdaHack/Lambda...r-architecture, though it may not be very accurate nor specific. It will also get abstracted a bit more when I let the client-server communication operate via net and so they will no longer reside in the same binary (and not in the same binary as the frontend thread either).]

[Bandobras]

I've just released v0.4.101.1 of Allure of the Stars (a standalone game based on LambdaHack):

https://github.com/AllureOfTheStars/...eleases/latest

and a slightly updated LambdaHack (the engine and the example game):

https://github.com/LambdaHack/Lambda...eleases/latest

The next version will be the grand v0.5, but the API is already frozen (won't succumb this time, promise).

Have fun!

[Bandobras]

Allure of the Stars, the Sci-Fi squad roguelike game, with source and binaries

https://github.com/AllureOfTheStars/...s/tag/v0.5.0.0

(screenshots: http://www.roguebasin.com/index.php?...e_of_the_Stars)

and its free software engine in Haskell (with it's own little game)

https://github.com/LambdaHack/Lambda...s/tag/v0.5.0.0

(screenshots: http://www.roguebasin.com/index.php?title=LambdaHack)

are out, ready for your tinkering, the API is frozen, the branch will be bugfixed and supported for some time.

Enjoy!

P.S. Windows and Linux binaries are included, but OSX binaries would be very much appreciated as well.

[gglibertine]

When I first saw this thread, I thought, "What a great idea! You have to fight off handsy drunks and avoid ex-boyfriends, acquire drinks and hors d'oeuvres, and you win by taking home the biggest boss!"

Imagine my disappointment.

[Bandobras]

It contains an open engine, ready to encode just what you describe.

[MadeOfBees]

I love haskell speak.

Now fork it to erlang too!