yukirij

Really enjoying all the depictions of interesting creatures—the art also has a good sense of personality.

One of the more substantial difficulties has been composing classes with conditional, parameterized building blocks—and that is before handling modifying traits, capabilities, behavior, and rendering.
That said, I seem to be making progress on a functional (though efficiently questionable) system.

Putting some more research into component-based/parameterized character construction, anime-style visualizations, and constrained emergent story systems for a small adventure game.
Designing a generalized, self-normalizing system is challenging but at least seems technically feasible.
#gamedev

Close-up photo of a densely petaled, salmon-pink flower.

Close-up photo of a petalless Magnolia-hybrid flower with sea anemone-like stamens and a narrow, pointed style.

A small section of bamboo and other dispersed vegetation.

A section of pond with dense aquatic and surrounding vegetation.

A few reference photos taken at the San Francisco Botanical Garden.

Started on a rewrite of the typed runtime data system/embedded language for Rust.
My code is still trashy, but the foundation is looking better, more representations are supported (e.g. DNS header), and the interfaces are mostly easier to use.
That said, there are certainly better ways to do this.

Additionally, some weapons deal bonus damage when all hit attempts are successful (or if summing, no dice are left over—this was annoying to work out algorithmically).
Naturally, this complicates statistical analysis beyond enumeration, though I am hoping to find a better solution.

For context, the current design uses two sets of d6—hit dice (specified by the weapon + modifier) and critical dice (1 + modifier). Most weapons provide a per-die/damage target number for each range bracket (though some allow summing). Any die value that matches the a critical die is doubled;

To help with balancing and player planning, I added an output to the card generator for displaying damage statistics.
The attack mechanics make calculation annoying (currently brute-forcing percentages, which quickly inflates computation with the number of dice);
acli.army/cards/table/
#gamedev 🎲✂️

Thanks—the program is fairly trivial (just composing HTML from data) but a little easier than using a spreadsheet in terms of variable structuring.

The nice part about using a scripting language to define card data is referencing object properties and shared data while having decent validation and without the overhead of a database (and should be better once I rewrite the language runtime)—plus it is easy to share and use with version control.

Started working on a small tabletop game and wrote a quick program to build an HTML card sheet from structured data defined in my configuration language.
The visuals and content legibility are lacking, but it at least keeps the cards mostly consistent.
Sample: acli.army/cards/
#gamedev 🎲✂️

Reasonably content with my Rust implementation of a persistently identified, hierarchical search tree container.
Not good enough to publish, but maybe with some more polish (a better implementation might already exist, regardless).
doc.tsukiyo.org/trailtree

Spent far too much time lately working on character bios instead of technical implementations. At least they are starting to feel more like characters than concepts—and I am content with most of the names now.
Picked up the Greater/Lesser Keys to help give my demon/devil groups a better foundation.

It depends on the specifics, but 2FA still has a lot of holes (just fewer than without). SMS and sessions can be hijacked, email and auth providers can be compromised, services can be hacked or accessed from the inside, recovery options can be exploited.

I still need to figure out a formula for converting these parameters into an outcome (likely a probability distribution of outcomes, to include some variation), but this should allow me to describe a variety of reproductive characteristics.

To avoid the "humans are average" problem, I am leaning toward giving humans neutral bias, high compatibility, and high transfer—making them good at integrating with other kinds and sharing features between kinds.
This would also play well into a handful of other common fantasy tropes..

The matrix describes the kind bias, compatibility modifier, and a transfer bias for both introductory and receptive components.
Kind bias affects the kind of the offspring; compatibility improves or hinders outcomes; and transfer affects how easily the offspring takes mixed kind features..

My system first defines a range of outcomes—properties of development and the offspring.
Each kind is represented in a graph, with directional edge costs, intermediate (taxon) nodes, and shortcut edges (making the graph not a DAG).
Each kind also has a parameter matrix modifying graph results..

Had some inspiration for formalizing the system governing reproductive compatibility between kinds in my (fantasy) worldbuilding—at least for gamete-based organisms.
There is still a lot of unhandled complexity, but I should have enough for the kinds I have explored thus far..

My biggest difficulty with building a well-defined, scientific fantasy world is having an idea that I find interesting but lacking a concept for how it should work mechanically—not to mention technical implementation into the existing system structure.

Made some progress on my character abstracts (finally landed on some names and stories I can work with), though I really ought to get the data system specification figured out so I can compile this all in a consistent format.

(Odd thought) While considering anatomy for my dinosaurs-but-not-really, the idea of large sauropods having the equivalent of fueling arms for reproduction popped into my head—not sure how that would work structurally...
Perhaps my mechanical systems research has been a bit excessive as of late.

I would not tell anyone to blindly trust the statements of any particular expert, but to at least recognize the knowledge, experience, and methodology developed over generations of people devoting their lives to better understanding our world. A little scientific literacy goes a long way.

What really bothers me about this is that the slightest changes in wording and tone could make this almost reasonable.
People should seek better understanding of the information they ingest, but too many see research as reading the first few search engine results (now LLM summary)...

Low-poly composition of land masses and ocean covering a spherical relief map.

Featureless, spherical relief map of a large bay and islands.

Spherical relief map of peninsulas and islands surrounded by oceans and continents.

Spherical relief map of chains of islands.

Spent some time over the last few days re-implementing the planetary terrain system (still working on regional LoD).
I integrated the algorithm from my hex terrain generator and, while not perfect and missing biomes, the output has been reasonably consistent in quality.
#gamedev #procgen

Finally got around to adding enumerated unions to the configuration language—they have been quite useful for consistently describing game content.
I also formally defined an empty type and fixed up anonymous schemas and follow-up scope blocks (for defining constants inside the schema's namespace).

Been working on a small game project with some friends for the last month.
While my knowledge of Unity is still lacking, I have gotten a fair amount of practice with systems architecture and exporting Rust libraries to C#. I also made quite a few improvements to my configuration language.

I am still working on an implementation of the design described thus far, with most of the difficulty being the hybridization of kinds/transfer of features.
Ultimately, I am far from describing (much less implementing) the complete system, but the foundation and direction seem workable. 8/8

Attributes augment the capabilities derived from the character's kinds and feature descriptions.
Attribute scores are applied to interactions by multiplying calculated values (e.g. lifting strength) by fractional powers of two: `std * 2^(score / basis)`. 7/

I am currently planning to have a sizable number of attributes (~28), with integer scores produced by normally-distributed randomization centered on a mean computed by multiplying a fraction of the basis by the number of points allocated to the attribute. 6/