Forum du Mamarland › Autres Loisirs › Warhammer 40K v
Projet Calculateur

Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
Linear Mode
Projet Calculateur
Philou Offline
Posting Freak
*****
Posts: 3,458
Threads: 126
Joined: Jun 2003
Reputation: 1
#8
24-10-2022, 01:08 PM
Finit les Orks. Et avec la dernière FAQ.
J'ai même innové. Pour les règles, j'ai fait les tests avant l'implémentation (TDD).


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

Code:
[
   {
      "factory":"com.calculateur.warhammer.data.regles.factory.ork.RegleAttaqueOrkFactory",
      "ressource":{
         "id":38000,
         "ressource":"com.calculateur.warhammer.dto.regles.faction.ork.ork"
      },
      "donnees":[
         {
            "url":"/ork/attaque",
            "ressources":{
               "id":38000,
               "ressource":"com.calculateur.warhammer.dto.regles.faction.ork.ork"
            },
            "description":"A choisir entre WAAAAGH,ZIWAAAGH et rien.",
            "id":38000,
            "nom":"attaque.ork",
            "cleTraduction":"donnee.attaque.ork",
            "libelle":"Le type d\u0027attaque Ork en cours"
         },
         {
            "url":"/ork/attaque",
            "ressources":{
               "id":38000,
               "ressource":"com.calculateur.warhammer.dto.regles.faction.ork.ork"
            },
            "description":"A choisir entre le stade 1 ou 2.",
            "id":38001,
            "nom":"phase.attaque.ork",
            "cleTraduction":"donnee.phase.attaque.ork",
            "libelle":"Stade de l\u0027attaque Ork."
         }
      ],
      "description":"A choisir entre WAAAAGH,ZIWAAAGH et rien.",
      "id":38000,
      "nom":"WAAAGH/ZYWAAAGH Ork",
      "cleTraduction":"regle.attaque.ork",
      "libelle":"Le type d\u0027attaque Ork en cours"
   },
   {
      "factory":"com.calculateur.warhammer.data.regles.factory.ork.RegleBrinquebalantFactory",
      "ressource":{
         "id":38000,
         "ressource":"com.calculateur.warhammer.dto.regles.faction.ork.ork"
      },
      "donnees":[
         
      ],
      "description":"Les véhicule Ork réduisent les dégâts de 1 (minimum 1).",
      "id":38001,
      "nom":"Brinquelant",
      "cleTraduction":"regle.brinquebalant",
      "libelle":"Brinquebalant"
   },
   {
      "factory":"com.calculateur.warhammer.data.regles.factory.ork.RegleAlpagueurFactory",
      "ressource":{
         "id":38000,
         "ressource":"com.calculateur.warhammer.dto.regles.faction.ork.ork"
      },
      "donnees":[
         
      ],
      "description":"Ajoutez 1 au jet de touche contre les véhicule ou les monstres. Sauvegarde invulnérable de 6+.",
      "id":38002,
      "nom":"Alpagueur",
      "cleTraduction":"regle.alpagueur",
      "libelle":"Alpagueur"
   }
]

Pour Brinquebalant:
Code:
package com.calculateur.warhammer.data.regles.regle.ork;

import java.util.Set;

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

/**
* Implémentation règle Brinquebalant (-1 aux dégâts pour les véhicule non titanesque)
* @author phili
*
*/
public class RegleBrinquebalant implements IRegleDefense{

    
    private final Set<EProfil> typesProfils;

    public RegleBrinquebalant(Set<EProfil> typesProfils) {
        super();
        this.typesProfils = typesProfils;
    }
    
    @Override
    public Integer getMalusDegat() {
        return (typesProfils.contains(EProfil.VEHICULE) && !typesProfils.contains(EProfil.TITANESQUE))?-1:0 ;
    }
    
}


Code:
package com.calculateur.warhammer.data.regles.factory.ork;

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.ork.RegleBrinquebalant;

/**
* Factory de la règle Brinquelant
* @author phili
*
*/
public class RegleBrinquebalantFactory implements IFactoryRegle{

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

    @Override
    public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
        return new RegleBrinquebalant(donnees.getDefenseur().getProfil().getTypesProfils());
    }

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

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

}

