@er1n Not sure what you mean. Can I get a link? :/

@Angle or, rather, mind mapping, fug

https://en.wikipedia.org/wiki/Mind_map

@er1n That might be useful for a personal reference, but I want something that I can use to store data that I feed into my program. :/

@Angle ahhhhhhhhhhhhhhhh, I see

@enkiv2 @natecull All of the above. For example, here's my storage of data for elements, like fire, earth, air, water:

ArrayList<CharacterTree.Focus> focuses;
ArrayList<Ability.Detail> targetDetails;
ArrayList<Ability.Detail> effectDetails;
ArrayList<Ability.Detail> costDetails;
ArrayList<Ability.Detail> scalingDetails;
ArrayList<String> relations;
ArrayList<StatDescriptor> primaryAttributes;
ArrayList<StatDescriptor> secondaryAttributes;
ArrayList<StatDescriptor> debuffAttributes;
HashMap<String, Float> resistances;
Obviously, it's a fucking mess. :/

@Angle @natecull
I'd start with a system like triples, probably. (Triples are what RDF uses, in theory, and a lot of stuff decomposes into triples.)

A triple is a relation between two things, so it's basically just a 3-tuple of IDs.

https://en.wikipedia.org/wiki/Semantic_triple

I don't recommend actually using RDF. But, for instance, CMU NELL just stores all its knowledge as a 3-column TSV of unique names.

@enkiv2 @natecull Hmm. Are there any good libraries for this kind of thing for Java? Or is that massive overkill? :/

@Angle @natecull
Depends on what exactly you're trying to do.

If you're going to use a planner on these associations, I'm pretty sure there are planner libraries, and there's a Java binding for Swi-Prolog & vice versa if you really like overkill.

If you plan to traverse a tree & choose a random valid value it's overkill and you should just roll your own triplet store with fast lookup.

@enkiv2 @natecull Not sure what a planner is in this context? But I'm mainly going to use them for procedural generation. Making skill trees with random weapons, techniques, stats used, etc. But I don't just want it to be random, I want there to be a certain degree of cohesiveness. So the stats fit the weapons fit the techniques, etc. But still have a chance for variation and oddball stuff. :/

@Angle @natecull
If you want to structure your thing so that you can chain by appropriateness (ex., choose a random weapon and if it's a two-handed weapon choose a secondary weapon that doesn't require a free hand) then you don't need a planner.

If you want to be able to make an incoherent build and then back up and retry until it's coherent, you need a planner.

Rolling your own planner might be easier than using an existing one, if you don't need it super general.

@enkiv2 @natecull Ah, gotcha. Do you know any good primers on this sort of thing? It's all pretty new to me. :/

@Angle @natecull
Sorry, I learned all this by learning prolog, basically. (And learning prolog is not necessarily the ideal way to approach it -- but is still better than approaching it from the RDF/OWL side.)

There used to be a bunch of good books on the subject in the 80s.

The other place you can look is the tracery community. They're the former (non-planner) approach -- they use generative grammars. http://www.crystalcodepalace.com/traceryTut.html

@natecull @Angle
There's probably good stuff specific to generative game design re: conventional 2d/3d games that I'm simply not aware of though.

@Angle
Ex., here's a planner I wrote for generating caper stories: https://github.com/enkiv2/scene-sequel

@enkiv2 @Angle @natecull speaking of rolling your own triple store in Java, this article might help if you want to save some time and learn a new tool https://neo4j.com/blog/rdf-triple-store-vs-labeled-property-graph-difference/

@enkiv2 @Angle

I don't have a lot of recommendations because I'm still feeling my way around a similar problem. (Adventure games with semi-smart AI agents). I've resorted to Prolog, but it's not quite ideal.

You might find JSON is acceptable for small sets of data - worst case, you can probably just shove stuff in a big old array if it won't fit in an object.

Longterm, I think Lisp/Scheme is the most flexible for weird data sets, but it's hard to use.

Would love to know what works for you!

@natecull @enkiv2 I'm already using JSON. I was hoping maybe there'd be a better way? I'll look at prolog though, maybe it'll give me some ideas. Same with lisp/scheme. :/

@Angle @natecull
You're still going to be stuck listing these associations.

The benefit of Prolog, Lisp, and RDF is that you can use an off-the-shelf planner to navigate the associations and produce reasonable results.

The benefit of tracery is the above plus it's pretty compact (since it's json), but on the other hand you don't have backtracking.

@natecull @Angle
If your data is sufficiently general-purpose / matches well with reality, there are some data sets that might be able to fill in gaps.

OpenCYC is a project where, since the early 80s, a team of people have been writing an ontology for "common sense" in a scheme dialect. They're not done.

http://github.com/dariusk/corpora has some data sets that are more specific.

@Triplefox @Angle
+1 for a somewhat denormalised relational DB, loaded with data from spreadsheets

I like to mock up an editor UI before I go too crazy on the data model front.

You're talking about weapons, so you'll probably care about weapon balance. Traditionally spreadsheets work well for balancing - nice tabular format, formulas, graphs.