"Yeah, I woke up on a red-velvet couch, a coked-up slut licking on my cock, everyone passed the fuck out on crystal shit, hoes with them fucking tits and ass out atop piles of empty bottles and used condoms, and at first I thought: *Ugh, Tuesday.* But then I turned to my right, and saw that my best friend was dead. And *that* changed me, not the anal probe. So don't get it twisted."

- Eddy Cuddles, Metropolis (1986)

Previously, I half-assedly theorized that, given a timeline on which I'd store state mutations, with each mutation being an action taken ingame by either the player or computer, I could feasibly construct a somewhat generative narrative engine.

Basis: the system reads the current state, builds [some structure] holding possible choices, and prompts the player to take an action from those choices. The action modifies the state, and the loop begins anew, save that now it's the system "prompting itself", so to speak.

Utterly barebones and abstract as it may be, it was useful to build this concept in my head as it gave me a way to reason about what I wanted to build. But there were two problems which I had to grapple with:
- What would [some structure] even be?
- How would the computer make choices based on an instance of [some structure]?

I found myself striking the philosopher pose for long hours on the toilet, deeply pondering these questions which I couldn't help but merge into one due to the shared incognita; silly brain wanted trees but I kept figuring out that's not going to work as the relationships between symbols are sometimes but not always hierarchical. Shhh, silly brain, it's not trees.

So what is the answer?
Well, can you guess it?

Graphs, of course it's fucking graphs. Specifically, a state transition graph. It was right in my face the whole time and I couldn't see it. Well, close enough.

It's ideal as the system in question is a finite state machine with strong emphasis on finite -- the whole point is narrowing down choices, which now that I think about it, can also come down to another graph. Let me explain.

A 'symbol' or rather SIGIL is an individual in-game effect. To this FSM, it's an instruction. Sigils are used to compose actions, which you can think of as an encapsulation of some function, or better yet, an *undoable transaction* which causes some alteration in the game world.

But to form a narrative from a sequence of such transactions, and to allow the system to respond to them coherently, relationships need to be established between sigils in a manner that can be reasoned about in code. You may not realize this yet but this is both a language processing and text generation problem, so fuck me.

However, we have a big advantage in that we are not dealing with *natural* language, that is to say, each sigil is a structure from which we can extract valuable information on the nature of the state transformation applied.

This allows us to find relationships between sigils programmatically: two words are related if some comparison between the underlying structure -- and the transformation it describes -- holds true. Therefore, if we take the sigils that compose the last transformation in the timeline, fetch relationships for said sigils according to a given criteria, then eliminate all immediate relationships that are not shared between all members of the group, we end up with a new one that can be utilized as starting point to construct a reply.

More elimination of possibilities would have to be performed as this reply is constructed [*], but the point is that because the context (timeline) is itself made of previous transforms, the system *could* make such a reply coherent, or at the very least internally consistent.

Well... in the world of half-assed theory. I don't know whether I'm stupid, insane, both, pad for alignment, or this is an actual breakthrough. Maybe none of the above.

Anyway, it's another way to mentally model the problem which is very useful. New challenge would be the text generation part, extremely high chance of gibberish within existing vision; need more potty-pondering.

[*]: I'll break it into bits OK.

0. Determine intention. That's right, the reply isn't actually _fully_ generated, it's just making variations on a template. So pick a template depending on who is taking a turn and replying to who (think companion relationship score bullshit)

1. Sort the new group according to the number of connections the constituent sigils had to the context from which they were extracted, higher first.

2. Pop from the sorted group (least connections). If there are other nodes left in the group, and it doesn't connect back to any of the other nodes (sigils) up to a certain distance, then discard it and repeat. Else keep going.

2. Unshift from the sorted group (most connections). If can traverse up to another sigil in the same group, then go for it. Else derive search criteria from current context (including intention), so as to look for another sigil to concatenate. Some form of weighting would be needed here, need to think about that.

3. Decide when to stop. Probably some chance, as in the more sigils you have, the lower the chance a new one will be added maybe. Need to think about this too.

4. Send transform, loop begins anew.

And that's it. So alright brb I'm going to take a dump on the Agora.

.rep:

Fixing old bits of code for my build tool so I can extend the damn thing and I'm throwing away so much shit. Can't stop man.

Pretty crazy as this code is, IIRC, 2 to 4 years old at most. And I am sure that I was feeling like an absolute legend when I wrote this ignominious fucking garbage, as in it is quite clever, just in a downright dogshit kind of way.

So I'm hacking away at this eternal monument to the abstract gonorrhea-infected bleeding and fully dilated defecating anus that are my past decisions, and I'm wondering, have I actually learned to write simpler code or am I just gonna repeat this process a few years down the road and get stuck in some kind of funky chronodisplacement self-sodomizing limbo.

Well, for one, I *am* very much simplifying the code because most of it I'm just outright deleting, and what I have to replace or rewrite is fairly succinct, so I'm feeling good about that. Second, and get this, now I have the advantage that I've actually used this piece of shit for a few years so I have the benefit of knowing where I fucked up from a user perspective, which is invaluable.

Yeah, I think I nailed it this time. No more fucking around; pinky-promise.

jmp .rep

Correction: oligarchy, not "democracy".

