ClassDiagram.puml

@startuml


'elements

+enum ElementType {
    ..Values..
    + ANIMAL
    + PLANT
    + WATER
}

+interface WorldElement {
    + {abstract} Vector2d getPos()
    + {abstract} ElementType getElementType()
}

abstract class InanimateElement {
    ..Attributes..
    - Vector2d position
    ..Constructor..
    + InanimateElement(Vector2d position)
    ..Getters..
    + Vector2d getPos() <<override>>
}

InanimateElement ..> WorldElement : <<implements>>

+class Animal {
    ..Attributes..
    - MovementVariant movementVariant
    - MutationVariant mutationVariant
    - List<Animal> children
    - int energyToReproduce
    - int energyToPassToChild
    - int energyCostToMove
    - int birthDate
    - PositionDirectionTuple positionDirection
    - int geneIndex
    - int energy
    - int age
    - int deathDate
    - int plantsEaten
    - int childrenMade
    - int[] genotype
    ..Constructor..
    + Animal(Vector2d position, Genotype genotype, SimulationProperties simulationProperties)
    ..Simulation methods..
    + void move(MoveValidator validator)
    + void eatPlant(int plantEnergy)
    + Animal reproduce(Animal mate, SimulationProperties simulationProperties)
    + void addChildToList(Animal child)
    ..Utilities..
    + String toString() <<override>>
    ..Getters..
    + Vector2d getPos() <<override>>
    + getEnergy()
    + int[] getGenotype()
    + ElementType getElementType() <<override>>
    + int getBirthDate()
    + int getDeathDate()
    + int getChildrenMade()
    + int getPlantsEaten()
    + int getAge()
    + MovementVariant getMovementVariant()
    ..Setters..
    + void setEnergy(int energy)
    + void setGenotype(int[] genotype)
    + void setDeathDate(int date)
    
}

Animal ..> WorldElement : <<implements>>

+class Plant {
    ..Constructor..
    + Plant(Vector2d position)
    ..Utilities..
    + String toString() <<override>>
    ..Getters..
    + ElementType getElementType() <<override>>
}

Plant --> InanimateElement : <<extends>>

+class Water {
    ..Constructor..
    + Water(Vector2d position)
    ..Utilities..
    + String toString() <<override>>
    ..Getters..
    + ElementType getElementType() <<override>>
}

Water --> InanimateElement : <<extends>>


'genotype

+enum MutationVariant {
    ..Values..
    + RANDOM
}

+interface Mutation {
    + {abstract} void applyMutation(int[] genes, SimulationProperties simulationProperties);
}

+class RandomMutation {
    ..Methods..
    + void applyMutation(int[] Genotype, SimulationProperties simulationProperties) <<override>>
}

RandomMutation ..> Mutation : <<implements>>

+class Genotype {
    ..Attributes..
    - int[] genes
    - SimulationProperties simulationProperties
    ..Constructors..
    + Genotype(SimulationProperties simulationProperties)
    + Genotype(Animal parent1, Animal parent2, SimulationProperties simulationProperties)
    ..Simulation methods..
    + void initializeRandomGenes()
    + void generateChildGenes(Animal parent1, Animal parent2)
    + void performMutation(int[] genes, SimulationProperties simulationProperties)
    ..Utilities..
    + String toString() <<override>>
    + int hashCode() <<override>>
    ..Getters..
    + int[] getGenes()
}


'maps

+enum MapVariant {
    ..Values..
    + GLOBE
    + WATER_WORLD
}

+interface MoveValidator {
    + {abstract} PositionDirectionTuple correctPosition(Vector2d oldPosition, Vector2d newPosition, MapDirection direction)
}

abstract class AbstractWorldMap {
    ..Attributes..
    # List<MapChangeListener> observers
    # MapVisualizer mapVisualizer
    # UUID id
    # HashMap<Vector2d, List<Animal>> animals
    # HashMap<Vector2d, Plant> plants
    # List<Vector2d> freePlantPositions
    # int width
    # int height
    ..Constructor..
    + AbstractWorldMap(SimulationProperties simulationProperties)
    ..Simulation methods..
    + void placeAnimal(Vector2d position, Animal animal)
    + void removeAnimal(Animal animal)
    + void placePlant(Vector2d position, Plant plant)
    + void move(Animal animal)
    ..Utilities..
    + WorldElement objectAt(Vector2d position)
    + void addObserver(MapChangeListener observer)
    + void notifyObservers(String message)
    + PositionDirectionTuple correctPosition(Vector2d oldPosition, Vector2d newPosition, MapDirection direction) <<override>>
    + String toString() <<override>>
    ..Getters..
    + HashMap<Vector2d, List<Animal>> getAnimals()
    + HashMap<Vector2d, Plant> getPlants()
    + List<Vector2d> getFreePlantPositions()
    + UUID getID()
    + Boundary getCurrentBounds()
}

