Projet Calculateur

[Philou]

Et terminé pour la Death Guard.

Code:

curl -XPOST -v -d '{"langage":"fr","idCamp":"2","idFaction":"4","idSousFaction":"1","idSousSousFaction":"1"}' -H "Content-type: application/json" http://localhost:8080/regles/parRecherche

Code:

[
   {
      "factory":"com.calculateur.warhammer.data.regles.factory.factory.general.RegleArmureOfContentFactory",
      "ressource":{
         "id":1,
         "ressource":"com.calculateur.warhammer.dto.regles.faction.general.general"
      },
      "donnees":[
         
      ],
      "description":"Réduit la PA adverse de 1. La figurine ne doit pas être équipé d\u0027un Bouclier Tempête.",
      "id":1,
      "nom":"Armure of Content",
      "cleTraduction":"regle.armure.of.content",
      "libelle":"Armure of Content"
   },
   {
      "factory":"com.calculateur.warhammer.data.regles.factory.factory.death.guard.RegleImplacableFactory",
      "ressource":{
         "id":24000,
         "ressource":"com.calculateur.warhammer.dto.regles.faction.death_guard.death_guard"
      },
      "donnees":[
         
      ],
      "description":"Ignore les malus aux tests d\u0027attrition.",
      "id":24000,
      "nom":"Implacable",
      "cleTraduction":"regle.death.guard.implacable",
      "libelle":"Implacable"
   },
   {
      "factory":"com.calculateur.warhammer.data.regles.factory.factory.death.guard.RegleSalveMalveillanteFactory",
      "ressource":{
         "id":24000,
         "ressource":"com.calculateur.warhammer.dto.regles.faction.death_guard.death_guard"
      },
      "donnees":[
         
      ],
      "description":"Tir 2 fois pour les armes à tir rapide de type Bolt. La figurine doit être une infanterie ou un terminator.",
      "id":24001,
      "nom":"Salve Malveillante",
      "cleTraduction":"regle.death.guard.salve.malveillante",
      "libelle":"Salve Malveillante"
   },
   {
      "factory":"com.calculateur.warhammer.data.regles.factory.factory.death.guard.RegleAffreusementResistantFactory",
      "ressource":{
         "id":24000,
         "ressource":"com.calculateur.warhammer.dto.regles.faction.death_guard.death_guard"
      },
      "donnees":[
         
      ],
      "description":"Réduit les dégâts des armes de 1.",
      "id":24002,
      "nom":"Affreusement Résistant",
      "cleTraduction":"regle.death.guard.affreusement.resistant",
      "libelle":"Affreusement Résistant"
   }
]

Pour la règle Implacable:

Code:

package com.calculateur.warhammer.data.regles.regle.death.guard;

import com.calculateur.warhammer.data.regles.IRegleDefense;

/**
* Règle Implcable de la Death Guard
* @author phili
*
*/
public class RegleImplacable implements IRegleDefense{

    @Override
    public boolean isIgnoreMalusAttrition() {
        return true;
    }
}

Code:

package com.calculateur.warhammer.data.regles.factory.factory.death.guard;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.IRegleDefense;
import com.calculateur.warhammer.data.regles.factory.donnees.IDonneeFactory;
import com.calculateur.warhammer.data.regles.factory.regle.IFactoryRegle;
import com.calculateur.warhammer.data.regles.regle.death.guard.RegleImplacable;

/**
* Factory Règle Implacable
* @author phili
*
*/
public class RegleImplacableFactory implements IFactoryRegle{

    @Override
    public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
        return null;
    }

    @Override
    public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
        return new RegleImplacable();
    }

    @Override
    public boolean isRegleApplicableAttaque() {
        return false;
    }

    @Override
    public boolean isRegleApplicableDefense() {
        return true;
    }

}

Code:

package com.calculateur.warhammer.data.regles.factory.factory.death.guard;

import static org.junit.jupiter.api.Assertions.fail;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.parallel.Execution;
import org.junit.jupiter.api.parallel.ExecutionMode;
import org.mockito.junit.jupiter.MockitoExtension;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.regles.factory.regle.AbstractFactoryRegleTest;

@Execution(ExecutionMode.SAME_THREAD)
@ExtendWith(MockitoExtension.class)
public class RegleImplacableFactoryTest extends AbstractFactoryRegleTest{

    public RegleImplacableFactoryTest() {
        super(new RegleImplacableFactory());
    }

    @Override
    protected boolean isRegleAttaqueAttendu() {
        return false;
    }

    @Override
    protected boolean isRegleDefenseAttendu() {
        return true;
    }

    @Test
    public void testRegleImplacable() {
        try {
            Assertions.assertThat(factoryRegle.getRegleDefense(donnees).isIgnoreMalusAttrition()).isTrue();
        }catch(FunctionnalExeption e) {
            fail(e);
        }
    }
}

