FieldStats.java

import java.util.HashMap;
import javafx.scene.text.Text;
import javafx.scene.text.TextFlow;
import javafx.scene.paint.Color;

/**
 * This class collects and provides some statistical data on the state
 * of a field. It is flexible: it will create and maintain a counter
 * for any type of animal that is found within the field.
 *
 * @author Yingtao Zheng(Kevin) and Kexin Wang
 * @time 2025.02.21
 * @version 1.0
 */

public class FieldStats {
    
    private HashMap<Animal.Type, Counter> counters;
    private boolean countsValid;

    /**
     * Construct a FieldStats object.  Set up a collection for counters for
     * each type of animal that we might find
     */
    public FieldStats() {
        counters = new HashMap<>();
        countsValid = true;
    }

    /**
     * Get details of what is in the field.
     * @return A string describing what is in the field.
     */
    public TextFlow getPopulationDetails(Field field) {
        TextFlow textFlow = new TextFlow();

        if (!countsValid) {
            generateCounts(field);
        }
        for (Animal.Type animalType : counters.keySet()) {
            Counter info = counters.get(animalType);
            String animalTypeString = info.getName();
            String animalNumberString = String.valueOf(info.getCount());
            String string = animalTypeString + ": " + animalNumberString + " ";

            Text text = new Text(String.valueOf(string));

            HashMap<Animal.Type, Color> colors = Animal.colors;

            text.setFill(colors.get(animalType));
            textFlow.getChildren().add(text);
        }
        return textFlow;
    }

    /**
     * Invalidate the current set of statistics; reset all
     * counts to zero.
     */
    public void reset() {
        countsValid = false;
        for (Animal.Type animalType : counters.keySet()) {
            Counter count = counters.get(animalType);
            count.reset();
        }
    }

    /**
     * Increment the count for one type of animal
     * @param animalType The type of animal to increment.
     */
    public void incrementCount(Animal animal) {
    Animal.Type animalType = animal.getType();
        Counter count = counters.get(animalType);

        if (count == null) {
            // We do not have a counter for this species yet. Create one.
            count = new Counter(animalType.toString());
            counters.put(animalType, count);
        }
        count.increment();
    }

    /**
     * Indicate that an animal count has been completed.
     */
    public void countFinished() {
        countsValid = true;
    }

    /**
     * Determine whether the simulation is still viable.
     * I.e., should it continue to run.
     * @return true If there is more than one animal form alive
     */
    public boolean isViable(Field field) {
        int nonZero = 0;
        if (!countsValid) {
            generateCounts(field);
        }
        for (Animal.Type animalType : counters.keySet()) {
            Counter info = counters.get(animalType);
            if (info.getCount() > 0) {
                nonZero++;
            }
        }

        return nonZero >= 1;
    }

    /**
     * Generate counts of the number of animals.
     * These are not kept up to date.
     * @param field The field to generate the stats for.
     */
    private void generateCounts(Field field) {
        reset();
        for (int row = 0; row < field.getDepth(); row++) {
            for (int col = 0; col < field.getWidth(); col++) {
                Animal animal = field.getObjectAt(row, col);

                if (animal != null) {
                    incrementCount(animal);
                }
            }
        }
        countsValid = true;
    }
}