AbstractWorldMap ..> MoveValidator : <<implements>>

+class Globe {
    ..Constructor..
    + Globe(SimulationProperties simulationProperties)
}

Globe --> AbstractWorldMap : <<extends>>

class WaterWorld {
    ..Attributes..
    - HashMap<Vector2d, Water> waterFields
    ..Constructor..
    + WaterWorld(SimulationProperties simulationProperties)
    ..Simulation methods..
    + void waterFlow(boolean highTide, int waterViolence)
    + List<Vector2d> getSelectedWaterFields()
    + void generateFreePlantPositions()
    ..Utilities..
    + PositionDirectionTuple correctPosition(Vector2d oldPosition, Vector2d newPosition, MapDirection direction) <<override>>
    + WorldElement objectAt(Vector2d position) <<override>>
}

WaterWorld --> AbstractWorldMap : <<extends>>


'movement

+enum MovementVariant {
    ..Values..
    + PREDESTINED
    + OLD_AGE_AINT_NO_PICNIC
}


'vegetation

+enum VegetationVariant {
    ..Values..
    + FORESTED_EQUATOR
}

+interface Vegetation {
    + {abstract} boolean validatePlantPosition(Vector2d position)
    + {abstract} boolean preferred(Vector2d position)
    + {abstract} String getFieldType(Vector2d position)
}

abstract class AbstractVegetationVariant {
    ..Methods..
    + boolean validatePlantPosition(Vector2d position) <<override>>
}

AbstractVegetationVariant ..> Vegetation : <<implements>>

+class ForestedEquator {
    ..Attributes..
    - Vector2d equatorLowerLeft
    - Vector2d equatorUpperRight
    ..Constructor..
    + ForestedEquator(int equatorHeight, int mapWidth, int mapHeight)
    ..Methods..
    + boolean preferred(Vector2d position) <<override>>
    + String getFieldType(Vector2d position) <<override>>
}

ForestedEquator --> AbstractVegetationVariant : <<extends>>


'presenter

+interface MapChangeListener{
    + {abstract} void mapChanged(AbstractWorldMap worldMap, String message)
}

+class ConsoleMapDisplay {
    ..Attributes..
    - int count
    ..Methods..
    + void mapChanged(AbstractWorldMap worldMap, String message) <<override>>
}

ConsoleMapDisplay ..> MapChangeListener : <<implements>>


'simulation

class SimulationParameters {
    - int genotypeSize
    - MovementVariant movementVariant
    - MutationVariant mutationVariant
    - MapVariant mapVariant
    - VegetationVariant vegetationVariant
    - int width
    - int height
    - int equatorHeight
    - int animalCount
    - int plantCount
    - int plantsPerDay
    - int startEnergy
    - int plantEnergy
    - int energyNeededToReproduce
    - int energyToPassToChild
    - int energyCostToMove
    - int simulationStep
    - int minimumNumberOfMutations
    - int maximumNumberOfMutations
    - int waterViolence
    - int daysElapsed
}


'util

class Boundary {
    + Vector2d lowerLeft
    + Vector2d upperRight
}

enum MapDirection {
    ..Values..
    + NORTH
    + NORTHEAST
    + EAST
    + SOUTHEAST
    + SOUTH
    + SOUTHWEST
    + WEST
    + NORTHWEST
    ..Methods..
    + MapDirection next()
    + MapDirection opposite()
    + Vector2d toUnitVector()
    + MapDirection getRandomDirection()
    + MapDirection rotate(int angle)
    + String toString()
}

class PositionDirectionTuple <<record>> {
    + Vector2d position
    + MapDirection direction)
}

class RandomPositionGenerator {
    - List<Vector2d> positions
    + RandomPositionGenerator(int maxWidth, int maxHeight, int count)
    + Iterator<Vector2d> iterator()
    + Vector2d getHead()
    + Vector2d getTail()
    + int getIndex(Vector2d pos)
    + Vector2d getPos(int index)
}

class RandomPositionIterator {
    - RandomPositionGenerator generator
    - Vector2d current
    + RandomPositionIterator(RandomPositionGenerator generator)
    + boolean hasNext()
    + Vector2d next()
    + void remove()
}

RandomPositionGenerator --* RandomPositionIterator : <<contains>>

class Vector2d <<record>> {
    - int x
    - int y
    + boolean precedes(Vector2d other)
    + boolean follows(Vector2d other)
    + Vector2d add(Vector2d other)
    + Vector2d subtract(Vector2d other)
    + Vector2d upperRight(Vector2d other)
    + Vector2d lowerLeft(Vector2d other)
    + Vector2d opposite()
    + String toString()
}


@enduml