Règle Salves Malveillantes:

Code:

package com.calculateur.warhammer.data.regles.regle.death.guard;

import java.util.Set;

import com.calculateur.warhammer.data.enumeration.EArme;
import com.calculateur.warhammer.data.enumeration.EArmeMotCle;
import com.calculateur.warhammer.data.enumeration.EProfil;
import com.calculateur.warhammer.data.enumeration.EProfilMotCle;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.factory.donnees.IDonneeFactory;

/**
* Règle salve malveillante de la Death Guard
* @author phili
*
*/
public class RegleSalveMalveillante implements IRegleAttaque{

    private final EArme typeArme;
    
    private final Set<EArmeMotCle> motsClesArmes;
    
    private final Set<EProfil> typesProfils;
    
    private final Set<EProfilMotCle> profilsMotsCles;
    
    public RegleSalveMalveillante(IDonneeFactory donnees) {
        typeArme = donnees.getAttaquant().getArme().getType();
        motsClesArmes = donnees.getAttaquant().getArme().getMotsCles();
        typesProfils = donnees.getAttaquant().getProfil().getTypesProfils();
        profilsMotsCles = donnees.getAttaquant().getProfil().getMotsCles();
    }
    
    @Override
    public boolean isMaitriseArmeTirRapide() {
        return isRegleApplicable() && isRegleAppliquee();
    }
    
    private boolean isRegleApplicable() {
        return typeArme == EArme.TIR_RAPIDE && motsClesArmes.contains(EArmeMotCle.BOLT);
    }
    
    private boolean isRegleAppliquee() {
        return typesProfils.contains(EProfil.INFANTERIE) || profilsMotsCles.contains(EProfilMotCle.TERMINATOR);
    }
}

Code:

package com.calculateur.warhammer.data.regles.factory.factory.death.guard;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.IRegleDefense;
import com.calculateur.warhammer.data.regles.factory.donnees.IDonneeFactory;
import com.calculateur.warhammer.data.regles.factory.regle.IFactoryRegle;
import com.calculateur.warhammer.data.regles.regle.death.guard.RegleSalveMalveillante;

/**
* Factory Règle Salve Malveillante de la Death Guard
* @author phili
*
*/
public class RegleSalveMalveillanteFactory implements IFactoryRegle{

    @Override
    public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
        return new RegleSalveMalveillante(donnees);
    }

    @Override
    public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
        return null;
    }

    @Override
    public boolean isRegleApplicableAttaque() {
        return true;
    }

    @Override
    public boolean isRegleApplicableDefense() {
        return false;
    }

}

Code:

package com.calculateur.warhammer.data.regles.factory.factory.death.guard;

import static org.junit.jupiter.api.Assertions.fail;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.parallel.Execution;
import org.junit.jupiter.api.parallel.ExecutionMode;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.enumeration.EArme;
import com.calculateur.warhammer.data.enumeration.EArmeMotCle;
import com.calculateur.warhammer.data.enumeration.EProfil;
import com.calculateur.warhammer.data.enumeration.EProfilMotCle;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.factory.regle.AbstractFactoryRegleTest;

@Execution(ExecutionMode.SAME_THREAD)
@ExtendWith(MockitoExtension.class)
public class RegleSalveMalveillanteFactoryTest extends AbstractFactoryRegleTest{

    public RegleSalveMalveillanteFactoryTest() {
        super(new RegleSalveMalveillanteFactory());
    }

    @Override
    protected boolean isRegleAttaqueAttendu() {
        return true;
    }

    @Override
    protected boolean isRegleDefenseAttendu() {
        return false;
    }

    @Test
    public void testInfanterieBoltTirRapide() {
        testRegle(EProfil.INFANTERIE, null, EArme.TIR_RAPIDE, EArmeMotCle.BOLT, true);
    }
    
    @Test
    public void testInfanterieNonBoltTirRapide() {
        testRegle(EProfil.INFANTERIE, null, EArme.TIR_RAPIDE, null, false);
    }
    
    @Test
    public void testInfanterieBoltLourd() {
        testRegle(EProfil.INFANTERIE, null, EArme.LOURDE, EArmeMotCle.BOLT, false);
    }
    
    @Test
    public void testVehiculeBoltTirRapide() {
        testRegle(EProfil.VEHICULE, null, EArme.TIR_RAPIDE, EArmeMotCle.BOLT, false);
    }
    
    @Test
    public void testVehiculeNonBoltTirRapide() {
        testRegle(EProfil.VEHICULE, null, EArme.TIR_RAPIDE, null, false);
    }
    
    @Test
    public void testVehiculeBoltLouud() {
        testRegle(EProfil.VEHICULE, null, EArme.LOURDE, EArmeMotCle.BOLT, false);
    }
    