Code:
package com.calculateur.warhammer.data.regles.factory.ork;

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

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;

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.EProfil;
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 RegleBrinquebalantFactoryTest extends AbstractFactoryRegleTest{

    public RegleBrinquebalantFactoryTest() {
        super(new RegleBrinquebalantFactory());
    }

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

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

    @Test
    public void testRegleInfanterie() {
        testRegleDefense(Arrays.asList(EProfil.INFANTERIE));
    }
    
    @Test
    public void testRegleVehicule() {
        testRegleDefense(Arrays.asList(EProfil.VEHICULE));
    }
    
    @Test
    public void testRegleVehiculeTitanesque() {
        testRegleDefense(Arrays.asList(EProfil.VEHICULE,EProfil.TITANESQUE));
    }
    
    private void testRegleDefense(List<EProfil> typesProfils) {
        try {
            initMockDefense(typesProfils);
            IRegleDefense regle = factoryRegle.getRegleDefense(donnees);
            validateRegleDefense(regle, typesProfils);
        }catch(FunctionnalExeption e) {
            fail(e);
        }
    }
    
    private void initMockDefense(List<EProfil> typesProfils) {
        Mockito.when(donnees.getDefenseur()).thenReturn(defenseur);
        Mockito.when(defenseur.getProfil()).thenReturn(profil);
        Mockito.when(profil.getTypesProfils()).thenReturn(new HashSet<>(typesProfils));
    }
    
    private void validateRegleDefense(IRegleDefense regle,List<EProfil> typesProfils) {
        Integer reductionDegats = (typesProfils.contains(EProfil.VEHICULE) && !typesProfils.contains(EProfil.TITANESQUE))?
                -1:0;
        Assertions.assertThat(regle.getMalusDegat()).isEqualTo(reductionDegats);
    }
}


Pour Alpagueur:
Un peu plus difficile, il y en a en défense et en attaque.
Code:
package com.calculateur.warhammer.data.regles.regle.ork;

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

/**
* La règle Alpagueur en Attaque. En l'occurence, +1 au jet de touche si la cible est un véhicule ou un monstre
* @author phili
*
*/
public class RegleAlpagueurAttaque implements IRegleAttaque{

    private final boolean isRegleApplicable;
    
    public RegleAlpagueurAttaque(boolean isAlpagueur,boolean isVehiculeOuMonstre) {
        isRegleApplicable = isAlpagueur && isVehiculeOuMonstre;
    }
    
    @Override
    public Integer getBonusJetTouche() {
        return isRegleApplicable?-1:0;
    }
}

Code:
package com.calculateur.warhammer.data.regles.regle.ork;

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

/**
* Règle Alpagueur en défense, à savoir sauvegarde invulnérable à 6+.
* @author phili
*
*/
public class RegleAlpagueurDefense implements IRegleDefense{

    private final boolean isAlpagueur;
    
    public RegleAlpagueurDefense(boolean isAlpagueur) {
        this.isAlpagueur = isAlpagueur;
    }
    
    @Override
    public Integer getSauvegardeInvulnerable() {
        return isAlpagueur?6:0;
    }
}

Code:
package com.calculateur.warhammer.data.regles.factory.ork;

import java.util.Set;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
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.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.ork.RegleAlpagueurAttaque;
import com.calculateur.warhammer.data.regles.regle.ork.RegleAlpagueurDefense;

/**
* Factory de la règle Alpagueur
* @author phili
*
*/
public class RegleAlpagueurFactory implements IFactoryRegle{

    @Override
    public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
        return new RegleAlpagueurAttaque(
                isAlpagueur(donnees.getAttaquant().getProfil().getMotsCles()),
                    isVehiculeOuMonstre(donnees.getDefenseur().getProfil().getTypesProfils()));
    }

    @Override
    public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
        return new RegleAlpagueurDefense(isAlpagueur(donnees.getDefenseur().getProfil().getMotsCles()));
    }

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

    @Override
    public boolean isRegleApplicableDefense() {
        return true;
    }
    
    private boolean isAlpagueur(Set<EProfilMotCle> motsCles) {
        return motsCles.contains(EProfilMotCle.ALPAGUEUR);
    }

    private boolean isVehiculeOuMonstre(Set<EProfil> types) {
        return types.contains(EProfil.VEHICULE) || types.contains(EProfil.MONSTRE);
    }
}

Pour la WAAAGH:
Là, ça a été complexe. J'ai même innové en utilisant les classes scellé, qui énumèrent les classes filles attendues.
Il n'y a que la WAAAGH et la ZYWAAAGH.

Pour l'attaque:
Code:
package com.calculateur.warhammer.data.regles.regle.ork;

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

