¿Cómo puedo incrementar una variable sin exceder un valor máximo?

Estoy trabajando en un programa de videojuego simple para la escuela y he creado un método en el que el jugador obtiene 15 puntos de salud si se llama a ese método. Tengo que mantener la salud en un máximo de 100 y con mi capacidad de programación limitada en este momento estoy haciendo algo como esto.

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

Entiendo que mi sintaxis no es perfecta, pero mi pregunta es, cuál puede ser una mejor manera de hacerlo, porque también tengo que hacer algo similar con los puntos de daño y no bajar de 0.

A esto se le llama aritmética de saturación .

Solo haría esto. Básicamente, toma el mínimo entre 100 (la salud máxima) y cuál sería la salud con 15 puntos extra. Asegura que la salud del usuario no supere los 100.

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

Para asegurar que los puntos de golpe no caen por debajo de cero, puede utilizar una función similar: Math.max.

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

solo agregue 15 a la salud, entonces:

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

Sin embargo, como ha señalado Bland, a veces con el subproceso múltiple (varios bloques de código ejecutándose a la vez) tener la salud sobre 100 en cualquier punto puede causar problemas, y cambiar la propiedad de salud varias veces también puede ser malo. En ese caso, puede hacer esto, como se menciona en otras respuestas.

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

No necesita un caso separado para cada uno de los intanteriores 85. Solo tenga uno else, de modo que si la salud ya es 86o superior, configúrelo directamente en 100.

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

Creo que una forma idiomática y orientada a objetos de hacer esto es tener un setHealthen la Characterclase. La implementación de ese método se verá así:

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

Esto evita que la salud vaya por debajo de 0 o por encima de 100, independientemente de lo que establezca.

Tu getHealed()implementación puede ser simplemente esta:

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

Si tiene sentido Charactertener un getHealed()método es un ejercicio que se deja al lector :)

Solo voy a ofrecer un fragmento de código más reutilizable, no es el más pequeño, pero puede usarlo con cualquier cantidad, por lo que aún vale la pena decirlo.

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

También puede cambiar el 100 a una variable maxHealth si desea agregar estadísticas al juego que está creando, por lo que todo el método podría ser algo como esto

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

EDITAR

Para más información

Podrías hacer lo mismo cuando el jugador se dañe, pero no necesitarías un minHealth porque sería 0 de todos modos. Si lo hace de esta manera, podrá dañar y curar cualquier cantidad con el mismo código.

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

Haría un método estático en una clase auxiliar. De esta manera, en lugar de repetir el código para cada valor que debe ajustarse a algunos límites, puede tener un método para todo uso. Aceptaría dos valores que definen el mínimo y el máximo, y un tercer valor que se fijará dentro de ese rango.

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

Para su caso, declararía su salud mínima y máxima en algún lugar.

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

Luego llame a la función pasando su salud mínima, máxima y ajustada.

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

Sé que este es un proyecto de la escuela, pero si quieres expandir tu juego más adelante y poder mejorar tu poder curativo, escribe la función así:

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

y llame a la función:

getHealed(15);
getHealed(25);

... etc ...

Además, puede crear su HP máximo creando una variable que no sea local para la función. Como no sé qué idioma está usando, no mostraré un ejemplo porque podría tener la sintaxis incorrecta.

¿Tal vez esto?

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

Si quieres ser descarado y ajustar tu código en una línea, puedes usar un operador ternario :

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

Tenga en cuenta que algunas personas desaprobarán esta sintaxis debido a (posiblemente) una mala legibilidad.

Creo que esto servirá

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

Explicación:

• Si la brecha para la curación es de 15 o menos, la salud se convertirá en 100.

• De lo contrario, si la brecha es mayor que 15, agregará 15 a la salud.

Entonces, por ejemplo: si la salud es 83, se convertirá en 98 pero no 100.

Si quisiera ser seguro para subprocesos, lo haría de esta manera en lugar de usar un bloque sincronizado.

El compareAndSet atómico logra el mismo resultado que sincronizado sin la sobrecarga.

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

La forma más sencilla utilizando el operador de módulo.

salud = (salud + 50)% 100;

la salud nunca será igual o superior 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;
    }