V5

doc/plantuml/V5.txt

+@startuml
+
+package DP{
+    skin rose
+    abstract class Arme {
+        #int degat
+        #String nom
+        #double poids
+        + Arme(int degat, String nom, double poids)
+    }
+
+    class Epee extends Arme {
+        - int longueur
+        + Epee()
+    }
+
+    class BatonDeSorcier extends Arme {
+        -String pouvoir
+        + BatonDeSorcier()
+    }
+
+    class BaguetteMagique extends Arme {
+        -int soin
+        + BaguetteMagique()
+    }
+
+    abstract class Personnage implements ComposantEquipe{
+        #int pointsDeVie
+        #int niveau
+        #String nom
+        #boolean vivant;
+        + Personnage(int pointsDeVie, String nom, Arme arme)
+        + void subirDegats(int d)
+        + void setStrategie(StrategieCombat strategie)
+        + boolean estVivant()
+    }
+    Personnage -left- "1" Arme
+    Personnage -- "1" StrategieCombat
+
+    class Guerrier extends Personnage {
+        - int force
+        + Guerrier()
+        + void accept(VisiteurPersonnage visiteur)
+    }
+
+    class Roi extends Personnage {
+        - int force
+        - String royaume
+        + Roi()
+        + void accept(VisiteurPersonnage visiteur)
+    }
+
+    class Sorcier extends Personnage {
+        - int intelligence
+        + Sorcier()
+        + void accept(VisiteurPersonnage visiteur)
+    }
+
+    class Guerisseur extends Personnage {
+        - int sagesse
+        + Guerisseur()
+        + void accept(VisiteurPersonnage visiteur)
+    }
+
+    interface VisiteurPersonnage {
+        + void visitGuerrier(Guerrier guerrier)
+        + void visitRoi(Roi roi)
+        + void visitSorcier(Sorcier sorcier)
+        + void visitGuerisseur(Guerisseur guerisseur)
+        + void visitEquipe(Equipe equipe)
+    }
+
+    class DegatVisiteur implements VisiteurPersonnage {
+        + void visitGuerrier(Guerrier guerrier)
+        + void visitRoi(Roi roi)
+        + void visitSorcier(Sorcier sorcier)
+        + void visitGuerisseur(Guerisseur guerisseur)
+        + void visitEquipe(Equipe equipe)
+    }
+
+    class NiveauVisiteur implements VisiteurPersonnage {
+        + void visitGuerrier(Guerrier guerrier)
+        + void visitRoi(Roi roi)
+        + void visitSorcier(Sorcier sorcier)
+        + void visitGuerisseur(Guerisseur guerisseur)
+        + void visitEquipe(Equipe equipe)
+    }
+
+    class CptSorcierVisiteur implements VisiteurPersonnage {
+        - int compteur
+        + CptSorcierVisiteur()
+        + void visitGuerrier(Guerrier guerrier)
+        + void visitRoi(Roi roi)
+        + void visitSorcier(Sorcier sorcier)
+        + void visitGuerisseur(Guerisseur guerisseur)
+        + void visitEquipe(Equipe equipe)
+        + int getCompteur()
+    }
+
+    interface ComposantEquipe {
+        + void accept(VisiteurPersonnage visiteur)
+    }
+
+    class Equipe implements ComposantEquipe {
+        + Equipe()
+        + void addComposant(ComposantEquipe ... ces)
+        + void rmComposant(ComposantEquipe ce)
+        + void accept(VisiteurPersonnage visiteur)
+    }
+    Equipe --"0..*" ComposantEquipe : composants
+
+    class Configuration {
+        - Configuration()
+        + Configuration getInstance()
+        + int getDifficulte()
+        + int getMaxEquipe()
+    }
+    Configuration --"1" Configuration : instance (static)
+
+    interface StrategieCombat {
+        + int modifieDegats(int d)
+    }
+
+    class StrategieNeutre implements StrategieCombat {
+        + int modifieDegats(int d)
+    }
+
+    class StrategieAgressive implements StrategieCombat {
+        + int modifieDegats(int d)
+    }
+
+    class StrategieDefensive implements StrategieCombat {
+        + int modifieDegats(int d)
+    }
+
+}
+
+@enduml
\ No newline at end of file

src/main/java/DP/Personnage.java