Unless you mean it in the classical sense of the word, where "people" is not as broad a term, given how **citinzenship** was an exclusive status in the ancient city-states that developed these concepts.

However, even in that case -- which I find highly unlikely -- I'd argue that oligarchy is equivalently if not moreso applicable as an accurate description of said form of government.

Every few years, you (probably) go and vote _not_ for whomever better represents your interests, but rather for whomever seems to be the lesser evil: the 'best of the worst', if you will, out of a series of horrible candidates you absolutely do not trust.

That is undemocratic; no semblance of power is vested in us, much less "supreme power", and we cannot speak of anything even remotely alike to popular sovereignty within this context. By which I mean, we have overlords rather than "representatives".

And this, altogether, does beg the question: why do we parrot these terms as if they were ever a faithful description of anything? Have we no capacity for language, perhaps?

Appropriately enough, it's bollocks all the way down.

Almost finished with latest preprocessor.
Why am I always working on preprocessors tho? Shit...

Anyway, almost finished ok.

Idea is, basically, that inside a C source or header you can write a perl subroutine instead of `#define ...`.

The mechanism is rather simple:

```C (wat?)
macro mymacro($expr) {
· // perl code goes here
· return "$expr;"
};
```

`$expr` is just a string holding whatever block of code comes after an invocation of `mymacro`. You can use the builtins `tokenshift` and `tokenpop` on a string to get the first and last token, respectively, and then `tokensplit` gives you *all* the tokens.

Whatever string you return is what the expression you received is replaced by:
- You can just give back the expression as-is to get the exact same thing you wrote -- so `mymacro char* wat;` gives you `char* wat;`.
- But if you return a galaxy's worth of C code, then bam. Macro expanded into it, just like that. It's a perl subroutine, so let your imagination fly. Wanna run some scripts at (pre)compile time? Then you can.
- If you return an empty string, then puff. No code. Input consumed.
- If you give the name of another macro (eg "another_macro $expr;"), the expansion recurses.
- If you return the name of the currently executing macro, no recursion happens. This lets you wrap C keywords without (too much) fear.

It's kind of cool because a separate perl module is built from the macros themselves. So then you can include those in another C file. Syntax is basically more perl because why not:

```C (yes)
package mypkg;
· use lib "path/to/myshit/";
· use pm funk qw(mymacro);
```

The `lib` bit actually translates to `-I(path)` for gcc. But for some reason the way you add an include path in perl is `use lib "path"`, so yep. I get it's confusing but just go with the ::~ f l o w ~:: ok.

Then the `pm` stuff is not valid perl (i think), but I took the easy way out and invented it to ensure there is a way to say "OK I don't give a single shit about the C stuff, just give me these qw()'d funky macros from this file." If you simply `use funk qw(mymacro)` then you also get an `#include "funk.h"`.

Speaking of which, headers are automatically generated. Yeah, fuck you, I added `public` to C, bite me. It's actually quite sexy as I defined it using the preprocessor:

```C (yes but actually perl)
macro public($expr) {
· my $dst=cmamout()->{export};\
· tokentidy $expr;
· push @$dst,$expr;
· return "$expr;";
};
```

Where `cmamout()` is a hash from which the output is generated. Oh, and `tokentidy` is just a random builtin that cleans up extra whitespace, don't mind it.

So now the bad stuff: I have to fix a few things. For instance, notice how I had to escape a new line there? Yeah. It's called dumb fix to shit parsing, of course.

But overall I'm quite satisfied with this. And the reason why may not be so obvious so I'ma spill it out: backticks, motherfucker.

That's right. Have a source emitter written in an esoteric language?

```C (yes really but not really)
macro bashit($expr) {
· my ($exe,@args)=tokensplit $expr;
· return `$exe @args`;
};
```

So now you can fork off into parallel dimensions; what can I say pass the pipe brother.

MAMmoth in the room is yes, this depends on MAM. What is MAM? MAMMI. It's the original name of my infamous picture of an ouroboros eating it's own ass while stuck in limbo contemplating terrible life decisions of a build tool, avtomat (go ARSLASH <AR/> [habibi]).

So what's the deal with that? avtomat is a good build tool _for me_, not... ugh, you. I made it for *myself* baby things are not going to work out between us I'm sorry. MAM just does lots of things I wanted build tools to do in the __EXACT__ way I wanted them done. I'd say you should go use it too maybe, but actually don't and you shouldn't because I broke main some weeks ago to fix some other shit and then implement this. Yeah, pretty stupid, but what the hell. I'm the only user after all!

In conclusion, I am fully expecting to receive my mad props and street cred in the mail along with your marriage proposals en masse, effective immediately.

Further reading: https://youtube.com/watch/...

Consider:

For a "Save As" dialog, you pipe into an external util from your application, passing in directory and an extension filter, something like `|` separated "Description (*.ext)".

Your code waits as the user picks. When they press OK, you get back a filename.

---

Quick poll:

If the user chose an extension/filter, but wrote the filename _without_ an extension, then what is the expected output?

[A] The filename as-is, no extension.

[B] The filename with the extension added, according to the selected filter, unless the filter was just "All Files (*.*)".

[C] "\1\0\0\0" and errno set to `EDEADLOCK`.

About a year, maybe two years ago I stupidly spill drink on keyboard, immediate RIP.

