How I started playing Crawl, and the early history of the Stone Soup project.
In the winter of 2002, I had large amounts of free time at my job, and I spent it in two ways: reading books and playing roguelikes. I’d played a lot of NetHack, but I’d reached a point where the game was quite easy and boring, and I was looking for a new roguelike to play. It wasn’t that roguelikes were the only games that interested me, but they possess several features that make them perfect for playing at work.
Looking for fresh material, I saw a mention of Crawl on Erik Inge Bolsø’s site Balrog. The description looked interesting, so I downloaded Crawl b24 and took it for a spin. My first game started with a kobold shouting at me, which I found odd. The tiny map display made me feel claustrophobic, and the constant scrolling of the map was disorienting. The game ended rather abruptly soon after it started. I don’t recall what killed me, but the overall experience quenched my interest in Crawl for a while.
I tried Adom and played enough to score a bug-temple-abused win or two, but it was a little too story-heavy to hold my interest for long. I’m all in favour of rescuing mad carpenters in moderate quantities for humanitarian reasons, but starting every game by rescuing eccentric carpenters palled on me quickly. There was also a regrettable incident when I read a description on herb farming in the bigroom in Andy Williams’ Guidebook, and spent the next several hours of my life in a glazed zombie-like trance accumulating absurd stockpiles of stomafillia herbs. Adom has numerous fine qualities, notably its beautiful locations, but my lack of self-control in the face of its numerous encouragements to farm meant that playing it involved terrifying amounts of self-inflicted brain damage.
Still looking for new games, I decided I couldn’t get into Angband or Tome (I kept getting beaten up by things in town, and the non-persistent levels bothered me strangely), and after dabbling in some of the lesser known roguelikes, I came back to Crawl. The quotes page (http://www.dungeoncrawl.org/?l.q) had interesting endorsements, and I decided it was time to find out just how accurate they were.
I bit the bullet, endured the constant scrolling and the postage-stamp-sized map display, and discovered a wonderful game. I played summoners and was thrilled that my friendly white imps could use their frost spell, unlike NetHack where pets are dumb things that magically lose all their fun abilities when tamed. I played enchanters, and the first time I used enslavement on an orc sorcerer in the Mines, I couldn’t stop laughing for half an hour.
One thing did niggle at me a lot, though. When moving around on a level, I kept getting lost in the winding corridors. If I wanted to go downstairs after clearing a level, I’d have to keep hitting ‘X’ to look at the level map, figure out my next few moves towards the stairs, then go back to the main screen and trace the steps I remembered from the map. It seemed like it would be so much more convenient if I could just move the cursor to the place I wanted to go on the ‘X’ level map and hit Enter to go there. I’d already seen travel in NetHack, I’d found it handy there, and it would obviously be even more useful in Crawl, with its large levels and tiny map display.
So one evening after work I decided to hack a travel command into Crawl. I was happily ignorant of pathfinding algorithms at the time, and I decided to use NetHack’s (NetHack uses Dijkstra’s). This was also the first time I’d looked at Crawl’s source, and after cautiously poking at various bits and going “Ohh, so that’s what that does!”, I shoehorned most of the travel code into acr.cc. I wasn’t very proud of shoveling the travel code into acr.cc, which had apparently suffered much punishment over the years and looked like a sad, whipped, source file, but I thought it would serve as a starting point.
It was amazing how much that one small change (travel) improved the playability of the game. I also made some minor tweaks to other settings, including an implementation of Roderick Schertler’s pickup_thrown patch for NetHack, and a change in similar vein to autopickup to ignore items that the player had previously dropped, and decided to share these patches with the Crawl community.
At the time (2003), most Crawl players hung out on the Usenet newsgroup rec.games.roguelike.misc. I believe there was IRC discussion even at this point, but it was minor; I’d certainly never heard of IRC discussion. The Crawl devteam apparently collaborated by email and on Yahoo groups mailing lists, but i was unaware of this at the time, so I announced my patch only on rgrmisc:
The patch proved popular, so I asked the NetHack team for permission to use the travel code under the terms of the Crawl license, which was almost, but not quite, identical to the NetHack license, and Warwick Allison graciously agreed. Players suggested new features, and I experimented with a minor riff on travel to create autoexplore. For a while I was unsure that I actually liked autoexplore, but other players seemed to enjoy it, and then I got used to it too. :-)
I was discussing Crawl in email with another ex-NetHacker, Tina Hall, when she mentioned how tedious it was to keep track of items in stashes — she actually took notes outside the game. After a few discussions on how this could be improved, I added a first cut at a feature to track stashed items to the patch. The early stash-tracker looked almost nothing like its modern self — you couldn’t search for items using ^F, you couldn’t travel to items directly (travel between levels with G wasn’t around yet). The only way to use the stash-tracker in its first incarnation was to make a character dump and grovel around in the .lst file it created to find items you wanted. For a while I wasn’t sure if the stash-tracker was worth keeping, and toyed with throwing it out entirely, but Tina insisted that it was useful and convinced me to keep it around. :-)
In all this time, official Crawl development seemed to barely advance at all. I’d started playing Crawl with 4.0 beta 24, and I’d seen beta 25 and 26 soon after, but nothing beyond b26. In the meantime, I kept working on the Patch (which players dubbed the Travel patch, after its signature feature), improving it based on player suggestions. Real interlevel travel (^G) made it into the patch in May 2004. It took me a while longer to make the stash tracker searchable and integrate it with interlevel travel (Oct 2005), but in my defense I’d changed jobs and my new job kept me a lot busier than the lazy years of 2002/2003. :-)
After the long, slumbrous reign of 4.0 b26, Crawl maintainer Brent Ross announced that an alpha version of the next Crawl release (4.1) was available for players to look at in Jul 2005. 4.1 was new and excitingly different from b26. I spent a feverish couple of days porting the Travel patch (by now a massive beast) to work with 4.1. Brent accepted the travel patch and merged it into the Crawl 4.1 svn repository, which thrilled me to bits. Back in 2001 and 2002, when I was playing NetHack, I’d written a NetHack patch or two, to general indifference, so being able to actually contribute to Crawl was a huge, pleasant change.
Brent had made a lot of improvements to 4.1. The old, nightmarishly ugly view code that gave me such trouble writing the initial travel patch was gone, replaced with a much cleaner view layer. Brent also repaired the mutation system and overhauled all the crufty layers of combat code. Where Crawl 4.0 was ugly, 4.1 was beautiful. There was just one problem: 4.1′s gameplay and balance was nothing like 4.0. The early game was too easy for fighters, too hard for spellcasters. The mid-game was brutally hard for all characters, and the sight of a monster wearing a shield in 4.1 was enough to make the best Crawl player cringe, because you knew almost *nothing* was going to get past that shield. :-)
Brent fixed some of the balance problems in 4.1, but he was also very busy and had little time to work on Crawl, so development languished after he released the 4.1.2 alpha. Months passed, it began to look as if Brent might never get back to Crawl development, and it was obvious nobody else was working on it.
All through the long b26 days, I’d rarely been troubled by the lack of visible Crawl development, but now with 4.1.2 out there, it was obvious that I’d been missing out. 4.1 was loaded with good stuff, but the game wasn’t really playable. I’d won a fair few Crawl games by then, but I wasn’t good enough to get far in 4.1.
Since Brent had apparently retired, I decided that I should try my hand at fixing 4.1 to be more playable. I didn’t trust my judgement of game balance issues much, so I asked Erik Piper — a very cool person, and the best Crawl player I knew — whether he could help me to analyse and rebalance 4.1. Erik agreed, and we got together and worked on 4.1 for a while. After a couple of weeks wrestling with 4.1, it was obvious to us that too many things had changed in 4.1 for it to be easy to rebalance. We began to reconsider whether fixing 4.1 was the best approach. At this point, Martin Read suggested on rgrmisc that it might be better to start with 4.0 b26 and gradually add new features from 4.1, instead of trying to fix 4.1 outright, and Erik and I agreed that this was the way to go.
So back we went, Erik and I, in the summer of 2006, to 4.0 b26 as the basis for development. Erik thought we needed a codename for the project, and he proposed we call it “Stone Soup”.
Stone Soup progressed quickly, since we had a rich larder of good ideas in the 4.1 alphas. Erik picked the things we should lift, and I hacked them into the b26 codebase, cleaning up code where possible. Since I’d mainly focussed on user interface changes up to that point, I was not familiar with the core gameplay code such as combat and spellcasting, which meant that I made several amusing mistakes in the 4.1 imports.
Initially, Erik and I worked more or less in secret on Stone Soup, because we weren’t sure if we’d be able to make a worthwhile release, and we didn’t want to announce ambitious plans on rgrmisc and disappoint everyone later. I was pretty hopeful that once we had a decent first release, we’d be able to find more players to help us out, because there were other people on rgrmisc who looked interested in contributing to Crawl, including Haran Pilpel, who had written an excellent patch adding Angband-style inscriptions to Crawl. I also exchanged a few emails with David P., who I knew from rgrn, and who was enthusiastic for Crawl development to keep moving.
Eventually, Erik and I decided that we had enough material to make a first release of Stone Soup and see how it was received. A little before the 4.1 alpha release discussion, two gentlemen (Nat Lanza and Peter Berger) had started a Sourceforge project (crawl-ref) to revive Crawl development. It seemed logical to join forces with them and host Stone Soup on the crawl-ref Sourceforge project instead of starting a brand new Sourceforge project. We asked Nat and Peter if they wanted to collaborate on DCSS, and they agreed.
And so it began, and Stone Soup was officially launched with Erik’s announcement:
Players seemed happy with the release, despite the rough edges (I still didn’t know much about the code :P). I was delighted at how well DCSS was received, but at that point Erik and I were spending unsustainable amounts of time working on Crawl, and we desperately needed more developers to lighten the load. I asked Haran Pilpel if he would be interested in joining the team, and to my delight, he accepted. Haran integrated the inscription patch and cleaned up a lot of the uglier stretches of code.
Stone Soup kept growing, and Crawl players kept contributing to development. We soon invited David P. to join the team and he did a lot of good work organising and rewriting the documentation and simplifying the knotted mess of .crawlrc options.
On a long weekend’s Crawl-hacking, I came upon the monstrosity that was b26′s maps.cc. All the special levels in Crawl were scrunched up in maps.cc, each in a function, described as arrays of string constants, a perfectly horrific mess to edit. I’d seen how NetHack handled special levels, with a special .des file format and a compiler that translated those into maps that the game could use, so I tried my hand at implementing something similar for Crawl. I was handicapped by not knowing anything about lex and yacc, but eventually I beat them into submission and Crawl’s level compiler was born. I liked the existing vaults and special levels and wanted more, but after a few pathetic attempts at creating new levels, I gave up and asked the team if they would like to try. Happily David and Erik were good at the vault-design thing. :-)
By December 2006, Stone Soup development was warming up, and it looked like Stone Soup might actually be self-sustaining. I was much prone to vanity Googling at this time, looking for kind mentions of Stone Soup on the internet that I could revel in. One such search turned up a public telnet server for Stone Soup 0.1.5, run by Rachel Elizabeth Dillon (raxvulpine/rax on IRC).
I should mention here that I’d never actually played a game on a public telnet server before. Back in my NetHack days, I was aware of the existence of public telnet servers, but the average ping time to US servers from India in 2001 was around 800ms, which made it impossibly painful to play games online. 5 years later, in 2006, my ping time to rax’s server (now crawl.akrasiac.org, at that time yiff.mit.edu) was a very playable 300ms. I let out a whoop of joy and dived in. Telnet play was intoxicating. I could meet interesting ghosts, compete for high scores and watch other games. I loved it and pretty soon, I could not play games offline at all. (I have not played a non-wizmode Crawl game offline since akrasiac was launched).
CAO was the best technical change to happen to Stone Soup development. It gave us great playtesting feedback, we could diagnose bugs easily by looking at ttyrecs, and Rachel gave us a lot of feedback on making Crawl play well with dgamelaunch.
One problem we still had, though, was testing Crawl before official releases. The second major Stone Soup release (0.2) was a buggy disaster (I was *really* not familiar with some of the code I messed with :P) that needed several emergency point releases to fix bad crashes. Happily, Marc Thoben expressed interest in running another public server to host development releases, and started the crawl.develz.org server. Since CDO’s arrival, new Crawl releases are much better tested, since CDO always runs the latest development code and players can find bugs much earlier in the development cycle.
Stone Soup has gone from strength to strength since its early days. After the 0.3 release (late 2007), I joined a startup that gave me much less free time to spend on Crawl, and David P. aka dpeg took the helm. Crawl has progressed hugely under dpeg’s guidance, lots of good new developers have joined the team, and every new release has greatly improved on its predecessors. Enne Walker, the author of the tiles port (building on Mitsuhiro Itakura’s tiles port for b26) joined the team in 2007, bringing official tiles support to Stone Soup.
Now, in 2010, I think Stone Soup is one of the best roguelikes available, and one of the all-round best games to play, period. I still really enjoy my games of Crawl, nearly eight years after I started playing the game, and there are DCSS developers who started playing Crawl even before I did.
We have a great game in Stone Soup, probably the best development team and the most enthusiastic and involved player community in the roguelike world, and I’m sure DCSS has great days ahead of it, with 0.6 and beyond.