Comment créer une formule ajustable pour les exigences de niveau RPG?

43

J'essaie de créer une formule qui peut être modifiée simplement en modifiant deux valeurs: number_of_levels et last_level_experience. Cela permet aux personnes qui modifient le jeu de modifier les exigences de mise à niveau.

Je l'ai afin de pouvoir spécifier le nombre d'XP nécessaire pour le dernier niveau, mais je veux pouvoir contrôler l'XP nécessaire pour le premier niveau, qui peut dans ce cas être très différent. Par exemple, si j'ai 40 niveaux et 1 000 000 XP pour le dernier niveau, l'exigence de premier niveau est alors de 625. Mais si je modifie les niveaux à 80, le premier niveau devient 156. Dans les deux cas, le dernier niveau nécessite 1 000 000.

Il doit y avoir un moyen de faire en sorte que l’ordinateur calcule une courbe appropriée en se basant uniquement sur ces deux valeurs fondamentales.

#include <iostream>

int main()
{
    int levels = 40;
    if (levels < 2) levels = 2;

    int experience_for_last_level = 1e6;
    float fraction = 1.0 / levels;

    {
        int i = 0;
        float fraction_counter = fraction;
        int counter = levels;
        int total = 0;

        for (i = 1; i <= levels; ++i, fraction_counter += fraction, --counter)
        {
            int a = static_cast<int>(fraction_counter * experience_for_last_level / counter);

            std::cout <<"Level "<<i<<":  "<<a<<" ("<<counter<<")"<<"\n";

            total += a;
        }

        std::cout << "\nTotal Exp: " << total;
    }
}

Sortie:

Level 1:  625   (40)      Level 15: 14423  (26)      Level 29: 60416  (12)
Level 2:  1282  (39)      Level 16: 16000  (25)      Level 30: 68181  (11)
Level 3:  1973  (38)      Level 17: 17708  (24)      Level 31: 77499  (10)
Level 4:  2702  (37)      Level 18: 19565  (23)      Level 32: 88888  (9)
Level 5:  3472  (36)      Level 19: 21590  (22)      Level 33: 103124 (8)
Level 6:  4285  (35)      Level 20: 23809  (21)      Level 34: 121428 (7)
Level 7:  5147  (34)      Level 21: 26250  (20)      Level 35: 145833 (6)
Level 8:  6060  (33)      Level 22: 28947  (19)      Level 36: 179999 (5)
Level 9:  7031  (32)      Level 23: 31944  (18)      Level 37: 231249 (4)
Level 10: 8064  (31)      Level 24: 35294  (17)      Level 38: 316666 (3)
Level 11: 9166  (30)      Level 25: 39062  (16)      Level 39: 487499 (2)
Level 12: 10344 (29)      Level 26: 43333  (15)      Level 40: 999999 (1)
Level 13: 11607 (28)      Level 27: 48214  (14)
Level 14: 12962 (27)      Level 28: 53846  (13)
Matraque
la source
13
Le problème fondamental est qu’il existe une infinité de courbes de niveau d’XP qui se terminent avec le dernier niveau nécessitant autant d’XP. Vous n'avez pas limité les dimensions du problème, car vous n'avez pas indiqué comment vous souhaitez que l'XP change d'un niveau à l'autre. Voulez-vous une courbe de croissance exponentielle? Une courbe de croissance parabolique? Un linéaire? Votre problème est insoluble dans son état actuel. Personnellement, si je modifiais le jeu, je voudrais avoir plus de contrôle sur la courbe de XP que le dernier numéro de niveau et le dernier niveau de XP. Je voudrais contrôler la courbe elle-même.
Nicol Bolas
Je peux permettre aux moddeurs de contrôler le nivellement via un script.
Truncheon

Réponses:

70

Bien qu'il existe une infinité de façons de les choisir, il est courant que les courbes de nivellement suivent une règle de puissance telle que la suivante:

f(level) == A * exp(B * level)

L’avantage majeur de cette formule s’explique aisément: pour une règle donnée, il existe une valeur fixe N telle que chaque niveau coûte N pour cent de plus que le précédent .