Got myself a new one right away, obviously. Didn't have much money at the time so I cheaped out on it, got a piece of trash that can't read more than two inputs at once. Like say I can't hold down shift, press W and then space to jump, shit like that. I developed a little muscle memory to get around it, just quickly switching between running and jumping. Dumbest shit ever, it kills your momentum.

Anyway I don't mind that but I've started noticing the caps are disintegrating. Particularly Meta, Shift, Arrows, they're just destroyed. The Enter keycap flat-out shattered. I can see which key I hit the most by how much the plastic has... well, melted and caved in. my touch is fire (baby) oh yeah.

So, go into normie internet to look for stuff to buy. Yay consumerism, everything sucks. Look at these pieces o fshit. And these fucking websites man. Who designed this your mother, don't answer, your mother would've done a WAY better job. Ugh. Fucking bullshit.

And why is everything "gamer" and has that horrible rainbow aRrGeebEe shit. Dafuq, boi. This is some of the most visually displeasing shit I've ever seen, and I am a shit poster by trade, I have witnessed some of the most cavernous depths of the internet's unholy butthole. I thought bleeding through the urethra was painful, but no, this is somehow worse. I am experiencing such profound disgust it has affected me physically. Also am I just a ranting geezer at 31, heh, well best to be a rapidly mentally aging son of a bitch than a fucking jerkwad with an atrocious taste that somehow gets picked up and circlejackaloped off by an entire fucking industry.

But enough about your terrorized rectum, I have money to spend. Is that mechanical shit worth it I wonder. Like those oh so ~ a e s t h e t i c ~ shitbags that take keys away from you and yet charge you more for it. Like I don't care about it being cute, will the keys witstand the ecstasy of my flaming fingers. I type a lot, and I mean a lot, man. Have you ever seen my repos, millions upon millions of pseudo pornographic keystrokes spent on shit that does nothing, I am unashamed to admit it, now where is my medal of sin bestowed on me by the finest of malignant sponsors.

Anyway, fuck this rant, I lost my train of thought midway through and it became an abomination that I am too stubborn to hit delete on.

Also I have no delete key pls halp.

me is make search:
c fun strsub name was?

aI oVeRQuEEfvIew:
tHeRE iZ nO fUnKCHon iN ceE foR gEtTen sUb sTrEnggGzEn

no, that is lie! you are liar!
me is thumb you down. bad gugul.
me is make search again now.
oh wait memory return.
strstr.
right.
that the name silly me.
i be alias fun to strsub because more mnemonic.

but why is gugul degenerating search don't know.
ruining experience not OK.

please someone tell mister pichai is make search bad thanks.
i want good search back, can switch to duck?
open duck.
oh noes.
duck is degenerate now.
has duck.ai on frontpage.

whyyyyyyyyyyy me is make tears now.
need good search not gorgabe.

rebuild preprocessor package applying preprocessor OK.

dependency cycle: the preprocessor depends on the lib it's trying to process oh noes.

OK fixed. how? code duplication (just a little).
checkmate, motherfucker.

up yours best practices i am max wright, maximum crackhead power.

now syntax check file once preprocessor is applied. normally need fork, but slows down build. can do with function?

yes but file has dependency cycle with itself because trying to load it's symbol table while loading it's symbol table so cannot compile. oops.

how about overwrite namespace with namespace cat ++unique_id (static uint64_t)? OK can do. not even store original name, just cat OUT_${uid} to it.

work like charm. now have syntax error messages, format all shit.
utilize power of crack /at\s (?<fname>.+) \s line \s (?<line>\d+) , \s near "/\e[32;1m$+{fname}\e[0m at \e[33;21m$+{line}\n\n\e[36;1m```/;

excellent, now subst closing quotes, easier said than done or maybe not really. just catch /\n"/```\e[0m\n/ OK for now.

errmes easy read and build complete in under a second now vs TWO MINUTES before; willy tanner strikes again.

I wins cookie now. brb need more magic.

There was this question I came up with that was very good at inducing hallucinations on what at the time I thought was a *lobotomized* LLM.

I can't recall the exact wording right now, but in essence you asked it to perform OpenGL batched draw calls in straight x86_64 assembly. It would begin writing seemingly correct code, quickly run out of registers, and then immediately start making up register names instead of moving data to memory.

You may say: big deal, it has nowhere to pull from to answer such an arcane fucking riddle, so of course it's going to bullshit you. That's not the point. The point is it cannot realize that it's running out of registers, and more importantly, that it makes up a multitude of register names which _will_ degrade the context due to the introduction of absolute fabrications, leading to the error propagating further even if you clearly point out the obvious mistake.

Basically, my thought process went as follows: if it breaks at something fundamental, then it __will__ most certainly break in every other situation, in either subtle or overt ways.

Which begged the question: is it a trait of _this_ model in particular, or is it applicable to LLMs in general?

I felt I was on to something, but I couldn't be sure because, again, I was under the impression that the model on which I tested this was too old and stupid so as to consider these results significant proof of anything; AI is certainly not my field, so I had to entertain the idea that I could be wrong, albeit I did so begrudgingly -- for obvious reasons, I want at least "plausible based on my observations" rather than just "I can feel it in my balls".