    @Test
    public void testTerminatorBoltTirRapide() {
        testRegle(EProfil.PERSONNAGE, EProfilMotCle.TERMINATOR, EArme.TIR_RAPIDE, EArmeMotCle.BOLT, true);
    }
    
    @Test
    public void testTerminatorNonBoltTirRapide() {
        testRegle(EProfil.PERSONNAGE, EProfilMotCle.TERMINATOR, EArme.TIR_RAPIDE, null, false);
    }
    
    @Test
    public void testTerminatorBoltLourd() {
        testRegle(EProfil.PERSONNAGE, EProfilMotCle.TERMINATOR, EArme.LOURDE, EArmeMotCle.BOLT, false);
    }
    
    private void testRegle(EProfil typeProfil,EProfilMotCle profilMotCle,EArme typeArme,EArmeMotCle armeMotCle,boolean attendu) {
        initMocks(typeProfil, profilMotCle, typeArme, armeMotCle);
        try {
            IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
            Assertions.assertThat(regle.isMaitriseArmeTirRapide()).isEqualTo(attendu);
        }catch(FunctionnalExeption e) {
            fail(e);
        }
    }
    
    private void initMocks(EProfil typeProfil,EProfilMotCle profilMotCle,EArme typeArme,EArmeMotCle armeMotCle) {
        Mockito.when(donnees.getAttaquant()).thenReturn(attaquant);
        
        Set<EProfil> typesProfils = new HashSet<>(Arrays.asList(typeProfil));
        Set<EProfilMotCle> profilsMotsCles = new HashSet<>();
        if(profilMotCle != null) {
            profilsMotsCles.add(profilMotCle);
        }
        Mockito.when(attaquant.getProfil()).thenReturn(profil);
        Mockito.when(profil.getTypesProfils()).thenReturn(typesProfils);
        Mockito.when(profil.getMotsCles()).thenReturn(profilsMotsCles);
        
        Set<EArmeMotCle> motsClesArmes = new HashSet<>();
        if(armeMotCle != null) {
            motsClesArmes.add(armeMotCle);
        }
        Mockito.when(attaquant.getArme()).thenReturn(arme);
        Mockito.when(arme.getType()).thenReturn(typeArme);
        Mockito.when(arme.getMotsCles()).thenReturn(motsClesArmes);
    }
}

Et la règle Affreusement Résistant:

Code:

package com.calculateur.warhammer.data.regles.regle.death.guard;

import com.calculateur.warhammer.data.regles.IRegleDefense;

/**
* Règle affreusement résistant (réduit les dégâts de 1, minimum 1).
* @author phili
*
*/
public class RegleAffreusementResistant implements IRegleDefense{

    @Override
    public Integer getMalusDegat() {
        return -1;
    }
}

Code:

package com.calculateur.warhammer.data.regles.factory.factory.death.guard;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.IRegleDefense;
import com.calculateur.warhammer.data.regles.factory.donnees.IDonneeFactory;
import com.calculateur.warhammer.data.regles.factory.regle.IFactoryRegle;
import com.calculateur.warhammer.data.regles.regle.death.guard.RegleAffreusementResistant;

/**
* Factory pour la règle Affreusement résistant
* @author phili
*
*/
public class RegleAffreusementResistantFactory implements IFactoryRegle{

    @Override
    public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
        return null;
    }

    @Override
    public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
        return new RegleAffreusementResistant();
    }

    @Override
    public boolean isRegleApplicableAttaque() {
        return false;
    }

    @Override
    public boolean isRegleApplicableDefense() {
        return true;
    }

}

Code:

package com.calculateur.warhammer.data.regles.factory.factory.death.guard;

import static org.junit.jupiter.api.Assertions.fail;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.parallel.Execution;
import org.junit.jupiter.api.parallel.ExecutionMode;
import org.mockito.junit.jupiter.MockitoExtension;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.regles.IRegleDefense;
import com.calculateur.warhammer.data.regles.factory.regle.AbstractFactoryRegleTest;

@Execution(ExecutionMode.SAME_THREAD)
@ExtendWith(MockitoExtension.class)
public class RegleAffreusementResistantFactoryTest extends AbstractFactoryRegleTest{

    public RegleAffreusementResistantFactoryTest() {
        super(new RegleAffreusementResistantFactory());
    }

    @Override
    protected boolean isRegleAttaqueAttendu() {
        return false;
    }

    @Override
    protected boolean isRegleDefenseAttendu() {
        return true;
    }

    @Test
    public void testRegle() {
        try {
            IRegleDefense regle = factoryRegle.getRegleDefense(donnees);
            Assertions.assertThat(regle.getMalusDegat()).isEqualTo(-1);
        }catch(FunctionnalExeption e) {
            fail(e);
        }
    }
}