16-10-2022, 11:36 AM
Fini les Nécrons. Et ça a été long.
Pour commencer, il faut choisir le protocole de commandement:
Ce qui donne:
Et la directive:
On arrive à:
Protocole de réanimation:
La règle:
La factory:
Et le test:
Règle Protocole de commandement:
Là, c'est le début des emmerdes. Il y en a trop
.
Pour commencer, on met la logique dans l'énumération:
La factory devient donc un décorateur:
Ce qui donne ce TU imbittable:
Pour commencer, il faut choisir le protocole de commandement:
Quote:curl -H "Content-type: application/json" http:/localhost:8080/necron/protocole/all/fr
Ce qui donne:
Code:
[
{
"protocoleCommandementNecron":"PROTOCOLE_GARDIEN_ETERNEL",
"libelle":"Protocole du Gardien Eternel",
"directive1":"Chaque fois qu\u0027une attaque est faite contre cette unité, si cette dernière n\u0027a pas fait de mouvement normal, avancé ou battu en retraite, cette unité a le bénéfice du couvert.",
"directive2":"Chaque fois que l\u0027oin déclare une charge contre cette unité, celle ci peut tenir bon ou préparer sa défense si elle n\u0027est pas en zone d\u0027engagement. Si elle tient bon, alors le tir d\u0027état d\u0027alerte touche sur 5+. Si elle prépare sa défense, alors on ajoute 1 au jet de touche de l\u0027attaque."
},
{
"protocoleCommandementNecron":"PROTOCOLE_TEMPETE_SOUDAINE",
"libelle":"Protocole de la Tempête Soudaine",
"directive1":"Ajouter 1ps à la caractéristique de mouvement.",
"directive2":"Si cette unité fait une action, elle peut tirer sans faire échouer l\u0027action."
},
{
"protocoleCommandementNecron":"PROTOCOLE_ASTRES_VENGEURS",
"libelle":"Protocole des Astres Vengeurs",
"directive1":"Chaque fois qu\u0027une unité fait une attaque de tir, sur un jet non modifié de 6, amélioré la pénétration d\u0027armure de 1.",
"directive2":"Chaque fois qu\u0027une unité tire sur une cible à mi-portée, alors la cible ne bénéficie pas du couvert"
},
{
"protocoleCommandementNecron":"PROTOCOLE_NEANT_AVIDE",
"libelle":"Protocole du Néant Avide",
"directive1":"Si la figurine fait une attaque de mêlée, un jet de touche de 6 non modifié ajoute -1 à la pénétration d\u0027armure.",
"directive2":"Si la figurine fait une attaque de mêlée, et a chargé, été chargé ou effectué une intervention héroîque, ajouter 1 à la force de l\u0027attaque."
},
{
"protocoleCommandementNecron":"PROCOTOLE_LEGIONS_IMPERISSABLES",
"libelle":"Protocole des légions impérissables",
"directive1":"Si la figurine utilise métal organique, récupéré 1 PV en plus.",
"directive2":"Pour un jet de protocole de réanimation, relancé 1 Dé."
},
{
"protocoleCommandementNecron":"PROTOCOLE_TYRAN_CONQUERANT",
"libelle":"Protocole du Tyran Conquérant ",
"directive1":"Ajouté 3 ps à la portée des aptitude d\u0027aura (maximum 12ps).",
"directive2":"Cette unité peut tirer si elle a battu en retraite."
}
]Code:
curl -H "Content-type: application/json" http:/localhost:8080/necron/protocole/applique/all/frCode:
[
{
"protocoleApplique":"AUCUN",
"description":"Aucune directive n\u0027est appliquée.",
"libelle":"Aucun"
},
{
"protocoleApplique":"DIRECTIVE_1",
"description":"La directive 1 est appliquée.",
"libelle":"Directive 1"
},
{
"protocoleApplique":"DIRECTIVE_2",
"description":"La directive 2 est appliquée.",
"libelle":"Directive 2"
},
{
"protocoleApplique":"LES_DEUX",
"description":"Les deux directive sont appliquées.",
"libelle":"Les deux"
}
]On arrive à:
Code:
curl -XPOST -v -d '{"langage":"fr","idCamp":"3","idFaction":"5","idSousFaction":"1","idSousSousFaction":"1"}' -H "Content-type: application/json" http://localhost:8080/regles/parRechercheCode:
[
{
"factory":"com.calculateur.warhammer.data.regles.factory.necron.RegleProtocoleReanimationFactory",
"ressource":{
"id":35000,
"ressource":"com.calculateur.warhammer.dto.regles.faction.necron.necron"
},
"donnees":[
],
"description":"Si on a x figurines mortes avec n points de vies chacune, on lance x * n dés. Sur 5+, on a une réussite. si on a r réussites, on relève r/n (arrondit à l\u0027inférieur) figurines. On peut modifier ce jet entre +1 et -1. ",
"id":35000,
"nom":"Protocole Réanimation Nécron",
"cleTraduction":"regle.protocole.reanimation.necron",
"libelle":"Protocole de réanimation"
},
{
"factory":"com.calculateur.warhammer.data.regles.factory.necron.RegleProtocoleCommandementNecronFactory",
"ressource":{
"id":35000,
"ressource":"com.calculateur.warhammer.dto.regles.faction.necron.necron"
},
"donnees":[
{
"url":"/necron/protocole",
"ressources":{
"id":35000,
"ressource":"com.calculateur.warhammer.dto.regles.faction.necron.necron"
},
"description":"Le protocole de Commandement nécron sélectionné pour ce tour.",
"id":35000,
"nom":"protocole.commandement.necron",
"cleTraduction":"donnee.protocole.necron",
"libelle":"Protocole Nécron"
},
{
"url":"/necron/protocole/applique",
"ressources":{
"id":35000,
"ressource":"com.calculateur.warhammer.dto.regles.faction.necron.necron"
},
"description":"La directive appliquée pour le protocole Nécron.",
"id":35001,
"nom":"protocole.commandement.necron.applique",
"cleTraduction":"donnee.directive.necron",
"libelle":"Directive"
}
],
"description":"Les Protocoles de commandement Nécron.",
"id":35001,
"nom":"Protocole Commandement Nécron",
"cleTraduction":"regle.protocole.commandement.necron",
"libelle":"Protocole de commandement Nécron"
}
]La règle:
Code:
package com.calculateur.warhammer.data.regles.regle.necron;
import java.util.HashSet;
import java.util.Set;
import com.calculateur.warhammer.data.enumeration.EProfilMotCle;
import com.calculateur.warhammer.data.regles.IRegleDefense;
/**
* Implémentation de la règle protocole de réanimation
* @author phili
*
*/
public class RegleProtocoleReanimation implements IRegleDefense{
private final Set<EProfilMotCle> motsCles;
public RegleProtocoleReanimation(Set<EProfilMotCle> motsCles) {
this.motsCles = motsCles;
}
@Override
public Integer getJetSeReleve() {
return 5;
}
@Override
public Set<Integer> getRelancesSeReleve() {
Set<Integer> sReturn = new HashSet<>();
if(motsCles.contains(EProfilMotCle.GUERRIER_NECRON)) {
sReturn.add(1);
}
return sReturn;
}
}Code:
package com.calculateur.warhammer.data.regles.factory.necron;
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.necron.RegleProtocoleReanimation;
/**
* Factory de la règle protocole de réanimation
* @author phili
*
*/
public class RegleProtocoleReanimationFactory implements IFactoryRegle{
@Override
public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
return null;
}
@Override
public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
return new RegleProtocoleReanimation(donnees.getDefenseur().getProfil().getMotsCles());
}
@Override
public boolean isRegleApplicableAttaque() {
return false;
}
@Override
public boolean isRegleApplicableDefense() {
return true;
}
}Code:
package com.calculateur.warhammer.data.regles.factory.necron;
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.EProfilMotCle;
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 RegleProtocoleReanimationFactoryTest extends AbstractFactoryRegleTest{
public RegleProtocoleReanimationFactoryTest() {
super(new RegleProtocoleReanimationFactory());
}
@Override
protected boolean isRegleAttaqueAttendu() {
return false;
}
@Override
protected boolean isRegleDefenseAttendu() {
return true;
}
@Test
public void testRegleGuerrierNecron() {
testRegle(true);
}
@Test
public void testRegleNecronGeneral() {
testRegle(false);
}
private void testRegle(boolean isGuerrierNecron) {
try {
initMock(isGuerrierNecron);
IRegleDefense regle = factoryRegle.getRegleDefense(donnees);
validateRegle(regle, isGuerrierNecron);
}catch(FunctionnalExeption e) {
fail(e);
}
}
private void initMock(boolean isGuerrierNecron) {
Mockito.when(donnees.getDefenseur()).thenReturn(defenseur);
Mockito.when(defenseur.getProfil()).thenReturn(profil);
Set<EProfilMotCle> motsCles = new HashSet<>();
if(isGuerrierNecron) {
motsCles.add(EProfilMotCle.GUERRIER_NECRON);
}
Mockito.when(profil.getMotsCles()).thenReturn(motsCles);
}
private void validateRegle(IRegleDefense regle, boolean isGuerrierNecron) {
Assertions.assertThat(regle.getJetSeReleve()).isEqualTo(5);
if(isGuerrierNecron) {
Set<Integer> set = new HashSet<>(Arrays.asList(1));
Assertions.assertThat(regle.getRelancesSeReleve()).isEqualTo(set);
}else {
Assertions.assertThat(regle.getRelancesSeReleve()).isEmpty();
}
}
}Règle Protocole de commandement:
Là, c'est le début des emmerdes. Il y en a trop
.Pour commencer, on met la logique dans l'énumération:
Code:
package com.calculateur.warhammer.data.regles.regle.necron;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.enumeration.EMouvement;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.ArmeUtils;
import com.calculateur.warhammer.data.identifiable.IArmeDeTir;
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;
public enum EProtocoleCommandementNecron implements IFactoryRegle{
PROTOCOLE_GARDIEN_ETERNEL(1){
@Override
public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleAttaque() {
@Override
public Integer getJetToucheTirContreCharge() {
return isDirective2(donnees, true)?5:6;
}
@Override
public Integer getBonusJetTouche() {
boolean isBonus = isDirective2(donnees, true) && !donnees.getContexteAction().isAttaquantAFaitTirDeContreCharge()
&& donnees.getContexteAction().getSimule() == ESimule.CORPS_A_CORPS_APRES_CHARGE;
return isBonus?-1:0;
}
};
}
@Override
public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleDefense() {
@Override
public boolean isSauvegardeCouvert() {
return isDirective1(donnees,false) && donnees.getContexteAction().getMouvementDefenseur() == EMouvement.IMMOBILE;
}
};
}
},
PROTOCOLE_TEMPETE_SOUDAINE(2){
@Override
public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleAttaque() {
@Override
public Integer getBonusMouvement() {
return isDirective1(donnees, true)?1:0;
}
};
}
@Override
public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleDefense() {};
}
},
PROTOCOLE_ASTRES_VENGEURS(3){
@Override
public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleAttaque() {
@Override
public Map<Integer,Integer> getMapJetBlessureBonusPA() {
Map<Integer, Integer> mapReturn = new HashMap<>();
if(isDirective1(donnees,true) && donnees.getContexteAction().getSimule().isActionTir()) {
mapReturn.put(6, -1);
}
return mapReturn;
}
@Override
public boolean isIgnoreSauvegardeCouvert() {
boolean isDirective2 = isDirective2(donnees, true);
boolean isMiPortee = false;
if(ArmeUtils.isArmeTir(donnees.getAttaquant().getArme())) {
IArmeDeTir armeTir = ArmeUtils.getArmeDeTir(donnees.getAttaquant().getArme());
isMiPortee = donnees.getContexteAction().getDistanceEntreBelligerant().intValue() <= (armeTir.getPorteeMaximale() / 2);
}
return isDirective2 && isMiPortee;
}
};
}
@Override
public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleDefense() {};
}
},
PROTOCOLE_NEANT_AVIDE(4){
@Override
public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleAttaque() {
@Override
public Map<Integer,Integer> getMapJetBlessureBonusPA() {
Map<Integer, Integer> mapReturn = new HashMap<>();
if(isDirective1(donnees,true) && donnees.getContexteAction().getSimule().isActionCorpACorp()) {
mapReturn.put(6, -1);
}
return mapReturn;
}
@Override
public Integer getBonusForceAttaque() {
return isDirective2(donnees,true) &&
donnees.getContexteAction().getSimule().isAChargeOuSubbitCharge()?1:0;
}
};
}
@Override
public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleDefense() {};
}
},
PROCOTOLE_LEGIONS_IMPERISSABLES(5){
@Override
public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleAttaque() {};
}
@Override
public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleDefense() {};
}
},
PROTOCOLE_TYRAN_CONQUERANT(6){
@Override
public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleAttaque() {
@Override
public boolean isPeutTirerApresRetraite() {
return isDirective2(donnees, true);
}
@Override
public Integer getBonusJetTouche() {
//Certes, il peut tirer quand il fait un mouvement de retraite, mais il a un malus de +1 au jet.
boolean isDirective2 = isDirective2(donnees, true);
boolean isMouvementRetraite = donnees.getContexteAction().getMouvementAttaquant() == EMouvement.RETRAITE;
boolean isTir = donnees.getContexteAction().getSimule() == ESimule.TIR_PHASE_TIR;
boolean isRegle = isDirective2 && isMouvementRetraite && isTir;
return isRegle?1:0;
}
};
}
@Override
public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
return new IRegleDefense() {};
}
};
public static final String ID_MAP_PROTOCOLE_COMMANDEMENT = "protocole.commandement.necron";
private final Integer idProtocole;
private EProtocoleCommandementNecron(Integer idProtocole) {
this.idProtocole = idProtocole;
}
public Integer getIdProtocole() {
return idProtocole;
}
public static EProtocoleCommandementNecron getById(Integer id) {
Optional<EProtocoleCommandementNecron> o = Arrays.asList(EProtocoleCommandementNecron.values()).stream().filter(p -> p.getIdProtocole().equals(id)).findFirst();
return o.isPresent()?o.get():null;
}
@Override
public boolean isRegleApplicableAttaque() {
return true;
}
@Override
public boolean isRegleApplicableDefense() {
return true;
}
private static boolean isDirective1(IDonneeFactory donnee,boolean isAttaquant) {
EProtocoleCommandementNecronApplique protocoleApplique= getProtocoleApplique(donnee,isAttaquant);
return protocoleApplique == EProtocoleCommandementNecronApplique.DIRECTIVE_1 || protocoleApplique == EProtocoleCommandementNecronApplique.LES_DEUX;
}
private static boolean isDirective2(IDonneeFactory donnee,boolean isAttaquant) {
EProtocoleCommandementNecronApplique protocoleApplique= getProtocoleApplique(donnee,isAttaquant);
return protocoleApplique == EProtocoleCommandementNecronApplique.DIRECTIVE_2 || protocoleApplique == EProtocoleCommandementNecronApplique.LES_DEUX;
}
private static EProtocoleCommandementNecronApplique getProtocoleApplique(IDonneeFactory donnee,boolean isAttaquant) {
return isAttaquant?
EProtocoleCommandementNecronApplique.getById(donnee.getDonneesAttaquant().get(EProtocoleCommandementNecronApplique.ID_MAP_PROTOCOLE_COMMANDEMENT_APPLIQUE)):
EProtocoleCommandementNecronApplique.getById(donnee.getDonneesDefenseur().get(EProtocoleCommandementNecronApplique.ID_MAP_PROTOCOLE_COMMANDEMENT_APPLIQUE));
}
}La factory devient donc un décorateur:
Code:
package com.calculateur.warhammer.data.regles.factory.necron;
import java.util.Arrays;
import java.util.Map;
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.necron.EProtocoleCommandementNecron;
import com.calculateur.warhammer.data.regles.regle.necron.EProtocoleCommandementNecronApplique;
/**
* Factory de la règle Protocole de commandement Nécron
* @author phili
*
*/
public class RegleProtocoleCommandementNecronFactory implements IFactoryRegle{
private static final String RES = "com.calculateur.warhammer.data.regles.factory.regle.necron.necron";
@Override
public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
return getProtocole(donnees.getDonneesAttaquant()).getRegleAttaque(donnees);
}
@Override
public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
return getProtocole(donnees.getDonneesDefenseur()).getRegleDefense(donnees);
}
@Override
public boolean isRegleApplicableAttaque() {
return true;
}
@Override
public boolean isRegleApplicableDefense() {
return true;
}
private EProtocoleCommandementNecron getProtocole(Map<String, Integer> mapDonnees) throws FunctionnalExeption{
if(!mapDonnees.containsKey(EProtocoleCommandementNecron.ID_MAP_PROTOCOLE_COMMANDEMENT)) {
throw new FunctionnalExeption(Arrays.asList("necron.protocol.presence"), RES);
}
EProtocoleCommandementNecron protocole =EProtocoleCommandementNecron.getById(mapDonnees.get(EProtocoleCommandementNecron.ID_MAP_PROTOCOLE_COMMANDEMENT));
if(protocole == null) {
throw new FunctionnalExeption(Arrays.asList("necron.protocol.null"), RES);
}
if(!mapDonnees.containsKey(EProtocoleCommandementNecronApplique.ID_MAP_PROTOCOLE_COMMANDEMENT_APPLIQUE)) {
throw new FunctionnalExeption(Arrays.asList("necron.protocol.appliquee.presence"), RES);
}
EProtocoleCommandementNecronApplique directive = EProtocoleCommandementNecronApplique.getById(mapDonnees.get(
EProtocoleCommandementNecronApplique.ID_MAP_PROTOCOLE_COMMANDEMENT_APPLIQUE));
if(directive == null) {
throw new FunctionnalExeption(Arrays.asList("necron.protocol.applique.null"), RES);
}
return protocole;
}
}Code:
package com.calculateur.warhammer.data.regles.factory.necron;
import static org.junit.jupiter.api.Assertions.fail;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.enumeration.EMouvement;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.IArmeDeCorpsACorps;
import com.calculateur.warhammer.data.identifiable.IArmeDeTir;
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.necron.EProtocoleCommandementNecron;
import com.calculateur.warhammer.data.regles.regle.necron.EProtocoleCommandementNecronApplique;
@Execution(ExecutionMode.SAME_THREAD)
@ExtendWith(MockitoExtension.class)
public class RegleProtocoleCommandementNecronFactoryTest extends AbstractFactoryRegleTest{
@Mock
private IArmeDeTir armeDeTir;
@Mock
private IArmeDeCorpsACorps armeMelee;
public RegleProtocoleCommandementNecronFactoryTest() {
super(new RegleProtocoleCommandementNecronFactory());
}
@Override
protected boolean isRegleAttaqueAttendu() {
return true;
}
@Override
protected boolean isRegleDefenseAttendu() {
return true;
}
@Test
public void testProtocoleMauvaisAttaque() {
try {
parameters.clear();
parameters.put(EProtocoleCommandementNecron.ID_MAP_PROTOCOLE_COMMANDEMENT, -1);
Mockito.when(donnees.getDonneesAttaquant()).thenReturn(parameters);
factoryRegle.getRegleAttaque(donnees);
fail();
}catch(FunctionnalExeption e) {
validateFunctionnalException(e);
}
}
@Test
public void testProtocoleAbsentAttaque() {
try {
parameters.clear();
Mockito.when(donnees.getDonneesAttaquant()).thenReturn(parameters);
factoryRegle.getRegleAttaque(donnees);
fail();
}catch(FunctionnalExeption e) {
validateFunctionnalException(e);
}
}
@Test
public void testProtocoleAppliqueMauvaisAttaque() {
try {
parameters.clear();
parameters.put(EProtocoleCommandementNecron.ID_MAP_PROTOCOLE_COMMANDEMENT, EProtocoleCommandementNecron.PROCOTOLE_LEGIONS_IMPERISSABLES.getIdProtocole());
parameters.put(EProtocoleCommandementNecronApplique.ID_MAP_PROTOCOLE_COMMANDEMENT_APPLIQUE, -1);
Mockito.when(donnees.getDonneesAttaquant()).thenReturn(parameters);
factoryRegle.getRegleAttaque(donnees);
fail();
}catch(FunctionnalExeption e) {
validateFunctionnalException(e);
}
}
@Test
public void testProtocoleAppliqueAbsentAttaque() {
try {
parameters.clear();
parameters.put(EProtocoleCommandementNecron.ID_MAP_PROTOCOLE_COMMANDEMENT, EProtocoleCommandementNecron.PROCOTOLE_LEGIONS_IMPERISSABLES.getIdProtocole());
Mockito.when(donnees.getDonneesAttaquant()).thenReturn(parameters);
factoryRegle.getRegleAttaque(donnees);
fail();
}catch(FunctionnalExeption e) {
validateFunctionnalException(e);
}
}
public void testProtocoleMauvaisDefense() {
try {
parameters.clear();
parameters.put(EProtocoleCommandementNecron.ID_MAP_PROTOCOLE_COMMANDEMENT, -1);
Mockito.when(donnees.getDonneesDefenseur()).thenReturn(parameters);
factoryRegle.getRegleDefense(donnees);
fail();
}catch(FunctionnalExeption e) {
validateFunctionnalException(e);
}
}
@Test
public void testProtocoleAbsentDefense() {
try {
parameters.clear();
Mockito.when(donnees.getDonneesDefenseur()).thenReturn(parameters);
factoryRegle.getRegleDefense(donnees);
fail();
}catch(FunctionnalExeption e) {
validateFunctionnalException(e);
}
}
@Test
public void testProtocoleAppliqueAbsentDefense() {
try {
parameters.put(EProtocoleCommandementNecron.ID_MAP_PROTOCOLE_COMMANDEMENT, EProtocoleCommandementNecron.PROCOTOLE_LEGIONS_IMPERISSABLES.getIdProtocole());
parameters.clear();
Mockito.when(donnees.getDonneesDefenseur()).thenReturn(parameters);
factoryRegle.getRegleDefense(donnees);
fail();
}catch(FunctionnalExeption e) {
validateFunctionnalException(e);
}
}
public void testProtocoleAppliqueMauvaisDefense() {
try {
parameters.clear();
parameters.put(EProtocoleCommandementNecron.ID_MAP_PROTOCOLE_COMMANDEMENT, EProtocoleCommandementNecron.PROCOTOLE_LEGIONS_IMPERISSABLES.getIdProtocole());
parameters.put(EProtocoleCommandementNecron.ID_MAP_PROTOCOLE_COMMANDEMENT, EProtocoleCommandementNecron.PROCOTOLE_LEGIONS_IMPERISSABLES.getIdProtocole());
Mockito.when(donnees.getDonneesDefenseur()).thenReturn(parameters);
factoryRegle.getRegleDefense(donnees);
fail();
}catch(FunctionnalExeption e) {
validateFunctionnalException(e);
}
}
//Règle en Attaque
@Test
public void testRegleAttaqueProtocoleGardienEternelDirective1Tir() throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_GARDIEN_ETERNEL, directive);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
boolean isDirective2 = directive == EProtocoleCommandementNecronApplique.LES_DEUX;
Assertions.assertThat(regle.getJetToucheTirContreCharge()).isEqualTo(isDirective2?5:6);
}
}
@Test
public void testRegleAttaqueProtocoleGardienEternelDirective2Tir() throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective2()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_GARDIEN_ETERNEL, directive);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.getJetToucheTirContreCharge()).isEqualTo(5);
}
}
@Test
public void testRegleAttaqueProtocoleGardienEternelDirective1Melee() throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
for(ESimule simule:ESimule.values()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_GARDIEN_ETERNEL, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getSimule()).thenReturn(simule);
Mockito.when(contexteAction.isAttaquantAFaitTirDeContreCharge()).thenReturn(false);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
boolean isDirective2 = directive == EProtocoleCommandementNecronApplique.LES_DEUX;
boolean isReponseCharge = simule == ESimule.CORPS_A_CORPS_APRES_CHARGE;
Assertions.assertThat(regle.getBonusJetTouche())
.isEqualTo((isDirective2 && isReponseCharge)?-1:0);
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_GARDIEN_ETERNEL, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.isAttaquantAFaitTirDeContreCharge()).thenReturn(true);
regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.getBonusJetTouche()).isZero();
}
}
}
@Test
public void testRegleAttaqueProtocoleGardienEternelDirective2Melee() throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective2()) {
for(ESimule simule:ESimule.values()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_GARDIEN_ETERNEL, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getSimule()).thenReturn(simule);
Mockito.when(contexteAction.isAttaquantAFaitTirDeContreCharge()).thenReturn(false);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
boolean isReponseCharge = simule == ESimule.CORPS_A_CORPS_APRES_CHARGE;
Assertions.assertThat(regle.getBonusJetTouche()).isEqualTo((isReponseCharge)?-1:0);
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_GARDIEN_ETERNEL, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.isAttaquantAFaitTirDeContreCharge()).thenReturn(true);
regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.getBonusJetTouche()).isZero();
}
}
}
@Test
public void testRegleDefenseProtocoleGardienEternelDirective1Immobile() throws FunctionnalExeption {
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
initMockDefense(EProtocoleCommandementNecron.PROTOCOLE_GARDIEN_ETERNEL, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getMouvementDefenseur()).thenReturn(EMouvement.IMMOBILE);
IRegleDefense regle = factoryRegle.getRegleDefense(donnees);
Assertions.assertThat(regle.isSauvegardeCouvert()).isTrue();
}
}
@Test
public void testRegleDefenseProtocoleGardienEternelDirective1Mouvement() throws FunctionnalExeption {
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
initMockDefense(EProtocoleCommandementNecron.PROTOCOLE_GARDIEN_ETERNEL, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getMouvementDefenseur()).thenReturn(EMouvement.NORMAL);
IRegleDefense regle = factoryRegle.getRegleDefense(donnees);
Assertions.assertThat(regle.isSauvegardeCouvert()).isFalse();
}
}
@Test
public void testRegleAttaqueProtocoleTempeteSoudaineDirective1() throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_TEMPETE_SOUDAINE, directive);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.getBonusMouvement()).isEqualTo(1);
}
}
@Test
public void testRegleAttaqueProtocoleTempeteSoudaineDirective2() throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective2()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_TEMPETE_SOUDAINE, directive);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.getBonusMouvement())
.isEqualTo((directive == EProtocoleCommandementNecronApplique.LES_DEUX)?
1:0);
}
}
@Test
public void testRegleProtocoleAstreVengeurDirective1AmeliorationPA() throws FunctionnalExeption {
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
for(ESimule simule:ESimule.values()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_ASTRES_VENGEURS, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getSimule()).thenReturn(simule);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Map<Integer, Integer> mapAmeliorationPA = new HashMap<>();
if(simule.isActionTir()) {
mapAmeliorationPA.put(6, -1);
}
Assertions.assertThat(regle.getMapJetBlessureBonusPA()).isEqualTo(mapAmeliorationPA);
}
}
}
@Test
public void testRegleProtocoleAstreVengeurDirective2AmeliorationPA() throws FunctionnalExeption {
for(EProtocoleCommandementNecronApplique directive:getListDirective2()) {
for(ESimule simule:ESimule.values()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_ASTRES_VENGEURS, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getSimule()).thenReturn(simule);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Map<Integer, Integer> mapAmeliorationPA = new HashMap<>();
if(simule.isActionTir() && directive == EProtocoleCommandementNecronApplique.LES_DEUX) {
mapAmeliorationPA.put(6, -1);
}
Assertions.assertThat(regle.getMapJetBlessureBonusPA()).isEqualTo(mapAmeliorationPA);
}
}
}
@Test
public void testRegleProtocoleAstreVengeurDirective1IgnoreSauvegardeCouvertMelee() throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_ASTRES_VENGEURS, directive);
Mockito.when(donnees.getAttaquant()).thenReturn(attaquant);
Mockito.when(attaquant.getArme()).thenReturn(armeMelee);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.isIgnoreSauvegardeCouvert()).isFalse();
}
}
@Test
public void testRegleProtocoleAstreVengeurDirective2IgnoreSauvegardeCouvertMelee() throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective2()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_ASTRES_VENGEURS, directive);
Mockito.when(donnees.getAttaquant()).thenReturn(attaquant);
Mockito.when(attaquant.getArme()).thenReturn(armeMelee);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.isIgnoreSauvegardeCouvert()).isFalse();
}
}
@Test
public void testRegleProtocoleAstreVengeurDirective1IgnoreSauvegardeCouvertTirLonguePortee()throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_ASTRES_VENGEURS, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getDistanceEntreBelligerant()).thenReturn(17.0);
Mockito.when(donnees.getAttaquant()).thenReturn(attaquant);
Mockito.when(attaquant.getArme()).thenReturn(armeDeTir);
Mockito.when(armeDeTir.getPorteeMaximale()).thenReturn(30);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.isIgnoreSauvegardeCouvert()).isFalse();
}
}
@Test
public void testRegleProtocoleAstreVengeurDirective2IgnoreSauvegardeCouvertTirLonguePortee()throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective2()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_ASTRES_VENGEURS, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getDistanceEntreBelligerant()).thenReturn(17.0);
Mockito.when(donnees.getAttaquant()).thenReturn(attaquant);
Mockito.when(attaquant.getArme()).thenReturn(armeDeTir);
Mockito.when(armeDeTir.getPorteeMaximale()).thenReturn(30);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.isIgnoreSauvegardeCouvert()).isFalse();
}
}
@Test
public void testRegleProtocoleAstreVengeurDirective1IgnoreSauvegardeCouvertTirMiPortee()throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_ASTRES_VENGEURS, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getDistanceEntreBelligerant()).thenReturn(8.0);
Mockito.when(donnees.getAttaquant()).thenReturn(attaquant);
Mockito.when(attaquant.getArme()).thenReturn(armeDeTir);
Mockito.when(armeDeTir.getPorteeMaximale()).thenReturn(30);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.isIgnoreSauvegardeCouvert())
.isEqualTo(directive == EProtocoleCommandementNecronApplique.LES_DEUX);
}
}
@Test
public void testRegleProtocoleAstreVengeurDirective2IgnoreSauvegardeCouvertTirMiPortee()throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective2()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_ASTRES_VENGEURS, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getDistanceEntreBelligerant()).thenReturn(8.0);
Mockito.when(donnees.getAttaquant()).thenReturn(attaquant);
Mockito.when(attaquant.getArme()).thenReturn(armeDeTir);
Mockito.when(armeDeTir.getPorteeMaximale()).thenReturn(30);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.isIgnoreSauvegardeCouvert()).isTrue();
}
}
@Test
public void testRegleProtocoleNeantAvideDirective1AmeliorationPA() throws FunctionnalExeption {
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
for(ESimule simule:ESimule.values()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_NEANT_AVIDE, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getSimule()).thenReturn(simule);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Map<Integer, Integer> mapAmeliorationPA = new HashMap<>();
if(simule.isActionCorpACorp()) {
mapAmeliorationPA.put(6, -1);
}
Assertions.assertThat(regle.getMapJetBlessureBonusPA()).isEqualTo(mapAmeliorationPA);
}
}
}
@Test
public void testRegleProtocoleNeantAvideDirective2AmeliorationPA() throws FunctionnalExeption {
for(EProtocoleCommandementNecronApplique directive:getListDirective2()) {
for(ESimule simule:ESimule.values()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_NEANT_AVIDE, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getSimule()).thenReturn(simule);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Map<Integer, Integer> mapAmeliorationPA = new HashMap<>();
if(simule.isActionCorpACorp() && directive == EProtocoleCommandementNecronApplique.LES_DEUX) {
mapAmeliorationPA.put(6, -1);
}
Assertions.assertThat(regle.getMapJetBlessureBonusPA()).isEqualTo(mapAmeliorationPA);
}
}
}
@Test
public void testRegleProtocoleNeantAvideDirective1()throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
for(ESimule simule:ESimule.values()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_NEANT_AVIDE, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getSimule()).thenReturn(simule);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
boolean isCharge = simule.isAChargeOuSubbitCharge();
boolean isDirective2 = directive == EProtocoleCommandementNecronApplique.LES_DEUX;
Integer bonusForce = (isCharge && isDirective2)?1:0;
Assertions.assertThat(regle.getBonusForceAttaque()).isEqualTo(bonusForce);
}
}
}
@Test
public void testRegleProtocoleNeantAvideDirective2()throws FunctionnalExeption{
for(EProtocoleCommandementNecronApplique directive:getListDirective2()) {
for(ESimule simule:ESimule.values()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_NEANT_AVIDE, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getSimule()).thenReturn(simule);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
boolean isCharge = simule.isAChargeOuSubbitCharge();
Integer bonusForce = (isCharge)?1:0;
Assertions.assertThat(regle.getBonusForceAttaque()).isEqualTo(bonusForce);
}
}
}
@Test
public void testRegleTyranConquerantDirective1() throws FunctionnalExeption {
for(EProtocoleCommandementNecronApplique directive:getListDirective1()) {
for(EMouvement mouvement:EMouvement.values()) {
for(ESimule simule:ESimule.values()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_TYRAN_CONQUERANT, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getMouvementAttaquant()).thenReturn(mouvement);
Mockito.when(contexteAction.getSimule()).thenReturn(simule);
boolean isDirective2 = directive == EProtocoleCommandementNecronApplique.LES_DEUX;
boolean isTirApresRetraite = mouvement == EMouvement.RETRAITE;
boolean isRegle = isDirective2 && isTirApresRetraite && simule == ESimule.TIR_PHASE_TIR;
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.isPeutTirerApresRetraite()).isEqualTo(isDirective2);
Assertions.assertThat(regle.getBonusJetTouche()).isEqualTo(isRegle?1:0);
}
}
}
}
@Test
public void testRegleTyranConquerantDirective2() throws FunctionnalExeption {
for(EProtocoleCommandementNecronApplique directive:getListDirective2()) {
for(EMouvement mouvement:EMouvement.values()) {
for(ESimule simule:ESimule.values()) {
initMockAttaque(EProtocoleCommandementNecron.PROTOCOLE_TYRAN_CONQUERANT, directive);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getMouvementAttaquant()).thenReturn(mouvement);
Mockito.when(contexteAction.getSimule()).thenReturn(simule);
boolean isTirApresRetraite = mouvement == EMouvement.RETRAITE;
boolean isRegle = isTirApresRetraite && simule == ESimule.TIR_PHASE_TIR;
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
Assertions.assertThat(regle.isPeutTirerApresRetraite()).isTrue();
Assertions.assertThat(regle.getBonusJetTouche()).isEqualTo(isRegle?1:0);
}
}
}
}
private void initMockAttaque(EProtocoleCommandementNecron protocole,EProtocoleCommandementNecronApplique directive) {
parameters.clear();
parameters.put(EProtocoleCommandementNecron.ID_MAP_PROTOCOLE_COMMANDEMENT, protocole.getIdProtocole());
parameters.put(EProtocoleCommandementNecronApplique.ID_MAP_PROTOCOLE_COMMANDEMENT_APPLIQUE, directive.getIdProtocoleApplique());
Mockito.when(donnees.getDonneesAttaquant()).thenReturn(parameters);
}
private void initMockDefense(EProtocoleCommandementNecron protocole,EProtocoleCommandementNecronApplique directive) {
parameters.clear();
parameters.put(EProtocoleCommandementNecron.ID_MAP_PROTOCOLE_COMMANDEMENT, protocole.getIdProtocole());
parameters.put(EProtocoleCommandementNecronApplique.ID_MAP_PROTOCOLE_COMMANDEMENT_APPLIQUE, directive.getIdProtocoleApplique());
Mockito.when(donnees.getDonneesDefenseur()).thenReturn(parameters);
}
private List<EProtocoleCommandementNecronApplique> getListDirective1(){
return Arrays.asList(EProtocoleCommandementNecronApplique.DIRECTIVE_1,EProtocoleCommandementNecronApplique.LES_DEUX);
}
private List<EProtocoleCommandementNecronApplique> getListDirective2(){
return Arrays.asList(EProtocoleCommandementNecronApplique.DIRECTIVE_2,EProtocoleCommandementNecronApplique.LES_DEUX);
}
}