Wie kann ich eine Variable erhöhen, ohne einen Maximalwert zu überschreiten?

füge der Gesundheit einfach 15 hinzu, also:

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

Wie langweilig bemerkt wurde, kann es jedoch manchmal bei Multithreading (mehrere Codeblöcke, die gleichzeitig ausgeführt werden) zu Problemen kommen, wenn die Integrität an einem beliebigen Punkt über 100 steigt, und die Integritätseigenschaft kann auch mehrmals geändert werden sei böse. In diesem Fall können Sie dies tun, wie in anderen Antworten erwähnt.

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

Sie benötigen keinen separaten Fall für jeden int über 85. Habe nur einen else, damit, wenn die Gesundheit schon da ist 86 oder höher, dann setzen Sie es direkt auf 100.

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

Ich denke, eine idiomatische, objektorientierte Art, dies zu tun, besteht darin, eine setHealth in der Character -Klasse zu haben. Die Implementierung dieser Methode sieht folgendermaßen aus:

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

Dies verhindert, dass der Zustand unter 0 oder über 100 sinkt, unabhängig davon, auf was Sie ihn eingestellt haben.

Ihre getHealed() -Implementierung kann Folgendes sein:

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

Ob es für die Character Sinn macht, eine getHealed() -Methode zu haben, bleibt dem Leser überlassen :)

Ich werde nur eine wiederverwendbarere Codeschnitte anbieten, die nicht die kleinste ist, aber Sie können sie mit jeder beliebigen Menge verwenden, sodass sie immer noch die Rede wert ist

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

Sie können die 100 auch in eine maxHealth-Variable ändern, wenn Sie dem erstellten Spiel Statistiken hinzufügen möchten, sodass die gesamte Methode in etwa so aussehen kann

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

BEARBEITEN

Für zusätzliche Informationen

Sie könnten dasselbe tun, wenn der Player beschädigt wird, aber Sie würden keine minHealth benötigen, da dies sowieso 0 wäre. Auf diese Weise könnten Sie mit demselben Code alle Mengen beschädigen und heilen.

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

Ich würde eine statische Methode in einer Helferklasse erstellen. Auf diese Weise können Sie eine Allzweckmethode verwenden, anstatt den Code für jeden Wert zu wiederholen, der innerhalb einiger Grenzen liegen muss. Es würden zwei Werte akzeptiert, die das Minimum und das Maximum definieren, und ein dritter Wert, der innerhalb dieses Bereichs festgehalten werden soll.

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;
    }
}

Für Ihren Fall würden Sie irgendwo Ihre minimale und maximale Gesundheit angeben.

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

Rufen Sie dann die Funktion auf, die Ihre minimale, maximale und angepasste Gesundheit übergibt.

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

Ich weiß, dass dies ein Schulprojekt ist, aber wenn Sie Ihr Spiel später erweitern und Ihre Heilkraft verbessern möchten, schreiben Sie die Funktion wie folgt:

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

und rufen Sie die Funktion auf:

getHealed(15);
getHealed(25);

...etc...

Darüber hinaus können Sie Ihre maximale HP erstellen, indem Sie eine Variable erstellen, die für die Funktion nicht lokal ist. Da ich nicht weiß, welche Sprache Sie verwenden, werde ich kein Beispiel zeigen, da es möglicherweise die falsche Syntax hat.

Vielleicht das?

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

Wenn Sie frech sein und Ihren Code in eine Zeile einpassen möchten, können Sie einen ternären Operator verwenden:

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

Beachten Sie, dass einige Leute diese Syntax wegen (vermutlich) schlechter Lesbarkeit verachten!

Einfachster Weg mit dem Modul Operator.

gesundheit = (Gesundheit + 50)% 100;

gesundheit wird niemals 100 betragen oder überschreiten.

Ich glaube das wird reichen

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

Erläuterung:

• Wenn die Heilungslücke 15 oder weniger beträgt, wird die Gesundheit 100.

• Andernfalls erhöht sich die Gesundheit um 15, wenn die Lücke größer als 15 ist.

Zum Beispiel: Wenn der Gesundheitszustand 83 ist, wird er zu 98, aber nicht zu 100.

Wenn ich threadsicher sein wollte, würde ich es auf diese Weise tun, anstatt einen synchronisierten Block zu verwenden.

Das atomare compareAndSet erzielt das gleiche Ergebnis wie das ohne Overhead synchronisierte.

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));
}

   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;
    }