Como posso incrementar uma variável sem exceder um valor máximo?

Estou trabalhando em um programa de videogame simples para a escola e criei um método em que o jogador ganha 15 pontos de saúde se esse método for chamado. Eu tenho que manter a saúde em um máximo de 100 e com minha capacidade de programação limitada neste ponto, estou fazendo algo assim.

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

Eu entendo que minha sintaxe sobre não é perfeita, mas minha dúvida é, qual pode ser a melhor maneira de fazer isso, porque eu também tenho que fazer algo semelhante com os pontos de dano e não ficar abaixo de 0.

Isso é chamado de aritmética de saturação .

Eu simplesmente faria isso. Basicamente, leva o mínimo entre 100 (a saúde máxima) e o que seria a saúde com 15 pontos extras. Isso garante que a saúde do usuário não exceda 100.

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

Para garantir que hitpoints não cair abaixo de zero, você pode usar uma função semelhante: Math.max.

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

basta adicionar 15 à saúde, então:

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

No entanto, como observou sem graça, às vezes com multi-threading (vários blocos de código em execução ao mesmo tempo), ter a integridade acima de 100 em qualquer ponto pode causar problemas, e alterar a propriedade de integridade várias vezes também pode ser ruim. Nesse caso, você poderia fazer isso, conforme mencionado em outras respostas.

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

Você não precisa de um caso separado para cada intacima 85. Basta ter um else, de modo que se a saúde já for 86ou superior, defina-o diretamente para 100.

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

Acho que uma forma idiomática e orientada a objetos de fazer isso é ter um setHealthna Characterclasse. A implementação desse método será semelhante a esta:

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

Isso evita que a saúde fique abaixo de 0 ou acima de 100, independentemente de como você definiu.

Sua getHealed()implementação pode ser apenas esta:

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

Se faz sentido para o método Characterter-um getHealed()é um exercício deixado para o leitor :)

Vou apenas oferecer uma parte de código mais reutilizável, não é a menor, mas você pode usá-la com qualquer quantidade, então ainda vale a pena ser dito

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

Você também pode alterar o 100 para uma variável maxHealth se quiser adicionar estatísticas ao jogo que você está criando, então todo o método pode ser algo assim

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

EDITAR

Para informações extras

Você poderia fazer o mesmo quando o player for danificado, mas não precisaria de um minHealth porque seria 0 de qualquer maneira. Fazendo desta forma, você seria capaz de danificar e curar qualquer quantia com o mesmo código.

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

Eu faria um método estático em uma classe auxiliar. Dessa forma, em vez de repetir o código para cada valor que precisa se ajustar a alguns limites, você pode ter um método para todos os fins. Aceitaria dois valores que definem o mínimo e o máximo, e um terceiro valor a ser fixado nessa faixa.

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 o seu caso, você declararia sua saúde mínima e máxima em algum lugar.

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

Em seguida, chame a função transmitindo sua saúde mínima, máxima e ajustada.

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

Eu sei que este é um projeto escolar, mas se você quiser expandir seu jogo mais tarde e ser capaz de atualizar seu poder de cura, escreva a função assim:

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

e chamar a função:

getHealed(15);
getHealed(25);

... etc ...

Além disso, você pode criar seu HP máximo criando uma variável que não é local para a função. Como não sei qual linguagem você está usando, não vou mostrar um exemplo porque pode ter a sintaxe errada.

Talvez isto?

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

Se você quiser ser atrevido e colocar seu código em uma linha, pode usar um operador ternário :

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

Observe que algumas pessoas irão desaprovar essa sintaxe devido à (possivelmente) má legibilidade!

Eu acredito que isso vai servir

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

Explicação:

• Se a lacuna de cura for 15 ou menos, a saúde passará a 100.

• Caso contrário, se a lacuna for maior que 15, isso adicionará 15 à saúde.

Por exemplo: se a saúde for 83, ela se tornará 98, mas não 100.

Se eu quisesse ter um thread safe, faria dessa forma, em vez de usar um bloco sincronizado.

O compareAndSet atômico atinge o mesmo resultado que sincronizado sem a 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));
}

Maneira mais simples usando o operador de módulo.

saúde = (saúde + 50)% 100;

a saúde nunca será igual ou 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;
    }