Currently, I am programming an RPG with the help of the RPG maker MZ and the visustella engine, and I noticed that my game gets extremely sensitive to stat changes. To explain this further, I first want to show you the most central mechanics:

the Damage calculation is basically the following:

BaseDamage (of the skill that's used) * user.ATK / target.DEF * CritModifier (1 when not crit, more when crit)

CritModifier = (1.5 + 1.5 * (user.luk / target.luk))

In addition to that, my system uses a Tick based combat system (in my case ATB). That means, that the AGI (speed) does not only determine the order in which the battlers attack, but also how often they get a turn. Higher AGI = more turns.

The stat growths of enemies and Players are currently very linear, they basically increase every time about 10 percent of the base value (at least as far as I am aware of). This is due to current technical limitations as well as for the sake of simplicity.

If I had to make a comparison, my system is kinda a mix from summoners war (Turn system) and pokemon (damage calculation).

Now today I realized that because of how many multiplications there are in my system, every level up has a major influence over everything that happens. Especially after I removed the square root calculations from the ATB plugin (turn system), which basically served as a nerf to the AGI stat. for example:

Fighter A has 81 AGI

Fighter B has 64 AGI

with the square root calculations, the end result looked like this:

RealFightingAGI A: 9

RealFightingAGI B: 8

Which results in the effect that every stat increase in AGI gets progressively less worth.

Removing that lead to the effect that the overleveled protagonists are just overrounding underleveled enemies with ease.

But also Damage got extremely sensitive, as the inclusion of the luk stat into the calculations of the crit damage made crits extremely strong.

Now my question would be how other battle systems do manage to keep the balance of the game in a way that a stat increase is noticeable without that 1 level up has such a dramatic influence on the game.

arko5 said:
The stat growths of enemies and Players are currently very linear, they basically increase every time about 10 percent of the base value

This seems like a mistake. Every RPG I've ever played has had an exponential increase in attributes with level. By the end of the game you are 10x-100x stronger than at start. I.e. rather than statNew = statOld + baseValue*0.1, use something like statNew = statOld*1.1 or statNew = baseValue * pow(1.1, level). You probably want to limit it to a maximum stat value to avoid really big numbers. This makes sure that every skill increase feels like a consistent relative increase. With linear increases, the relative increase versus previous level will diminish as the player progresses, which is not satisfying.

@undefined it kinda is, but currently i cannot really change that due to the calculation of the enemy stats being a bit more hardcoded than I would need to do exponential increase (They also have levels, but the stat calculation is hardcoded in the engine, so i would need a bigger workaround to set up what i want.

I don't know too much about how RPGMaker handles combat calculations, but as someone who happens to be designing combat and stat formulas for a turn-based RPG right now, I can at least point to how I've been approaching the process. Since this is an ongoing process, I can't guarantee that it's truly a good idea! But so far I've found it useful.

Personally, I've setup the architecture of my combat code such that it's fully decoupled from the game engine, allowing me to pass it through automated scripts. Through these scripts, I generate fake characters, targets, gear, etc. that roughly reflect what I expect them to look like at any given level. Those are then run through thousands combat simulations that record the damage numbers and other relevant data points into a giant CSV file, which can then be used for data vis and statistical analysis.

The biggest benefit I've gotten from this approach is that I can see not just what the numbers look like in one configuration, but what they look like across the entirety of the game's progression on a single plot. From there, it's much easier to iterate since you can directly see how any adjustment affects the balance of different builds throughout the game rather than just at the point you're developing.