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

Ich arbeite an einem einfachen Videospielprogramm für die Schule und habe eine Methode erstellt, bei der der Spieler 15 Gesundheitspunkte erhält, wenn diese Methode aufgerufen wird. Ich muss die Gesundheit auf maximal 100 halten und mit meinen begrenzten Programmierfähigkeiten mache ich zu diesem Zeitpunkt so etwas.

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

Ich verstehe, dass meine Syntax nicht perfekt ist, aber meine Frage ist, was ein besserer Weg ist, weil ich auch mit den Schadenspunkten etwas Ähnliches machen muss und nicht unter 0 gehe.

Dies nennt man Sättigungsarithmetik .

Ich würde das einfach machen. Grundsätzlich beträgt das Minimum zwischen 100 (die maximale Gesundheit) und der Gesundheit mit 15 zusätzlichen Punkten. Es stellt sicher, dass der Gesundheitszustand des Benutzers 100 nicht überschreitet.

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

Um sicherzustellen, dass die Trefferpunkte nicht unter Null fallen, können Sie eine ähnliche Funktion verwenden : Math.max.

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

Fügen Sie einfach 15 zur Gesundheit hinzu, also:

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

Wie langweilig jedoch festgestellt hat, kann es bei Problemen mit Multithreading (mehrere gleichzeitig ausgeführte Codeblöcke) manchmal zu Problemen kommen, wenn der Zustand zu jedem Zeitpunkt über 100 liegt , und es kann auch schlecht sein, die Gesundheitseigenschaft mehrmals zu ändern. 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 für jeden intoben genannten Fall keinen eigenen Fall 85. Haben Sie nur eine else, damit, wenn die Gesundheit bereits 86oder höher ist, stellen Sie sie einfach direkt auf 100.

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

Ich denke , eine idiomatisch, objektorientierte Art und Weise , dies zu tun ein haben , ist setHealthauf der CharacterKlasse. Die Implementierung dieser Methode sieht folgendermaßen aus:

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

Dies verhindert, dass die Gesundheit unter 0 oder höher als 100 fällt, unabhängig davon, auf was Sie sie eingestellt haben.

Ihre getHealed()Implementierung kann einfach so sein:

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

Ob es Sinn macht, Charactereine getHealed()Methode zu haben , ist eine Übung, die dem Leser überlassen bleibt :)

Ich werde nur ein wiederverwendbareres Stück Code anbieten, es ist nicht das kleinste, aber Sie können es mit jeder Menge verwenden, so dass es immer noch wert ist, gesagt zu werden

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

Sie können die 100 auch in eine maxHealth-Variable ändern, wenn Sie dem von Ihnen erstellten Spiel Statistiken hinzufügen möchten. Die gesamte Methode könnte also ungefähr so ​​aussehen

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 das Gleiche tun, wenn der Spieler beschädigt wird, aber Sie würden keine minHealth benötigen, da dies sowieso 0 wäre. Wenn Sie dies auf diese Weise tun, können Sie alle Beträge mit demselben Code beschädigen und heilen.

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

Ich würde eine statische Methode in einer Hilfsklasse machen. Auf diese Weise können Sie eine Allzweckmethode verwenden, anstatt Code für jeden Wert zu wiederholen, der in bestimmte Grenzen passen muss. Es würde zwei Werte akzeptieren, die min und max definieren, und einen dritten Wert, der innerhalb dieses Bereichs geklemmt 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 nicht lokal für die Funktion 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 einfügen möchten, können Sie einen ternären Operator verwenden :

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

Beachten Sie, dass einige Leute diese Syntax wegen (wohl) schlechter Lesbarkeit missbilligen werden!

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 die Gesundheit 83 ist, wird sie 98, aber nicht 100.

Wenn ich threadsicher sein wollte, würde ich dies 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));
}

Einfachste Methode mit dem Moduloperator.

Gesundheit = (Gesundheit + 50)% 100;

Gesundheit wird niemals 100 erreichen oder überschreiten.

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