Projet Calculateur

[Philou]

Et assez rapidement, on teste les marines dans la boite Leviathan: l'escouade Infernus.

Un nouveau TU est écrit:

Code:

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

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.SpaceMarineBuilderAttaque;
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;

public class SpaceMarineInfernusVsTermagantTirTest extends AbstractCalculArbreTest{

    @Test
    public void testMarineContreTermagantDecouvert() throws FunctionnalExeption {
        IContexteAction contexte = getContexteAction(false);
        IDataCalculProbabilite data = getData(contexte, ESermentInstantChoix.NON);
        testMarineContreTermagantSansRelance(data);
    }
    
    @Test
    public void testMarineContreTermagantCouvert() throws FunctionnalExeption {
        IContexteAction contexte = getContexteAction(true);
        IDataCalculProbabilite data = getData(contexte, ESermentInstantChoix.NON);
        testMarineContreTermagantSansRelance(data);
    }
    
    private void testMarineContreTermagantSansRelance(IDataCalculProbabilite dada) throws FunctionnalExeption {
        Fraction probaBlesse = new Fraction(2, 3);
        Fraction probaRateSauvegarde = new Fraction(2,3);
        Fraction probaAttendu = FractionCheminBuilder.getInstance().addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
        Integer pool = 26;
        INoeudArbre noeud = doTestStandard(dada, probaAttendu, pool);
        int nombreChemin = 0;
        Integer blessure;
        for(INoeudArbre aNoeud:noeud.arbre()) {
            if(aNoeud.getNatureNoeud() == ENatureNoeud.REUSSITE) {
                nombreChemin++;
                Assertions.assertThat(aNoeud.mapBlessure()).hasSize(1);
                blessure = aNoeud.mapBlessure().get(EBlessure.NORMALES);
                Assertions.assertThat(blessure).isEqualTo(1);
                Assertions.assertThat(aNoeud.mapBlessuresAleatoires()).isEmpty();
            }
        }
        Assertions.assertThat(nombreChemin).isEqualTo(1);
    }
    
    @Test
    public void testMarineContreTermagantDecouvertSermentInstant() throws FunctionnalExeption {
        IContexteAction contexte = getContexteAction(false);
        IDataCalculProbabilite data = getData(contexte, ESermentInstantChoix.OUI);
        testMarineContreTermagantAvecRelance(data);
    }
    
    @Test
    public void testMarineContreTermagantCouvertSermentInstant() throws FunctionnalExeption {
        IContexteAction contexte = getContexteAction(true);
        IDataCalculProbabilite data = getData(contexte, ESermentInstantChoix.OUI);
        testMarineContreTermagantAvecRelance(data);
    }
    
    private void testMarineContreTermagantAvecRelance(IDataCalculProbabilite dada) throws FunctionnalExeption {
        Fraction probaBlesse = new Fraction(2, 3);
        Fraction probaRateBlesse = new Fraction(1,3);
        Fraction probaRateSauvegarde = new Fraction(2,3);
        
        Fraction chemin1 = FractionCheminBuilder.getInstance().addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
        Fraction chemin2 = FractionCheminBuilder.getInstance().addFraction(probaRateBlesse).addFraction(probaBlesse).addFraction(probaRateSauvegarde).build();
        Fraction probaAttendu = chemin1.add(chemin2);
        
        Integer pool = 34;
        INoeudArbre noeud = doTestStandard(dada, probaAttendu, pool);
        int nombreChemin = 0;
        Integer blessure;
        for(INoeudArbre aNoeud:noeud.arbre()) {
            if(aNoeud.getNatureNoeud() == ENatureNoeud.REUSSITE) {
                nombreChemin++;
                Assertions.assertThat(aNoeud.mapBlessure()).hasSize(1);
                blessure = aNoeud.mapBlessure().get(EBlessure.NORMALES);
                Assertions.assertThat(blessure).isEqualTo(1);
                Assertions.assertThat(aNoeud.mapBlessuresAleatoires()).isEmpty();
            }
        }
        Assertions.assertThat(nombreChemin).isEqualTo(2);
    }
    
    
    private IDataCalculProbabilite getData(IContexteAction contexteAction,ESermentInstantChoix choix) {
        SpaceMarineBuilderAttaque builderAttaquant = SpaceMarineBuilderAttaque.getInstance(contexteAction, 10).equipeAvecPyroBlaster();
        builderAttaquant.addBatiment(contexteAction.getBatimentAttaquant());
        builderAttaquant.addSermentInstant(choix);
        
        TermagantBuilderDefense builderDefenseur = TermagantBuilderDefense.getInstance(contexteAction, 10);
        builderDefenseur.addBatiment(contexteAction.getBatimentDefenseur());
        
        return DataCalculProbabiliteBuilder.getInstance()
                .addContextAction(contexteAction).addAttaquant(builderAttaquant.build()).addDefenseur(builderDefenseur.build())
                .addGestionNombreAttaque(EGestionDe.SIMULATION_OPTIMISTE).addGestionJetToucheBlessure(EGestionDe.SIMULATION_OPTIMISTE)
                .addGestionSauvegardeDefenseur(EGestionDe.SIMULATION_OPTIMISTE).build();
                
        
    }
    
    private IContexteAction getContexteAction(boolean defenseurCouvert) {
        return 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(defenseurCouvert, false))
                .addDistanceEntreBelligerant(6.0)
                .build();
    }
}

Ce qui permet de finir le code de calcul:

Code:

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

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.calcul.mort.arbre.INoeudArbre;
import com.calculateur.warhammer.calcul.mort.arbre.NoeudJetBlessure;
import com.calculateur.warhammer.calcul.mort.arbre.NoeudJetTouche;
import com.calculateur.warhammer.calcul.mort.arbre.data.IDataCalculProbabilite;
import com.calculateur.warhammer.calcul.mort.parametres.IParametres;
import com.calculateur.warhammer.calcul.mort.validation.IValidationCalcul;
import com.calculateur.warhammer.calcul.mort.validation.ValidationContextAction;

public class CalculArbre implements ICalculArbre{

    private final IParametres parametres;
    
    private final IValidationCalcul validationContext;
    
    public CalculArbre(IParametres parametres) {
        this.parametres = parametres;
        validationContext = new ValidationContextAction();
    }

    @Override
    public INoeudArbre getRacine(IDataCalculProbabilite data) throws FunctionnalExeption {
        //Validation
        validationContext.valideCalcul(data);
        
        for(IValidationCalcul validationCalcul:parametres.getFactoryValidation().getValidations(data.getContexteAction().getSimule())) {
            validationCalcul.valideCalcul(data);
        }
        
        //Initialisation diverse
        parametres.getFactoryInitialisation().getInterfaceInitialisationAttaquant().initialiseAttaquant(data.getAttaquant());
        
        Integer nombreAttaque = parametres.getFactoryAttaque().getInterfaceCalculNombreAttaque(data.getGestionNombreAttaque()).getNombreAttaque(data)
                * data.getAttaquant().getNombre();
        INoeudArbre racine;
        
        if(data.getAttaquant().getRegles().isIgnoreJetTouche()) {
            racine = NoeudJetBlessure.getJetBlessureAsRacine(data, parametres, nombreAttaque);
        }else {
            racine = NoeudJetTouche.getJetToucheAsRacine(nombreAttaque, data, parametres);
        }
        return racine;
    }

}