So, as time went on, I made similar tests on other models whenever I got a chance to do so, and full disclosure, I spent no money on this so you may utilize that fact in your doomed attempt to disprove me lmao. Anyway, it's been a long enough while, I think, and I have a feeling you folks can guess the final answer already:

(**SLIGHTLY OMINOUS DRUM ROLL**)

The "lobotomy" in question was merely a low cap on context tokens (~4000), which I never went over in the first place; newer/"more advanced" models don't fare any better, and I have been _very_ lenient in what I consider a passable answer.

So that's that, is what I'm starting to think: I was right all along, and went through the burdensome hurdle of sincerely questioning the immaculate intuition of my balls entirely for naught -- learn from this mistake and never question your own mystical seniority. Just kidding, but not really.

The problem with the force of belief is it can work both ways, by which I mean, belief that I could be wrong is the reason I bothered looking further into it, whereas belief to the contrary very much compels me to dismiss doubt entirely. I don't need that, I need certainty, dammit. And though I cannot in good faith say that I am _certain_, "sufficiently convinced" will have to do for the time being.

TL;DR I don't know but the more I see it just seems shittier.

me: just removing trash and bloat, no biggie.

walrus: nO RpERFACkTOWwwrRRinG noOOoOooOO UuHH!! YYYYOu IZ roEwFAuKToRyG!!!!!!!1!!one lOwW zElFf ztTeEMMmMme && sO ~~wEk~~!!

me: hehe rm -rf go brrrrrrrrrrrrrrrrrrr.

I may frame this.

OK, I think Ive figured out how I want to implement the core of my game.

Basic idea. Everything is made of sigils. What is a sigil? Lorewise, a representation of a concrete idea. Mechanically, it's a container for one or more ingame effects.

Again, anything you can think of, be it mundane or arcane, is a sigil. Every object attribute and method that causes a mutation of the game world state is composed of either a single or a sequence of sigils, known as a signa. You can do abstraction and have one thing encapsulate others, all that good stuff.

We go turnbased because tabletop rules. In your turn, you choose what to do with the sigils available to you. Common stuff like walk, talk, crouch, attack, et cetera are available to everyone.

You choose which effects to use, keeping in mind that order matters, and these effects either clash against or boost each other according to internal rules. Any relevant environmental modifiers around you or status effects apply here as well. Theyre also made of sigils, so theyre just implicitly components of the spell.

Finally, we get the result. An aura. It is simply the aggregate of all the sigils, containing the final transaction that will be applied to the game world, with dicerolls, if any are needed, already performed.

So here's the crucial bit. We record the aura for each turn, taken by either the player or the game itself, which includes the sequence of sigils used. Because each of these are words, or a series of words, it can be used narratively.

Let me give you an example. You are in a swamp, you use your turn to move around. This gives you an aura like so.

src: player, location: swamp, status: ok, walk.

We push that to a stack the game can see.

Now the game has to take its turn, and will look at the stack to get ideas. So lets say this swamp hindered your movement, gave you some trouble getting around. This is noteworthy enough as it affected something in the game world, and theres nothing else going on, so its made into a topic. The game will now pay attention to it and make it available for talking about.

topic: swamp-slow on player-party.

Everything is sigils, remember? Speaking is an effect, as is giving you something to talk about. Adding a topic results in an aura, push that to the stack.

Maybe then the game decides have the players companion make a comment on this topic. OK, just pair speak with other sigils to make an expression. The current topic is simply about a single negative effect, so one or two should be enough for a comment.

Factoring in the companions traits, also sigils, and the fact that for now this only a minor annoyance, we end up with an aura.

speak: topic -> complain about.

Do you see where this is going yet? The spellmaker gives us the means for text generation. The key here is instead of processing natural language like a bunch of dumbasses we just have an array of structures meant specifically for this purpose.

Anyway, the player now takes their turn. They can keep silent and continue moving, or say something as well. So let's say you pick the speak sigil too because why not, the current topic is also available to you, so you can reply. Depending on what the last message (aura) was, you get a range of options, and why not, let's factor in the player's chosen traits as well.

speak: shutdown -> complain about topic DOT change-topic -> mcguffin-quest.

We're on a mission to recover some plot stuff so shut up.

This results in further state changes, albeit behind the scenes. Our companion isn't happy, and we have a sequence of structures to prove it. Actions taken in relation to a topic can be associated with it if they're deemed significant, id est they caused a mutation of the game world's state.

speak: remind -> topic-name.

Thats right. Companion dude WILL remember that, you son of a bitch, and you bet your ass hes gonna bring it up if you keep acting like youre his boss or some shit. You dont even pay him!

You may say its such a small thing, but it all matters in a story. So we keep track of it, see what we can make this branch off into once a little more time has gone by.

What do you mean crazy, Im a fucking patrician of tenebrous arcana. You solve the problem by not solving the problem, obviously. Fuck natural language processing, all my homies use Litechnics to make narrative-driven programmable representations of the human condition.

Further rules include breaking gameplay down into scenes and acts as if it were theatre, because why not, and having baddies cooking shit up behind the scenes. Mechanism for that is the same, read the current stack and output structured wordsoup based on it.

We can even have a chorus narrating.
Or an audience reacting lmao.

OH GOD.
BUT I'M SO FRIGGIN SLOW OF A DEV.

