Esoteric Update #267 - Work, Or We Start Embedding Springs

I'm going to do an early update this week because I'll just use this as a way to clear my head about something I'm working on.

First, I did some nice work with the remaining assets. This also means the backlog for assets is cleared now. I've been sitting on this large stack of assets for a while now, and it's nice to have it cleared off now, at least as far as those related to the document system go. I still have some other stuff to sift through. Anyway, I won't bore you with posting more generated document covers, but this has progressed nicely. It's not just about the new assets but also about including them in the generator.

Now, the second part is more about the test adventure and a little issue I've encountered. I want to talk about this a bit more in-depth because the whole thing has been a source of frustration for me.

So, the crux of the issue is mind maps on the UI/UX side of things. But also how that plays into design and development. That is to say, what we're doing here works fine on the backend. The systems aren't an issue. It's just the process of presenting it to the player. And that is absolutely buggered. Just gone dogging in the bushes.

I will do something I don't often do and directly bring up a game with a similar mechanic. This will be Sherlock Holmes: Crimes & Punishments (a 2014 game by Frogwares, a developer I am generally rather fond of). That game also similarly uses mind maps. When you solve a case, you are presented with a mind map with nodes, some of which contain observations, some your thoughts on the matter, and some lead to conclusions, with your goal being to come to some solution. That's not exactly how we're doing this, but it's close enough.

Here's an example of how this looks in Sherry Homie:

(Source: A Complex Mind achievement in Sherlock Holmes: Crimes & Punishments.)

Especially if you peruse the linked article, you might note that this isn't the only possible arrangement for this case; there are other ones, though this is a side note at best. The important thing is that you will note we have around a dozen nodes visible at any time and that they are laid out very purposefully. 

We want to be able to do the same, but our own "cases" contain a lot more nodes. The test adventure already has a dozen initial nodes, from which you reach further compound conclusions. And I assume we'll have about two dozen of these nodes once we finish everything. The problem is that this is a case where it starts being a problem to do manually, as it was done in Frogwares games using mechanics like this. It would be the best case if we could hold full authorial intent over how the mind maps are structured. Unfortunately, there's a point where practicality gets in the way and, in particular, adjustments to the mind map, like adding new nodes, veers off toward unfeasibility.

You might feel justified in pointing out that I have already worked on a system to arrange mind map nodes automatically. And this is true. However, just as the mind maps themselves are not based on the way they are used in the Sherlock Holmes game, the algorithm that exists there already isn't meant to solve this specific problem.

(If you want to know, the mind maps are based on a program called The Brain, which I have used for years to keep world-building, campaign, and character notes for tabletop RPGs.)

(This is from their site.)

(You might note that this does indeed have some more resemblance to what you might see in the game.)

I've already looked through possible solutions, and it seems like the best solution might be to use a Spring Embedder (also known as a Force-directed Graph Drawing algorithm) to calculate the graph's initial position and then manually correct the output to make the effort required to solve this problem manageable while retaining some degree of manual control over the results.

Unfortunately, I've only finished reading about how such a solution is implemented and have not yet had time to attempt it. So, that's likely what we're doing for the next update.