/**
* Une classe pour touts les assauts Orks
* @author phili
*
*/
public sealed class RegleAttaqueOrkAttaque implements IRegleAttaque permits RegleWaaaghAttaque,RegleZywaaaghAttaque{

    protected final EPhaseAttaqueOrk stade;

    public RegleAttaqueOrkAttaque(EPhaseAttaqueOrk stade) {
        this.stade = stade;
    }
}

Code:
package com.calculateur.warhammer.data.regles.regle.ork;

import com.calculateur.warhammer.data.enumeration.EMouvement;

/**
* Règle d'attaque pour une WAAAGH Ork
* @author phili
*
*/
public final class RegleWaaaghAttaque extends RegleAttaqueOrkAttaque{

    private final boolean isBaseOuPersonnage;
    
    public RegleWaaaghAttaque(EPhaseAttaqueOrk stade,boolean isBaseOuPersonnage) {
        super(stade);
        this.isBaseOuPersonnage = isBaseOuPersonnage;
    }
    
    @Override
    public boolean isChargeApresTypeMouvement(EMouvement mouvement) {
        return super.isChargeApresTypeMouvement(mouvement)
                || (stade == EPhaseAttaqueOrk.PHASE_1 && mouvement == EMouvement.ADVANCE && isBaseOuPersonnage);
    }
    
    @Override
    public Integer getBonusForce() {
        return 1;
    }
    
    @Override
    public Integer getBonusNombreAttaque() {
        return 1;
    }
}

Code:
package com.calculateur.warhammer.data.regles.regle.ork;

import com.calculateur.warhammer.data.enumeration.EArme;
import com.calculateur.warhammer.data.enumeration.EMouvement;

/**
* Classe pour la règle Zywaaagh
* @author phili
*
*/
public final class RegleZywaaaghAttaque extends RegleAttaqueOrkAttaque{

    private final boolean isVehiculeOuMoto;
    private final EArme typeArme;
    
    public RegleZywaaaghAttaque(EPhaseAttaqueOrk stade,boolean isVehiculeOuMoto,EArme typeArme) {
        super(stade);
        this.isVehiculeOuMoto = isVehiculeOuMoto;
        this.typeArme = typeArme;
    }

    @Override
    public boolean isIgnoreMalusMouvementAuTir(EMouvement mouvement) {
        return super.isIgnoreMalusMouvementAuTir(mouvement) ||
                (mouvement == EMouvement.ADVANCE && stade ==  EPhaseAttaqueOrk.PHASE_1 && typeArme == EArme.ASSAUT);
    }
    
    @Override
    public Integer getBonusAttaqueArme(EArme aTypeArme) {
        return (stade == EPhaseAttaqueOrk.PHASE_1 && isVehiculeOuMoto && aTypeArme == EArme.DAKA)?1:0;
    }
    
    @Override
    public Integer getBonusPA() {
        return (isVehiculeOuMoto && typeArme != EArme.CORPS_A_CORPS)?-1:0;
    }
}
Heuresement qu'en défense, il n'y a que WAAAGH:
Code:
package com.calculateur.warhammer.data.regles.regle.ork;

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

/**
* Règle Waaagh en défense
* @author phili
*
*/
public class RegleWaaaghDefense implements IRegleDefense{
    
    private final EPhaseAttaqueOrk stade;

    public RegleWaaaghDefense(EPhaseAttaqueOrk stade) {
        super();
        this.stade = stade;
    }
    
    @Override
    public Integer getSauvegardeInvulnerable() {
        return stade == EPhaseAttaqueOrk.PHASE_1?5:6;
    }
}
Soit la Factory:
Code:
package com.calculateur.warhammer.data.regles.factory.ork;

import java.util.Arrays;
import java.util.Map;
import java.util.Set;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.enumeration.EProfil;
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.ork.EAttaqueOrk;
import com.calculateur.warhammer.data.regles.regle.ork.EPhaseAttaqueOrk;
import com.calculateur.warhammer.data.regles.regle.ork.RegleWaaaghAttaque;
import com.calculateur.warhammer.data.regles.regle.ork.RegleWaaaghDefense;
import com.calculateur.warhammer.data.regles.regle.ork.RegleZywaaaghAttaque;

/**
* Une factory pour les différentes WAAAGH des orks
* @author phili
*
*/
public class RegleAttaqueOrkFactory implements IFactoryRegle{

