Health.java

package Character;

import Listeners.HealthChangeListener;
import UI.InfoPopup;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;

import java.util.ArrayList;
import java.util.Collections;

public class Health {
    private final ArrayList<Integer> healthBoxes = new ArrayList<>();
    private final SimpleIntegerProperty numberOfHealth = new SimpleIntegerProperty(0);
    private final ArrayList<HealthChangeListener> healthChangeListeners = new ArrayList<>();

    private int bashing = 0;
    private int lethal = 0;
    private int agg = 0;

    /**
     * @param base Basic health boxes
     * @param oxBody Health boxes per ox-body
     * @param oxBodies Number of ox-bodies purchased
     */
    public Health(int[] base, int[] oxBody, int oxBodies) {
        //Add base health boxes
        for(int box : base) {
            healthBoxes.add(box);
        }
        //Add ox body health boxes
        for(int i =0 ; i < oxBodies; i++) {
            for(int box : oxBody) {
                healthBoxes.add(box);
            }
        }
        sort();
    }

    /**
     * Sort list & update length
     */
    public void sort() {
        //Sort health boxes in order
        healthBoxes.sort(Collections.reverseOrder());
        //Update number of health
        numberOfHealth.set(healthBoxes.size());
    }

    /**
     * Add Health boxes
     */
    public void gainMaxHealth(int[] boxes) {
        for(int box:boxes) {
            healthBoxes.add(box);
        }
        sort();
        notifyListeners();
    }

    /**
     * Remove Health boxes
     */
    public void loseMaxHealth(int[] boxes) {
        //Remove given health boxes
        for(int box:boxes) {
            healthBoxes.remove(Integer.valueOf(box));
        }
        sort();

        //If new health levels lower than current damage, resolve
        if(bashing > numberOfHealth.get()) {
            bashingDamage(0);
        }
        if(lethal > numberOfHealth.get()) {
            lethalDamage(0);
        }
        if(agg > numberOfHealth.get()) {
            aggDamage(0);
        }
        notifyListeners();
    }

    /**
     * Take bashing damage
     */
    public void bashingDamage(int damage) {
        if(bashing + damage > numberOfHealth.get()) {
            bashing = numberOfHealth.get();
            lethalDamage(bashing + damage - numberOfHealth.get());
        } else {
            bashing += damage;
            if(bashing < 0) {
                bashing = 0;
            }
        }
        notifyListeners();
    }

    /**
     * Take lethal damage
     */
    public void lethalDamage(int damage) {
        if(lethal + damage > numberOfHealth.get()) {
            lethal = numberOfHealth.get();
            aggDamage(lethal + damage - numberOfHealth.get());
        } else {
            lethal += damage;
            if(lethal < 0) {
                lethal = 0;
            }
        }
        if(bashing < lethal) {
            bashing = lethal;
        }
        notifyListeners();
    }

    /**
     * Take agg damage
     */
    public void aggDamage(int damage) {
        if(agg + damage > numberOfHealth.get()) {
            agg = numberOfHealth.get();
            death(agg + damage - numberOfHealth.get());
        } else {
            agg += damage;
            if(agg < 0) {
                agg = 0;
            }
        }
        if(lethal < agg) {
            lethal = agg;
        }
        notifyListeners();
    }

    /**
     * When agg damage == health
     */
    public void death(int damage) {
        Parent root;
        try {
            root = new InfoPopup("You're "+damage+" agg over limit.");
            Stage stage = new Stage();
            stage.setTitle("Death");
            stage.setScene(new Scene(root, 200, 150));
            stage.show();
        } catch (Exception ignored) {

        }
    }

    /**
     * Assorted getting list
     */
    public SimpleIntegerProperty getNumberOfHealth() {
        return numberOfHealth;
    }
    public int getBashing() {
        return bashing;
    }
    public int getLethal() {
        return lethal;
    }
    public int getAgg() {
        return agg;
    }
    public ArrayList<Integer> getHealthBoxes() {
        return healthBoxes;
    }

    /**
     * Add new listener
     */
    public void addNewListener(HealthChangeListener listener) {
        healthChangeListeners.add(listener);
    }

    /**
     * Alert all listeners of an update
     */
    private void notifyListeners() {
        for(HealthChangeListener listener: healthChangeListeners) {
            listener.update();
        }
    }

    /**
     * Get current penalty
     */
    public int getDamagePenalty() {
        if(bashing == 0) {
            return 0;
        }
        return healthBoxes.get(bashing-1);
    }
}