Posts: 3,439
Threads: 126
Joined: Jun 2003
Reputation:
1
Délire, j'ai même fait les règles de tir indirect, ce qui a été ... facile 
Code: package com.calculateur.warhammer.data.regles;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.utils.ModificateursUtils;
/**
* Règle du défenseur pour le tir indirect.
* @author phili
*
*/
public class RegleTirIndirect implements IRegleDefense{
private final boolean isDefense;
public RegleTirIndirect(ESimule simule, boolean isTirIndirect) {
isDefense = isTirIndirect && simule == ESimule.TIR_PHASE_TIR;
}
@Override
public boolean isSauvegardeCouvert() {
return isDefense;
}
@Override
public Integer getMalusJetTouche() {
return isDefense?ModificateursUtils.MALUS_BASE_JET:ModificateursUtils.NO_BONUS;
}
}
Posts: 3,439
Threads: 126
Joined: Jun 2003
Reputation:
1
On commence à s'intéresser au Terminator. Ce qui est laborieux, il touche sur 2+ lorsqu'il y a un serment de l'instant en jeu (grâce à la règle colère de l'élite...).
Code: package com.calculateur.warhammer.calcul.mort.arbre.calcul;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.math3.fraction.Fraction;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.calcul.mort.arbre.ENatureNoeud;
import com.calculateur.warhammer.calcul.mort.arbre.INoeudArbre;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.space.marine.TerminatorBuilderAttaque;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.tyranide.TermagantBuilderDefense;
import com.calculateur.warhammer.calcul.mort.arbre.data.DataCalculProbabiliteBuilder;
import com.calculateur.warhammer.calcul.mort.arbre.data.IDataCalculProbabilite;
import com.calculateur.warhammer.calcul.test.utils.FractionCheminBuilder;
import com.calculateur.warhammer.data.action.IContexteAction;
import com.calculateur.warhammer.data.enumeration.EBlessure;
import com.calculateur.warhammer.data.enumeration.EGestionDe;
import com.calculateur.warhammer.data.enumeration.EMouvement;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.batiment.RecordBatiment;
import com.calculateur.warhammer.data.regles.detachement.space.marine.ESermentInstantChoix;
import com.calculateur.warhammer.data.unite.IConstituantAttaquant;
import com.calculateur.warhammer.data.unite.IConstituantDefenseur;
public class TerminatorSpaceMarineVsTermagauntTest extends AbstractCalculArbreTest{
@Test
public void testTerminatorBolterStorm10psPasSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.NON, 10.0), getAttenduAttaqueFulgurantSansRelance(), 12);
valideTestsBolterStorm(racine, 1);
}
@Test
public void testTerminatorBolterStorm12psPasSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.NON, 12.0), getAttenduAttaqueFulgurantSansRelance(), 12);
valideTestsBolterStorm(racine, 1);
}
@Test
public void testTerminatorBolterStorm118psPasSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.NON, 18.0), getAttenduAttaqueFulgurantSansRelance(), 6);
valideTestsBolterStorm(racine, 1);
}
private Fraction getAttenduAttaqueFulgurantSansRelance() {
Fraction probaTouche = new Fraction(2,3);
Fraction probaBlesse = new Fraction(2,3);
Fraction probaRateSauvegarde = new Fraction(2,3);
return FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
}
@Test
public void testTerminatorBolterStorm10psSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.OUI, 10.0), getAttenduAttaqueFulgurantAvecRelance(), 22);
valideTestsBolterStorm(racine, 4);
}
@Test
public void testTerminatorBolterStorm12psSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.OUI, 12.0), getAttenduAttaqueFulgurantAvecRelance(), 22);
valideTestsBolterStorm(racine, 4);
}
@Test
public void testTerminatorBolterStorm118psSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.OUI, 18.0), getAttenduAttaqueFulgurantAvecRelance(), 11);
valideTestsBolterStorm(racine, 4);
}
private Fraction getAttenduAttaqueFulgurantAvecRelance() {
Fraction probaTouche = new Fraction(5,6);
Fraction probaRateTouche = new Fraction(1,6);
Fraction probaBlesse = new Fraction(2,3);
Fraction probaRateBlesse = new Fraction(1,3);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin3 = FractionCheminBuilder.getInstance().addFraction(probaTouche)
.addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin4 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
return chemin1.add(chemin2).add(chemin3).add(chemin4);
}
private void valideTestsBolterStorm(INoeudArbre racine,int nombreNoeudReussite) {
int trouve = 0;
Map<EBlessure, Integer> mAttendu = new HashMap<>();
mAttendu.put(EBlessure.NORMALES, 1);
for(INoeudArbre noeud:racine.arbre()) {
if(noeud.getNatureNoeud() == ENatureNoeud.REUSSITE) {
trouve++;
Assertions.assertThat(noeud.mapBlessuresAleatoires()).isEmpty();
Map<EBlessure, Integer> map = noeud.mapBlessure();
Assertions.assertThat(map).isEqualTo(mAttendu);
}
}
Assertions.assertThat(trouve).isEqualTo(nombreNoeudReussite);
}
private IDataCalculProbabilite getDataBolterStorm(ESermentInstantChoix sermentInstant,Double distanceBelligerants) {
IContexteAction contextAction = ContextActionForTestProbaBuilder.getInstance()
.addSimule(ESimule.TIR_PHASE_TIR)
.addNumeroTour(2)
.addEffectifInitialAttaquant(10)
.addNombreAttaquant(10)
.addMouvementAttaquant(EMouvement.IMMOBILE)
.addBatimentAttaquant(new RecordBatiment(false, false))
.addNombreDefenseur(10)
.addMouvementDefenseur(EMouvement.IMMOBILE)
.addBatimentDefenseur(new RecordBatiment(false, false))
.addDistanceEntreBelligerant(distanceBelligerants)
.build();
IConstituantDefenseur termagaunt = TermagantBuilderDefense.getInstance(contextAction, 10).build();
IConstituantAttaquant terminator = TerminatorBuilderAttaque.getInstance(contextAction, 10).addSermentInstant(sermentInstant).build();
return DataCalculProbabiliteBuilder.getInstance().addAttaquant(terminator).addDefenseur(termagaunt).addContextAction(contextAction)
.addGestionNombreAttaque(EGestionDe.SIMULATION_OPTIMISTE).addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE).addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE).build();
}
}
Posts: 3,439
Threads: 126
Joined: Jun 2003
Reputation:
1
Bon, on a fini le termi qui tire . Le faire tirer au canon d'assaut (qui en plus est une arme classe) permet d'ajouter les blessures mortelles dans l'arbre de probabilité.
Code: package com.calculateur.warhammer.calcul.mort.arbre.calcul;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.math3.fraction.Fraction;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.calcul.mort.arbre.ENatureNoeud;
import com.calculateur.warhammer.calcul.mort.arbre.INoeudArbre;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.space.marine.TerminatorBuilderAttaque;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.tyranide.TermagantBuilderDefense;
import com.calculateur.warhammer.calcul.mort.arbre.data.DataCalculProbabiliteBuilder;
import com.calculateur.warhammer.calcul.mort.arbre.data.IDataCalculProbabilite;
import com.calculateur.warhammer.calcul.test.utils.FractionCheminBuilder;
import com.calculateur.warhammer.data.action.IContexteAction;
import com.calculateur.warhammer.data.enumeration.EBlessure;
import com.calculateur.warhammer.data.enumeration.EGestionDe;
import com.calculateur.warhammer.data.enumeration.EMouvement;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.batiment.RecordBatiment;
import com.calculateur.warhammer.data.regles.detachement.space.marine.ESermentInstantChoix;
import com.calculateur.warhammer.data.unite.IConstituantAttaquant;
import com.calculateur.warhammer.data.unite.IConstituantDefenseur;
public class TerminatorSpaceMarineVsTermagauntTest extends AbstractCalculArbreTest{
@Test
public void testTerminatorBolterStorm10psPasSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.NON, 10.0), getAttenduAttaqueFulgurantSansRelance(), 12);
valideTestsBolterStorm(racine, 1);
}
@Test
public void testTerminatorBolterStorm12psPasSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.NON, 12.0), getAttenduAttaqueFulgurantSansRelance(), 12);
valideTestsBolterStorm(racine, 1);
}
@Test
public void testTerminatorBolterStorm118psPasSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.NON, 18.0), getAttenduAttaqueFulgurantSansRelance(), 6);
valideTestsBolterStorm(racine, 1);
}
private Fraction getAttenduAttaqueFulgurantSansRelance() {
Fraction probaTouche = new Fraction(2,3);
Fraction probaBlesse = new Fraction(2,3);
Fraction probaRateSauvegarde = new Fraction(2,3);
return FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
}
@Test
public void testTerminatorBolterStorm10psSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.OUI, 10.0), getAttenduAttaqueFulgurantAvecRelance(), 22);
valideTestsBolterStorm(racine, 4);
}
@Test
public void testTerminatorBolterStorm12psSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.OUI, 12.0), getAttenduAttaqueFulgurantAvecRelance(), 22);
valideTestsBolterStorm(racine, 4);
}
@Test
public void testTerminatorBolterStorm118psSermentInstant() throws FunctionnalExeption{
INoeudArbre racine = doTestStandard(getDataBolterStorm(ESermentInstantChoix.OUI, 18.0), getAttenduAttaqueFulgurantAvecRelance(), 11);
valideTestsBolterStorm(racine, 4);
}
private Fraction getAttenduAttaqueFulgurantAvecRelance() {
Fraction probaTouche = new Fraction(5,6);
Fraction probaRateTouche = new Fraction(1,6);
Fraction probaBlesse = new Fraction(2,3);
Fraction probaRateBlesse = new Fraction(1,3);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin3 = FractionCheminBuilder.getInstance().addFraction(probaTouche)
.addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin4 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
return chemin1.add(chemin2).add(chemin3).add(chemin4);
}
private void valideTestsBolterStorm(INoeudArbre racine,int nombreNoeudReussite) {
int trouve = 0;
Map<EBlessure, Integer> mAttendu = new HashMap<>();
mAttendu.put(EBlessure.NORMALES, 1);
for(INoeudArbre noeud:racine.arbre()) {
if(noeud.getNatureNoeud() == ENatureNoeud.REUSSITE) {
trouve++;
Assertions.assertThat(noeud.mapBlessuresAleatoires()).isEmpty();
Map<EBlessure, Integer> map = noeud.mapBlessure();
Assertions.assertThat(map).isEqualTo(mAttendu);
}
}
Assertions.assertThat(trouve).isEqualTo(nombreNoeudReussite);
}
private IDataCalculProbabilite getDataBolterStorm(ESermentInstantChoix sermentInstant,Double distanceBelligerants) {
IContexteAction contextAction = ContextActionForTestProbaBuilder.getInstance()
.addSimule(ESimule.TIR_PHASE_TIR)
.addNumeroTour(2)
.addEffectifInitialAttaquant(10)
.addNombreAttaquant(10)
.addMouvementAttaquant(EMouvement.IMMOBILE)
.addBatimentAttaquant(new RecordBatiment(false, false))
.addNombreDefenseur(10)
.addMouvementDefenseur(EMouvement.IMMOBILE)
.addBatimentDefenseur(new RecordBatiment(false, false))
.addDistanceEntreBelligerant(distanceBelligerants)
.build();
IConstituantDefenseur termagaunt = TermagantBuilderDefense.getInstance(contextAction, 10).build();
IConstituantAttaquant terminator = TerminatorBuilderAttaque.getInstance(contextAction, 10).addSermentInstant(sermentInstant).build();
return DataCalculProbabiliteBuilder.getInstance().addAttaquant(terminator).addDefenseur(termagaunt).addContextAction(contextAction)
.addGestionNombreAttaque(EGestionDe.SIMULATION_OPTIMISTE).addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE).addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE).build();
}
@Test
public void testTerminatorTirCanonAssautSansSermentInstant() throws FunctionnalExeption {
INoeudArbre racine = doTestStandard(getDataCanonAssaut(ESermentInstantChoix.NON), getProbaCanonAssautSansRelance(), 2);
validateCanonAssaut(racine, 1, 1);
}
private Fraction getProbaCanonAssautSansRelance() {
Fraction probaTouche = new Fraction(2,3);
Fraction probaBlesse = new Fraction(2,3);
Fraction probaBlessureMortelle = new Fraction(1,6);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction cheminBlessureNormales = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction cheminBlessureMortelles = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlessureMortelle).build();
return cheminBlessureNormales.add(cheminBlessureMortelles);
}
@Test
public void testTerminatorTirCanonAssautSermentInstant() throws FunctionnalExeption {
INoeudArbre racine = doTestStandard(getDataCanonAssaut(ESermentInstantChoix.OUI), getProbaCanonAssautAvecRelance(), 4);
validateCanonAssaut(racine, 4, 4);
}
private Fraction getProbaCanonAssautAvecRelance() {
Fraction probaTouche = new Fraction(5,6);
Fraction probaRateTouche = new Fraction(1,6);
Fraction probaBlesse = new Fraction(2,3);
Fraction probaBlessureMortelle = new Fraction(1,6);
Fraction probaRateBlessure = new Fraction(1,6);
Fraction probaRateSauvegarde = new Fraction(2,3);
//Normale
Fraction cNormal1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction cNormal2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction cNormal3 = FractionCheminBuilder.getInstance().addFraction(probaTouche)
.addFraction(probaRateBlessure).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction cNormal4 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaRateBlessure).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction cheminNormal = cNormal1.add(cNormal2).add(cNormal3).add(cNormal4);
//Mortelle
Fraction cMortelle1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlessureMortelle).build();
Fraction cMortelle2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaBlessureMortelle).build();
Fraction cMortelle3 = FractionCheminBuilder.getInstance().addFraction(probaTouche)
.addFraction(probaRateBlessure).addFraction(probaBlessureMortelle).build();
Fraction cMortelle4 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaRateBlessure).addFraction(probaBlessureMortelle).build();
Fraction cheminMortelle = cMortelle1.add(cMortelle2).add(cMortelle3).add(cMortelle4);
return cheminNormal.add(cheminMortelle);
}
private void validateCanonAssaut(INoeudArbre racine,int attenduNormal,int attenduMortelle) {
int nbNormal = 0;
int nbMortelle = 0;
Map<EBlessure, Integer> map;
Integer nbBlessure;
for(INoeudArbre noeud:racine.arbre()) {
if(noeud.getNatureNoeud() == ENatureNoeud.REUSSITE) {
Assertions.assertThat(noeud.mapBlessuresAleatoires()).isEmpty();
map = noeud.mapBlessure();
Assertions.assertThat(map).hasSize(1);
if(map.containsKey(EBlessure.NORMALES)) {
nbNormal++;
nbBlessure = map.get(EBlessure.NORMALES);
Assertions.assertThat(nbBlessure).isEqualTo(1);
}else if(map.containsKey(EBlessure.MORTELLES)) {
nbMortelle++;
nbBlessure = map.get(EBlessure.MORTELLES);
Assertions.assertThat(nbBlessure).isEqualTo(1);
}
}
}
Assertions.assertThat(nbNormal).isEqualTo(attenduNormal);
Assertions.assertThat(nbMortelle).isEqualTo(attenduMortelle);
}
private IDataCalculProbabilite getDataCanonAssaut(ESermentInstantChoix sermentInstant) {
IContexteAction contextAction = ContextActionForTestProbaBuilder.getInstance()
.addSimule(ESimule.TIR_PHASE_TIR)
.addNumeroTour(2)
.addEffectifInitialAttaquant(10)
.addNombreAttaquant(10)
.addMouvementAttaquant(EMouvement.IMMOBILE)
.addBatimentAttaquant(new RecordBatiment(false, false))
.addNombreDefenseur(10)
.addMouvementDefenseur(EMouvement.IMMOBILE)
.addBatimentDefenseur(new RecordBatiment(false, false))
.addDistanceEntreBelligerant(12.0)
.build();
IConstituantDefenseur termagaunt = TermagantBuilderDefense.getInstance(contextAction, 10).build();
IConstituantAttaquant terminator = TerminatorBuilderAttaque.getInstance(contextAction, 1).equipeCanonAssaut().addSermentInstant(sermentInstant).build();
return DataCalculProbabiliteBuilder.getInstance().addAttaquant(terminator).addDefenseur(termagaunt).addContextAction(contextAction)
.addGestionNombreAttaque(EGestionDe.SIMULATION_OPTIMISTE).addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE).addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE).build();
}
}
Posts: 3,439
Threads: 126
Joined: Jun 2003
Reputation:
1
Début de tabassage en règle de la Metaragne 
Code: package com.calculateur.warhammer.calcul.mort.arbre.calcul;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.math3.fraction.Fraction;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.calcul.mort.arbre.ENatureNoeud;
import com.calculateur.warhammer.calcul.mort.arbre.INoeudArbre;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.chaos.space.marine.MetaragneDefenseBuilderDefense;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.space.marine.TerminatorBuilderAttaque;
import com.calculateur.warhammer.calcul.mort.arbre.data.DataCalculProbabiliteBuilder;
import com.calculateur.warhammer.calcul.mort.arbre.data.IDataCalculProbabilite;
import com.calculateur.warhammer.calcul.test.utils.FractionCheminBuilder;
import com.calculateur.warhammer.data.action.IContexteAction;
import com.calculateur.warhammer.data.enumeration.EBlessure;
import com.calculateur.warhammer.data.enumeration.EGestionDe;
import com.calculateur.warhammer.data.enumeration.EMouvement;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.batiment.RecordBatiment;
import com.calculateur.warhammer.data.regles.detachement.space.marine.ESermentInstantChoix;
import com.calculateur.warhammer.data.unite.IConstituantAttaquant;
import com.calculateur.warhammer.data.unite.IConstituantDefenseur;
public class TerminatorSpaceMarineVSMataragneTest extends AbstractCalculArbreTest{
@Test
public void testAttaqueGanteletNonSermentInstant() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(2, 3);
Fraction probaBlesse = new Fraction(1,3);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
INoeudArbre racine = doTestStandard(getDataTerminatorGanteletEnergetique(ESermentInstantChoix.NON), probaAttendu, 4);
validateAttaqueGantelet(racine, 1);
}
@Test
public void testAttaqueGanteletSermentInstant() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(5, 6);
Fraction probaRateTouche = new Fraction(1,6);
Fraction probaBlesse = new Fraction(1,3);
Fraction probaRateBlesse = new Fraction(2,3);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin3 = FractionCheminBuilder.getInstance().addFraction(probaTouche)
.addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin4 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction probaAttendu = chemin1.add(chemin2).add(chemin3).add(chemin4);
INoeudArbre racine = doTestStandard(getDataTerminatorGanteletEnergetique(ESermentInstantChoix.OUI), probaAttendu, 8);
validateAttaqueGantelet(racine, 4);
}
private void validateAttaqueGantelet(INoeudArbre racine,int attendu) {
int nombre = 0;
Map<EBlessure, Integer> mapAttendu = new HashMap<>();
mapAttendu.put(EBlessure.NORMALES, 2);
for(INoeudArbre noeud:racine.arbre()) {
if(noeud.getNatureNoeud() == ENatureNoeud.REUSSITE) {
nombre++;
Assertions.assertThat(noeud.mapBlessure()).isEqualTo(mapAttendu);
Assertions.assertThat(noeud.mapBlessuresAleatoires()).isEmpty();
}
}
Assertions.assertThat(nombre).isEqualTo(attendu);
}
private IDataCalculProbabilite getDataTerminatorGanteletEnergetique(ESermentInstantChoix sermentInstant) {
IContexteAction context = getContexte();
IConstituantAttaquant attaquant = TerminatorBuilderAttaque.getInstance(context, 9)
.equipeGanteletEnergetique()
.addSermentInstant(sermentInstant)
.build();
IConstituantDefenseur defenseur = MetaragneDefenseBuilderDefense.getInstance(context).build();
return DataCalculProbabiliteBuilder.getInstance().addContextAction(context).addAttaquant(attaquant).addDefenseur(defenseur)
.addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE).addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionNombreAttaque(EGestionDe.MOYENNE_STATISTIQUE_OPTIMISTE).build();
}
private IContexteAction getContexte() {
return ContextActionForTestProbaBuilder.getInstance()
.addSimule(ESimule.CORPS_A_CORPS_APRES_CHARGE)
.addNumeroTour(2)
.addEffectifInitialAttaquant(10)
.addNombreAttaquant(10)
.addMouvementAttaquant(EMouvement.NORMAL)
.addBatimentAttaquant(new RecordBatiment(false, false))
.addNombreDefenseur(1)
.addMouvementDefenseur(EMouvement.NORMAL)
.addBatimentDefenseur(new RecordBatiment(false, false))
.addDistanceEntreBelligerant(0.0)
.build();
}
}
Posts: 3,439
Threads: 126
Joined: Jun 2003
Reputation:
1
Fin du tabassage de Métaraigne.
Code: package com.calculateur.warhammer.calcul.mort.arbre.calcul;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.math3.fraction.Fraction;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.calcul.mort.arbre.ENatureNoeud;
import com.calculateur.warhammer.calcul.mort.arbre.INoeudArbre;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.chaos.space.marine.MetaragneDefenseBuilderDefense;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.space.marine.TerminatorBuilderAttaque;
import com.calculateur.warhammer.calcul.mort.arbre.data.DataCalculProbabiliteBuilder;
import com.calculateur.warhammer.calcul.mort.arbre.data.IDataCalculProbabilite;
import com.calculateur.warhammer.calcul.test.utils.FractionCheminBuilder;
import com.calculateur.warhammer.data.action.IContexteAction;
import com.calculateur.warhammer.data.enumeration.EBlessure;
import com.calculateur.warhammer.data.enumeration.EGestionDe;
import com.calculateur.warhammer.data.enumeration.EMouvement;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.batiment.RecordBatiment;
import com.calculateur.warhammer.data.regles.detachement.space.marine.ESermentInstantChoix;
import com.calculateur.warhammer.data.unite.IConstituantAttaquant;
import com.calculateur.warhammer.data.unite.IConstituantDefenseur;
public class TerminatorSpaceMarineVSMataragneTest extends AbstractCalculArbreTest{
@Test
public void testAttaqueGanteletNonSermentInstant() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(2, 3);
Fraction probaBlesse = new Fraction(1,3);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
INoeudArbre racine = doTestStandard(getDataTerminatorGanteletEnergetique(ESermentInstantChoix.NON), probaAttendu, 4);
validateBlessuresTerminators(racine, 1);
}
@Test
public void testAttaqueGanteletSermentInstant() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(5, 6);
Fraction probaRateTouche = new Fraction(1,6);
Fraction probaBlesse = new Fraction(1,3);
Fraction probaRateBlesse = new Fraction(2,3);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin3 = FractionCheminBuilder.getInstance().addFraction(probaTouche)
.addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin4 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction probaAttendu = chemin1.add(chemin2).add(chemin3).add(chemin4);
INoeudArbre racine = doTestStandard(getDataTerminatorGanteletEnergetique(ESermentInstantChoix.OUI), probaAttendu, 8);
validateBlessuresTerminators(racine, 4);
}
private IDataCalculProbabilite getDataTerminatorGanteletEnergetique(ESermentInstantChoix sermentInstant) {
IContexteAction context = getContexte();
IConstituantAttaquant attaquant = TerminatorBuilderAttaque.getInstance(context, 9)
.equipeGanteletEnergetique()
.addSermentInstant(sermentInstant)
.build();
IConstituantDefenseur defenseur = MetaragneDefenseBuilderDefense.getInstance(context).build();
return DataCalculProbabiliteBuilder.getInstance().addContextAction(context).addAttaquant(attaquant).addDefenseur(defenseur)
.addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE).addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionNombreAttaque(EGestionDe.MOYENNE_STATISTIQUE_OPTIMISTE).build();
}
@Test
public void testAttaquePoingTronconneurNonSermentInstant() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(1, 2);
Fraction probaBlesse = new Fraction(1,2);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
INoeudArbre racine = doTestStandard(getDataTerminatorPoingTronconneur(ESermentInstantChoix.NON), probaAttendu, 1);
validateBlessuresTerminators(racine, 1);
}
@Test
public void testAttaquePoingTronconneurSermentInstant() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(2, 3);
Fraction probaRateTouche = new Fraction(1,3);
Fraction probaBlesse = new Fraction(1,2);
Fraction probaRateBlesse = new Fraction(1,2);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin3 = FractionCheminBuilder.getInstance().addFraction(probaTouche)
.addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin4 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction probaAttendu = chemin1.add(chemin2).add(chemin3).add(chemin4);
INoeudArbre racine = doTestStandard(getDataTerminatorPoingTronconneur(ESermentInstantChoix.OUI), probaAttendu, 1);
validateBlessuresTerminators(racine, 4);
}
private IDataCalculProbabilite getDataTerminatorPoingTronconneur(ESermentInstantChoix sermentInstant) {
IContexteAction context = getContexte();
IConstituantDefenseur defenseur = MetaragneDefenseBuilderDefense.getInstance(context).build();
IConstituantAttaquant attaquant = TerminatorBuilderAttaque.getInstance(context, 2)
.equipePoingTronconneur(defenseur)
.addSermentInstant(sermentInstant)
.build();
return DataCalculProbabiliteBuilder.getInstance().addContextAction(context).addAttaquant(attaquant).addDefenseur(defenseur)
.addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE).addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionNombreAttaque(EGestionDe.MOYENNE_STATISTIQUE_OPTIMISTE).build();
}
private void validateBlessuresTerminators(INoeudArbre racine,int attendu) {
int nombre = 0;
Map<EBlessure, Integer> mapAttendu = new HashMap<>();
mapAttendu.put(EBlessure.NORMALES, 2);
for(INoeudArbre noeud:racine.arbre()) {
if(noeud.getNatureNoeud() == ENatureNoeud.REUSSITE) {
nombre++;
Assertions.assertThat(noeud.mapBlessure()).isEqualTo(mapAttendu);
Assertions.assertThat(noeud.mapBlessuresAleatoires()).isEmpty();
}
}
Assertions.assertThat(nombre).isEqualTo(attendu);
}
private IContexteAction getContexte() {
return ContextActionForTestProbaBuilder.getInstance()
.addSimule(ESimule.CORPS_A_CORPS_APRES_CHARGE)
.addNumeroTour(2)
.addEffectifInitialAttaquant(10)
.addNombreAttaquant(10)
.addMouvementAttaquant(EMouvement.NORMAL)
.addBatimentAttaquant(new RecordBatiment(false, false))
.addNombreDefenseur(1)
.addMouvementDefenseur(EMouvement.NORMAL)
.addBatimentDefenseur(new RecordBatiment(false, false))
.addDistanceEntreBelligerant(0.0)
.build();
}
}
Posts: 3,439
Threads: 126
Joined: Jun 2003
Reputation:
1
Cette fois, honneur aux saintes de l'Adepta Sororitas.
Pour commencer, la règle de détachement.
On commence par les tests:
Code: package com.calculateur.warhammer.data.regles.factory.regle.detachement.adepta.sororitas;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.factory.regle.AbstractFactoryRegleTest;
import com.calculateur.warhammer.data.utils.ModificateursUtils;
public class RegleDetachementSangDesMartyrsFactoryTest extends AbstractFactoryRegleTest{
private static final Integer NOMBRE_POINT_VIE_PERSONNAGE = 4;
private static final Integer NOMBRE_FIGURINE_BASE = 10;
public RegleDetachementSangDesMartyrsFactoryTest() {
super(new RegleDetachementSangDesMartyrsFactory());
}
@Override
protected boolean isRegleAttaqueAttendu() {
return true;
}
@Override
protected boolean isRegleDefenseAttendu() {
return false;
}
@Override
protected Integer getDefaultParameterAttaque() {
return null;
}
@Test
public void testPesonnage4PV() throws FunctionnalExeption{
testReglePersonnage(0,false, false);
}
@Test
public void testPesonnage3PV() throws FunctionnalExeption{
testReglePersonnage(1,true, false);
}
@Test
public void testPesonnage2PV() throws FunctionnalExeption{
testReglePersonnage(2,true, false);
}
@Test
public void testPesonnage1PV() throws FunctionnalExeption{
testReglePersonnage(3,true, true);
}
private void testReglePersonnage(Integer pvPerdu,boolean isBonusTouche,boolean isBonusBlesse) throws FunctionnalExeption{
initMockPersonnage(pvPerdu);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees, null);
valideRegles(regle, isBonusTouche, isBonusBlesse);
}
private void initMockPersonnage(Integer pvPerdu) {
Mockito.when(contexteAction.getPointsViesPerdusAttaquant()).thenReturn(pvPerdu);
Mockito.when(contexteAction.getEffectifInitialAttaquant()).thenReturn(1);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(profil.getNombrePointDeVie()).thenReturn(NOMBRE_POINT_VIE_PERSONNAGE);
Mockito.when(donnees.getAttaquant()).thenReturn(attaquant);
Mockito.when(attaquant.getProfil()).thenReturn(profil);
}
@Test
public void testRegleUnite10Figurines() throws FunctionnalExeption{
testRegleUnite(10, false, false);
}
@Test
public void testRegleUnite7Figurines() throws FunctionnalExeption{
testRegleUnite(7, true, false);
}
@Test
public void testRegleUnite5Figurines() throws FunctionnalExeption{
testRegleUnite(5, true, false);
}
@Test
public void testRegleUnite4Figurines() throws FunctionnalExeption{
testRegleUnite(4, true, true);
}
private void testRegleUnite(Integer nombreFigurine,boolean isBonusTouche,boolean isBonusBlesse) throws FunctionnalExeption{
initMockUnite(nombreFigurine);
IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees, null);
valideRegles(regle, isBonusTouche, isBonusBlesse);
}
private void initMockUnite(Integer nombreFigurine) {
Mockito.when(contexteAction.getEffectifInitialAttaquant()).thenReturn(NOMBRE_FIGURINE_BASE);
Mockito.when(contexteAction.getEffectifCourantAttaquant()).thenReturn(nombreFigurine);
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
}
private void valideRegles(IRegleAttaque regle,boolean isBonusTouche,boolean isBonusBlesse) {
Integer bonusTouche = isBonusTouche?ModificateursUtils.BONUS_BASE_JET:ModificateursUtils.NO_BONUS;
Integer bonusBlesse = isBonusBlesse?ModificateursUtils.BONUS_BASE_JET:ModificateursUtils.NO_BONUS;
Assertions.assertThat(regle.getBonusJetTouche()).isEqualTo(bonusTouche);
Assertions.assertThat(regle.getBonusJetBlessures()).isEqualTo(bonusBlesse);
}
}
Comme je fais une factory, je découpe l'implémentation selon la figurine unique et l'unité:
Code: package com.calculateur.warhammer.data.regles.detachement.adepta.sororitas;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.utils.ModificateursUtils;
/**
* Implémentation de la règle Sang des Martyrs appliquées aux figurines uniques. Dans ce cas, si il y a perte d'1PV, -1 aux jets de touche. Si il y a perte de plus de la moitié des PV, -1 aux jets de blessures.
* @author phili
*
*/
public class RegleDetachementSangDesMartyrsFigurine implements IRegleAttaque{
private final Integer pvInitial;
private final Integer pvCourant;
public RegleDetachementSangDesMartyrsFigurine(Integer pvInitial, Integer pvCourant) {
this.pvInitial = pvInitial;
this.pvCourant = pvCourant;
}
@Override
public Integer getBonusJetTouche() {
return (pvCourant < pvInitial)?ModificateursUtils.BONUS_BASE_JET:ModificateursUtils.NO_BONUS;
}
@Override
public Integer getBonusJetBlessures() {
return (pvCourant < (pvInitial / 2))?ModificateursUtils.BONUS_BASE_JET:ModificateursUtils.NO_BONUS;
}
}
Code: package com.calculateur.warhammer.data.regles.detachement.adepta.sororitas;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.utils.ModificateursUtils;
/**
* Règle Sang des Martyrs pour l'Adeptas Sororitas, appliqué aux unités de plusieurs modèle. A savoir si perte d'un modèle, -1 pour toucher, et si perte de plus de la moitié des modèles, -pour blesser.
* @author phili
*
*/
public class RegleDetachementSangDesMartyrsUnite implements IRegleAttaque{
private final Integer effectifInitial;
private final Integer effectifCourant;
public RegleDetachementSangDesMartyrsUnite(Integer effectifInitial, Integer effectifCourant) {
this.effectifInitial = effectifInitial;
this.effectifCourant = effectifCourant;
}
@Override
public Integer getBonusJetTouche() {
return (effectifCourant < effectifInitial)?ModificateursUtils.BONUS_BASE_JET:ModificateursUtils.NO_BONUS;
}
@Override
public Integer getBonusJetBlessures() {
return (effectifCourant < (effectifInitial / 2))?ModificateursUtils.BONUS_BASE_JET:ModificateursUtils.NO_BONUS;
}
}
Soit pour la Factory:
Code: package com.calculateur.warhammer.data.regles.factory.regle.detachement.adepta.sororitas;
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.detachement.adepta.sororitas.RegleDetachementSangDesMartyrsFigurine;
import com.calculateur.warhammer.data.regles.detachement.adepta.sororitas.RegleDetachementSangDesMartyrsUnite;
import com.calculateur.warhammer.data.regles.factory.donnees.IDonneeFactory;
import com.calculateur.warhammer.data.regles.factory.regle.IFactoryRegle;
/**
* Factory de la règle Sang des Martyrs pour l'Adeptas Sororitas.
* @author phili
*
*/
public class RegleDetachementSangDesMartyrsFactory implements IFactoryRegle{
@Override
public IRegleAttaque getRegleAttaque(IDonneeFactory donnees, Integer parameter) throws FunctionnalExeption {
IRegleAttaque regle;
Integer effectifInitial = donnees.getContexteAction().getEffectifInitialAttaquant();
if(effectifInitial.intValue() == 1) {
Integer pvBase = donnees.getAttaquant().getProfil().getNombrePointDeVie();
Integer pvPerdu = donnees.getContexteAction().getPointsViesPerdusAttaquant();
regle = new RegleDetachementSangDesMartyrsFigurine(pvBase, pvBase - pvPerdu);
}else {
Integer effectifCourant = donnees.getContexteAction().getEffectifCourantAttaquant();
regle = new RegleDetachementSangDesMartyrsUnite(effectifInitial, effectifCourant);
}
return regle;
}
@Override
public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
return null;
}
@Override
public boolean isRegleApplicableAttaque() {
return true;
}
@Override
public boolean isRegleApplicableDefense() {
return false;
}
}
Et le stratagème utile:
Code: package com.calculateur.warhammer.data.regles.factory.regle.stratageme.adepta.sororitas;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.factory.regle.AbstractFactoryRegleTest;
import com.calculateur.warhammer.data.utils.ModificateursUtils;
public class StratagemeRageSacreeFactoryTest extends AbstractFactoryRegleTest{
public StratagemeRageSacreeFactoryTest() {
super(new StratagemeRageSacreeFactory());
}
@Override
protected boolean isRegleAttaqueAttendu() {
return true;
}
@Override
protected boolean isRegleDefenseAttendu() {
return false;
}
@Override
protected Integer getDefaultParameterAttaque() {
return null;
}
@Test
public void testStratageme()throws FunctionnalExeption{
IRegleAttaque regle;
for(ESimule simule:ESimule.values()) {
initMock(simule);
regle = factoryRegle.getRegleAttaque(donnees, null);
valideRegle(regle, simule);
}
}
private void initMock(ESimule simule) {
Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
Mockito.when(contexteAction.getSimule()).thenReturn(simule);
}
private void valideRegle(IRegleAttaque regle,ESimule simule) {
Integer bonus = simule.isActionCorpACorp()?ModificateursUtils.BONUS_BASE_JET:ModificateursUtils.NO_BONUS;
Assertions.assertThat(regle.getBonusJetBlessures()).isEqualTo(bonus);
}
}
Pour la Factory:
Code: package com.calculateur.warhammer.data.regles.factory.regle.stratageme.adepta.sororitas;
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.stratageme.adepta.sororitas.StratagemeRageSacree;
/**
* Factory pour le stratagème Rage Sacrée de l'Adepta Sororitas.
* @author phili
*
*/
public class StratagemeRageSacreeFactory implements IFactoryRegle{
@Override
public IRegleAttaque getRegleAttaque(IDonneeFactory donnees, Integer parameter) throws FunctionnalExeption {
return new StratagemeRageSacree(donnees.getContexteAction().getSimule());
}
@Override
public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
return null;
}
@Override
public boolean isRegleApplicableAttaque() {
return true;
}
@Override
public boolean isRegleApplicableDefense() {
return false;
}
}
Soit la règle:
Code: package com.calculateur.warhammer.data.regles.stratageme.adepta.sororitas;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.utils.ModificateursUtils;
/**
* Implémentation du stratagème Rage Sacrée de l'Adepta Sororitas. A savoir -1 aux jets de blessures au corps à corps.
* @author phili
*
*/
public class StratagemeRageSacree implements IRegleAttaque{
private final ESimule simule;
public StratagemeRageSacree(ESimule simule) {
this.simule = simule;
}
@Override
public Integer getBonusJetBlessures() {
return simule.isActionCorpACorp()?ModificateursUtils.BONUS_BASE_JET: IRegleAttaque.super.getBonusJetBlessures();
}
}
Posts: 3,439
Threads: 126
Joined: Jun 2003
Reputation:
1
Uu tour d'horizon de notre ami le Castigator.
Ce qui donne le TU suivant:
Code: package com.calculateur.warhammer.calcul.mort.arbre.calcul;
import org.apache.commons.math3.fraction.Fraction;
import org.junit.jupiter.api.Test;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.calcul.mort.arbre.INoeudArbre;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.adepta.sororitas.CastigatorAttaqueBuilder;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.tyranide.TermagantBuilderDefense;
import com.calculateur.warhammer.calcul.mort.arbre.data.DataCalculProbabiliteBuilder;
import com.calculateur.warhammer.calcul.mort.arbre.data.IDataCalculProbabilite;
import com.calculateur.warhammer.calcul.test.utils.FractionCheminBuilder;
import com.calculateur.warhammer.data.action.IContexteAction;
import com.calculateur.warhammer.data.enumeration.EGestionDe;
import com.calculateur.warhammer.data.enumeration.EMouvement;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.batiment.RecordBatiment;
import com.calculateur.warhammer.data.unite.IConstituantAttaquant;
import com.calculateur.warhammer.data.unite.IConstituantDefenseur;
public class CastigatorVSTermagauntTest extends AbstractCalculArbreTest{
@Test
public void testObusierCastigatorPasPertePV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), false, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirObusierCastigator(0, 12.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void testObusierCastigatorPerte5() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), false, new Fraction(5,6));
Integer nombre = 7;
IDataCalculProbabilite data = getDataTirObusierCastigator(5, 12.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void testObusierCastigatorPerte10PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), false, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirObusierCastigator(10, 12.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void testObusierCastigatorPerte10PVLumiereEmpereur() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), false, new Fraction(5,6));
Integer nombre = 7;
IDataCalculProbabilite data = getDataTirObusierCastigator(10, 12.0, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 1);
validateBlessureNormales(racine, blessures);
}
private IDataCalculProbabilite getDataTirObusierCastigator(Integer pvPerdu,Double distanceBelligerent,boolean isStratagemeLumiereEmpereur) {
IContexteAction contexteAction = getContextAction(pvPerdu, ESimule.TIR_PHASE_TIR, distanceBelligerent);
IConstituantDefenseur defenseur = TermagantBuilderDefense.getInstance(contexteAction, 10).build();
CastigatorAttaqueBuilder builder = CastigatorAttaqueBuilder.getInstance(contexteAction, 1).equipeObusierCastigator(defenseur.getProfil().getTypesProfils());
if(isStratagemeLumiereEmpereur) {
builder.utiliseStratagemeLumiereEmpereur();
}
IConstituantAttaquant attaquant = builder.build();
return DataCalculProbabiliteBuilder.getInstance()
.addContextAction(contexteAction)
.addAttaquant(attaquant)
.addDefenseur(defenseur)
.addGestionNombreAttaque(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE)
.build();
}
@Test
public void testAutocanonCastigator30psPasPertePV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), true, new Fraction(5,6));
Integer nombre = 3;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 0, 30.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator30psPerte5PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), true, new Fraction(5,6));
Integer nombre = 3;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 5, 30.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator30psPerte10PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), true, new Fraction(5,6));
Integer nombre = 3;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 10, 30.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator30psPerte10PVLumiereEmpereur() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), true, new Fraction(5,6));
Integer nombre = 3;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 10, 30.0, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator24psPasPertePV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), true, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 0, 24.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator24psPerte5PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), true, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 5, 24.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator24psPerte10PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), true, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 10, 24.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator24psPerte10PVLumiereEmpereur() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), true, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 10, 24.0, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator6psPasPertePV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), true, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 0, 6.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator6psPerte5PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), true, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 5, 6.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator6psPerte10PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), true, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 10, 6.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator6psPerte10PVLumiereEmpereur() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), true, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_PHASE_TIR, 10, 6.0, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator0psPasPertePV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(1,2), true, new Fraction(5,6));
Integer nombre = 6;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_AU_SEIN_CORPS_A_CORPS, 0, 0.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator0psPerte5PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), true, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_AU_SEIN_CORPS_A_CORPS, 5, 0.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator0psPerte10PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(1,2), true, new Fraction(5,6));
Integer nombre = 6;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_AU_SEIN_CORPS_A_CORPS,10, 0.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
@Test
public void testAutocanonCastigator0psPerte10PVLumiereEmpereur() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), true, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirAutocanonCastigator(ESimule.TIR_AU_SEIN_CORPS_A_CORPS, 10, 0.0, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(3, null, null, 4);
validateBlessureNormales(racine, blessures);
}
private IDataCalculProbabilite getDataTirAutocanonCastigator(ESimule simule,Integer pvPerdu,Double distanceBelligerent,boolean isStratagemeLumiereEmpereur) {
IContexteAction contexteAction = getContextAction(pvPerdu, simule, distanceBelligerent);
IConstituantDefenseur defenseur = TermagantBuilderDefense.getInstance(contexteAction, 10).build();
CastigatorAttaqueBuilder builder = CastigatorAttaqueBuilder.getInstance(contexteAction, 1).equipeAutocanonCastigator(defenseur.getProfil().getTypesProfils());
if(isStratagemeLumiereEmpereur) {
builder.utiliseStratagemeLumiereEmpereur();
}
IConstituantAttaquant attaquant = builder.build();
return DataCalculProbabiliteBuilder.getInstance()
.addContextAction(contexteAction)
.addAttaquant(attaquant)
.addDefenseur(defenseur)
.addGestionNombreAttaque(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE)
.build();
}
@Test
public void testBolterLourd30psPasPertePV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), false, new Fraction(2,3));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirBolterLourd(ESimule.TIR_PHASE_TIR, 0, 30.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void testBolterLourd30psPerte5PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), false, new Fraction(2,3));
Integer nombre = 6;
IDataCalculProbabilite data = getDataTirBolterLourd(ESimule.TIR_PHASE_TIR, 5, 30.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void testBolterLourd30psPerte10PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), false, new Fraction(5,6));
Integer nombre = 6;
IDataCalculProbabilite data = getDataTirBolterLourd(ESimule.TIR_PHASE_TIR, 10, 30.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void testBolterLourd30psPerte10PVLumiereEmpereur() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), false, new Fraction(5,6));
Integer nombre = 7;
IDataCalculProbabilite data = getDataTirBolterLourd(ESimule.TIR_PHASE_TIR, 10, 30.0, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void testBolterLourd0psPasPertePV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(1,2), false, new Fraction(2,3));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirBolterLourd(ESimule.TIR_AU_SEIN_CORPS_A_CORPS, 0, 0.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void testBolterLourd0psPerte5PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(2,3), false, new Fraction(2,3));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirBolterLourd(ESimule.TIR_AU_SEIN_CORPS_A_CORPS, 5, 0.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void testBolterLourd0psPerte10PV() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(1,2), false, new Fraction(5,6));
Integer nombre = 5;
IDataCalculProbabilite data = getDataTirBolterLourd(ESimule.TIR_AU_SEIN_CORPS_A_CORPS, 10, 0.0, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void testBolterLourd0psPerte10PVLumiereEmpereur() throws FunctionnalExeption{
Fraction probaAttendu = getProbaAttendu(new Fraction(5,6), false, new Fraction(5,6));
Integer nombre = 7;
IDataCalculProbabilite data = getDataTirBolterLourd(ESimule.TIR_PHASE_TIR, 10, 0.0, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombre);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
private IDataCalculProbabilite getDataTirBolterLourd(ESimule simule,Integer pvPerdu,Double distanceBelligerent,boolean isStratagemeLumiereEmpereur) {
IContexteAction contexteAction = getContextAction(pvPerdu, simule, distanceBelligerent);
IConstituantDefenseur defenseur = TermagantBuilderDefense.getInstance(contexteAction, 10).build();
CastigatorAttaqueBuilder builder = CastigatorAttaqueBuilder.getInstance(contexteAction, 3).equipeBolterLourd();
if(isStratagemeLumiereEmpereur) {
builder.utiliseStratagemeLumiereEmpereur();
}
IConstituantAttaquant attaquant = builder.build();
return DataCalculProbabiliteBuilder.getInstance()
.addContextAction(contexteAction)
.addAttaquant(attaquant)
.addDefenseur(defenseur)
.addGestionNombreAttaque(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE)
.build();
}
private IContexteAction getContextAction(Integer pvPerdu,ESimule simule,Double distanceBelligerent) {
return ContextActionForTestProbaBuilder.getInstance()
.addSimule(simule)
.addNumeroTour(2)
.addEffectifInitialAttaquant(1)
.addEffectifCourantAttaquant(1)
.addPointsViesPerdusAttaquant(pvPerdu)
.addMouvementAttaquant(EMouvement.IMMOBILE)
.addBatimentAttaquant(new RecordBatiment(false, false))
.addEffectifCourantDefenseur(10)
.addMouvementDefenseur(EMouvement.IMMOBILE)
.addBatimentDefenseur(new RecordBatiment(false, false))
.addDistanceEntreBelligerant(distanceBelligerent)
.build();
}
private Fraction getProbaAttendu(Fraction probaTouche, boolean isRelance,Fraction probaBlesse) {
Fraction ensemble = new Fraction(1);
Fraction probaRateTouche = ensemble.subtract(probaTouche);
Fraction probaRateBlesse = ensemble.subtract(probaBlesse);
Fraction probaRateSauvegarde = new Fraction(5,6);
Fraction probaAttendu;
if(isRelance) {
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin3 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction chemin4 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche).addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
probaAttendu = chemin1.add(chemin2).add(chemin3).add(chemin4);
}else {
probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
}
return probaAttendu;
}
}
Question: Faut-il mieux face à des termagaunt l'autocanon (qui est jumelé et relance les touche contre l'infanterie) ou l'obusier (qui relance les touche contre l'infanterie).
Notez que l'obusier ignore les couvert (par regardé cet aspect).
Pour le test, on gère l'aléatoire (car l'obusier est Blast) du plus haut vers le plus bas.
Effectivement, si on lance 8D6, les scores sont (6,5,4,3,2,1,6,5).
Donc ici, l'obusier fait 6 (j'ai de la chance).
Ce choix est fait pour écrire plus facilement le TU. Mais je gère j'ai pas de chance, j'ai de la chance mais je suis centré sur la moyenne, j'ai pas de chance mais je suis centré sur la moyenne, et je fait de l'aléatoire pur.
Déjà, rapelons que l'autocanon peut, contrairement à l'obusier, tirer au corps à corps.
Donc, il faut comparer l'obsier et l'autocanon à mi-porté (car celui-ci est tir-rapide).
Les cas intéressant sont pas de perte de PV, perte de quelques PV (-1 au jet de touche), perte de 10PV (en reste 1 donc ici -1 au jet de blessure) et utilisation si on perd 10 PV du stratagème lumière de l'empereur (Ignore les malus).
Avoir la vision proba est plus complexe (mais c'est testé).
Au final, à l'obusier on fait respectivement 5,7,5,7 morts dans les rangs termagaunts (ce qui est la moitié, restre les bolters lourds).
On fait 5,5,5 et 5 morts dans les rangs termagaunts.
Donc au final, pour tuer du termagaunt, l'obusier est mieux.
Posts: 3,439
Threads: 126
Joined: Jun 2003
Reputation:
1
Et de la sacro-sainte Céleste.
Soit le TU suivant:
Code: package com.calculateur.warhammer.calcul.mort.arbre.calcul;
import org.apache.commons.math3.fraction.Fraction;
import org.junit.jupiter.api.Test;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.calcul.mort.arbre.INoeudArbre;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.adepta.sororitas.SacroSainteCelesteBuilderAttaque;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.chaos.space.marine.SpaceMarineDuChaosBuilderDefense;
import com.calculateur.warhammer.calcul.mort.arbre.data.DataCalculProbabiliteBuilder;
import com.calculateur.warhammer.calcul.mort.arbre.data.IDataCalculProbabilite;
import com.calculateur.warhammer.calcul.test.utils.FractionCheminBuilder;
import com.calculateur.warhammer.data.action.IContexteAction;
import com.calculateur.warhammer.data.enumeration.EGestionDe;
import com.calculateur.warhammer.data.enumeration.EMouvement;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.batiment.RecordBatiment;
import com.calculateur.warhammer.data.unite.IConstituantDefenseur;
public class SacroSainteCelesteVSChaosSpaceMarineTest extends AbstractCalculArbreTest{
@Test
public void SacrosSaintes10HallebardeTest() throws FunctionnalExeption{
Fraction probaTouche = new Fraction(2, 3);
Fraction probaBlesse = new Fraction(2,3);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 6;//On tue donc 3 marines
IDataCalculProbabilite data = getData(10, false, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes10HallebardeRageSacreeTest() throws FunctionnalExeption{
Fraction probaTouche = new Fraction(2, 3);
Fraction probaBlesse = new Fraction(5,6);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 8;//On tue donc 4 marines
IDataCalculProbabilite data = getData(10, false, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5HallebardeTest() throws FunctionnalExeption{
Fraction probaTouche = new Fraction(5, 6);
Fraction probaBlesse = new Fraction(2,3);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 4;//On tue donc 2 marines
IDataCalculProbabilite data = getData(5, false, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5HallebardeRageSacreeTest() throws FunctionnalExeption{
Fraction probaTouche = new Fraction(5, 6);
Fraction probaBlesse = new Fraction(5,6);
Fraction probaRateSauvegarde = new Fraction(2,3);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 4;//On tue donc 2 marines
IDataCalculProbabilite data = getData(5, false, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes10MasseTest() throws FunctionnalExeption{
Fraction probaTouche = new Fraction(2, 3);
Fraction probaBlesse = new Fraction(1,2);
Fraction probaRateSauvegarde = new Fraction(1,2);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 3;//On tue donc 3 marines
IDataCalculProbabilite data = getData(10, true, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes10MasseRageSacree() throws FunctionnalExeption{
Fraction probaTouche = new Fraction(2, 3);
Fraction probaBlesse = new Fraction(2,3);
Fraction probaRateSauvegarde = new Fraction(1,2);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 4;//On tue donc 4 marines
IDataCalculProbabilite data = getData(10, true, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5MasseTest() throws FunctionnalExeption{
Fraction probaTouche = new Fraction(5, 6);
Fraction probaBlesse = new Fraction(1,2);
Fraction probaRateSauvegarde = new Fraction(1,2);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 3;//On tue donc 3 marines
IDataCalculProbabilite data = getData(5, true, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5MasseRageSacree() throws FunctionnalExeption{
Fraction probaTouche = new Fraction(5, 6);
Fraction probaBlesse = new Fraction(2,3);
Fraction probaRateSauvegarde = new Fraction(1,2);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 3;//On tue donc 3 marines
IDataCalculProbabilite data = getData(5, true, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
private IDataCalculProbabilite getData(Integer nbSoeur,boolean isMasse,boolean isRageSacree) {
IContexteAction context = getContextAction(nbSoeur);
SacroSainteCelesteBuilderAttaque builder = SacroSainteCelesteBuilderAttaque.getInstance(context, nbSoeur);
if(isMasse) {
builder.equipeMasseEnergetique();
}else {
builder.equipeHallebardeConsacree();
}
if(isRageSacree) {
builder.utiliseStratagemeRageSacree();
}
IConstituantDefenseur defenseur = SpaceMarineDuChaosBuilderDefense.getInstance(context, 10).build();
return DataCalculProbabiliteBuilder.getInstance()
.addContextAction(context)
.addAttaquant(builder.build())
.addDefenseur(defenseur)
.addGestionNombreAttaque(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE)
.build();
}
private IContexteAction getContextAction(Integer nbSoeur) {
return ContextActionForTestProbaBuilder.getInstance()
.addSimule(ESimule.CORPS_A_CORPS_APRES_CHARGE)
.addNumeroTour(2)
.addEffectifInitialAttaquant(10)
.addEffectifCourantAttaquant(nbSoeur)
.addMouvementAttaquant(EMouvement.IMMOBILE)
.addBatimentAttaquant(new RecordBatiment(false, false))
.addEffectifCourantDefenseur(10)
.addMouvementDefenseur(EMouvement.IMMOBILE)
.addBatimentDefenseur(new RecordBatiment(false, false))
.addDistanceEntreBelligerant(0.0)
.build();
}
}
On teste avec 10 sacro-saintes (sans stratagème, rage sacrée: +1 au jet de blessure) et avec 5 sacro-saintes.
On a donc respectivement 3/4/2/2 morts à coup de hallebarde (car le marine a 2PV).
Mais on a 3/4/3/3 morts à coup de masse.
La masse (F:4, PA:-1,Dégât:2) est donc plus intéressant que la Hallebarde (F:5, PA:-2,Dégâts:1).
C'est du au nombre de dégâts. Quand le marine rate sa sauvegarde face à une masse, il meurt!
Posts: 3,439
Threads: 126
Joined: Jun 2003
Reputation:
1
On ajoute la chanoinesse aux sacro-saintes célestes:
Code: package com.calculateur.warhammer.calcul.mort.arbre.calcul;
import org.apache.commons.math3.fraction.Fraction;
import org.junit.jupiter.api.Test;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.calcul.mort.arbre.INoeudArbre;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.adepta.sororitas.SacroSainteCelesteBuilderAttaque;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.chaos.space.marine.SpaceMarineDuChaosBuilderDefense;
import com.calculateur.warhammer.calcul.mort.arbre.data.DataCalculProbabiliteBuilder;
import com.calculateur.warhammer.calcul.mort.arbre.data.IDataCalculProbabilite;
import com.calculateur.warhammer.calcul.test.utils.FractionCheminBuilder;
import com.calculateur.warhammer.data.action.IContexteAction;
import com.calculateur.warhammer.data.enumeration.EGestionDe;
import com.calculateur.warhammer.data.enumeration.EMouvement;
import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.batiment.RecordBatiment;
import com.calculateur.warhammer.data.unite.IConstituantDefenseur;
public class SacroSainteCelesteVSChaosSpaceMarineTest extends AbstractCalculArbreTest {
@Test
public void SacrosSaintes10HallebardeTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(2, 3);
Fraction probaBlesse = new Fraction(2, 3);
Fraction probaRateSauvegarde = new Fraction(2, 3);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 6;// On tue donc 3 marines
IDataCalculProbabilite data = getData(10, false, false, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes10HallebardeChanoinesseTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(2, 3);
Fraction probaRateTouche = new Fraction(1, 3);
Fraction probaBlesse = new Fraction(2, 3);
Fraction probaRateSauvegarde = new Fraction(2, 3);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction probaAttendu = chemin1.add(chemin2);
Integer nombreReussite = 8;// On tue donc 4 marines
IDataCalculProbabilite data = getData(10, false, false, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 2);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes10HallebardeRageSacreeTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(2, 3);
Fraction probaBlesse = new Fraction(5, 6);
Fraction probaRateSauvegarde = new Fraction(2, 3);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 8;// On tue donc 4 marines
IDataCalculProbabilite data = getData(10, false, true, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes10HallebardeRageSacreeChanoinesseTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(2, 3);
Fraction probaRateTouche = new Fraction(1, 3);
Fraction probaBlesse = new Fraction(5, 6);
Fraction probaRateSauvegarde = new Fraction(2, 3);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction probaAttendu = chemin1.add(chemin2);
Integer nombreReussite = 10;// On tue donc 5 marines
IDataCalculProbabilite data = getData(10, false, true, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 2);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5HallebardeTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(5, 6);
Fraction probaBlesse = new Fraction(2, 3);
Fraction probaRateSauvegarde = new Fraction(2, 3);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 4;// On tue donc 2 marines
IDataCalculProbabilite data = getData(5, false, false, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5HallebardeChanoinesseTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(5, 6);
Fraction probaRateTouche = new Fraction(1, 6);
Fraction probaBlesse = new Fraction(2, 3);
Fraction probaRateSauvegarde = new Fraction(2, 3);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction probaAttendu = chemin1.add(chemin2);
Integer nombreReussite = 4;// On tue donc 2 marines
IDataCalculProbabilite data = getData(5, false, false, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 2);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5HallebardeRageSacreeTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(5, 6);
Fraction probaBlesse = new Fraction(5, 6);
Fraction probaRateSauvegarde = new Fraction(2, 3);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 4;// On tue donc 2 marines
IDataCalculProbabilite data = getData(5, false, true, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5HallebardeRageSacreeChanoinesseTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(5, 6);
Fraction probaRateTouche = new Fraction(1, 6);
Fraction probaBlesse = new Fraction(5, 6);
Fraction probaRateSauvegarde = new Fraction(2, 3);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche)
.addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
Fraction probaAttendu = chemin1.add(chemin2);
Integer nombreReussite = 4;// On tue donc 2 marines
IDataCalculProbabilite data = getData(5, false, true, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(1, null, null, 2);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes10MasseTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(2, 3);
Fraction probaBlesse = new Fraction(1, 2);
Fraction probaRateSauvegarde = new Fraction(1, 2);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 3;// On tue donc 3 marines
IDataCalculProbabilite data = getData(10, true, false, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes10MasseChanoinesseTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(2, 3);
Fraction probaRateTouche = new Fraction(1, 3);
Fraction probaBlesse = new Fraction(1, 2);
Fraction probaRateSauvegarde = new Fraction(1, 2);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction probaAttendu = chemin1.add(chemin2);
Integer nombreReussite = 3;// On tue donc 3 marines
IDataCalculProbabilite data = getData(10, true, false, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 2);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes10MasseRageSacree() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(2, 3);
Fraction probaBlesse = new Fraction(2, 3);
Fraction probaRateSauvegarde = new Fraction(1, 2);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 4;// On tue donc 4 marines
IDataCalculProbabilite data = getData(10, true, true, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes10MasseRageSacreeChanoinesse() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(2, 3);
Fraction probaRateTouche = new Fraction(1, 3);
Fraction probaBlesse = new Fraction(2, 3);
Fraction probaRateSauvegarde = new Fraction(1, 2);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction probaAttendu = chemin1.add(chemin2);
Integer nombreReussite = 5;// On tue donc 10 marines
IDataCalculProbabilite data = getData(10, true, true, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 2);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5MasseTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(5, 6);
Fraction probaBlesse = new Fraction(1, 2);
Fraction probaRateSauvegarde = new Fraction(1, 2);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 3;// On tue donc 3 marines
IDataCalculProbabilite data = getData(5, true, false, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5MasseChanoinesseTest() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(5, 6);
Fraction probaRateTouche = new Fraction(1, 6);
Fraction probaBlesse = new Fraction(1, 2);
Fraction probaRateSauvegarde = new Fraction(1, 2);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction probaAttendu = chemin1.add(chemin2);
Integer nombreReussite = 3;// On tue donc 3 marines
IDataCalculProbabilite data = getData(5, true, false, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 2);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5MasseRageSacree() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(5, 6);
Fraction probaBlesse = new Fraction(2, 3);
Fraction probaRateSauvegarde = new Fraction(1, 2);
Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Integer nombreReussite = 3;// On tue donc 3 marines
IDataCalculProbabilite data = getData(5, true, true, false);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 1);
validateBlessureNormales(racine, blessures);
}
@Test
public void SacrosSaintes5MasseRageSacreeChanoinesse() throws FunctionnalExeption {
Fraction probaTouche = new Fraction(5, 6);
Fraction probaRateTouche = new Fraction(1, 6);
Fraction probaBlesse = new Fraction(2, 3);
Fraction probaRateSauvegarde = new Fraction(1, 2);
Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateTouche).addFraction(probaTouche).addFraction(probaBlesse)
.addFraction(probaRateSauvegarde).build();
Fraction probaAttendu = chemin1.add(chemin2);
Integer nombreReussite = 3;// On tue donc 3 marines
IDataCalculProbabilite data = getData(5, true, true, true);
INoeudArbre racine = doTestStandard(data, probaAttendu, nombreReussite);
RecordBlessures blessures = new RecordBlessures(2, null, null, 2);
validateBlessureNormales(racine, blessures);
}
private IDataCalculProbabilite getData(Integer nbSoeur, boolean isMasse, boolean isRageSacree,
boolean isChanoinesse) {
IContexteAction context = getContextAction(nbSoeur);
SacroSainteCelesteBuilderAttaque builder = SacroSainteCelesteBuilderAttaque.getInstance(context, nbSoeur);
if (isMasse) {
builder.equipeMasseEnergetique();
} else {
builder.equipeHallebardeConsacree();
}
if (isRageSacree) {
builder.utiliseStratagemeRageSacree();
}
if (isChanoinesse) {
builder.ajouteChanoinesse();
}
IConstituantDefenseur defenseur = SpaceMarineDuChaosBuilderDefense.getInstance(context, 10).build();
return DataCalculProbabiliteBuilder.getInstance().addContextAction(context).addAttaquant(builder.build())
.addDefenseur(defenseur).addGestionNombreAttaque(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE)
.addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE).build();
}
private IContexteAction getContextAction(Integer nbSoeur) {
return ContextActionForTestProbaBuilder.getInstance().addSimule(ESimule.CORPS_A_CORPS_APRES_CHARGE)
.addNumeroTour(2).addEffectifInitialAttaquant(10).addEffectifCourantAttaquant(nbSoeur)
.addMouvementAttaquant(EMouvement.IMMOBILE).addBatimentAttaquant(new RecordBatiment(false, false))
.addEffectifCourantDefenseur(10).addMouvementDefenseur(EMouvement.IMMOBILE)
.addBatimentDefenseur(new RecordBatiment(false, false)).addDistanceEntreBelligerant(0.0).build();
}
}
Posts: 3,439
Threads: 126
Joined: Jun 2003
Reputation:
1
|
