Как я могу увеличить переменную, не превышая максимального значения?

Я работаю над простой программой видеоигр для школы и создал метод, в котором игрок получает 15 очков здоровья, если этот метод вызывается. Я должен поддерживать здоровье на максимум 100, и с моими ограниченными возможностями программирования на данный момент я делаю что-то вроде этого.

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

Я понимаю, что мой синтаксис не идеален, но мой вопрос в том, что может быть лучшим способом сделать это, потому что я также должен проделать то же самое с точками повреждения и не опускаться ниже 0.

Это называется арифметикой насыщения .

Я бы просто сделал это. Это в основном занимает минимум от 100 (максимальное здоровье) до того, что было бы с 15 дополнительными очками. Это гарантирует, что здоровье пользователя не превышает 100.

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

Для того, чтобы убедиться , что хитпоинты не опускается ниже нуля, вы можете использовать аналогичную функцию: Math.max.

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

просто добавьте 15 к здоровью, так что:

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

Однако, как было отмечено мягким, иногда при многопоточности (одновременное выполнение нескольких блоков кода), когда состояние работоспособности превышает 100 в любой момент, могут возникнуть проблемы, а изменение свойства работоспособности несколько раз также может быть плохим. В этом случае вы можете сделать это, как упоминалось в других ответах.

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

Вам не нужен отдельный кейс для каждого из intперечисленных выше 85. Просто имейте один else, чтобы, если здоровье уже 86или выше, просто установите его прямо на 100.

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

Я думаю , идиоматическое, объектно - ориентированный способ сделать это , чтобы иметь setHealthна Characterклассе. Реализация этого метода будет выглядеть так:

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

Это предотвращает падение здоровья ниже 0 или выше 100, независимо от того, что вы его установили.

Ваша getHealed()реализация может быть такой:

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

Имеет ли смысл использовать метод Characterto have-a getHealed()- задача читателя :)

Я просто собираюсь предложить более многоразовый фрагмент кода, он не самый маленький, но вы можете использовать его с любым количеством, так что его все же стоит сказать

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

Вы также можете изменить 100 на переменную maxHealth, если хотите добавить статистику к игре, которую вы создаете, чтобы весь метод мог быть примерно таким

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

РЕДАКТИРОВАТЬ

Для дополнительной информации

Вы можете сделать то же самое, когда игрок получает урон, но вам не понадобится minHealth, потому что в любом случае это будет 0. Поступая таким образом, вы сможете наносить урон и лечить любые суммы одним и тем же кодом.

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

Я бы сделал статический метод во вспомогательном классе. Таким образом, вместо того, чтобы повторять код для каждого значения, которое должно соответствовать определенным границам, у вас может быть один универсальный метод. Он будет принимать два значения, определяющие минимальное и максимальное значение, и третье значение, которое будет ограничено в этом диапазоне.

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

Для вашего случая вы бы где-нибудь заявили о своем минимальном и максимальном здоровье.

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

Затем вызовите функцию, передав минимальное, максимальное и скорректированное здоровье.

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

Я знаю, что это школьный проект, но если вы позже захотите расширить свою игру и иметь возможность повысить свою целительную силу, напишите функцию так:

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

и вызовите функцию:

getHealed(15);
getHealed(25);

...так далее...

Кроме того, вы можете создать максимальное значение HP, создав переменную, которая не является локальной для функции. Поскольку я не знаю, какой язык вы используете, я не буду показывать пример, потому что он может иметь неправильный синтаксис.

Может быть, это?

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

Если вы хотите проявить дерзость и уместить свой код в одну строку, вы можете использовать тернарный оператор :

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

Обратите внимание, что некоторые люди не одобрят этот синтаксис из-за (возможно) плохой читаемости!

Я верю, что это подойдет

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

Пояснение:

• Если разрыв для исцеления составляет 15 или меньше, здоровье станет 100.

• В противном случае, если разрыв больше 15, он добавит 15 к здоровью.

Так, например: если здоровье 83, оно станет 98, а не 100.

Если бы я хотел быть потокобезопасным, я бы сделал это таким образом, а не использовал бы синхронизированный блок.

Атомарный compareAndSet дает тот же результат, что и synchronized, без дополнительных затрат.

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

Самый простой способ использовать оператор модуля.

здоровье = (здоровье + 50)% 100;

здоровье никогда не будет равно 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;
    }