Come posso incrementare una variabile senza superare un valore massimo?

Sto lavorando a un semplice programma di videogiochi per la scuola e ho creato un metodo in cui il giocatore ottiene 15 punti salute se viene chiamato quel metodo. Devo mantenere la salute a un massimo di 100 e con la mia limitata capacità di programmazione a questo punto sto facendo qualcosa del genere.

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

Capisco che la mia sintassi non sia perfetta, ma la mia domanda è: quale potrebbe essere un modo migliore per farlo, perché devo anche fare una cosa simile con i punti di danno e non andare sotto lo 0.

Questa è chiamata aritmetica della saturazione .

Lo farei solo. Fondamentalmente ci vuole il minimo tra 100 (la salute massima) e quella che sarebbe la salute con 15 punti extra. Assicura che la salute dell'utente non superi 100.

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

Per garantire che punti ferita non scendono sotto lo zero, è possibile utilizzare una funzione simile: Math.max.

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

aggiungi solo 15 alla salute, quindi:

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

Tuttavia, come ha notato blando, a volte con il multi-threading (più blocchi di codice eseguiti contemporaneamente) avere l'integrità superiore a 100 in qualsiasi momento può causare problemi e anche la modifica della proprietà dell'integrità più volte può essere dannosa. In tal caso, potresti farlo, come menzionato in altre risposte.

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

Non hai bisogno di un caso separato per ciascuno intsopra 85. Basta averne uno else, in modo che se la salute è già 86o superiore, impostala direttamente su 100.

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

Penso che un modo idiomatico e orientato agli oggetti per farlo sia quello di avere un ruolo setHealthnella Characterclasse. L'implementazione di quel metodo sarà simile a questa:

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

Ciò impedisce che la salute scenda al di sotto di 0 o superiore a 100, indipendentemente da ciò su cui è impostata.

La tua getHealed()implementazione può essere proprio questa:

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

Se ha senso per Characteravere un getHealed()metodo è un esercizio lasciato al lettore :)

Sto solo per offrire una porzione di codice più riutilizzabile, non è la più piccola ma puoi usarla con qualsiasi importo quindi è comunque degno di essere detto

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

Puoi anche cambiare il 100 in una variabile maxHealth se vuoi aggiungere statistiche al gioco che stai creando, quindi l'intero metodo potrebbe essere qualcosa del genere

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

MODIFICARE

Per ulteriori informazioni

Potresti fare lo stesso per quando il giocatore viene danneggiato, ma non avresti bisogno di un minHealth perché sarebbe comunque 0. In questo modo saresti in grado di danneggiare e curare qualsiasi importo con lo stesso codice.

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

Creerei un metodo statico in una classe helper. In questo modo, invece di ripetere il codice per ogni valore che deve rientrare in alcuni limiti, puoi avere un metodo per tutti gli usi. Accetterebbe due valori che definiscono il minimo e il massimo e un terzo valore da bloccare entro tale intervallo.

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

Nel tuo caso, dichiareresti la tua salute minima e massima da qualche parte.

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

Quindi chiama la funzione che passa nella tua salute minima, massima e regolata.

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

So che questo è un progetto scolastico, ma se vuoi espandere il tuo gioco in un secondo momento ed essere in grado di aumentare il tuo potere di guarigione, scrivi la funzione in questo modo:

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

e chiama la funzione:

getHealed(15);
getHealed(25);

...eccetera...

Inoltre puoi creare il tuo massimo HP creando una variabile che non è locale alla funzione. Poiché non so quale lingua stai utilizzando, non mostrerò un esempio perché potrebbe avere la sintassi sbagliata.

Forse questo?

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

Se vuoi essere sfacciato e adattare il tuo codice su una riga, potresti usare un operatore ternario :

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

Nota che alcune persone non vedranno questa sintassi a causa di (probabilmente) cattiva leggibilità!

Credo che andrà bene

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

Spiegazione:

• Se il divario per la guarigione è 15 o meno, la salute diventerà 100.

• Altrimenti, se il divario è maggiore di 15, aggiungerà 15 alla salute.

Quindi, ad esempio: se la salute è 83, diventerà 98 ma non 100.

Se volessi essere thread-safe, lo farei in questo modo anziché utilizzare un blocco sincronizzato.

L'atomic compareAndSet ottiene lo stesso risultato della sincronizzazione senza l'overhead.

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

Il modo più semplice utilizzando l'operatore modulo.

salute = (salute + 50)% 100;

la salute non sarà mai uguale o superiore a 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;
    }