Bagaimana cara menaikkan variabel tanpa melebihi nilai maksimum?

Saya sedang mengerjakan program video game sederhana untuk sekolah dan saya telah membuat metode di mana pemain mendapat 15 poin kesehatan jika metode itu dipanggil. Saya harus menjaga kesehatan pada maksimal 100 dan dengan kemampuan pemrograman saya yang terbatas pada saat ini saya melakukan sesuatu seperti ini.

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

Saya mengerti sintaks saya tentang tidak sempurna tetapi pertanyaan saya adalah, cara apa yang lebih baik untuk melakukannya, karena saya juga harus melakukan hal serupa dengan titik kerusakan dan tidak berada di bawah 0.

Ini disebut aritmatika saturasi .

Saya hanya akan melakukan ini. Ini pada dasarnya membutuhkan minimum antara 100 (kesehatan maksimal) dan seperti apa kesehatan dengan 15 poin tambahan. Ini memastikan bahwa kesehatan pengguna tidak melebihi 100.

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

Untuk memastikan bahwa hitpoints tidak turun di bawah nol, Anda dapat menggunakan fungsi yang sama: Math.max.

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

tambahkan saja 15 ke kesehatan, jadi:

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

Namun, seperti yang dicatat oleh hambar, terkadang dengan multi-threading (beberapa blok kode yang dijalankan sekaligus) memiliki kesehatan melebihi 100 pada titik mana pun dapat menyebabkan masalah, dan mengubah properti kesehatan beberapa kali juga bisa berdampak buruk. Dalam hal ini, Anda dapat melakukan ini, seperti yang disebutkan dalam jawaban lain.

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

Anda tidak memerlukan kasing terpisah untuk setiap kasus di intatas 85. Cuma punya satu else, biar kalo kesehatannya udah 86atau lebih tinggi ya langsung set saja ke 100.

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

Saya pikir cara idiomatik, berorientasi objek untuk melakukan ini adalah dengan memiliki setHealthdi Characterkelas. Implementasi metode itu akan terlihat seperti ini:

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

Ini mencegah kesehatan turun di bawah 0 atau lebih tinggi dari 100, terlepas dari apa yang Anda atur.

getHealed()Penerapan Anda bisa saja seperti ini:

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

Apakah masuk akal jika metode Characterto have-a getHealed()adalah latihan yang diserahkan kepada pembaca :)

Saya hanya akan menawarkan potongan kode yang lebih dapat digunakan kembali, ini bukan yang terkecil tetapi Anda dapat menggunakannya dengan jumlah berapa pun sehingga masih layak untuk dikatakan

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

Anda juga dapat mengubah 100 menjadi variabel maxHealth jika Anda ingin menambahkan statistik ke permainan yang Anda buat, sehingga seluruh metode bisa menjadi seperti ini

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

EDIT

Untuk informasi tambahan

Anda dapat melakukan hal yang sama ketika pemain mengalami kerusakan, tetapi Anda tidak memerlukan minHealth karena itu akan menjadi 0. Melakukannya dengan cara ini Anda akan dapat merusak dan menyembuhkan jumlah berapa pun dengan kode yang sama.

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

Saya akan membuat metode statis di kelas pembantu. Dengan cara ini, daripada mengulang kode untuk setiap nilai yang harus sesuai dengan beberapa batasan, Anda dapat memiliki satu metode serbaguna. Ini akan menerima dua nilai yang mendefinisikan min dan max, dan nilai ketiga untuk dijepit dalam kisaran itu.

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

Untuk kasus Anda, Anda akan menyatakan kesehatan minimum dan maksimum Anda di suatu tempat.

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

Kemudian panggil fungsi yang meneruskan kesehatan min, maks, dan yang disesuaikan.

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

Saya tahu ini adalah proyek sekolah, tetapi jika Anda ingin mengembangkan game Anda nanti dan dapat meningkatkan kekuatan penyembuhan Anda, tulis fungsinya seperti ini:

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

dan panggil fungsinya:

getHealed(15);
getHealed(25);

... dll ...

Selanjutnya Anda dapat membuat HP maks Anda dengan membuat variabel yang tidak sesuai dengan fungsi. Karena saya tidak tahu bahasa apa yang Anda gunakan, saya tidak akan menampilkan contoh karena mungkin sintaksnya salah.

Mungkin ini?

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

Jika Anda ingin menjadi kurang ajar dan memasukkan kode Anda dalam satu baris, Anda dapat menggunakan operator terner :

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

Perhatikan bahwa beberapa orang tidak menyukai sintaks ini karena (bisa dibilang) keterbacaan yang buruk!

Saya yakin ini akan berhasil

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

Penjelasan:

• Jika celah untuk penyembuhan 15 atau kurang, kesehatan akan menjadi 100.

• Jika tidak, jika jaraknya lebih besar dari 15, itu akan menambah 15 kesehatan.

Jadi misalnya: jika kesehatannya 83, itu akan menjadi 98 tetapi bukan 100.

Jika saya ingin thread safe, saya akan melakukannya dengan cara ini daripada menggunakan blok tersinkronisasi.

Perbandingan atomik mencapai hasil yang sama seperti yang disinkronkan tanpa 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));
}

Cara paling sederhana menggunakan operator modulus.

kesehatan = (kesehatan + 50)% 100;

kesehatan tidak akan pernah sama atau melebihi 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;
    }