When you're trying to go to sleep, but the requested features are calling your name.

😔😟😣😫

I just wanna sleep for once!!!

Worst dev experience of the year:
So, I went to my folks' for the holidays. My old man is a hospital practitian and is still resentful because I did not want to be a doctor too.

So he made me fix the whole fucking wiring at his place over this last couple days, because "well, you choose to be a glorified electrician!"

BTW, I have three kids and am still WFH during this time. I haven't slept in a week.

@retoor I did it I FUCKING DID IT. I CRACKED THE COWDZ.

HAVEN'T SLEPT IN ALMOST THREE DAYS.
BUT I FED THIS TO A LOBOTOMIZED BOTII.
IT WAS ABLE TO RUN MY RULESET.
WELL, A VERY LIMITED VERSION.
BUT STILL.

PRO VIBES-ORIENTED PROGRAMMING.
IN MARKDOWN.
PSEUDOMARKDOWN.
what?
WHAT??!!!!

OH YEAH.
BEHOOOOOLLLD THE POWER OF CRACK:

```
# Definition of Basic Terms:

- Actor;
· * "An Actor is a character or entity actively or passively participating in the game";

- Action:
· * "An Action is whatever an Actor does during their turn";
· * **IMPORTANT: "In addition to taking an Action during their own turn, an Actor can opt to prepare a Re-Action to activate during another Actor's turn, *if* they have enough SP/MP to do so"**;

- Signa:
· * "A Signa is an in-game effect that describes an Actor's Actions and Re-Actions";
· * "In-game effects can only alter values within the Actor->Status dict";
· * Signa->Caster = the Actor that activated the Signa;
· * Signa->Target = the Actor that is affected by the Signa;
· * **IMPORTANT: "A Signa can be cast 'OnSelf', that is, the Caster can choose to cause the effect on themselves"**;

---
# Actor Attributes:

- Actor->ReadOnly:
· * **IMPORTANT: "ReadOnly attributes represent an Actor's natural advantages and cannot be changed through in-game effects"**;
· * **IMPORTANT: "The purpose of these immutable attributes is determining the base values for game formulas"**;
· * "Actor->ReadOnly is a (key=>value) dict that stores the Actor's innate and immutable attributes";
· * **IMPORTANT: "These bonuses are fixed and cannot be altered by in-game effects"**;
· * "Each key corresponds to a specific game formula";
· * "Each value is a constant signed integer that represents a modifier for the associated formula";

- Actor->Grit:
· * Actor->ReadOnly->{"HP->Max"} = 8+(Actor->Grit*2);
· * "Actor->HP->Regen is not affected by Grit";
· * Actor->ReadOnly->{"Strength"} = Actor->Grit*1;
· * Actor->ReadOnly->{"Resist"} = Actor->Grit*1;

- Actor->Wit:
· * Actor->ReadOnly->{"MP->Max"} = 4+(Actor->Wit*2);
· * "Actor->MP->Regen is not affected by Wit";
· * Actor->ReadOnly->{"Intelligence"} = Actor->Wit*1;
· * Actor->ReadOnly->{"Dexterity"} = Actor->Wit*1;

- Actor->Charm:
· * Actor->ReadOnly->{"SP->Max"} = 1+(Actor->Charm*1);
· * Actor->ReadOnly->{"Perception"} = Actor->Charm*2;
· * Actor->ReadOnly->{"Charisma"} = Actor->Charm*2;

- Actor->Spirit:
· * Actor->ReadOnly->{"Arcana"} = Actor->Spirit*2;

- Actor->Faith:
· * Actor->ReadOnly->{"Defend"} = Actor->Faith*1;
· * Actor->ReadOnly->{"Heal"} = Actor->Faith*1;
· * Actor->ReadOnly->{"Bless"} = Actor->Faith*1;

- Actor->Hatred:
· * Actor->ReadOnly->{"Damage"} = Actor->Hatred*1;
· * Actor->ReadOnly->{"Curse"} = Actor->Hatred*1;

---
# Diceroll Definition:

- rand:
· * "A pseudo-random number between 0 and 0.99";

- roll->dX:
· * roll->dX = truncate (rand*X);

---
# Basic Formulas:

- Actor->Status:
· * "Actor->Status is a (key=>value) dict that stores the Actor's current status effects";
· * "These bonuses are temporary and can be altered by in-game effects";
· * "Each key corresponds to a specific game formula";
· * "Each value is a signed integer that represents a modifier for the associated formula";

- Actor->Damage:
· * let base = roll->d4;
· * let X = Actor->ReadOnly->{"Damage"};
· * let Y = Actor->Status->{"Damage"};
· * Actor->Damage = base+(X+Y);
· * "Result can be negative if (X+Y) is less than -base";

---
# Regeneration Rates:

- Actor->HP->Regen:
· * const base = 0;
· * let X = Actor->Status->{"HP->Regen"};
· * Actor->HP->Regen = base+X;
· * "Result can be negative if X is less than 0";

- Actor->MP->Regen:
· * const base = 1;
· * let X = Actor->Status->{"MP->Regen"};
· * Actor->MP->Regen = base+X;
· * "Result can be negative if X is less than -1";

- Actor->SP->Regen:
· * let base = Actor->Status->{"SP->Max"};
· * let X = Actor->Status->{"SP->Regen"};
· * Actor->SP->Regen = base+X;
· * "Result can be negative if X is less than -base";

---
# Default Signas:

- Movement (Signa):
· * Movement->Cost->SP = 1;
· * Movement->Cost->MP = 0;
· * Movement->Duration = 1 turn;
· * Movement->AreaOfEffect = 4 tiles;
· * "Allows the Caster to move the target up to 4 tiles distance";
· * **IMPORTANT: "This Signa does not allow the Caster to avoid obstacles"**;

- Attack (Signa):
· * Attack->Cost->SP = 1;
· * Attack->Cost->MP = 0;
· * Attack->Duration = 1 turn;
· * Attack->AreaOfEffect = 1 tile;
· * let dst = Attack->Target;
· * let src = Attack->Caster;
· * dst->HP->Current -= src->Damage;
· * **IMPORTANT: "This Signa never misses"**;
```