Full Control of the Experience Curve

[Faherya]

Description of the Feature: Currently, the class experience editor is not quite an editor. You just select a base value, and edit parameters based on it, as in a generator. If you could edit the experiment curve with the same features with which you edit the parameter curves (ATK, DEF, and the like), you would have much more control. For example, this is currently the minimum experience curve:

Spoiler

If I wanted the value of the experience to always be a multiple of 5, I would have to combine the extra values and the growth until I get something close. Even so, many levels would have values outside this standard. This is extremely easy to do in RPG Maker 2003 experience curve. The only problem with it is that you can not set the Extra Value to zero:

Spoiler: RPG Maker 2003 Experience Curve

The developer can always create an experience curve in events, of course. But if it could have the same result with the curve editor, it would be great.

Code for Implementation:
Nothing to say here.

Mockups:
I do not think it's necessary to include images. The interface could be similar to that used in the parameter curves.

Why is this feature good?
Full control of the experience curve. And that's all you need.

Possible issues with this feature?
I believe there would be no problem at all.

 

[Pine Towers]

Yes, oh yes.

Makers want full control of their games. Having full control of their XP Table allows for better planning on encounters and monster XP. Sure, a generator (as the default) is always good, but we can't be restricted to that. Allows for a formula input [xp to next level = (level -1)*1000], or table editing for manual placement of values! Heck, even the way parameters do it, allowing for the maker to set a starting and ending xp requirements and hitting "generate curve" is better than what we got now.

 

[The Stranger]

This is a much needed feature. I remember needing to use a lil' code snippet in Ace to achieve this - not sure if a similar piece of code exists for MV.

 

[wariolandgoldpiramid]

We do need that.

 

[Wavelength]

Total agreement; the way that RPG Maker handles it is far too limited. There are games for which it might be important to the gameplay to use a very precise geometric formula to determine level up requirements, or even where it would be desirable to have the EXP required to reach the next level be the same at every level (like Paper Mario).

I'm fine with this "generate a curve based on a couple of sliders" method as a default, but there should be a button on the screen that allows you to choose one of three other entry methods to override the default curve:

• Formula: Type in any mathematical formula in JS that evaluates to a value, allowing the keywords "level" and "id" (such as 5 * (level ^ 2) + 100 or even if id === 3 { 40 * level } else { 25 * level } ). Each level will require that much EXP (in total) to reach.
• Recursive: Kind of like having a formula for the "To Next Level" tab. Explicitly set the EXP required to reach Level 2, and type in any mathematical formula in JS that evaluates to a value, allowing the keywords "level", "id", and "previous" (which is the difference in total EXP needed to reach the two previous levels) - such as previous + level * 10 . Each level will require that much EXP beyond what the previous level required, to reach.
• Manual: Manually set the number of EXP needed to reach each level, just like you can manually set a character's Stats at each level on the Classes box.

In the same breath, it would also be nice to allow the Level Cap to be set by the designer (up to at least 9999). Just make the static boxes that show EXP in the program into scroll boxes, fix a few pieces of code that only look for 1..99, and problem solved!

 

[Faherya]

I had not considered the possibility of including a formula. Apparently, it would be as practical as the one used for calculating damage. In particular, I prefer to include the values manually (even if it takes more work), but using this method would also be great. In doubt, options for both!

 

[bgillisp]

Yes, please! I feel like the current EXP curve is so unintuitive. There's no way to just look at it and say if I add 1 point to ACC_A THIS is exactly what it will change my formula to. In fact, does anyone but the programmer of the system even know what exactly each button does to a precise enough level they could explain to someone else what the effect of adding 1 point to any setting in the sliders will do?

 

[Kaliya]

Yes, please! I feel like the current EXP curve is so unintuitive. There's no way to just look at it and say if I add 1 point to ACC_A THIS is exactly what it will change my formula to. In fact, does anyone but the programmer of the system even know what exactly each button does to a precise enough level they could explain to someone else what the effect of adding 1 point to any setting in the sliders will do?

I do! I'm not the programmer of the system originally, but I am one of the ones who know MV's internal code the most now. All silliness aside though, we are actively looking to improve the editor and engine as a whole now, so we may get around to looking into this depending on the popularity of this poll. Thanks for posting another improvement idea @Faherya.

I personally advocate for more control to the users, while trying to keep it as simple as possible, or at least keeping a "simple" option for those new to the Maker series. So if we were to ever get around to this, I would preferably have two or so methods of deciding the EXP required to level. A more simple version (though possibly revised) like we have now, and then perhaps a custom formula version for those who like to do math.

Thanks,
- Liquidize

 

[Faherya]

Thanks for posting another improvement idea @Faherya.

No problem. Well, I believe that in the case of a formula, it would be interesting if it were as dynamic as the calculation of damages. I quoted this above, and now:

I forgot to put it in print, but the command v [x] would also be very welcome, just like the like. About the manual inclusion of values:

Small windows to save space and make it easier to program the interface. I just could not put together an example curve, like the parameters or the experiment curve itself.

 

[wariolandgoldpiramid]

Actually, it's kind of weird that Stats can be configured manualy, but EXP/Levels can not.
We deffinetly need more control of the EXP curve.

 

[Faherya]

Sorry for the - as they say here - "bump". Just going on to add other ideas I had about the experience curve. More precisely, talking about formulas.

Going straight to the point: for even greater control, it would be interesting to be able to include these formulas in the field of experience provided by the enemies. Examples:

​

At number 1, I have a fixed value added to a variable, simulating the experience modifiers of tabletop RPGs. At number 2, the player's experience would be directly linked to the amount of HP remaining. It includes the "a" to show that if I want the experience to be influenced by an enemy attribute, it would suffice to include the "b". This would represent the enemies killed by the character in question. And in 3, a simpler formula, still using variables.

