Comment incrémenter une variable sans dépasser une valeur maximale?

Je travaille sur un programme de jeu vidéo simple pour l'école et j'ai créé une méthode où le joueur obtient 15 points de santé si cette méthode est appelée. Je dois garder la santé à un maximum de 100 et avec ma capacité de programmation limitée à ce stade, je fais quelque chose comme ça.

public void getHealed(){
    if(health <= 85)
        health += 15;
    else if(health == 86)
        health += 14;
    else if(health == 87)
    health += 13; 
}// this would continue so that I would never go over 100

Je comprends que ma syntaxe n'est pas parfaite, mais ma question est de savoir quelle est la meilleure façon de le faire, car je dois également faire une chose similaire avec les points de dommage et ne pas descendre en dessous de 0.

C'est ce qu'on appelle l' arithmétique de saturation .

Je ferais juste ça. Il faut essentiellement le minimum entre 100 (la santé maximale) et ce que serait la santé avec 15 points supplémentaires. Il garantit que la santé de l'utilisateur ne dépasse pas 100.

public void getHealed() {
    health = Math.min(health + 15, 100);
}

Pour vous assurer que hitpoints ne laissez pas tomber en dessous de zéro, vous pouvez utiliser une fonction similaire: Math.max.

public void takeDamage(int damage) {
    if(damage > 0) {
        health = Math.max(health - damage, 0);
    }
}

ajoutez simplement 15 à la santé, donc:

health += 15;
if(health > 100){
    health = 100;
}

Cependant, comme fade l'a noté, parfois avec le multi-threading (plusieurs blocs de code s'exécutant à la fois), la santé dépassant 100 à tout moment peut causer des problèmes, et la modification de la propriété de santé plusieurs fois peut également être mauvaise. Dans ce cas, vous pouvez le faire, comme mentionné dans d'autres réponses.

if(health + 15 > 100) {
    health = 100;
} else {
    health += 15;
}

Vous n'avez pas besoin d' un cas distinct pour chaque intci - dessus 85. Il suffit d'en avoir un else, de sorte que si la santé est déjà 86ou supérieure, réglez-la directement sur 100.

if(health <= 85)
    health += 15;
else
    health = 100;

Je pense qu'une manière idiomatique et orientée objet de faire cela est d'avoir un setHealthsur la Characterclasse. L'implémentation de cette méthode ressemblera à ceci:

public void setHealth(int newValue) {
    health = Math.max(0, Math.min(100, newValue))
}

Cela empêche la santé de descendre en dessous de 0 ou au-dessus de 100, quel que soit votre réglage.

Votre getHealed()implémentation peut être la suivante:

public void getHealed() {
    setHealth(getHealth() + 15);
}

Que ce soit logique pour la méthode d' Characteravoir-une getHealed()est un exercice laissé au lecteur :)

Je vais juste proposer une tranche de code plus réutilisable, ce n'est pas la plus petite mais vous pouvez l'utiliser avec n'importe quel montant, donc c'est toujours digne d'être dit

health += amountToHeal;
if (health >= 100) 
{ 
    health = 100;
}

Vous pouvez également changer le 100 en une variable maxHealth si vous voulez ajouter des statistiques au jeu que vous créez, donc toute la méthode pourrait être quelque chose comme ça

private int maxHealth = 100;
public void heal(int amountToHeal)
{
    health += amountToHeal;
    if (health >= maxHealth) 
    { 
        health = maxHealth;
    }
}

ÉDITER

Pour plus d'informations

Vous pouvez faire la même chose lorsque le joueur est endommagé, mais vous n'avez pas besoin d'un minHealth car ce serait de toute façon 0. En procédant de cette façon, vous seriez en mesure d'endommager et de guérir n'importe quel montant avec le même code.

health = health < 85 ? health + 15 : 100;

Je créerais une méthode statique dans une classe d'assistance. De cette façon, plutôt que de répéter le code pour chaque valeur qui doit tenir dans certaines limites, vous pouvez avoir une méthode polyvalente. Il accepterait deux valeurs définissant le min et le max, et une troisième valeur à serrer dans cette plage.

class HelperClass
{
    // Some other methods

    public static int clamp( int min, int max, int value )
    {
        if( value > max )
            return max;
        else if( value < min )
            return min;
        else
            return value;
    }
}

Pour votre cas, vous déclareriez votre santé minimum et maximum quelque part.

final int HealthMin = 0;
final int HealthMax = 100;

Appelez ensuite la fonction en passant votre santé min, max et ajustée.

health = HelperClass.clamp( HealthMin, HealthMax, health + 15 );

Je sais que c'est un projet scolaire, mais si vous vouliez étendre votre jeu plus tard et pouvoir améliorer votre pouvoir de guérison, écrivez la fonction comme suit:

public void getHealed(healthPWR) {
    health = Math.min(health + healthPWR, 100);
}

et appelez la fonction:

getHealed(15);
getHealed(25);

...etc...

De plus, vous pouvez créer votre HP max en créant une variable qui n'est pas locale à la fonction. Comme je ne sais pas quelle langue vous utilisez, je ne montrerai pas d'exemple car il pourrait avoir la mauvaise syntaxe.

Peut être ça?

public void getHealed()
{
  if (health <= 85)
  {
    health += 15;
  } else
  {
    health = 100;
  }
}

Si vous voulez être effronté et adapter votre code sur une seule ligne, vous pouvez utiliser un opérateur ternaire :

health += (health <= 85) ? 15 : (100 - health);

Notez que certaines personnes désapprouveront cette syntaxe en raison (sans doute) d'une mauvaise lisibilité!

Je crois que ça va faire

if (health >= 85) health = 100;
else health += 15;

Explication:

• Si l'écart de guérison est de 15 ou moins, la santé deviendra 100.

• Sinon, si l'écart est supérieur à 15, cela ajoutera 15 à la santé.

Par exemple: si la santé est de 83, elle deviendra 98 mais pas 100.

Si je voulais être thread-safe, je le ferais de cette façon plutôt que d'utiliser un bloc synchronisé.

L'atomic compareAndSet obtient le même résultat que synchronisé sans la surcharge.

AtomicInteger health = new AtomicInteger();

public void addHealth(int value)
{
    int original = 0;
    int newValue = 0;
    do
    {
        original = health.get();
        newValue = Math.min(100, original + value);
    }
    while (!health.compareAndSet(original, newValue));
}

Manière la plus simple en utilisant l'opérateur module.

santé = (santé + 50)% 100;

la santé ne sera jamais égale ou supérieure à 100.

   private int health;
    public void Heal()
    {
        if (health > 85)
            health = 100;
        else
            health += 15;
    }
    public void Damage()
    {
        if (health < 15)
            health = 0;
        else
            health -= 15;
    }