Hoe kan ik een variabele verhogen zonder een maximumwaarde te overschrijden?

Ik werk aan een eenvoudig videogameprogramma voor school en ik heb een methode gemaakt waarbij de speler 15 gezondheidspunten krijgt als die methode wordt aangeroepen. Ik moet de gezondheid op een maximum van 100 houden en met mijn beperkte programmeervermogen op dit moment doe ik zoiets als dit.

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

Ik begrijp dat mijn syntaxis niet perfect is, maar mijn vraag is, wat is een betere manier om het te doen, want ik moet ook iets soortgelijks doen met de schadepunten en niet onder de 0 gaan.

Dit wordt verzadigingsberekeningengenoemd.

Antwoord 1, autoriteit 100%

Ik zou dit gewoon doen. Het duurt in feite het minimum tussen 100 (de maximale gezondheid) en wat de gezondheid zou zijn met 15 extra punten. Het zorgt ervoor dat de gezondheid van de gebruiker niet hoger is dan 100.

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

Om ervoor te zorgen dat hitpoints niet onder nul komen, kun je een vergelijkbare functie gebruiken: Math.max.

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

Antwoord 2, autoriteit 31%

voeg gewoon 15 toe aan de gezondheid, dus:

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

Echter, zoals flauw is opgemerkt, kan soms met multi-threading (meerdere codeblokken tegelijk uitgevoerd) de gezondheid meer dan 100 krijgen op elkpunt, dit kan problemen veroorzaken, en het wijzigen van de gezondheidseigenschap meerdere tijden kunnen ook slecht zijn. In dat geval zou u dit kunnen doen, zoals vermeld in andere antwoorden.

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

Antwoord 3, autoriteit 19%

Je hebt geen aparte case nodig voor elke intboven 85. Neem gewoon één else, zodat als de gezondheid al 86of hoger is, deze dan direct op 100staat.

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

Antwoord 4, autoriteit 16%

Ik denk dat een idiomatische, objectgeoriënteerde manier om dit te doen is om een ​​setHealthin de klasse Characterte hebben. De implementatie van die methode ziet er als volgt uit:

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

Dit voorkomt dat de gezondheid onder 0 of hoger dan 100 komt, ongeacht waar u deze op instelt.

Uw getHealed()implementatie kan gewoon dit zijn:

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

Of het zinvol is dat de Character-methode een getHealed()-methode heeft, is een oefening die aan de lezer wordt overgelaten 🙂

Antwoord 5, autoriteit 6%

Ik ga gewoon een meer herbruikbaar stukje code aanbieden, het is niet de kleinste, maar je kunt het met elke hoeveelheid gebruiken, dus het is nog steeds de moeite waard om te zeggen

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

Je zou de 100 ook kunnen veranderen in een maxHealth-variabele als je statistieken wilt toevoegen aan het spel dat je maakt, dus de hele methode zou ongeveer zo kunnen zijn

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

BEWERKEN

Voor extra informatie

Je zou hetzelfde kunnen doen als de speler beschadigd raakt, maar je hebt geen minHealth nodig, want dat zou sowieso 0 zijn. Als je het op deze manier doet, kun je met dezelfde code alle hoeveelheden beschadigen en genezen.

Antwoord 6, autoriteit 4%

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

Antwoord 7, autoriteit 2%

Ik zou een statische methode maken in een helperklasse. Op deze manier kunt u, in plaats van code te herhalen voor elke waarde die binnen bepaalde grenzen moet passen, één universele methode hebben. Het zou twee waarden accepteren die de min en max definiëren, en een derde waarde die binnen dat bereik moet worden geklemd.

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

Voor jouw geval zou je ergens je minimale en maximale gezondheid aangeven.

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

Roep vervolgens de functie aan die uw min, max en aangepaste gezondheid doorgeeft.

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

Antwoord 8

Ik weet dat dit een schoolproject is, maar als je je spel later wilt uitbreiden en je helende kracht wilt upgraden, schrijf dan de functie als volgt:

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

en roep de functie op:

getHealed(15);
getHealed(25);

…etc…

Bovendien kunt u uw max HP creëren door een variabele te maken die niet lokaal is voor de functie. Aangezien ik niet weet welke taal je gebruikt, zal ik geen voorbeeld laten zien omdat het misschien de verkeerde syntaxis heeft.

Antwoord 9

Misschien dit?

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

Antwoord 10

Als je brutaal wilt zijn en je code op één regel wilt passen, kun je een ternary gebruiken operator:

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

Houd er rekening mee dat sommige mensen de wenkbrauwen fronsen bij deze syntaxis vanwege (aantoonbaar) slechte leesbaarheid!

Antwoord 11

Ik geloof dat dit voldoende is

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

Uitleg:

• Als de kloof voor genezing 15 of minder is, wordt de gezondheid 100.

• Anders, als de kloof groter is dan 15, voegt het 15 toe aan de gezondheid.

Dus bijvoorbeeld: als de gezondheid 83 is, wordt het 98 maar niet 100.

Antwoord 12

Als ik thread-safe wilde zijn, zou ik het op deze manier doen in plaats van een gesynchroniseerd blok te gebruiken.

De atomaire CompareAndSet bereikt hetzelfde resultaat als gesynchroniseerd zonder de 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));
}

Antwoord 13

De eenvoudigste manier om de modulus-operator te gebruiken.

gezondheid = (gezondheid + 50) % 100;

gezondheid zal nooit gelijk zijn aan of hoger zijn dan 100.

Antwoord 14

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