WHAT IF I DON'T LIVE LONG ENOUGH TO IMPLEMENT THIS?
SHIT.

WORST SHOULD COME TO PASS,
PLEASE AVENGE MY DEATH.

PERLGUTS
PERLXS
XSUBPP

DEATH
DEATH
DEATH

util: YOU CANT PASS VERSION IN THAT FORMAT IT MUST BE A VERSION OBJECT FROM THE VERSION MODULE IN THE VERSION CINEMATIC UNIVERSE BLAHBLAHB LAHBLAH BLAHBLAH (...) CANT COMPILE THOUGH EVERYTHING ELSE IS CORRECT.

me: fuck you, it's just a string. i'll pass it however the fuck i want, using whichever format i feel like, and your standards will suck my dick day and night.

util: NOOOOO!!! I WAS PROGRAMMED TO THROW AND DIE AND BURN ON THIS VERY SPECIFIC AND INFINITELY STUPID CONDITION THERE IS NOTHING YOU CAN DO!!

me: well you're a build tool so i guess i could just replace you with inhouse, right? i mean https://github.com/Liebranca/... im just the kinda guy to do it.

util: WHAT?!! NO PLEASE I DIDN'T MEAN T- **FUCKING DIES**

me: get uninstalled bitch.

I used inline C in perl to write inline assembly.

I deserve death.

For devJs (I think?), who asked me what I was working on after I said uuuh me is hexdump diver, here is some logs so as to illustrate the boring stuff I'm doing lmao:

; just checking what I'm allocating c:
0000000000000000 : ALO 000000001B0C42B0

; ^taking that allocation and inspecting it
$0000 <: 000000001B0C42B0

00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................

00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................

; it's 128 bytes, so OK, good.
; then I say perform some writes
000000001B0C42B0 : WRT [ 0 .. 56] | 128 ( 56 * 1)
000000001B0C42E8 : WRT [ 56 .. 61] | 128 ( 5 * 1)

; ^look at the buf again to check that I wrote what I
; ^intended to write
$0000 <: 000000001B0C42B0

0000558D F7C480C0 : 00000000 00000000 | .....U..........
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 544F4F52 | ........ROOT....

00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................

; ... do some more writes, and so it keeps going
000000001B0C42ED : WRT [ 61 .. 117] | 128 ( 56 * 1)
000000001B0C4325 : WRT [ 117 .. 119] | 128 ( 2 * 1)

; ^inspect...
$0000 <: 000000001B0C42B0

0000558D F7C480C0 : 00000000 00000000 | .....U..........
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : FFFFC300 544F4F52 | ........ROOT....

FFFFC3FF FFFFFFFF : 000000FF FFFFFFFF | ................
00000000 00000000 : 00000000 00000000 | ................
00000000 00000000 : 00000000 00000000 | ................
00002400 00000000 : 00000000 00000000 | .....$..........

; and here it crashes because I somehow still wrote
; outside of bounds ;> FUUUUUUUUUUUUUUCKKKK
realloc(): invalid next size
Aborted (core dumped)

I'm actually pretty fucking pissed that what may possibly be my last comments on devotion rant where not delirious tangents. No fair.

Now, let's huddle together and blame someone for this mild inconvenience with no basis for the accusation whatsoever, brb I'ma go get the torches ready...

lets run test funny experiment with memories OK.

> Fatal glibc error: malloc.c:2601 (sysmalloc): assertion failed: (old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)

well fuck.

echo "circle jerk" &> /dev/null

g++: TWENTY SCREENFULS WORTH OF ERRMES.

the mistake: `v=ptr` should be `v=*ptr`.

dude whenever someone says anything about idiomatic ceepluesplues I'ma just SLAP EM WITH A FISH~

Okay, summary of previous episodes:

1. Worked out a simple syntax to convert markdown into hashes/dictionaries, which is useful for say writing the data in a readable format and then generating a structured representation from it, like say JSON.

2. Added a preprocessor so I could declare and insert variables in the text, and soon enough realized that this was kinda useful for writing code, not just data. I went a little crazy on it and wound up assembling a simple app from this, just a bunch of stuff I wanted to share with friends, all packed into a single output html file so they could just run it from the browser with no setup.

3. I figured I might as well go all the way and turn this into a full-blown RPG for shits and giggles. First step was testing if I could do some simple sprites with SVG to see how far I could realistically get in the graphics department.

Now, the big problem with the last point is that using Inkscape to convert spritesheets into SVG was bit of a trouble, mostly because I am not very good at Inkscape. But I'm just doing very basic pixel art, so my thought process was maybe I can do this myself -- have a small tool handle the spritesheet to SVG conversion. And well... I did just that ;>

# pixel-to-svg:
- Input path-to-image, size.
- grep non-transparent pixels.
- Group pixels into 'islands' when they are horizontally or vertically adjacent.
- For each island, convert each pixel into *four* points because blocks:
· * (px*2+0, py*2+0), (px*2+1, py*2+0), (px*2+1, py*2+1), (px*2+0, py*2+1).
· * Each of the four generated coordinates gets saved to a hash unique to that island, where {coord: index}.

