Edit: 0.7.1 is now out with a fix for a severe bug affecting ziggurats and other Lua-triggered features such as bazaars. Please update to 0.7.1 if you’ve already downloaded the 0.7.0 release.

All 0.7.1 release files are available on the Downloads page.

You can also read something approximating a changelog for a rough summary of what’s in the release.

I’d like to thank the whole team for working to release 0.7 in the short space we have before the annual August crawl tournament, and I’d like to give extra thanks to kilobyte and rob for their help with the release.

Thanks again to Napkin for hosting Crawl development on CDO, and the Crawl player community for their help improving the game.

Mac and Windows binaries are on the development builds page as usual.

When filing bug reports on Mantis, please attach your save games if you have them. Also, please make your bug reports as detailed as possible to help us find and fix bugs before release.

Please pick up Mac and Windows builds for 0.7.0-rc2 on the development builds page. The new Windows installer is also available directly from the development builds page now.

There’s also a detailed list of changes if you enjoy that kind of thing.

Mac and Windows builds for 0.7.0-rc1 are available from the development builds page as usual.

We’re testing a new Windows installer for Crawl from kilobyte, and we’d appreciate feedback from Windows users.

Please file all bug reports on Mantis as usual.

Mac OSX Tiles Build
(Last updated 2010-07-09, 0.7.0-a1-136-g6024cb9)

Mac OSX Regular Build
(Last updated 2010-07-09, 0.7.0-a1-136-g6024cb9)

We’re close to a release candidate for 0.7, but saves will remain compatible with the alpha versions of 0.7. Have fun with Menkaure in the Violet Keep (Sprint), courtesy Chapayev, and please report bugs on Mantis as usual.

Windows builds are available on the Development Builds page.

Crawl 0.6.0-rc3 Mac Tiles

I’m not the person who usually builds Mac binaries so I may have screwed something up. If you notice problems with the build, please file bug reports on Mantis as usual.

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:

http://groups.google.com/group/rec.games.roguelike.misc/msg/0433064b9d36786c

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:

http://groups.google.com/group/rec.games.roguelike.misc/msg/4d0676b75dea067c

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.

For a while now, players have been chafing under the injustice of
having to do the Swamp, since its devilish generosity with rune and
items and shops forces players to brave the menacing terrain to rescue
these poor lost items, in the process running into charming monsters
like swamp worms that get double damage attacks while the character
wades in shallow water. When not being torn apart by suave swamp worms
in shallow water, our heroes are usually demolished by humane hydras,
which can swim much faster in water than most characters can walk on
dry land, and the occasional urbane unique.

The Crawl devteam has naturally been eager to improve the situation,
and has turned to a new branch that has an even chance of replacing
the treachery of the Swamp with outright murder — tasteful, exciting
murder. Murder with turtles in it. A new branch called the Shoals!

The Shoals are set near the sea, in a little archipelago of islands
with beaches, tides, mangroves, and the occasional man-eating monster
thrown in for seasoning. It’s a long, fascinating story (you’ll never
guess how many useful things harpies can do with human entrails!), but
today we’re going to talk about how Shoals levels are generated, and
how the tide works in the Shoals.

Shoals Level Generation

Shoal levels have two main characteristics:

1. the islands
2. the tide

The Shoals level generator creates a 3d heightmap of the level, where
a height of 0 at any given point is assumed to be sea-level, negative
heights being underwater, and positive heights being above water.

There are different ways of making reasonably realistic islands on a
heightmap; here’s the approach we use:

• Start with the entire map at a depth that’s just into deep water.
• Pick a random set of points on the map as island centres.
• For each island center, pick a few more random points near it as
  local high points on the island. i.e. each island can have multiple
  high points or hillocks on it.

• For each high point C on each island (the island centre and the
  other hillocks), raise the height of points near the high point
  C using this process:

  1. Pick a random point P near C at a distance (randomly chosen
     for each point) of 0 to R from C, where R is a rough radius for
     that high point — think of it as the radius of a conical
     mountain’s base.
  2. Raise the height at the point P.
  3. Repeat (1) and (2) a few hundred times.

  Most of the random points P will be close to the island centre,
  and the island centre will thus be approximately the highest
  point, with surrounding points at lower heights.

