Projet Calculateur

[Philou]

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();
    }
}