Used by User:Imper1um to figure out how this is coded. You probably won't understand this unless you're a programmer.

## General Overview Edit

Crit is based on your AGI, LUC, and the enemy's overall strength (it's "Point Value"). The below sections are an attempt by User:Imper1um to find the formula by looking through the game's code. It should be noted that the formula as it stands does not appear to accurately predict your critical chance, and should for now be taken with caution.

The take-home points for the average player, though, can be summarized as follows:

- Higher-level enemies are harder to crit. Thus, you need to frequently re-invest in AGI and/or LUC if you wish to maintain your critical hit rate
- Any single point in LUC is more important than a single point in AGI, but because AGI rises faster than LUC, they are likely approximately equivalent in cost-to-critical-hit-rate.Explaination about Kakuritu

One thing that I'm irked about is how many times I have to explain about how Kakuritu works in this game. Kakuritu is what the developers refer to as "Random Chance Stuff Happens." A Kakuritu calculation always works like this:

- An Array is imported, for example, [10,10,10].
- The system aggregates the total number of points (in this case, 30).
- The system uses the devices random number generator to generate a number from 0.000000 to 1.000000 (so it could be like 0.765), and times that by the number of points (30), then adds 0.5, then rounds to the nearest whole number.
- This sways the number away from the first entry, but this appears to cause a circular problem in one in every million cases, but I'll explain later.

- The system then goes through and adds each element in the array, verifying that the calculated number is less than or equal to the specified number, so if the generated number is 13, it will produce Element 1, which, in a zero-based array, would be the second element.

So, this is how random number generation works. Unfortunately, this also causes a circular reference in one in a million cases. What happens is it returns the default value (probably 0, I'm not running the code), so if you got a perfect 1.000000 generation, it would actually produce the maximum value + 0.5, which means that the final number would round UP to the nearest whole number. So, in essence, a perfect value actually gets you the worst value. This looks to be a bug, but that's just from what I see from my viewpoint.

## Damage Calculations Edit

Oi, I need to figure this stuff out.

Battle.as:2105 (1.2.1) - myGetDameSkNumFunc.

_loc3_ = criKakuritu (Base Crit Rate)

IsCrit = 0

- If HP <= 25%:
- If HP <= 50%: _loc3_ += 0.05
- If HP <= 10%: _loc3_ += 0.045
- If HP <= 15%: _loc3_ += 0.04
- If HP <= 25%: _loc3_ += 0.03

- Maximum Crit Rate: 70%
- Random 1.000 to 0.000: If <= _loc3_ then IsCrit = 1
- If First Turn && HasFirstCritAccessory: then IsCrit = 0

**Damage Calculation:**

Damage = myatk

SkNum = Random * 4

**Crit Calculation:**

Damage = (myatk + 1) * (1.75 + (Random * 6 * (criKakuritu * 3 + 0.2)) / 5) * CritPlusDamage + 4

SkNum = Random + 5

**Point Value:**

_loc4_ = EnemyPointValue

Take the enemy Point Value, and if Point Value > damage, _loc4_ = (PV * 3 + Damage * 2) / 5;

_loc4_ *= 0.3

If _loc4_ >= 32% of Damage, _loc4_ = (_loc4_ + damage * 0.32 * 99) / 100;

_loc4_ += Random * PV * 0.02 + PV * 0.02

If _loc4_ >= 44% of damage, _loc4_ = (_loc4_ + damage * 0.44 * 199) / 200;

Damage -= _loc4_

Damage *= 0.88

Damage += Random * Damage * 0.2 - Damage * 0.2 + Random * 4 - 2

- If Damage <= 0
- If Enemy HP < 100, Damage = Random * EnemyHP * 0.09 + 1
- Else, Damage = Random * 10 + 1