- Now walk that quad-ified output, and for each point, determine whether they are a corner. This is very wordy, but actually quite simple:
· * If a point immediately above (px, py-1) or below (px, py+1) this point doesn't exist in the coord hash, then you know it's either top or bottom side. You can determine whether they are right (px+1, py) or left (px-1, py) the same way.
· * A point is an outer corner if (top || bottom) && (left || right).
· * A point is an inner corner if ! ((top || bottom) && (left || right)) AND there is at least _one_ empty diagonal (TR, TL, BR, BL) adjacent to it, eg: (px+1, py+1) is not in the coord hash.
· * We take note of which direction (top, left, bottom, right) every outer or inner corner has, and every other point is discarded. Yes.

Finally, we connect the corners of each island to make a series of SVG paths:
- Get starting point, remember starting position. Keep the point in the coord hash, we want to check against it.
- Convert (px, py) back to non-quadriplied coords. Remember how I made four points from each pixel?
. * {px = px*0.5 + (px & 1)*0.5} will transform the coords from quadriple back to actual pixel space.
· * We do this for all coordinates we emit to the SVG path.

- We're on the first point of a shape, so emit "M${px} ${py}" or "m${dx} ${dy}", depending on whether absolute or relative positioning would take up less characters.
· * Delta (dx, dy) is just (last_position - point).

- We walk from the starting point towards the next:
· * Each corner has only two possible directions because corners.
· * We always begin with clockwise direction, and invert it if it would make us go backwards.
· * Iter in given direction until you find next corner.
· * Get new point, delete it from the coord hash, then get delta (last_position - new_point).
· * Emit "v${dy}" OR "h${dx}", depending on which direction we moved in.
· * Repeat until we arrive back at the start, at which point you just emit 'Z' to close the shape.
· * If there are still points in the coord hash, then just get the first one and keep going in the __inverse__ direction, else stop.

I'm simplifying here and there for the sake of """brevity""", but hopefully you get the picture: this fills out the `d` (for 'definition') of a <path/>. Been testing this a bit, likely I've missed certain edge cases but it seems to be working alright for the spritesheets I had, so me is happiee.

Elephant: this only works with bitmaps -- my entire idea was just adding cute little icons and calling it a day, but now... well, now I'm actually invested. I can _probably_ support full color, I'm just not sure what would be a somewhat efficient way to go about it... but it *is* possible.

Anyway, here's first output for retoori maybe uuuh mystery svg tag what could it be?? <svg viewBox="0 0 8 8" height="16" width="16"><path d="M0 2h1v-1h2v1h2v-1h2v1h1v3h-1v1h-1v1h-1v1h-2v-1h-1v-1h-1v-1h-1Z" fill="#B01030" stroke="#101010" stroke-width="0.2" paint-order="stroke"/></svg>

OK, I could maybe write a quick app in C++ and cross compile it so I can send it to my friends who use windows, what is wrong with you I am ashamed for us all.

But why do that? Let's just go the EXTREME route and do things in a very inappropriate way that is natively """portable""" so we can say that (((It Just Works™))).

So if you haven't guessed already, it's 100% js rawdogging and I'm doing the graphics in SVGOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH NOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO uoykuf OoOOOOOOOOOOOOOOOOOOOOOOoOOOOOOOOOOOOOOOOOOOOO it's not so bad but here's things I've learned:

If you're using inkscape to convert your lazy 8x8 pixels per frame spritesheet.png into an svg file, and don't know how to use inkscape, you have to stack each frame on top of one another. Yes.

Erase the layers, erase everything that isn't the paths you want. Also erase invisible paths generated by the pixelart mode of the trace bitmap thingy, sometimes these ghosts exist for mysterious reasons.

Then, neatly stack everything into one square big enough to hold all the frames, select all the frames, resize to selection. OK, now double check that the names of your layers werent changed to generic path94958509 out of the fucking blue AGAIN, all good.

Also double check that inkscape hasn't changed the name and extension of your output file AGAIN then make sure inkscape hasn't changed the dimensions of your export AGAIN and then AGAIN and AGAIN...

OK, so you've exported your svg, now we start doing even more stupid and questionable things. We go into the file and delete the header, specially the comment at the top that clearly states this file was made with inkscape, because my experience was so DELIGHTFUL that I very much require some abstract form of petty vengeance. Also a cigarette.

Hold on. Patiently erase useless tags such as defs and g and shit, all you want is the svg and paths. Then, painstakingly convert each <path id=$ .../> into <symbol id=$> <path .../>.

Why didn't I write a perl script for this part? Actually that's a good idea, goes on the todolist, I didn't write a todolist app though, because I have a textfile. I mean, just what kind of negative IQ troglodyte would do something like that? ;>;>;>;>;>;>;>

Anyway, now utilize your black-magic-infused devilspeak q$p e r l$ script to fasten together an entire webapp into a single html file, all done with duct tape and clown jizz of course, see previous rant for VERY technical details. Also I jjust time traveled and wrote the previous paragraph while writing this one everything is out of order oh noes.

No matter it works now me is happiee.

I got heart icon for health bar but no health bar implemented not aproblem.

Uh also outlines. Here, let's keep it topical, this is rom.rol:

