Wow, that looks like really sweet code there.

Before we talk specs, let's chat a bit about it and maybe solidify some informal thoughts on where this would eventually go.  Here's what I'm imaginging this eventually being like (and mind you, this is serious pie-in-the-sky stuff... there are steps in this direction that would be very useful libraries in their own right):

• First, we define a number of different algorithms (terrain, maze, dungeon, city, etc), all with various parameters for altering their behavior.  We assume that each algorithm will generate one or more 2d fields of data (for instance, a terrain algorithm would generate a height field, a climate map, and maybe do some basic calculus and generate a slope map as well) or some other type of data.  Doing this will be a task in itself, and will make for a useful library.  The API for these should be consistent, so it'll make sense going from one algorithm to another.  I imagine it will require a lot of thought.
• Second (and here's the cool bit), we allow for what essentially amounts to custom, fractal terrain generation algorithms defined in XML.  Here's what I mean by that: 
  • Let's say that you want to create a world map that in detail all the way from a view of continents down to a coffee cup sitting on someone's table.  Sounds crazy at first, but if you use pseudorandom seeds, you can just generate the data you need when you're looking at it, so at no point in time do you ever have to load the whole map into memory, or even store the whole thing on disk.  Daggerfall did this, although it was extremely bland.
  • So you'd start by generating a terrain map for the world, right?  Then, you take that terrain map, along with the slope, climate, relative population density, and other variables, and use that data to divide the map into specific sections.  The parameters for what determines what each section is are listed in the XML definition file.
  • I haven't really looked into climatology, but I do know that with the right data, you can divide your world up into climates.  For each type of climate, you have a definition in your XML file for how to generate that particular climate.  Say, for example, that the climate is temperate woodlands or somesuch.  The generator would then separate *that* into regions (say, meadows, farmland, towns, etc).
  • Each one of those is also defined in the XML file, along with how they break down, so it would essentially work out recursively.  World -> continent -> temperate woodland -> farmland -> farm house -> living room -> table -> coffee cup.

I hope I'm at least kind of making sense.  It will require being able to handle a lot of different algorithms and methods of partitioning data.  But the neat thing is that, depending on how far zoomed out you are, you could tell it how many iterations to go, and then store some of the really basic stuff in memory and generate the other stuff on the fly when the player is close enough to see it.

Also, I realize this is ungodly ambitious, but it would also be super awesome. :)

Bart

I cannot seem to find a screenshot of that, but for me the menus from Secret Of Mana were the best I have seen! They were ring menus (the first i've seen) with each piece of the ring being a category (like, spells, armour, weapons, stats), one key to enter a category and one to leave it. Entering a category (say, armour) then replaced the ring by another one (with a replace animation) and there you go.

Honestly, for whatever reason, the ring menu never really worked for me.  I felt like I always had to poke around for things.

Thanks.  We try.  :)

Touche.  I've corrected this. :)