• At this point, our heightmap has recognisable islands, but they
  look extremely choppy because of our scattershot island building.
  (Map legend: ^ – very high point on island, space – floor, close
  to sea level, = – shallow water, # – deep water)

  Note the complete lack of shallow water at this stage.

  
  ####################### ##############################################
  ####################   ###############################################
  ################# #### ###############################################
  #################### #################################################
  ##################  #^## #############################################
  ################# ####  ##############################################
  #################### # ## ############################################
  ################## ##### #############################################
  ##################### # # ############################################
  ####################    ##############################################
  #################### #  ##############################################
  ####################   ^  ############################################
  ####################  #  #############################################
  ######################  # ############################################
  ############ # ######   ##############################################
  ############ ################################## ######################
  ##########   #########################################################
  ########### ^^  # ############################# ######################
  ##########   ####### ################### #############################
  ########## #  # ##############################   #####################
  ########## #    ############################### # ##### ##############
  ##################  ## ##############   ##  #####  #### ##############
  ######### ### ## # ##  ############## ^  #  ###### # # #  # ##########
  ############# # ^^  # # #############   #  ^ #    ###^  ##############
  ########## ####  #^ # ######### #### ######### #  # ^^^#^ ############
  ############# ##      ################## ###^##  ^     ^ #  ##########
  ###############  # ######### #####  ##^#   #   # ^     ## #  #########
  ############## #   ######  #######   #  ## # ^   ## # ### ############
  ################### #### ## #  ####  ^##  # ## ^ #  ###### ###########
  ############ ### ####### ### ^ #   ^^    #^####^^^^  #################
  ######################## ## # ###    ###^ # ^^^^^^ # #################
  ########################    #   ## ^   ^^^ ^^   ^^  ##################
  ############################ # ##   ^ # #   ^^ #^^ ###################
  ############################        ^# ^# ##^     # ##################
  ######################### ###   # #    # #     ^#   ##################
  ####################### ### #  #     # #           # #################
  ######################## #    ^ # ^   #  #^^    ^ ####################
  ####################### #  ##     ^^ ###      ##  # ##################
  #####################   ###### ## ^^  ^   #^### ### ##################
  ####################### ##  # # #   ^  #     #########################
  ######################  #^##  ^  #^^^  ##     ##### ##################
  ######################  # #  ##^#     # # #    #######################
  ############### #######  # ^# ^ ^    # # ^^^^^########################
  ##############  #  #    #   ^  ###^ # ^ #   # ########################
  ##############  ^  ###   ^^ #^#   # # # ##   # #######################
  ##############  # ### #  ^^^  ^   ###### ##### #######################
  ############### #### #^    ^#    #  ##^ ## # #########################
  ######################   ^  ^#     # # ## # ### ######################
  ######################^ #^ ^   ^# ##^## ###   ## #####################
  ####################  ^^^^^^ # ### ##### ### #########################
  ###################### ^^^   ^  ##### # ####^  #######################
  #######################    ^  #  #########   #########################
  ###################### ###    # ############ #########################
  #####################  ### # #### #######  # # ## ####################
  #######################^# #### ##  ####### # # # #####################
  ######################### ############### # ##########################
  ######################################################################
  ######################################################################
  ######################################################################
  ######################################################################
  

• To fix this, we run a smoothing pass to average out the heights
  in our heightmap, simulating erosion:

  At each point P on the map, calculate a weighted average of the
  height at P and the heights at all points adjacent to P. The
  height at P is weighted more than the heights at adjacent points,
  and points on the cardinals are weighted higher than points on
  diagonals.

  Et voila, we have a Shoals map!

  
  ###################===  =#############################################
  ################=====  ==#############################################
  ################==#======#############################################
  #################===   ===############################################
  ################====   ===############################################
  ################====    ===###########################################
  #################===   ====###########################################
  #################======  ==###########################################
  ##################==      =###########################################
  ###################=     ==###########################################
  ###################   ^^^ ==##########################################
  ##################=   ^^  ==##########################################
  ##################==      ==##########################################
  ###########=====###==     ==##########################################
  ###########= ===####=   ====##################===#####################
  #########==  ==#####=======###################===#####################
  #########==    ====##====#####################===#####################
  #########=  ^  =======#################===####===#####################
  #########=     =======#################===###=   =####################
  #########=      ==#==##################===###    ==###===#############
  #########= =    ========############==  ==  ==     =##===#############
  ########========    =  =############= ^     =====  ==== =====#########
  ########===== =        ==########### ^^    ^       =     ====#########
  ########======         ==#####===##=      ^^         ^    ==##########
  #########=====        ===#####==###=             ^   ^     ==#########
  #########======       ==###===###== =           ^^          ==########
  ############==      ===#=====####=                         ===########
  #############       ============#=                    === ===#########
  ###########=======  ==#=====   ==  ^^^          ^^^   ======##########
  ###########==========##====    =   ^^          ^^^^   =====###########
  ###########========####= =              ^  ^^^^^^^   ==###############
  #######################====     =  ^^   ^ ^^^^^^^^   ==###############
  #######################=====       ^^      ^^^  ^^  ===###############
  ########################====                ^       ==################
  ######################======                        ==################
  ######################====                 ^^       ==################
  ######################==      ^  ^^^      ^^       ===################
  ####################==     =     ^^^               ===################
  ####################==  ====      ^^          =======#################
  ####################==            ^^^         =======#################
  #####################=            ^^^          ==#===#################
  ##############===####=        ^^          ^^^  ==#==##################
  #############========        ^^          ^^^^  ==#####################
  #############=     ==                      ^   ==#####################
  #############=     ==   ^^^^                   ==#####################
  #############=    ==    ^^^^  ^    ==         ==######################
  #############== =====    ^^             =   =====#####################
  #############========    ^^            ==== ======####################
  ###################== ^^^^^^   ^     == ===  =====####################
  ###################=  ^^^^^^      =========   ===#####################
  ###################== ^^^^^^^    ==========   ==######################
  ####################=     ^^     =========    ==######################
  ####################=          ====#####==   ======###################
  ####################=        =======####=     =====###################
  ####################==    ==========####== =======####################
  #####################==== =========#####=========#####################
  ######################======#############====#########################
  ######################################################################
  ######################################################################
  ######################################################################
  

  A point of interest here: you’ll notice islands often overlap,
  and overlapping islands make for more interesting maps than
  simple isolated islands.

The Shoals level generator in the current DCSS development branch
adds some refinements to this vanilla level builder, adding things
such as cliffs and clusters of plants (mangroves!), but we’ve
covered the essentials here.

And here’s the code (C++).

#include <iostream>
#include <cstdlib>
#include <cmath>
#include <algorithm>

const int N_PERTURB_ISLAND_CENTER = 50;
const int ISLAND_CENTER_RADIUS_LOW = 3;
const int ISLAND_CENTER_RADIUS_HIGH = 10;

const int N_PERTURB_OFFSET_LOW  = 25;
const int N_PERTURB_OFFSET_HIGH = 45;
const int PERTURB_OFFSET_RADIUS_LOW = 2;
const int PERTURB_OFFSET_RADIUS_HIGH = 7;

const int GXM = 70;
const int GYM = 60;

int nislands = 15;

struct coord_def {
  int x, y;
  explicit coord_def(int _x, int _y) : x(_x), y(_y) { }
  coord_def(const coord_def &c) : x(c.x), y(c.y) { }
  int abs() const { return x * x + y * y; }
  coord_def operator + (const coord_def &c) const {
    return coord_def(x + c.x, y + c.y);
  }
  coord_def operator - (const coord_def &c) const {
    return coord_def(x - c.x, y - c.y);
  }
  coord_def operator * (int mul) const {
    return coord_def(x * mul, y * mul);
  }
  coord_def operator / (int div) const {
    return coord_def(x / div, y / div);
  }
  coord_def &operator += (const coord_def &c) {
    x += c.x;
    y += c.y;
    return *this;
  }
  coord_def &operator -= (const coord_def &c) {
    x -= c.x;
    y -= c.y;
    return *this;
  }
  coord_def &operator *= (int mul) {
    x *= mul;
    y *= mul;
    return *this;
  }
  coord_def &operator /= (int div) {
    x /= div;
    y /= div;
    return *this;
  }
};

inline int dist2(const coord_def &a, const coord_def &b) {
  coord_def delta = a - b;
  return a.x * a.x + a.y * a.y;
}

int grid[GYM][GXM];

int random_max(int max) {
  return (max <= 1 ? 0 : random() % max);
}

int random_range(int low, int high) {
  if (low > high)
    std::swap(low, high);
  return low + random_max(high - low + 1);
}

int random_height() {
  // This could be skewed toward more water at greater depths.
  return -17; //random_range(-25 - depth * 10, -1);
}

void init_heightmap() {
  for (int y = 0; y < GYM; ++y) {
    for (int x = 0; x < GXM; ++x) {
      grid[y][x] = random_height();
    }
  }
}

int height_char(int height) {
  return height >= 100? '^' :
    height >= 0? ' ' :
    height >= -14? '=' : '#';
}

void dump_map() {
  char buf[GXM + 1];
  for (int y = 0; y < GYM; ++y) {
    for (int x = 0; x < GXM; ++x) {
      const int height = grid[y][x];
      buf[x] = height_char(height);
    }
    buf[GXM] = 0;
    std::cout << buf << std::endl;
  }
}

coord_def random_point(int offset = 0) {
  return coord_def(random_range(offset, GXM - offset - 1),
                   random_range(offset, GYM - offset - 1));
}

bool in_bounds(const coord_def &c) {
  return c.x >= 0 && c.x < GXM && c.y >= 0 && c.y < GYM;
}

coord_def random_point_from(const coord_def &c, int radius) {
  while (true) {
    const double angle = random_max(360) * M_PI / 180;
    coord_def res = c + coord_def(radius * cos(angle), radius * sin(angle));
    //coord_def res = c + coord_def(random_range(0, radius),
    //                              random_range(0, radius));
    if (in_bounds(res))
      return res;
  }
}

void island_center(const coord_def &c, int n_perturb, int radius,
                   int bounce_low, int bounce_high) {
  for (int i = 0; i < n_perturb; ++i) {
    coord_def p = random_point_from(c, random_max(1 + radius));
    grid[p.y][p.x] += random_range(bounce_low, bounce_high);
  }
}

void build_island(int sign = 1) {
  coord_def c = random_point(10);
  island_center(c, N_PERTURB_ISLAND_CENTER,
                random_range(ISLAND_CENTER_RADIUS_LOW,
                             ISLAND_CENTER_RADIUS_HIGH),
                40 * sign, 60 * sign);

  const int additional_heights = random_max(4);
  for (int i = 0; i < additional_heights; ++i) {
    const int addition_offset = random_range(2, 10);

    coord_def offsetC = random_point_from(c, addition_offset);

    island_center(offsetC, random_range(N_PERTURB_OFFSET_LOW,
                                        N_PERTURB_OFFSET_HIGH),
                  random_range(PERTURB_OFFSET_RADIUS_LOW,
                               PERTURB_OFFSET_RADIUS_HIGH),
                  25 * sign, 35 * sign);
  }
}

void init_islands() {
  for (int i = 0; i < nislands; ++i) {
    build_island();
  }
}

void smooth_at(const coord_def &c, int radius) {
  int max_delta = radius * radius * 2 + 2;
  int divisor = 0;
  int total = 0;
  for (int y = c.y - radius; y <= c.y + radius; ++y) {
    for (int x = c.x - radius; x <= c.x + radius; ++x) {
      const coord_def p(x, y);
      if (!in_bounds(p))
        continue;
      const coord_def off = c - p;
      int weight = max_delta - off.abs();
      divisor += weight;
      total += grid[p.y][p.x] * weight;
    }
  }
  grid[c.y][c.x] = total / divisor;
}

void smooth_level() {
  for (int y = 0; y < GYM; ++y) {
    for (int x = 0; x < GXM; ++x) {
      smooth_at(coord_def(x, y), 1);
    }
  }
}

void smooth_bumps() {
  const int nsmooth = 1;
  for (int i = 0; i < nsmooth; ++i)
    smooth_level();
}

int main(int argc, char **argv) {
  if (argc > 1) {
    nislands = atoi(argv[1]);
    if (nislands < 1)
      nislands = 1;
  }
  srandom(5);
  init_heightmap();
  init_islands();
  smooth_bumps();
  dump_map();
  return 0;
}

Shoals Tides

Once we have a heightmap from level generation, tides are trivial to
implement. If the current height of the tide is tracked as ‘t’, and
the height of a given point is ‘h’, then the effective height of the
point with respect to the tide is (h – t). Thus if you have a point
with height 3, and the tide is at height 10, the effective height of
the point is -7, which places it underwater.

There are some subtleties to handling the tide, such as propagating
the tide inward only from the open sea — isolated pools of water
which are surrounded by land should not grow and shrink with the tide,
but these are minor details.

Thank you!

For a list of changes, click here.

Edit: Mac binary and tiles port now available – Happy day!