Related eternal voteNever seen a topic on this, and none linked in the eternal suggestion thread. With it being the 4th pick, I feel it's time to bring it up formally.
It's has become important enough that this needs to be brought up, no matter how touchy a subject it has been in the past.
Dwarf Fortress has exploded in the past 6 or so years. It has grown larger and more complex, and there is no hint that this is even close to the halfway mark really, no matter that we're on version 0.40 of Dwarf Fortress.
We need an overhaul of the UI on every level of the game NOW.
To quote the eternal voting suggestion thread:
It would allow the community to improve the UI, all Toady would need to do is convert the UI into an XML format. We could spend the time improving the UI so Toady doesn't have to, possibly bringing in many more donaters and expanding the popularity of DF.
Before we even begin to get into how to actually set this up, or rather how it should be structured, we should first address -why- this is so important.
Anybody who knows about game design, as it is done in the professional industry, knows that you go through what is called a Design Spiral. As time goes on, you add more features, and they depend on previous features, so that changing previous features starts to fuck up anything added later on. There are ways to mitigate this and given Toady's history of changes, I think it's safe to say he's taken a good many of these already, but the point remains, the UI, as far as I can tell, has only been added to over time, it has never, in fact, been fundamentally overhauled, as it will need to be in the future, since the beginning of this entire development cycle.
Portions have been ripped out wholesale, bits and pieces have been replaced, but the root UI has never been altered.
This state of affairs cannot continue. Eventually we will reach a point in complexity and interactions that will require that the UI be altered so that the game is actually playable for anybody who's not been playing since before the 2012 release. We're already approaching that breaking point I might add. As fewer and fewer people are able to make headway with the system.
This is not to say the game itself is a problem, it is not. There are plenty of games that have just as many features (at least on the front end of things, back end, god only knows if anything has approached DF levels of complexity), that are more accessible, even ones with ASCII graphics, because their UI is not as labyrinthine nor requires learning nearly as many hotkeys or the use of third party software to easily play, as DF does.
Now, we can wait for Toady to get around to this himself, but the fact of the matter is that until the final product is done, the full necessary UI will change again and again. Combined with that, I believe Toady has said UI isn't his forte as I recall, much as Graphics isn't, which is why he made Graphics amongst the easiest to edit things for Modders in the first place.
Further, it might get to the point where so much complexity has been added, that changing the UI would break the system so thoroughly that Toady would not reasonably be able to make the necessary changes without setting himself back years in work simply to sort through all the bugs.
That is why, here and now, we need to ask him to implement an abstracted, modular, moddable UI. Something that will enable the modder community to change the UI and eventually for us to settle on a nice, reasonable UI that helps gameplay along without being obtuse nor sacrificing control over the game systems.
Edit: http://www.bay12forums.com/smf/index.php?topic=150131.msg6257905#msg6257905 probably the most important post in this thread
Now that we have discussed WHY this is necessary, let's discuss how to implement it.
I'd argue that making the UI something that is broken down based upon the following things would be necessary:
- Value Changes (things like setting your starting skills on an embark)
- Typable areas (searches, etc.)
- Selections (the usual keyboard interactions when you're choosing stuff)
- Screens (switching between not just say, the maps, but also other things such as between the main screen, the stocks screen, or the military screen, or the individual information about a dwarf)
- Uneditables (places of text that are reading directly from the system, and we don't want the players to be able to interfere with, such as the information on a dwarf's emotions).
- Containers (basically boxes that organize the look and layout of stuff)
- Links (either sends you to another screen, or activates a choice or designation such as mining)
I think that covers the various elements.
From there we'd want to set up a system, possibly in XML or other format, where what is being calculated is relative position of items based upon whatever standard measurement toady wants.
So you'd say
<Layer A>: (0.2,0.2) standard units in size, placed (0.3,0.5) standard units away from the bottom left hand corner of the DF window (which is (1.0,1.0) standard units in size total).
Next we want to put something inside of Layer A, call it <Layer B>. The new standard of measurement puts the size of Layer A (for the purposes of Layer B) as (1.0,1.0). So Layer be will be positioned relative to Layer A's size and postion in all cases.
Thus, notation could be read as for any one line:
layerName,sizeX,sizeY,posX,posY,UIFunctionType,SpecificUIFunction,imageFileNameIfApplicable
- layerName: Name of the Layer for the code to read and organize around
- sizeX:How wide the layer is, used by subLayers to understand their own relative positions, and reads from the screen resolution set at the beginning of the XML.
- sizeY:How tall the layer is, used by subLayers to understand their own relative positions, and reads from the screen resolution set at the beginning of the XML.
- posX:How far along the width of the higher layer this layer is, as defined by relative numbers.
- posY:How far along the height of the higher layer this layer is, as defined by relative numbers.
- UIFunctionType: Which of the above functions I listed this layer will be. Mostly they're going to be containers.
- SpecificUIFunction: Basically the linkage to a master list of all the various interactions in DF, what says when a link is going to send you to the military screen, or activate the dig designation
- imageFileNameIfApplicable: Would allow modders to make really pretty graphics sets specifically for the UI to make the overall feel much more friendly
a single space or some other predefined designation (such as "blank") could be put into any unusued slot. So if your container type doesn't have a specific function (which it shouldn't) then just put in "blank" after that comma. Same for any image files if you want to use the default dwarf fortress graphics.
then you'd drop a line, and you'd have it read so that anything inside of another layer was named
layerName_SubLayerName_SubSubLayerName,sizeX,sizeY,posX,posY,UIFunction,imageFIleNameIfApplicable
The above would be for a layer inside of a layer inside of a layer.
So everything would be defined by the first line, which would set the overall size of the screen to whatever.
WindowResolution=X,Y
then under that you put in the lines as I described above.
So the XML file, in a very simple way might look like this:
WindowResolution=X,Y
layerName1,sizeX,sizeY,posX,posY,UIFunctionType,SpecificUIFunction,imageFileNameIfApplicable
layerName1,subLayerName1,sizeX,sizeY,posX,posY,UIFunctionType,SpecificUIFunction,imageFileNameIfApplicable
layerName1,subLayerName1,subSubLayerName1,sizeX,sizeY,posX,posY,UIFunctionType,SpecificUIFunction,imageFileNameIfApplicable
layerName1,subLayerName1,subSubLayerName2,sizeX,sizeY,posX,posY,UIFunctionType,SpecificUIFunction,imageFileNameIfApplicable
layerName1,subLayerName2,sizeX,sizeY,posX,posY,UIFunctionType,SpecificUIFunction,imageFileNameIfApplicable
layerName1,subLayerName2,subSubLayerName3,sizeX,sizeY,posX,posY,UIFunctionType,SpecificUIFunction,imageFileNameIfApplicable
layerName2,sizeX,sizeY,posX,posY,UIFunctionType,SpecificUIFunction,imageFileNameIfApplicable
Then all the UI would be controlled by a single XML file, or you could potentially break it down so each Layer is it's own XML file, and the information on sublayers is contained within an XML file named after the layer it is defining things for?
Anyway. I hope this wasn't too difficult a read, and that it'll help Toady or anybody else figure out how an abstracted, relative size UI could function, and that this kind of thing can be implemented before feature-bloat renders it impossible or impractical in the future.
edit: Also, potentially depending on how little or how much control over the UI that Toady wants to give us, the whole UIFunctioType and SpecificUIFunction variables could be removed entirely and he defines what all of the various options we have to work with are by giving them all specific layer names that we then organize however we wish by putting them in, plus giving us some 'empty' layers that we can use to help rearrange stuff is we so desire (or just the ability to MAKE empty layers named Container1,2,3,etc).
To be more clear. The initial system I defined potentially enables players to come up with entirely new ways of interfacing with the game. Not just the current methods of altering data. I'm not sure how it would work in that case, but it -could-, in theory, be done, or at least make it easy to do so.
If we go with this method I just editted in, where the layerNames are already specifically linked to particular functions of the game (for example, on the start screen, each option, the logo, etc, would all be specific layers and named as such), then Toady retains 100% control over the raw mechanics of what players can fool around with, and modders only control presentation.