@@ -5,12 +5,16 @@ public abstract class Personnage implements ComposantEquipe {
     protected int niveau;
     protected String nom;
     protected Arme arme;
+    protected StrategieCombat strategie;
+    protected boolean vivant;
 
     public Personnage(int pointsDeVie, String nom, Arme arme){
         this.pointsDeVie = pointsDeVie;
         this.niveau = 1;
         this.nom = nom;
         this.arme = arme;
+        this.strategie = new StrategieNeutre();
+        vivant = true;
     }
 
     public abstract void accept(VisiteurPersonnage visiteur);
@@ -20,7 +24,9 @@ public abstract class Personnage implements ComposantEquipe {
     }
 
     public void setPointsDeVie(int pointsDeVie) {
-        this.pointsDeVie = pointsDeVie;
+        if(pointsDeVie > 0) {
+            this.pointsDeVie = pointsDeVie;
+        }
     }
 
     public int getNiveau() {
@@ -28,7 +34,9 @@ public abstract class Personnage implements ComposantEquipe {
     }
 
     public void setNiveau(int niveau) {
-        this.niveau = niveau;
+        if(niveau > 0){
+            this.niveau = niveau;
+        }
     }
 
     public String getNom() {
@@ -46,4 +54,30 @@ public abstract class Personnage implements ComposantEquipe {
     public void setArme(Arme arme) {
         this.arme = arme;
     }
+
+    public int getAttaque(){
+        if(arme != null){
+            return strategie.modifieDegats(arme.getDegat());
+        } else {
+            return 0;
+        }
+    }
+
+    public void subirDegats(int d){
+        int degats = strategie.modifieDegats(d);
+        pointsDeVie -= degats;
+        if(pointsDeVie <= 0){
+            vivant = false;
+        }
+    }
+
+    public void setStrategie(StrategieCombat strategie){
+        if(strategie != null){
+            this.strategie = strategie;
+        }
+    }
+
+    public boolean estVivant() {
+        return vivant;
+    }
 }

src/main/java/DP/StrategieAgressive.java

+package DP;
+
+public class StrategieAgressive implements StrategieCombat{
+    @Override
+    public int modifieDegats(int d) {
+        return d*2;
+    }
+}
+

src/main/java/DP/StrategieCombat.java

+package DP;
+
+public interface StrategieCombat {
+    public int modifieDegats(int d);
+}
+

src/main/java/DP/StrategieDefensive.java

+package DP;
+
+public class StrategieDefensive implements StrategieCombat{
+    @Override
+    public int modifieDegats(int d) {
+        return d/2;
+    }
+}
+

src/main/java/DP/StrategieNeutre.java

+package DP;
+
+public class StrategieNeutre implements StrategieCombat{
+    @Override
+    public int modifieDegats(int d) {
+        return d;
+    }
+}
+

tests/TestV5.java

+import DP.*;
+import org.junit.Test;
+
+import java.util.Random;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestV5 {
+    @Test
+    public void test_strategie_neutre(){
+        Guerrier g = new Guerrier();
+
+        g.subirDegats(20);
+        int attaque = g.getAttaque();
+        // un guerrier a 50 points de vie
+        assertEquals("Le guerrier n'a pas l'attaque attendue", 50, attaque);
+        assertEquals("Le guerrier devrait avoir perdu 20 points de vie", 30, g.getPointsDeVie());
+    }
+
+    @Test
+    public void test_strategie_agressive(){
+        Guerrier g = new Guerrier();
+        g.setStrategie(new StrategieAgressive());
+
+        g.subirDegats(20);
+        int attaque = g.getAttaque();
+        // un guerrier a 50 points de vie
+        assertEquals("Le guerrier n'a pas l'attaque attendue", 100, attaque);
+        assertEquals("Le guerrier devrait avoir perdu 40 points de vie", 10, g.getPointsDeVie());
+    }
+
+    @Test
+    public void test_strategie_defensive(){
+        Guerrier g = new Guerrier();
+        g.setStrategie(new StrategieDefensive());
+
+        g.subirDegats(20);
+        int attaque = g.getAttaque();
+        // un guerrier a 50 points de vie
+        assertEquals("Le guerrier n'a pas l'attaque attendue", 25, attaque);
+        assertEquals("Le guerrier devrait avoir perdu 10 points de vie", 40, g.getPointsDeVie());
+    }
+
+    @Test
+    public void test_simulation_1(){
+        Guerrier g = new Guerrier();
+        g.setStrategie(new StrategieAgressive());
+        int attaqueDuGuerrier = g.getAttaque();
+
+        Roi r = new Roi();
+        r.setStrategie(new StrategieAgressive());
+
+        r.subirDegats(attaqueDuGuerrier);
+        // le roi a 100 points de vie et recoie un coup de 50*2*2 degats
+        assertEquals("Le roi devrais avoir 0 points de vie", -100, r.getPointsDeVie());
+        assertEquals("Le roi devrais etre mort", false, r.estVivant());
+    }
+
+    @Test
+    public void test_simulation_2(){
+        Guerrier g = new Guerrier();
+        g.setStrategie(new StrategieDefensive());
+        int attaqueDuGuerrier = g.getAttaque();
+
+        Roi r = new Roi();
+        r.setStrategie(new StrategieDefensive());
+
+        r.subirDegats(attaqueDuGuerrier);
+        // le roi a 100 points de vie et recoie un coup de 50/2/2 degats
+        assertEquals("Le roi devrais avoir 88 points de vie", 88, r.getPointsDeVie());
+        assertEquals("Le roi devrais etre vivant", true, r.estVivant());
+    }
+}