```rol
# vars:
$:%peso;>
let sprite,"$.elems.srpite";
$:/peso;>
# css:
$:%asis;>
path {
· stroke: $080808;
· stroke-width: 0.1;
· stroke-linejoin: round;
· paint-order: stroke;
}
$:/asis;>
# html:
$:%asis;>
<svg width="2.1166811mm" height="2.1166601mm" viewBox="0 0 2.1166811 2.1166601" xmlns="http://www.w3.org/2000/svg">
<symbol id="{$$.%sprite}_hp_0">
<path d="M 0.264594,0.26458 V 0.52916 H 1.1e-5 V 0.79375 1.05833 1.32291 H 0.264594 V 1.5875 H 0.529177 V 1.85208 H 0.793761 V 2.11666 H 1.058344 1.322927 V 1.85208 H 1.587511 V 1.5875 H 1.852094 V 1.32291 H 2.116677 V 1.05833 0.79375 0.52916 H 1.852094 V 0.26458 H 1.587511 1.322927 V 0.52916 H 1.058344 0.793761 V 0.26458 H 0.529177 Z"/>
</symbol>
<!--NOW DO THE OTHER NINE FRAMES-->
</svg>
$:/asis;>
```

so now I can say (in base.rol):
```rol
$:%peso;>
lib "[based]";
rol "rom.rol";
let hud,"$.elems.hdu";
$:/peso;>
$:%asis;>
<svg viewBox="0 0 23.283329 2.1166601" width="16%" height="16%" fill="#880808">
<use id="{$$.%hud}_hp" href="#{$rom.%sprite}_hp_0"/>
</svg>
<script>
document.getElementById("{$$.%hud}_hp").setAttribute('href',"#{$rom.%sprite}_hp_" + n).
</script>
$:/asis;>
```

Where `n` is just some frame counter this is duct tape now request animation frames REQUEST THEM YOU MUST.

Anyway this is immensely stupid but it made me giggle so I share.
AAA RPG with full svg graphics when?

OK here's lang, very easy.

set lines, (split "\n", orc fname). ; ORC -- open, write, close
map lines, strip.
grep lines, filter blanks.

map lines, # lineproc:

- on line match, qr~^# \s* (?<name> [\a]+) \((?<type> [\a+])\) \s*:\s*~x.
· · * have type or default type.
· · * set dst, name or new type name.

- on line match, qr~^\- (?<name> .*)~x.
· · * dst->cur eq dst->[name] eq new list name.

- on line match qr~^\* (?<item> .*)~x.
· · * push dst->cur, item.

- else
· · * cat dst->cur, line or throw fuk.

I'm skipping over a couple edge cases (no dst/cur, I be throw fuk for brevity) but you get the gist of it maybe.

Anyway what's this for? Lists, like so:

```rol
# dst (type):
- attr:
· · * hi im item one in list
· · · still item one lmao.
· · * hi im item two in list.
```

That gives `dst { attr: [item_1, item_2] }`. There's another bit I'm omitting to make this recursive so as to allow for nested dicts, but nevermind that it's a tree you get it right.

So what it's lame. Yes. Let's smoke some crack now I can add preprocessor in subclass:
```
# dst (cracktype):
$:%fn args;>
(text)
$:/fn;>
```

That will call `fn text,args` to process text __before__ lineproc, `fn` is just callback from callback table in Nebraska maybe.

$:peso;> syntax is just so text can contain funstuff OK.
I like <fn args /> better, and $:this;> is just stuff no one ever writes so it's safe to use.

Want to reference object in text too, what? `{$obj [fn args]}` anywhere in text to make call, now can do database lookup so naming be important. Have import mechanism to fetch collections, can't bother showing.

Anyway what's the point I dunno, just copying and pasting from local library to pack entire app in single html file. Why? Can't remember; doesn't matter.

Also can convert to json but I prefer my own version of it.
Called jargon.
Same thing but no quotes just because so `obj {attr:[(value), (value)]}`.
Now eat baguettes.

Have a nice wallop.

Journalists reading tweets sent by grand ayatollah Khamenei live on argentinian TV is kinda surreal but I guess this is where we're at now.

Me, reading random wikipedia:

A boutonnière (French: [bu.tɔ.njɛʁ]) or butthole (British English) is a floral decoration, typically a single flower or bud, worn on the lapel of a tuxedo or suit jacket.

Wait, that can't be right

butthole.
buttonhole.

OOOOOH

Going through my lore notes. And I'm playing a game with myself, so to speak: it's called "is this metal enough?", but with a side of quasi-metaphysical arcane technobabble plus mass wallmelting and nightmarishly psychedelic confusion.

For example... why are shadow gates a thing? Well, because of the undoing of time caused a multiplicity of parallel cycles that will, inevitably, slowly collapse upon themselves through a sequence of irreducible asynchronicities. But of course!

Now, as for the metal part, that's the undoing of time. You see, the Somberlain attempted to cast the most sinful signa in order to restore the desolate mortal realm as it stood on the brink of a world-ending cataclysm, this was after a decade of brutal, reckless litechnical abuse during the civil war fought amongst the first undecimvirate...

Now, he intended to roll back time itself as a way to avoid the cataclysm and restore life to the mortal realm, but the cost was immense: time was not rolled back, but rather __forcefully__ torn apart; it was effectively shredded, shattered, and undone.

