src/main/java/Attack.java

@@ -0,0 +1,22 @@
+public abstract class Attack {
+    //Namnet och bägge dessa siffror är helt lösryckta
+    private static final String DEFAULT_NAME = "DEFAULT_NAME";
+    private static final double DEFAULT_ENERGY_COST = 5d;
+    private static final double DEFAULT_DAMAGE = 5d;
+
+    private String name;
+    private double energyCost;
+    private double damage;
+
+    public Attack() {
+        name = DEFAULT_NAME;
+        energyCost = DEFAULT_ENERGY_COST;
+        damage = DEFAULT_DAMAGE;
+    }
+
+    public Attack(String name, double energyCost, double damage) {
+        this.name = name;
+        this.energyCost = energyCost;
+        this.damage = damage;
+    }
+}

src/main/java/Biomes.java

@@ -0,0 +1,3 @@
+public enum Biomes {
+    GRASSLAND, MOUNTAIN, COAST, FOREST //Är inte fäst vid dessa
+}

src/main/java/Character.java

@@ -0,0 +1,75 @@
+//Vill inte göra så mycket med den här klassen, då jag vill påverka implementeringen av Player så lite som möjligt
+public abstract class Character {
+    private static final double DEFAULT_HEALTH = 50d;
+    private static final double DEFAULT_LEVEL = 1.0;
+    private static final double DEFAULT_ENERGY = 50d; //Detta borde kanske egentligen beräknas och sättas automatiskt genom en algoritm som tar health och level i beaktskap?? Eller något sådant
+    private static final Position DEFAULT_POSITION = new Position(0,0); //Är detta en bra idé?? Mest för att kunna ha defaultkonstruktor
+
+    // Borde jag bara sätta allt till default direkt här????
+    private double health;
+    private double level;
+    private double energy; //Borde kanske beräknas genom en algoritm istället för att kunna sättas i konstruktorn... Så det alltid blir balanserat
+    private Position position;
+
+    // Hur många varianter på konstruktorn behövs?
+    public Character() {
+        this.health = DEFAULT_HEALTH;
+        this.level = DEFAULT_LEVEL;
+        this.energy = DEFAULT_ENERGY;
+        this.position = DEFAULT_POSITION;
+    }
+
+    // Jag antar att den som instansierar massa monster i världen ansvarar
+    // för att kolla att "position" har ett tillåtet värde.
+    // Just denna variant är bara för testning i min implementation av Monster
+    public Character(Position position) {
+        this.health = DEFAULT_HEALTH;
+        this.level = DEFAULT_LEVEL;
+        this.energy = DEFAULT_ENERGY;
+        this.position = position;
+    }
+
+    public Character(double health, double level, double energy, Position position) {
+        this.health = health;
+        this.level = level;
+        this.energy = energy;
+        this.position = position;
+    }
+
+    //Returnerar true om attacken gick igenom, annars false
+    //Tänker att positionen som skickas in är karaktärens egna
+    //Kommer antagligen behöva diverse hjälpmetoder i implementeringen då det är många krav som måste uppfyllas för att attacken ska gå igenom
+    abstract boolean attack(Position position, Character character);
+
+    public double getHealth() {
+        return health;
+    }
+
+    public void setHealth(int newHealth) {
+        health = newHealth;
+    }
+
+    public double getLevel() {
+        return level;
+    }
+
+    public void setLevel(int newLevel) {
+        level = newLevel;
+    }
+
+    public double getEnergy() {
+        return energy;
+    }
+
+    public void setEnergy(double newEnergy) {
+        energy = newEnergy;
+    }
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public void setPosition(Position newPosition) {
+        position = newPosition;
+    }
+}

src/main/java/Monster.java

@@ -0,0 +1,30 @@
+import java.util.*;
+
+public abstract class Monster extends Character{
+
+    private final List<Biomes> habitat = new ArrayList<>();
+
+    public Monster() {
+        habitat.addAll(Arrays.asList(Biomes.GRASSLAND, Biomes.MOUNTAIN, Biomes.COAST, Biomes.FOREST));
+    }
+
+    public Monster(Position position) {
+        super(position);
+        habitat.addAll(Arrays.asList(Biomes.GRASSLAND, Biomes.MOUNTAIN, Biomes.COAST, Biomes.FOREST));
+    }
+
+    public Monster(double health, double level, double energy, Position position) {
+        super(health, level, energy, position);
+        habitat.addAll(Arrays.asList(Biomes.GRASSLAND, Biomes.MOUNTAIN, Biomes.COAST, Biomes.FOREST));
+    }
+
+    public Monster(double health, double level, double energy, Position position, List<Biomes> habitat) {
+        super(health, level, energy, position);
+        this.habitat.addAll(habitat);
+    }
+
+    //Är detta bra??? Med unmodifiableList dvs
+    public List<Biomes> getHabitat() {
+        return Collections.unmodifiableList(habitat);
+    }
+}

src/main/java/Shade.java

@@ -0,0 +1,3 @@
+public class Shade extends Monster {
+
+}

src/test/java/MonsterTest.java

@@ -0,0 +1,50 @@
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+
+public class MonsterTest {
+
+    @Test
+    void monster_cannot_attack_when_dead() {
+        /*
+        Monster someMonster = new Monster();
+        someMonster.setHealth(-5d);
+        Assert(false, someMonster.attack(someMonster.getPosition(), character));
+         */
+    }
+
+    @Test
+    void monster_cannot_be_attacked_when_dead() {
+        /*
+        Monster attackingMonster = new Monster();
+        Monster deadMonster = new Monster();
+        deadMonster.setHealth(-4d);
+        Assert(false, attackingMonster.attack(attackingMonster.getPosition(), deadMonster));
+         */
+    }
+
+    @Test
+    void monster_cannot_attack_character_at_different_position() {
+        /*
+        Monster monsterAtOnePosition = new Monster(new Position(0,0));
+        Monster monsterAtDifferentPosition = new Monster(new Position(1,1));
+        Assert(false, monsterAtOnePosition.attack(monsterAtOnePosition.getPosition(), monsterAtDifferentPosition);
+         */
+    }
+
+    @Test
+    void monster_is_instantiated_correctly_from_default_constructor() {
+        /*
+        AssertAll????
+         */
+    }
+
+    @Test
+    void monster_is_instantiated_correctly_from_position_only_constructor() {
+
+    }
+
+    @Test
+    void monster_is_instantiated_correctly_from_full_constructor() {
+
+    }
+}