    private static final String RES = "com.calculateur.warhammer.data.regles.factory.regle.ork.ork";
    
    private static final String KEY_ERROR_ATTAQUE_NULL = "attaque.ork.null";
    private static final String KEY_ERROR_ATTAQUE_INEXISTANT = "attaque.ork.inexistant";
    
    private static final String KEY_ERROR_PHASE_ATTAQUE_NULL = "phase.attaque.ork.null";
    private static final String KEY_ERROR_PHASE_ATTAQUE_INEXISTANT = "phase.attaque.ork.inexistant";
    
    @Override
    public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
        Map<String,Integer> map = donnees.getDonneesAttaquant();
        EAttaqueOrk typeWaaagh = getAttaqueOrk(map);
        EPhaseAttaqueOrk stade = getStade(map);
        
        Set<EProfil> profils = donnees.getAttaquant().getProfil().getTypesProfils();
        boolean isBaseOuPersonnage = profils.contains(EProfil.BASE) || profils.contains(EProfil.PERSONNAGE);
        boolean isVehiculeOuMoto = profils.contains(EProfil.VEHICULE) || profils.contains(EProfil.MOTO);
        return switch (typeWaaagh) {
            case WAAAGH: yield new RegleWaaaghAttaque(stade, isBaseOuPersonnage);
            case ZYWAAAGH: yield new RegleZywaaaghAttaque(stade, isVehiculeOuMoto, donnees.getAttaquant().getArme().getType());
            default: yield new IRegleAttaque() {};
        };
    }

    @Override
    public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
        Map<String,Integer> map = donnees.getDonneesDefenseur();
        EAttaqueOrk typeWaaagh = getAttaqueOrk(map);
        EPhaseAttaqueOrk stade = getStade(map);
        return switch (typeWaaagh) {
            case WAAAGH: yield new RegleWaaaghDefense(stade);
            default: yield new IRegleDefense() {};
        };
    }

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

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

    private EAttaqueOrk getAttaqueOrk(Map<String,Integer> map) throws FunctionnalExeption{
        if(!map.containsKey(EAttaqueOrk.ID_MAP_ATTAQUE_ORK)) {
            throw new FunctionnalExeption(Arrays.asList(KEY_ERROR_ATTAQUE_NULL), RES);
        }
        EAttaqueOrk aReturn = EAttaqueOrk.getById(map.get(EAttaqueOrk.ID_MAP_ATTAQUE_ORK));
        if(aReturn == null) {
            throw new FunctionnalExeption(Arrays.asList(KEY_ERROR_ATTAQUE_INEXISTANT), RES);
        }
        return aReturn;
    }
    
    private EPhaseAttaqueOrk getStade(Map<String,Integer> map)throws FunctionnalExeption{
        if(!map.containsKey(EPhaseAttaqueOrk.ID_MAP_PHASE_ATTAQUE_ORK)) {
            throw new FunctionnalExeption(Arrays.asList(KEY_ERROR_PHASE_ATTAQUE_NULL), RES);
        }
        EPhaseAttaqueOrk sReturn = EPhaseAttaqueOrk.getById(map.get(EPhaseAttaqueOrk.ID_MAP_PHASE_ATTAQUE_ORK));
        if(sReturn == null) {
            throw new FunctionnalExeption(Arrays.asList(KEY_ERROR_PHASE_ATTAQUE_INEXISTANT), RES);
        }
        return sReturn;
    }
}
Et le test suivant:
Code:
package com.calculateur.warhammer.data.regles.factory.ork;

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.EMouvement;
import com.calculateur.warhammer.data.enumeration.EProfil;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.IRegleDefense;
import com.calculateur.warhammer.data.regles.factory.regle.AbstractFactoryRegleTest;
import com.calculateur.warhammer.data.regles.regle.ork.EAttaqueOrk;
import com.calculateur.warhammer.data.regles.regle.ork.EPhaseAttaqueOrk;

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

    public RegleAttaqueOrkFactoryTest() {
        super(new RegleAttaqueOrkFactory());
    }

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

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

    @Test
    public void testAttaqueOrkAbsentPourAttaque() {
        try {
            parameters.clear();
            Mockito.when(donnees.getDonneesAttaquant()).thenReturn(parameters);
            factoryRegle.getRegleAttaque(donnees);
            fail();
        }catch(FunctionnalExeption e) {
            validateFunctionnalException(e);
        }
    }
    
    @Test
    public void testAttaqueOrkInexistantePourAttaque() {
        try {
            parameters.clear();
            parameters.put(EAttaqueOrk.ID_MAP_ATTAQUE_ORK, -1);
            Mockito.when(donnees.getDonneesAttaquant()).thenReturn(parameters);
            factoryRegle.getRegleAttaque(donnees);
            fail();
        }catch(FunctionnalExeption e) {
            validateFunctionnalException(e);
        }
    }
    
    @Test
    public void testStadeAttaqueOrkAbsentEnAttaque() {
        try {
            parameters.clear();
            parameters.put(EAttaqueOrk.ID_MAP_ATTAQUE_ORK, EAttaqueOrk.WAAAGH.getIdAttaqueOrk());
            Mockito.when(donnees.getDonneesAttaquant()).thenReturn(parameters);
            factoryRegle.getRegleAttaque(donnees);
            fail();
        }catch(FunctionnalExeption e) {
            validateFunctionnalException(e);
        }
    }
    
    @Test
    public void testStadeAttaqueOrkInexistantEnAttaque() {
        try {
            parameters.clear();
            parameters.put(EAttaqueOrk.ID_MAP_ATTAQUE_ORK, EAttaqueOrk.WAAAGH.getIdAttaqueOrk());
            parameters.put(EPhaseAttaqueOrk.ID_MAP_PHASE_ATTAQUE_ORK, -1);
            Mockito.when(donnees.getDonneesAttaquant()).thenReturn(parameters);
            factoryRegle.getRegleAttaque(donnees);
            fail();
        }catch(FunctionnalExeption e) {
            validateFunctionnalException(e);
        }
    }
    
    @Test
    public void testAttaqueOrkAbsentPourDefense() {
        try {
            parameters.clear();
            Mockito.when(donnees.getDonneesDefenseur()).thenReturn(parameters);
            factoryRegle.getRegleDefense(donnees);
            fail();
        }catch(FunctionnalExeption e) {
            validateFunctionnalException(e);
        }
    }
    
    @Test
    public void testAttaqueOrkInexistantePourDefense() {
        try {
            parameters.clear();
            parameters.put(EAttaqueOrk.ID_MAP_ATTAQUE_ORK, -1);
            Mockito.when(donnees.getDonneesDefenseur()).thenReturn(parameters);
            factoryRegle.getRegleDefense(donnees);
            fail();
        }catch(FunctionnalExeption e) {
            validateFunctionnalException(e);
        }
    }
    
    @Test
    public void testStadeAttaqueOrkAbsentEnDefense() {
        try {
            parameters.clear();
            parameters.put(EAttaqueOrk.ID_MAP_ATTAQUE_ORK, EAttaqueOrk.WAAAGH.getIdAttaqueOrk());
            Mockito.when(donnees.getDonneesDefenseur()).thenReturn(parameters);
            factoryRegle.getRegleDefense(donnees);
            fail();
        }catch(FunctionnalExeption e) {
            validateFunctionnalException(e);
        }
    }
    
    @Test
    public void testStadeAttaqueOrkInexistantEnDefense() {
        try {
            parameters.clear();
            parameters.put(EAttaqueOrk.ID_MAP_ATTAQUE_ORK, EAttaqueOrk.WAAAGH.getIdAttaqueOrk());
            parameters.put(EPhaseAttaqueOrk.ID_MAP_PHASE_ATTAQUE_ORK, -1);
            Mockito.when(donnees.getDonneesDefenseur()).thenReturn(parameters);
            factoryRegle.getRegleDefense(donnees);
            fail();
        }catch(FunctionnalExeption e) {
            validateFunctionnalException(e);
        }
    }
    
    @Test
    public void testRegleAttaqueChargeApresMouvement() throws FunctionnalExeption{
        for(EMouvement mouvement:EMouvement.values()) {
            for(EProfil typeProfil:EProfil.values()) {
                testRegleAttaqueChargeApresMouvement(mouvement, typeProfil);
            }
        }
    }
    
    private void testRegleAttaqueChargeApresMouvement(EMouvement mouvement,EProfil typeProfil) throws FunctionnalExeption{
        boolean isChargeApresMouvement = Arrays.asList(EMouvement.IMMOBILE,EMouvement.NORMAL).contains(mouvement);
        boolean isChargeApresAdvance;
        IRegleAttaque regle;
        for(EAttaqueOrk typeWaaagh:EAttaqueOrk.values()) {
            for(EPhaseAttaqueOrk stade:EPhaseAttaqueOrk.values()) {
                initMockAttaque(typeWaaagh, stade, typeProfil);
                regle = factoryRegle.getRegleAttaque(donnees);
                isChargeApresAdvance = typeWaaagh == EAttaqueOrk.WAAAGH
                        && stade == EPhaseAttaqueOrk.PHASE_1
                            &&mouvement == EMouvement.ADVANCE
                                && Arrays.asList(EProfil.BASE,EProfil.PERSONNAGE).contains(typeProfil);
                Assertions.assertThat(regle.isChargeApresTypeMouvement(mouvement)).isEqualTo(
                        isChargeApresMouvement || isChargeApresAdvance);
            }
        }
    }
    
    @Test
    public void testBonusAttaqueEtForce() throws FunctionnalExeption{
        for(EProfil typeProfil:EProfil.values()) {
            testBonusAttaqueEtForce(typeProfil);
        }
    }
    
    private void testBonusAttaqueEtForce(EProfil typeProfil) throws FunctionnalExeption{
        boolean isBonus;
        Integer bonus;
        IRegleAttaque regle;
        for(EAttaqueOrk typeWaaagh:EAttaqueOrk.values()) {
            for(EPhaseAttaqueOrk stade:EPhaseAttaqueOrk.values()) {
                initMockAttaque(typeWaaagh, stade, typeProfil);
                regle = factoryRegle.getRegleAttaque(donnees);
                isBonus = typeWaaagh == EAttaqueOrk.WAAAGH;
                bonus = isBonus?1:0;
                Assertions.assertThat(regle.getBonusNombreAttaque()).isEqualTo(bonus);
                Assertions.assertThat(regle.getBonusForce()).isEqualTo(bonus);
            }
        }
    }
    
    @Test
    public void testRegleIgnoreMalusAvecArmeAssaut()throws FunctionnalExeption{
        for(EArme typeArme:EArme.values()) {
            for(EProfil typeProfil: EProfil.values()) {
                testRegleIgnoreMalusAvecArmeAssaut(typeArme, typeProfil);
            }
        }
    }
    
    private void testRegleIgnoreMalusAvecArmeAssaut(EArme typeArme,EProfil typeProfil)throws FunctionnalExeption{
        IRegleAttaque regle;
        boolean isIgnoreMalusAdvance;
        for(EAttaqueOrk typeWaaagh:EAttaqueOrk.values()) {
            for(EPhaseAttaqueOrk stade:EPhaseAttaqueOrk.values()) {
                initMockAttaque(typeWaaagh, stade, typeProfil);
                if(typeWaaagh == EAttaqueOrk.ZYWAAAGH) {
                    Mockito.when(arme.getType()).thenReturn(typeArme);
                }
                
                regle = factoryRegle.getRegleAttaque(donnees);
                
                isIgnoreMalusAdvance = typeWaaagh == EAttaqueOrk.ZYWAAAGH
                        && stade == EPhaseAttaqueOrk.PHASE_1
                            && typeArme == EArme.ASSAUT;
                
                Assertions.assertThat(regle.isIgnoreMalusMouvementAuTir(EMouvement.ADVANCE)).isEqualTo(isIgnoreMalusAdvance);
            }
        }        
    }
    
    @Test
    public void testRegleBonusAttaque() throws FunctionnalExeption{
        for(EArme typeArme:EArme.values()) {
            for(EProfil typeProfil:EProfil.values()) {
                testRegleBonusAttaque(typeArme, typeProfil);
            }
        }
    }
    
    private void testRegleBonusAttaque(EArme typeArme,EProfil typeProfil) throws FunctionnalExeption{
        IRegleAttaque regle;
        boolean isBonus;
        Integer bonus;
        for(EAttaqueOrk typeWaaagh:EAttaqueOrk.values()) {
            for(EPhaseAttaqueOrk stade:EPhaseAttaqueOrk.values()) {
                initMockAttaque(typeWaaagh, stade, typeProfil);
                if(typeWaaagh == EAttaqueOrk.ZYWAAAGH) {
                    Mockito.when(arme.getType()).thenReturn(typeArme);
                }
                
                regle = factoryRegle.getRegleAttaque(donnees);
                
                isBonus = typeWaaagh == EAttaqueOrk.ZYWAAAGH
                            && stade == EPhaseAttaqueOrk.PHASE_1
                                && typeArme == EArme.DAKA
                                    && Arrays.asList(EProfil.VEHICULE,EProfil.MOTO).contains(typeProfil);
                
                bonus = isBonus?1:0;
                Assertions.assertThat(regle.getBonusAttaqueArme(typeArme)).isEqualTo(bonus);
            }
        }
    }
    
    @Test
    public void testRegleBonusPA() throws FunctionnalExeption{
        for(EArme typeArme:EArme.values()) {
            for(EProfil typeProfil:EProfil.values()) {
                testRegleBonusPA(typeArme, typeProfil);
            }
        }
    }
    
    private void testRegleBonusPA(EArme typeArme,EProfil typeProfil) throws FunctionnalExeption{
        IRegleAttaque regle;
        boolean isBonus;
        Integer bonus;
        for(EAttaqueOrk typeWaaagh:EAttaqueOrk.values()) {
            for(EPhaseAttaqueOrk stade:EPhaseAttaqueOrk.values()) {
                initMockAttaque(typeWaaagh, stade, typeProfil);
                if(typeWaaagh == EAttaqueOrk.ZYWAAAGH) {
                    Mockito.when(arme.getType()).thenReturn(typeArme);
                }
                
                regle = factoryRegle.getRegleAttaque(donnees);
                isBonus = typeWaaagh == EAttaqueOrk.ZYWAAAGH
                        && typeArme != EArme.CORPS_A_CORPS
                            && Arrays.asList(EProfil.VEHICULE,EProfil.MOTO).contains(typeProfil);
                bonus = isBonus?-1:0;
                
                Assertions.assertThat(regle.getBonusPA()).isEqualTo(bonus);
            }
        }
    }
    
    private void initMockAttaque(EAttaqueOrk typeWaaagh,EPhaseAttaqueOrk stade,EProfil typeProfil) {
        parameters.clear();
        parameters.put(EAttaqueOrk.ID_MAP_ATTAQUE_ORK, typeWaaagh.getIdAttaqueOrk());
        parameters.put(EPhaseAttaqueOrk.ID_MAP_PHASE_ATTAQUE_ORK, stade.getIdPhase());
        Mockito.when(donnees.getDonneesAttaquant()).thenReturn(parameters);
        
        Mockito.when(donnees.getAttaquant()).thenReturn(attaquant);
        Mockito.when(attaquant.getProfil()).thenReturn(profil);
        Set<EProfil> types = new HashSet<>(Arrays.asList(typeProfil));
        Mockito.when(profil.getTypesProfils()).thenReturn(types);
        
        if(typeWaaagh != EAttaqueOrk.AUCUN) {
            Mockito.when(attaquant.getArme()).thenReturn(arme);
        }
    }
    
    @Test
    public void testSauvegardeInvulnerable() throws FunctionnalExeption{
        for(EAttaqueOrk typeWaaagh:EAttaqueOrk.values()) {
            for(EPhaseAttaqueOrk stade:EPhaseAttaqueOrk.values()) {
                testSauvegardeInvulnerable(typeWaaagh, stade);
            }
        }
    }
    
    private void testSauvegardeInvulnerable(EAttaqueOrk typeWaaagh,EPhaseAttaqueOrk stade) throws FunctionnalExeption{
        initMockDefense(typeWaaagh, stade);
        IRegleDefense regle = factoryRegle.getRegleDefense(donnees);
        Integer sauvegarde;
        if(typeWaaagh == EAttaqueOrk.WAAAGH) {
            sauvegarde = stade == EPhaseAttaqueOrk.PHASE_1?5:6;
        }else {
            sauvegarde = 0;
        }
        Assertions.assertThat(regle.getSauvegardeInvulnerable()).isEqualTo(sauvegarde);
    }
    
    private void initMockDefense(EAttaqueOrk typeWaaagh,EPhaseAttaqueOrk stade) {
        parameters.clear();
        parameters.put(EAttaqueOrk.ID_MAP_ATTAQUE_ORK, typeWaaagh.getIdAttaqueOrk());
        parameters.put(EPhaseAttaqueOrk.ID_MAP_PHASE_ATTAQUE_ORK, stade.getIdPhase());
        Mockito.when(donnees.getDonneesDefenseur()).thenReturn(parameters);
    }
}
Find
Reply