I believe that errors could occur if the formula contained "a" and "b", since in troops with multiple enemies, these values could be replaced until the end of the battle. And if there were many, maybe it would get messy. Anyway, the suggestion is exposed. Those who better understand the mechanics of experience can clarify whether it would be useful or not - and why. This only leaves the curve itself a bit aside, entering into the control and distribution of its values.

 

[BishoujoHelper]

I've been planning on using my own plugin to do the kind of "arbitrary value needed to next level for x levels, then y per level from then on" used by systems such as Bard's Tale and AD&D, specifically to replicate a "Bard's Tale Construction Set" (BTCS) adventure. Javascript code snippet follows, I have to figure out how to call it properly when checking for level-up (need Actor's class ID, not just level)

Spoiler: BTCS EXP per level code

/* BTCS_LevelEXP
* The BTCS, like Advanced Dungeons & Dragons (C, TM, whatever) First Edition, uses a
* hybrid formula for level-up experience needed. It's best done with a lookup table for
* some low number of levels, then it switches to a straight "x more per additional level"
* that doesn't work with the default RPG Maker formula.
* So, a double-subscript array is defined with the following structure:
* For _class (first subscript),
* and _level (second subscript),
* this.array()[this._class][this._level]
*  when _level=0, array contains level value to switch to straight line increase
*  when _level=1 to (_level=0 contents), array contains total EXP needed to level-up to next level
*  when _level=(_level=0 contents +1), array contains additional EXP per level
* For example, a simple Warrior class uses these EXP values per level:
*  -Level-  -EXP for next-
*     1           2,000
*     2           4,000
*     3           7,000
*     4          11,000
*     5          21,000  <-- notice that it's now 10,000 additional
*     6          31,000  <-- and stays there (contrived example, yes)
*     7          41,000  <-- from level 4 onward
* So, array()[Warrior]=
*     [ 4, 2000, 4000, 7000, 11000, 10000 ];
* And the algorithm would basically use the array contents for the first 4 levels,
* then take 11,000 (from level 4) and add (level-4)*10000 from then on
* Level is defined as an integer above 0, will assume EXP totals that overflow are OK to crash
*/
/* the existing function that returns EXP needed per level is expForLevel in rpg_objects.js
 * so this function needs to overlay that somehow...
*/
Game_Actor.prototype.expForLevel = function (level) {
    var c = this.currentClass();   //MAJOR IMPLEMENTATION ISSUE!
    var d = 0;   //remap class to valid embedded tables
    var expArray = [];    //outer array of tables
    // BTCS class list, from 0 to 11 is:
    // Warrior, Paladin, Rogue, Bard, Hunter, Monk, Conjurer, Magician, Sorceror, Wizard,
    // Archmage, Monster. Illusion, at end of BTCS class list, doesn't level-up.
    // data tables embedded here, 10 values per line
    // rest of this function will remap those classes to these tables, because of duplicates
    // class 0 = BTCS Warrior (also used for Paladin, Rogue, Bard, Hunter, Monster)
    expArray[0] = [12,
        2000, 4000, 7000, 10000, 15000, 20000, 30000, 50000, 80000, 110000,
        150000, 200000,   200000];
    // class 1 = BTCS Monk (also used for Conjurer, Magician)
    expArray[1] = [12,
        1800, 4000, 6000, 10000, 14000, 19000, 29000, 50000, 90000, 120000,
        170000, 230000,   230000];
    // class 2 = BTCS Sorceror
    expArray[2] = [12,
        7000, 15000, 25000, 40000, 60000, 80000, 100000, 130000, 170000, 220000,
        300000, 400000,   400000];
    // class 3 = BTCS Wizard
    expArray[3] = [ 12,
        20000, 50000, 80000, 120000, 160000, 200000, 250000, 300000, 400000, 600000,
        900000, 1300000,   1300000];
    // class 4 = BTCS Archmage
    expArray[4] = [12,
        100000, 220000, 400000, 600000, 800000, 1100000, 1400000, 1800000, 2200000, 2600000,
        3000000, 4000000,   4000000];
    // remap "also used by" classes to defined tables
    switch (c) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 11:
        d = 0;
        break;
    case 5:
    case 6:
    case 7:
        d = 1;
        break;
    case 8:
        d = 2;
        break;
    case 9:
        d = 3;
        break;
    case 10:
        d = 4;
        break;
    default:
        d = 0;
        break;
    }
    if (level <= 0) {
        return 0;
    }
    // to simplify indexing, extract level transition value
    var n = expArray[d][0];
    if (level <= n) {
        return expArray[d][level];
    } else {
        return expArray[d][n]+expArray[d][n+1]*(level-n);
    }
};

Anything that supports this kind of algorithm is fine by me, but I have to go this route as these scenarios are already supposed to be balanced for these specific EXP values.

Update: doh, there's a Code tag right next to the Spoiler one!

Update: brute-forced it in my current project by calculating the values up to level 99 in one spreadsheet, then using the Himeworks "HIME_ExpTables" plugin to read a .csv file version of it.

 

[FlatDragon]

Gravedigging might just become a hobby of mine...

All jokes aside, I wanted to bump this thread because this is a feature that I would definitely love to see in a future update, and I'd love for it to get some more views from newer members and others who might have missed it. It would save me a lot of trouble with my current game project, and I'm sure it would help others even more.

Specifically, what I'd like to see is an option to manually set the experience for each level, but a formula that we can set would be awesome. Games that are shorter in length and have a lower level cap with more detailed stat growth would benefit greatly from this feature, in my opinion.

And sorry for the gravedig, to everyone who already saw this thread.