Free moves coming with new patch

It might work that way with mods that allow priorites into standing grapples; I haven't tested it with a transition as the trigger. They're designed to work with the opponent stunned, so I don't know if that would work without testing it.

All the things we can priority into now are things the computer will decide whether or not to do while the opponent is still down; prioing into other things than those is a little outside how it was designed and can be finicky.

None of which changes the fact that I really want a front-grapple endless German; I was mostly using Okada as an example of why it would be awesome, especially since he's the guy it was made for. He certainly wouldn't lose anything by it.

Thanks for the info on that.  I'd still love to have them, but it'd apparently take a decent bit of effort on their part to make it work.

ENUM means enumeration. When you want to have a bunch of values, you can define them once, and then refer to them later by those names, so you don't have 'magic numbers' all over your code. Meaning you'd have to go and re-update all your code every time you changed one of those numbers. This leads to bugs when you forget. It's also nice for code clarity.

enum BodyPart
{
   Head,
   Torso,
   Arms,
   Legs
}

The code compiler will automatically assign those numerical meaning. Then you can refer to BodyPart.Head or etc, and the compiler will swap it out for the correct number when making the executable.


docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/enum

Below is just a made up example.

The existence of enums in themselves doesn't mean anything. Just that they were defined values.

Like the body parts example. If every wrestler has different HP for different body parts, you'd have an array of integer (whole numbers) data types defined somewhere. You'd need 4.

So int32 HitPoints [4]; // and array of 4 32 bit integers

So each of those 4 integers in that array will refer to a different body part.

0 = body
1 = head
2 = arms
3 = legs

If you use those numbers directly, it's error prone if you write the wrong number somewhere, AND good luck changing all the code if those numbers ever changes for any reason. You'll have a mess to untangle. This also stops you from making a typo and indexing out of the bounds of the array, which would cause you to write into other memory. That array is really just the start and end of addresses in the computer's memory. It's just a bunch of ones and zeros, but they are in a specific place, and to be interpreted in a specific way. It's 128 bits / 16 bytes of reserved space. And we know that every 32 bits represents a whole number.

Hitpoints[0] occupies bytes 0-31,
Hitpoints[1] occupies bytes 32-63 and so on.
HitPoints[4] doesn't exist, and you'd just write random ones and zeroes over memory for something else, and possibly used in a completely different context. Most program crashes or strange behaviour happens when things get read or written to the wrong place. AKA, the buffer overflow.

So each move can use a BodyPart enum to specify which part it damages, and then that number can be used to index into the HitPoints array. If our data structures and functions have to take BodyPart enum values instead of raw numbers, it stops all those issues.

void Wrestler.TakeDamage(AttackInfo LastAttack)
{
  Self.HitPoints[LastAttack.BodyPart] -= LastAttack.DamageAmount;
}

I haven't looked at the Fire Pro code yet. I won't until the last patch comes out. I'm just going off the above statement. The existence or non existence of those enums doesn't mean anything outright. Nothing that happens in FirePro requires that complex of coding. It's a simple little game. Simply looking at a priority and choosing a grapple move to execute instead of the RNG is a few lines of code at best.

The problem is two fold here;

1) The FPW teams have incompetent at best.

2) Programming is like alchemy or other things of that nature. Only you really know how your code works, and you can make up any story you want about why things don't work, or why they aren't done yet. Having a problem to tackle is a form of job security. If your program works 100% outright, you aren't needed anymore. Having an easy to understand program code base also means you can be replaced at your employer's whim. So you have to break 2 things to fix one thing. And when simple things like grapple priorities, or adding new wrestlers to a promoter save come up, you say "We're looking into it" instead of writing simple code that opens the free agent list, appends new entries and closes the file. :)

Just like the alchemist telling the king. "We'll turn this horse urine turned to gold any day now" until funding runs out. Then it's "oh, we just about had it. We're on the verge of a major breakthrough any second now, we just ran into some unforseen troubles", "we just need a little more time and money!". Wash, rinse, repeat. ;)