Countless lives were lost as nearly six hundred years of Being were __erased__ in an instant, the most heinous large-scale blood sacrifice in history, spanning the entirety of the lower fragment of reality. I mean is this too dark, I'm not sure. How about I clarify: he didn't just snuff out their lives, no, they CEASED TO EXIST. THEY NEVER EXISTED. GONE. UNBECOMED INTO A TRUE IMMEMORIAL. OVER FIVE CENTURIES OF EVERY CONSCIOUS MOMENT ON EARTH DEVOURED TO FUEL HIS DARK MAGIC.

That's gotta have consequences, right? Well, obviously you'll get temporal distortions after that shit, I mean duh...

But wait, I'm lost, you say the undecimvirate deified themselves but were cast down after the whole superman spinning the earth backwards thing went full bathory and erased entire centuries from the fabric of the cosmos, so they were turned into the eleven thrones to guard over the eleven circles of the night eternal... but how is that linked to natural occurrences of teleportation?

First off, because *natural* teleportation is distinct from *artificial* teleportation. Failed experiments with (and miscasts of) mass transference of living matter are one of the leading causes of death among litarchs. It is not an instant transmission, just very, very quick, moreso than a mortal mind can process, that's why the "dilate" and "delay" sigils are added, so as to make the journey seem slowed down to the perceptions of whomever is teletransported, this is meant to ensure their brains don't __melt__ from the experience.

Similar reason as to why you have to give the _approximate_ total weight to carry when inscribing the ritual circle, you *do* know that it is __highly__ recommended to use accurate weighing scales to approximate this quantity, as under or overestimating it can lead to _FATAL_ consequences... do you not?

No, *natural* occurrences of teleportation do not have these constraints for two reasons: one, because both ends of the gateway are _fixed_ in both time and space due to the logic-defying occurrence of a future event being undeniably the cause of the past it revisited. Put on this toga. They are inextricably linked through the metaphorical and *literal* corpse of infinite collapsed timelines, which generates a conduit through the first circle of the night eternal, which *is* the domain of both forgetfulness and horror immemorial.

Second, the final layer on our stratified reality, that is, the final circle before the INVIOLABLE divine veil, wraps around the night eternal, which is why we call it "the shell". Or "Crisalida" if you dig Luis Alberto. It is a realm entirely outside of time, which is why the patriarchs can grant immortality, you see. By proximity to this sacred shell of existence, the timeline-corpse-conduit that links both ends of a shadow gate is, for all intents and purposes, approaching total chronostasis, therefore making it so bypassing physical space in a few seconds doesn't give you permanent loss of the sense of self as your brain turns into liquified jelly.

I don't remember what I was getting at and I don't care.

Oh look at it stupid technomusings.

Context:
- You have a sequence of N-byte-wide values.
- Each value is unique.
- You XOR them all together into an N-byte-wide key.
- Just dump the key into a list somewhere.

Problem:
- A new value sequence is input.
- Same rules: all values are unique and fixed-size.
- You XOR them all together into a key.
- You walk the list of keys and check them for equality against the new one.

The same sequence of values, regardless of order, would ((supposedly)) always give you the same key. I used this years ago, for a renderer that used indexed colors, to see if I had to make a new palette or not when saving/loading textures: the image format had the key on the header.

It worked, but I was using a __very__ limited value range, cursed 8-bit YUV lossy fuckery; never bothered investigating the idea any further.

So, question:
- Is there any specific situation in which you get a false positive?
- Is there any specific situation in which you get a false negative?

My brain wants to say 'yes' to both because I'm privy to the mystical truth that my methods invariably fall on the idiot side of the spectrum. But my lazy testing keeps saying 'no, you dumbass'.

So who's wrong?
brb gon hit that crack~

Something like 50 of my sweet, sweet plusplus just went poof, gone. Vanished, gone with the wind.

Could be a bunch of salty downvotes, no doubt a limpdick way to try and protest my immaculate logic? That is indeed a possibility. But the most likely explanation is someone nuked himself.

And you know what? Shit, man.
This is giving me flashbacks to when rutee left devRant and I hate it.

btw rutee, Mr Johnny Sins, your location literally inside me: in case you ever read this, I just want to say, you is the kewlest; no contest. Everyone else get fucked. I'm sorry, but you're not rutee. Nothing compares2u or some forbidden bromance shit sang by a bald woman, all night up the ass.

Anyway, where was I?
Ah, yeah. People-check.

So who deleted himself? I'm not seeing anyone missing. The whole gang is here. I think. I mean even ostream's shadowclones are still around.

Hmm. Maybe I did get downvoted?
Or maybe it was just a bunch of rants getting deleted, rather than a full-on nuke?

Huh. Indubitably, this is a case for Willy Tanner.
*REACHES FOR THE CRACKPIPE.*

fknshit. Am I stressing about linting and formatting moreso than what the code itself does or is it just another hallucination?

I call it correctness paranoia. Bitch does it even compile. Yes, perhaps, but I absently-minded added a single newline somewhere, and that's no good.

So re-read the diff again: oh.

const auto&
should be
const auto
probably.
F is not returning a ref...
Should it return a ref?

Fuck, I'm declaring this nonref, should I
T N(V)
or
T N = V

Plain old doesn't fucking matter most of the time, but what if I missed a detail somewhere and so it *does* matter here?

REREAD. AGAIN.
SLOWLY.
DYING.
DYING.
DYING.