Vos variables initiales ajoutent les restrictions suivantes:

f(1) - f(0) == experience_for_first_level
f(levels) - f(levels - 1) == experience_for_last_level

Deux équations, deux inconnues. Cela semble bon. Les mathématiques simples donnent Aet B:

B = log(experience_for_last_level / experience_for_first_level) / (levels - 1);
A = experience_for_first_level / (exp(B) - 1);

Résultat dans le code suivant:

#include <cmath>
#include <iostream>

int main(void)
{
    int levels = 40;
    int xp_for_first_level = 1000;
    int xp_for_last_level = 1000000;

    double B = log((double)xp_for_last_level / xp_for_first_level) / (levels - 1);
    double A = (double)xp_for_first_level / (exp(B) - 1.0);

    for (int i = 1; i <= levels; i++)
    {
        int old_xp = round(A * exp(B * (i - 1)));
        int new_xp = round(A * exp(B * i));
        std::cout << i << " " << (new_xp - old_xp) << std::endl;
    }
}

Et la sortie suivante:

1 1000          9 4125          17 17012        25 70170        33 289427
2 1193          10 4924         18 20309        26 83768        34 345511
3 1425          11 5878         19 24245        27 100000       35 412462
4 1702          12 7017         20 28943        28 119378       36 492389
5 2031          13 8377         21 34551        29 142510       37 587801
6 2424          14 10000        22 41246        30 170125       38 701704
7 2894          15 11938        23 49239        31 203092       39 837678
8 3455          16 14251        24 58780        32 242446       40 1000000
sam hocevar
la source
12
Si seulement toutes les réponses étaient bien planifiées et réfléchies.
Nate
La courbe ici est beaucoup plus acceptable.
Truncheon
Bonne réponse. C'est peut-être une question stupide, mais comment calculez N-vous ce que vous avez décrit ci-dessus? Et si vous vouliez créer Nla variable enfichable? Faites-moi savoir si je devrais poser une question distincte pour cela.
Daniel Kaplan
1
@tieTYT la relation entre Net Best exp(B) = 1 + N, ou B = log(1 + N). Donc, si vous voulez que chaque niveau nécessite, par exemple, 15% de plus que le précédent, vous en aurez besoin B = log(1 + 0.15) = 0.13976.
Sam hocevar
17

N'oubliez pas d'arrondir les chiffres après avoir déterminé votre courbe. Il n’a pas de sens de dire au joueur qu’il a besoin de 119 378 points d’expérience pour passer au niveau suivant, car il comprendrait toujours "environ 120 000". Ainsi, vous ferez mieux de faire le tour vous-même et de présenter des résultats "nets" à vos joueurs. Par exemple, le code suivant (qui s’applique à celui de Sam Hocevar) tentera d’arrondir à environ 2,2 chiffres significatifs (évidemment, cette constante peut être modifiée à votre guise):

from math import exp, log

levels = 40
xp_for_first_level = 1000
xp_for_last_level = 1000000

B = log(1.0 * xp_for_last_level / xp_for_first_level) / (levels - 1)
A = 1.0 * xp_for_first_level / (exp(B) - 1.0)

def xp_for_level(i):
    x = int(A * exp(B * i))
    y = 10**int(log(x) / log(10) - 2.2)
    return int(x / y) * y

for i in range(1, levels+1):
    print( "%d:  %d" % (i, xp_for_level(i) - xp_for_level(i-1)) )

La sortie est:

1:  1000     9:  4200     17:  17100    25:  70000     33:  287000
2:  1190    10:  4900     18:  20300    26:  84000     34:  340000
3:  1420    11:  5900     19:  24200    27:  100000    35:  420000
4:  1710    12:  7000     20:  28700    28:  119000    36:  490000
5:  2030    13:  8400     21:  34000    29:  142000    37:  590000
6:  2420    14:  10000    22:  42000    30:  171000    38:  700000
7:  2870    15:  11900    23:  49000    31:  203000    39:  840000
8:  3400    16:  14200    24:  59000    32:  242000    40:  1000000
Pacha
la source