Idées pour l'algorithme de dégâts d'attaque (langage non pertinent)

Je travaille sur un jeu et j'ai besoin d'idées pour les dégâts qui seront causés à l'ennemi lorsque votre joueur attaque. Le montant total de enemyHealthpoints de vie de l'ennemi est appelé et a une valeur de 1000. Vous commencez avec une arme qui inflige 40 points de dégâts (peut être modifiée). Le joueur a une statistique d'attaque que vous pouvez augmenter, appelée playerAttack. Cette valeur commence à 1 et a une valeur maximale possible de 100 après l'avoir augmentée plusieurs fois et l'avoir propulsée plus loin dans le jeu. La quantité de dégâts que l'arme fait est coupée et sèche, et soustrait 40 points du total de 1000 points de santé à chaque fois que l'ennemi est touché. Mais ce que cela playerAttackfait est d'ajouter à cette valeur avec un pourcentage. Voici l'algorithme que j'ai maintenant. (J'ai retiré tous les gui, classes, etc. et donné aux variables des noms très avancés)

double totalDamage = weaponDamage + (weaponDamage*(playerAttack*.05))
enemyHealth -= (int)totalDamage;

Cela semblait très bien fonctionner pour la plupart. J'ai donc commencé à tester certaines valeurs ...

//enemyHealth ALWAYS starts at 1000
weaponDamage = 50;
playerAttack = 30;

Si je fixe ces valeurs, la quantité de dégâts infligés à l'ennemi est de 125. Semblait être un bon nombre, donc je voulais voir ce qui se passerait si l'attaque des joueurs était au maximum, mais avec l'arme de départ la plus faible.

weaponDamage = 50;
playerAttack = 100;

le totalDamage finit par être 300, ce qui tuerait un ennemi en quelques coups. Même avec votre attaque aussi haute, je ne voudrais pas que l'arme la plus faible puisse tuer l'ennemi aussi vite. J'ai pensé à ajouter de la défense, mais je sens que le jeu perdra de sa cohérence et deviendra déséquilibré à long terme. Peut-être qu'un algorithme bien conçu pour un modificateur de diminution d'armes fonctionnerait pour des armes de niveau inférieur ou quelque chose comme ça. J'ai juste besoin d'une pause pour essayer de trouver la meilleure façon de procéder, et peut-être que quelqu'un qui a de l'expérience avec les jeux et qui maintient le niveau cohérent pourrait me donner quelques idées / conseils.

La réponse apportée par Grzegorz Sławecki est déjà bonne, mais je voulais expliquer la logique de sa méthode et vous donner les outils pour adapter les solutions à vos besoins de gameplay.

Les paramètres du problème actuel sont le niveau d'attaque du joueur a , les dégâts de l'arme w , le total des dégâts infligés en une seule attaque d , la santé de l'ennemi H et le nombre minimum de coups nécessaires pour tuer l'ennemi, appelons-le n .

Si vous voulez que le joueur tue en n coups, alors ses dégâts totaux d doivent être tels que

(n-1) .d <H ≤ nd    ou en d'autres termes, n = ceil (H / d) .

d dépend des dégâts de l'arme w et du niveau d'attaque du joueur a et nous pouvons nous attendre à ce que les armes s'améliorent à mesure que le niveau augmente, alors écrivons d (a) et w (a) au lieu de simplement d et w . Les ennemis auxquels le joueur est confronté devraient également devenir plus coriaces, donc, encore une fois, H (a) . Ce sont toutes des fonctions croissantes de a , et vous voulez qu'elles satisfassent aux inéquations ci-dessus. Les inconnues du problème sont les fonctions. Vous en définissez une comme contrainte et vous trouvez les autres. Vous avez cependant des degrés de liberté, ce qui est une bonne chose.

Si je comprends bien votre question, vous avez un gameplay précis à l'esprit, et ce gameplay est principalement représenté ici par le nombre de coups nécessaires pour tuer l'ennemi, n (a) . Par conséquent, définissez n (a) en fonction du gameplay que vous envisagez pour le jeu, puis recherchez les autres variables du problème . C'est ce que vous devez toujours faire parce que, comme le montre votre question, votre première tentative a été d'essayer un algorithme que vous pensiez pouvoir faire, puis vous avez réalisé qu'il entraînait un gameplay indésirable.

Supposons, par exemple, que vous souhaitiez que le joueur frappe de plus en plus de fois au cours de sa progression dans le jeu. Vous voulez également que, à mesure que le nombre de coups requis augmente, il augmente de moins en moins souvent, de sorte que le joueur passe une partie plus longue du jeu à frapper 5 fois que 2 fois. Voici à quoi ressemble n (a) :

La fonction utilisée est n (a) = ceil (2 / 3.sqrt (a)) .

Nous voulons que H (a) / d (a) reste dans les plages de valeurs qui font que n (a) a la valeur souhaitée et puisque n (a) = ceil (H (a) / d (a)) , ces plages sont les rectangles suivants:

et H (a) / d (a) peut naturellement être réglé sur 2 / 3.sqrt (a) de sorte que nous obtenons le graphique suivant, avec la courbe rouge étant H (a) / d (a) :

Remarque: nous pouvons facilement trouver H (a) / d (a) ici parce que nous connaissons la fonction dont n (a) est le plafond, mais si notre spécification pour n était moins agréable, nous devions faire notre propre ajustement fonction en utilisant diverses astuces. Tous les problèmes ne sont pas si agréables!

Nous voulons donc que H (a) / d (a) ressemble à une fonction de racine carrée personnalisée et nous savons que H et d doivent être des fonctions croissantes. Les solutions sont nombreuses. Par exemple,

H (a) = a. 2 / 3.sqrt (a)    et    d (a) = a

Mais nous aimerions que les dégâts et les PV de l'ennemi augmentent énormément afin qu'il y ait de gros chiffres impressionnants à la fin du jeu, juste pour le style, alors nous avons plutôt défini

H (a) = a². 20 / 3.sqrt (a)    et    d (a) = 10.a²

Le point principal, et la meilleure partie, est le suivant: vous savez que vos solutions au problème ( H (a) et d (a) ) obéissent aux spécifications ( n (a) ), donc vous obtenez le même n (a) , mais vous avez la liberté. Vous connaissez exactement la liberté dont vous disposez et vous pouvez l'utiliser pour personnaliser l'expérience. Vous devriez toujours essayer de vous donner une telle liberté tout en satisfaisant vos besoins les plus importants, dans la mesure du possible.

Maintenant que nous avons choisi les dégâts à un coup d (a) , et puisque d (a) dépend des dégâts de l'arme w (a) , nous pouvons utiliser d (a) comme spécification et essayer de trouver un w (a ) qui nous donne ce d (a) . Les principes sont les mêmes, le problème est différent: nous voulons que le joueur inflige plus de dégâts à mesure que son niveau augmente, même si l'arme reste la même, et nous voulons également que les dégâts augmentent lorsque l'arme seule s'améliore et que le niveau reste le même.

Mais quelle importance chaque facteur devrait-il avoir? Supposons que le niveau soit plus important que les armes: une plus grande partie des variations de d (a) = a² doit être indépendante de w (a) , par exemple avec

w (a) = 22.sqrt (a)    et, par conséquent,    d (a) = (22.sqrt (a)). (10 / 22.a.sqrt (a)) = w (a). (10 / 22.a.sqrt (a))

Nous obtenons le graphique suivant pour w (a) ...

... et toujours le même d (a) , car nous avons à nouveau trouvé une solution qui obéissait à la spécification , ici d (a) , et nous avons les propriétés mentionnées ci-dessus avec w et a contribuant aux dommages (supposons que nous regardions d en fonction de a et w : alors si a était fixe et que nous avions w varie dans l'équation d (a, w) = a / 30.w , d serait toujours une fonction croissante de w , et il en va de même si vous fixez w et faire une varier).

Ce w (a) pourrait vous donner la valeur à afficher dans la description du jeu de l'arme: nous obtiendrions "Weapon Damage: 220" avec la meilleure arme du jeu par exemple.

Nous aurions pu utiliser une spécification complètement différente pour notre gameplay et donc pour n (a) , par exemple une qui fait augmenter rapidement le nombre de hits requis au fur et à mesure que le jeu progresse puis se stabilise, et les solutions résultantes auraient été différentes.

Je vous recommanderais de concevoir votre jeu dans l'autre sens: réfléchissez d'abord à la façon dont vous voulez que votre jeu joue (en termes d'expérience de jeu, pas en termes de nombres), puis concevez à la fois les formules et les plages de nombres à obtenir ce résultat.

Votre objectif de gameplay est qu'il faut un certain nombre de coups pour tuer un ennemi. Le nombre de hits dépend de trois variables:

• niveau de puissance de l'ennemi
• niveau de puissance du personnage
• niveau de puissance de l'arme

Vous devez d'abord créer un tableau de toutes les combinaisons possibles de ces trois variables de bas, moyen ou haut niveau (pas encore de nombres concrets, juste "bas", "moyen" ou "haut") et combien de hits vous souhaitez être requis pour ces combinaisons.

Ensuite, vous devriez essayer de trouver une formule et des plages de valeurs qui correspondent le mieux à vos souhaits.

Le moyen le plus simple est d'augmenter de façon exponentielle les dégâts de l'arme entre les niveaux d'armes.

Cependant, ce qui importe, c'est que vous devez également définir comment les HP des ennemis augmentent lorsqu'ils deviennent plus forts. Ainsi, lorsque votre très fort vous devez tuer des ennemis faciles avec seulement quelques coups, mais ceux à votre niveau devraient être relativement plus difficiles à tuer que les ennemis qui étaient à votre niveau au début. Je le concevrais donc un peu comme ci-dessous:

level   weapon  enemy   attack  total   hits needed
        dmg     hp      factor  dmg     to kill
======================================================
1       1       2       5       1.25    1.6
2       4       16      10      6       2.666666667
3       9       54      15      15.75   3.428571429
4       16      128     20      32      4
5       25      250     25      56.25   4.444444444
6       36      432     30      90      4.8
7       49      686     35      134.75  5.090909091
8       64      1024    40      192     5.333333333
9       81      1458    45      263.25  5.538461538
10      100     2000    50      350     5.714285714
11      121     2662    55      453.75  5.866666667
12      144     3456    60      576     6
13      169     4394    65      718.25  6.117647059
14      196     5488    70      882     6.222222222
15      225     6750    75      1068.75 6.315789474
16      256     8192    80      128     6.4
17      289     9826    85      1517.25 6.476190476
18      324     11664   90      1782    6.545454545
19      361     13718   95      2075.75 6.608695652
20      400     16000   100     2400    6.666666667

Où:
1. le dmg total est calculé en utilisant votre formule
2. arme dmg = niveau * niveau (croissance exponentielle)
3. HP ennemi = 2 * niveau * niveau * niveau (croissance exponentielle)
4. facteur d'attaque = niveau 5 *
5. coups nécessaires décrit le nombre de coups nécessaires étant au niveau x et utilisant une arme au niveau x, pour tuer un ennemi au niveau x

J'ai ajusté ces facteurs constants dans les formules juste pour obtenir des résultats que je pense acceptables, mais ce qui est important, c'est où vous voulez une croissance linéaire et où vous voulez exponentielle.

Vous devriez également remarquer que, par exemple, pour tuer un ennemi de niveau 20 avec 100 attaques et avoir une arme de niveau 1 qui prend un total de 6 dmg, cela prendra beaucoup de temps. Si cela prend trop à votre avis, jouez avec les constantes.

Je pense que la méthode d'artisanat du monde de la guerre est l'une des meilleures. Les statistiques de base des joueurs ont un faible impact sur le total des dégâts, la plupart des modificateurs de dégâts provenant de statistiques bonus sur l'équipement. Cela rend beaucoup plus facile l'extension du jeu et son équilibre au fil du temps