Projet Calculateur

[Philou]

On continue avec les spaces marines du chaos, qui permettent de tester les touches supplémentaire (sur 6+) ou les blessures automatiques (sur 6+).

Soit le TU suivant:

Code:

package com.calculateur.warhammer.calcul.mort.arbre.calcul;

import static org.assertj.core.api.Assertions.assertThat;

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.SpaceMarineDuChaosBuilderAttaque;
import com.calculateur.warhammer.calcul.mort.arbre.calcul.builder.space.marine.SpaceMarineBuilderDefense;
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.chaos.space.marine.EPactesSombres;
import com.calculateur.warhammer.data.unite.IConstituantAttaquant;
import com.calculateur.warhammer.data.unite.IConstituantDefenseur;

public class SpaceMarineDuChaosVsSpaceMarineAdeptusAstartesTest extends AbstractCalculArbreTest{

    @Test
    public void testAttaqueMarineDuChaosPasDePacteContreSpaceMarine() throws FunctionnalExeption {
        IDataCalculProbabilite data = getData(EPactesSombres.AUCUN, false);
        
        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 poolAttendu = 6;
        INoeudArbre racine = doTestStandard(data, probaAttendu, poolAttendu);
        validateBlessures(racine, 1);
    }
    
    @Test
    public void testAttaqueMarineDuChaosPasDePacteContreSpaceArmureMepris() throws FunctionnalExeption {
        IDataCalculProbabilite data = getData(EPactesSombres.AUCUN, true);
        
        Fraction probaTouche = new Fraction(2,3);
        Fraction probaBlesse = new Fraction(1,2);
        Fraction probaRateSauvegarde = new Fraction(1,3);
        Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
        
        Integer poolAttendu = 4;
        INoeudArbre racine = doTestStandard(data, probaAttendu, poolAttendu);
        validateBlessures(racine, 1);
    }
    
    @Test
    public void testAttaqueMarineDuChaosPacteTouchesSoutenuesContreSpaceMarine() throws FunctionnalExeption {
        IDataCalculProbabilite data = getData(EPactesSombres.TOUCHES_SOUTENUES, false);
        
        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 poolAttendu = 9;
        INoeudArbre racine = doTestStandard(data, probaAttendu, poolAttendu);
        validateBlessures(racine, 1);
    }
    
    @Test
    public void testAttaqueMarineDuChaosPacteTouchesSoutenuesSpaceArmureMepris() throws FunctionnalExeption {
        IDataCalculProbabilite data = getData(EPactesSombres.TOUCHES_SOUTENUES, true);
        
        Fraction probaTouche = new Fraction(2,3);
        Fraction probaBlesse = new Fraction(1,2);
        Fraction probaRateSauvegarde = new Fraction(1,3);
        Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaTouche).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
        
        Integer poolAttendu = 6;
        INoeudArbre racine = doTestStandard(data, probaAttendu, poolAttendu);
        validateBlessures(racine, 1);
    }
    
    @Test
    public void testAttaqueMarineDuChaosPacteCoupsMortelsContreSpaceMarine() throws FunctionnalExeption {
        IDataCalculProbabilite data = getData(EPactesSombres.COUPS_MORTELS, false);
        
        Fraction probaToucheAvecJetBlessure = new Fraction(1,2);
        Fraction probaToucheSansJetBlessure = new Fraction(1,6);
        Fraction probaBlesse = new Fraction(1,2);
        Fraction probaRateSauvegarde = new Fraction(1,2);
        
        Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaToucheAvecJetBlessure).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
        Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaToucheSansJetBlessure).addFraction(probaRateSauvegarde).build();
        
        Fraction probaAttendu = chemin1.add(chemin2);
        
        Integer poolAttendu = 9;
        INoeudArbre racine = doTestStandard(data, probaAttendu, poolAttendu);
        validateBlessures(racine, 2);
    }
    
    @Test
    public void testAttaqueMarineDuChaosPacteCoupsMortelsSpaceArmureMepris() throws FunctionnalExeption {
        IDataCalculProbabilite data = getData(EPactesSombres.COUPS_MORTELS, true);
        
        Fraction probaToucheAvecJetBlessure = new Fraction(1,2);
        Fraction probaToucheSansJetBlessure = new Fraction(1,6);
        Fraction probaBlesse = new Fraction(1,2);
        Fraction probaRateSauvegarde = new Fraction(1,3);
        
        Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaToucheAvecJetBlessure).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
        Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaToucheSansJetBlessure).addFraction(probaRateSauvegarde).build();
        
        Fraction probaAttendu = chemin1.add(chemin2);
        
        Integer poolAttendu = 6;
        INoeudArbre racine = doTestStandard(data, probaAttendu, poolAttendu);
        validateBlessures(racine, 2);
    }
    
    private void validateBlessures(INoeudArbre racine,int attendu) {
        int found = 0;
        for(INoeudArbre noeud:racine.arbre()) {
            if(noeud.getNatureNoeud() == ENatureNoeud.REUSSITE) {
                found++;
                Assertions.assertThat(noeud.mapBlessure()).hasSize(1);
                Integer nombreBlessure = noeud.mapBlessure().get(EBlessure.NORMALES);
                assertThat(nombreBlessure).isEqualTo(1);
                Assertions.assertThat(noeud.mapBlessuresAleatoires()).isEmpty();
            }
        }
        Assertions.assertThat(found).isEqualTo(attendu);
    }
    
    private IDataCalculProbabilite getData(EPactesSombres pacte, boolean isArmureMepris) {
        IContexteAction context = ContextActionForTestProbaBuilder.getInstance()
                .addSimule(ESimule.CORPS_A_CORPS_APRES_CHARGE)
                .addNumeroTour(2)
                .addEffectifInitialAttaquant(10)
                .addNombreAttaquant(10)
                .addMouvementAttaquant(EMouvement.NORMAL)
                .addMouvementDefenseur(EMouvement.NORMAL)
                .addBatimentAttaquant(new RecordBatiment(false, false))
                .addNombreDefenseur(10)
                .addBatimentDefenseur(new RecordBatiment(false, false))
                .addDistanceEntreBelligerant(0.0)
                .build();
        IConstituantAttaquant spaceMarineChaos = SpaceMarineDuChaosBuilderAttaque.getInstance(context, 10, pacte).build();
        IConstituantDefenseur spaceMarine = SpaceMarineBuilderDefense.getInstance(context, 10, isArmureMepris).build();
        return DataCalculProbabiliteBuilder.getInstance()
                .addAttaquant(spaceMarineChaos).addDefenseur(spaceMarine).addContextAction(context)
                .addGestionNombreAttaque(EGestionDe.SIMULATION_OPTIMISTE).addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE)
                .addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE).build();
    }
}

Problème: Il y a le cas où la sauvegarde n'est pas permise...
Il va falloir construire un cas de test!