Messages In This Thread
Projet Calculateur - by Philou - 12-09-2022, 09:47 AM
RE: Projet Calculateur - by Philou - 12-09-2022, 09:52 AM
RE: Projet Calculateur - by Philou - 17-09-2022, 09:14 PM
RE: Projet Calculateur - by Philou - 25-09-2022, 07:26 AM
RE: Projet Calculateur - by Philou - 25-09-2022, 08:54 AM
RE: Projet Calculateur - by Philou - 03-10-2022, 10:54 AM
RE: Projet Calculateur - by Philou - 16-10-2022, 11:36 AM
RE: Projet Calculateur - by Philou - 24-10-2022, 01:08 PM
RE: Projet Calculateur - by Philou - 25-10-2022, 09:52 AM
RE: Projet Calculateur - by sdm - 25-10-2022, 11:06 PM
RE: Projet Calculateur - by Philou - 25-10-2022, 11:23 PM
RE: Projet Calculateur - by Philou - 26-10-2022, 03:09 PM
RE: Projet Calculateur - by Philou - 25-10-2022, 11:25 PM
RE: Projet Calculateur - by Philou - 06-11-2022, 05:27 PM
RE: Projet Calculateur - by Philou - 19-11-2022, 10:36 AM
RE: Projet Calculateur - by Philou - 23-11-2022, 08:34 AM
RE: Projet Calculateur - by Philou - 24-11-2022, 08:49 PM
RE: Projet Calculateur - by Philou - 04-12-2022, 06:57 PM
RE: Projet Calculateur - by Philou - 11-12-2022, 12:11 PM
RE: Projet Calculateur - by Philou - 18-12-2022, 06:47 PM
RE: Projet Calculateur - by Philou - 19-12-2022, 09:05 PM
RE: Projet Calculateur - by Philou - 03-01-2023, 09:34 PM
RE: Projet Calculateur - by Philou - 07-01-2023, 06:36 PM
RE: Projet Calculateur - by Philou - 01-02-2023, 08:21 PM
RE: Projet Calculateur - by Philou - 16-02-2023, 08:31 PM
RE: Projet Calculateur - by Gaeriel - 17-02-2023, 10:56 PM
RE: Projet Calculateur - by Philou - 17-02-2023, 11:32 PM
RE: Projet Calculateur - by Philou - 05-03-2023, 05:45 PM
RE: Projet Calculateur - by Philou - 06-03-2023, 08:55 PM
RE: Projet Calculateur - by Philou - 08-03-2023, 08:28 PM
RE: Projet Calculateur - by Philou - 12-03-2023, 07:56 AM
RE: Projet Calculateur - by Philou - 23-03-2023, 06:44 PM
RE: Projet Calculateur - by Philou - 28-03-2023, 08:58 PM
RE: Projet Calculateur - by Philou - 27-04-2023, 08:05 PM
RE: Projet Calculateur - by Philou - 30-04-2023, 10:29 AM
RE: Projet Calculateur - by Philou - 02-05-2023, 08:03 AM
RE: Projet Calculateur - by Philou - 19-05-2023, 11:36 AM
RE: Projet Calculateur - by Philou - 19-05-2023, 05:44 PM
RE: Projet Calculateur - by Philou - 20-05-2023, 09:10 PM
RE: Projet Calculateur - by Philou - 22-06-2023, 07:38 AM
RE: Projet Calculateur - by Philou - 24-06-2023, 07:09 AM
RE: Projet Calculateur - by Philou - 26-06-2023, 07:44 PM
RE: Projet Calculateur - by Philou - 28-06-2023, 07:09 AM
RE: Projet Calculateur - by Philou - 28-06-2023, 07:43 PM
RE: Projet Calculateur - by Philou - 30-06-2023, 07:22 PM
RE: Projet Calculateur - by Philou - 08-08-2023, 07:54 PM
RE: Projet Calculateur - by Philou - 19-08-2023, 10:30 AM
RE: Projet Calculateur - by Philou - 19-08-2023, 06:20 PM
RE: Projet Calculateur - by Philou - 20-08-2023, 10:17 AM
RE: Projet Calculateur - by Philou - 22-01-2024, 09:02 PM
RE: Projet Calculateur - by Philou - 09-05-2024, 10:21 AM
RE: Projet Calculateur - by Philou - 11-05-2024, 05:41 PM
RE: Projet Calculateur - by Philou - 25-05-2024, 08:41 AM
RE: Projet Calculateur - by Philou - 24-04-2025, 04:09 PM

Forum Jump:


Users browsing this thread: 1 Guest(s)