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/Character.java

@@ -1,40 +1,47 @@
 //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 int DEFAULT_HEALTH = 10;
-    private static final int DEFAULT_LEVEL = 1;
+    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 int health;
-    private int level;
+    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;
-    private boolean isAlive; //osäker på om den här variabeln är en bra idé
 
     // 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;
-        isAlive = true;
     }
 
     // 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;
-        this.isAlive = true;
     }
 
-    public Character(int health, int level, Position position) {
+    public Character(double health, double level, double energy, Position position) {
         this.health = health;
         this.level = level;
+        this.energy = energy;
         this.position = position;
-        this.isAlive = true;
     }
 
-    public int getHealth() {
+    //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;
     }
 
@@ -42,7 +49,7 @@ public abstract class Character {
         health = newHealth;
     }
 
-    public int getLevel() {
+    public double getLevel() {
         return level;
     }
 
@@ -50,6 +57,14 @@ public abstract class Character {
         level = newLevel;
     }
 
+    public double getEnergy() {
+        return energy;
+    }
+
+    public void setEnergy(double newEnergy) {
+        energy = newEnergy;
+    }
+
     public Position getPosition() {
         return position;
     }
@@ -57,14 +72,4 @@ public abstract class Character {
     public void setPosition(Position newPosition) {
         position = newPosition;
     }
-
-    public boolean isAlive() {
-        return isAlive;
-    }
-
-    // "status" är kanske inte ett jättebra namn...
-    public void setAlive(boolean status) {
-        isAlive = status;
-    }
-
 }

src/main/java/Monster.java

@@ -1,14 +1,30 @@
+import java.util.*;
+
 public abstract class Monster extends Character{
 
-    public Monster() {
+    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(int health, int level, Position position) {
-        super(health, level, position);
+    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

@@ -4,7 +4,47 @@ import org.junit.jupiter.api.Test;
 public class MonsterTest {
 
     @Test
-    void nothing_in_particular() {
+    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() {
 
     }
 }