Projet Calculateur

[Philou]

Et une armée de Fredo: Les Drukhari.

Je n'ai fais que ce qui est général à la faction. pas les sous factions (qui différentie kabalite, culte et gorgone).

Code:

curl -XPOST -v -d '{"langage":"fr","idCamp":"3","idFaction":"2","idSousFaction":"1","idSousSousFaction":"1"}' -H "Content-type: application/json" http://localhost:8080/regles/parRecherche

Code:

[
   {
      "factory":"com.calculateur.warhammer.data.regles.factory.drukhari.ReglePuissanceParLaSouffranceFactory",
      "ressource":{
         "id":32000,
         "ressource":"com.calculateur.warhammer.dto.regles.faction.drukhari.drukhari"
      },
      "donnees":[
         
      ],
      "description":"Tour 1: invulnérable 6+. Tour 2: Peut déclarer une charge au tour ou elle a advance. Tour 3: -1 au jet de touche et ignore à portée d\u0027engagement les malus des armes lourdes pour les véhicules et les monstres. Tour 4: Invulnérable à 5+. Tour 5: Ignore les tests de moral et est considéré comme ayant le double de PV pour les profils dégressifs.",
      "id":32000,
      "nom":"Puissance par la souffrance",
      "cleTraduction":"regle.puissance.souffrance",
      "libelle":"La Puissance Par La Souffrance"
   },
   {
      "factory":"com.calculateur.warhammer.data.regles.factory.drukhari.RegleArtisteDeLaLameFactory",
      "ressource":{
         "id":32000,
         "ressource":"com.calculateur.warhammer.dto.regles.faction.drukhari.drukhari"
      },
      "donnees":[
         
      ],
      "description":"Au corps à corps, tout jet naturel de 6 pour blesser améliore la PA de 1.",
      "id":32001,
      "nom":"Artiste des lames",
      "cleTraduction":"regle.artiste.lame",
      "libelle":"Artiste de la lame"
   }
]

règle puissance par la Souffrance:

Code:

package com.calculateur.warhammer.data.regles.regle.drukhari;

import java.util.Set;

import com.calculateur.warhammer.data.enumeration.EArme;
import com.calculateur.warhammer.data.enumeration.EProfil;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.factory.donnees.IDonneeFactory;

/**
* Implémentation règle la puissance par la souffrance en attaque
* @author phili
*
*/
public class ReglePuissanceParLaSouffranceAttaque implements IRegleAttaque{

    private static final Integer TOUR_3 = 3;

    private final boolean isPorteeEngagement;
    private final Set<EProfil> typesProfils;
    private final boolean isTour3;
    
    public ReglePuissanceParLaSouffranceAttaque(IDonneeFactory donnees) {
        isPorteeEngagement = donnees.getContexteAction().isZoneEngagement();
        typesProfils = donnees.getAttaquant().getProfil().getTypesProfils();
        isTour3 = donnees.getContexteAction().getNumeroTour() >= TOUR_3;
    }
    
    @Override
    public Integer getBonusJetTouche() {
        return isTour3?-1:0;
    }
    
    @Override
    public boolean isIgnoreMalusArme(EArme arme) {
        return isTour3 && isPorteeEngagement
                && arme == EArme.LOURDE
                    && (typesProfils.contains(EProfil.VEHICULE) || typesProfils.contains(EProfil.MONSTRE));
    }
}

Code:

package com.calculateur.warhammer.data.regles.regle.drukhari;

import com.calculateur.warhammer.data.regles.IRegleDefense;

/**
* La règle Puissance par la Souffrance en Défense
* @author phili
*
*/
public class ReglePuissanceParLaSouffranceDefense implements IRegleDefense{

    private static final Integer TOUR_1 = 1;
    private static final Integer TOUR_4 = 4;
    private static final Integer TOUR_5 = 5;
    
    private final Integer numeroTour;
    
    public ReglePuissanceParLaSouffranceDefense(Integer numeroTour) {
        this.numeroTour = numeroTour;
    }
    
    @Override
    public Integer getSauvegardeInvulnerable() {
        Integer sauvegardeInvulnerable;
        if(TOUR_1 <= numeroTour && numeroTour < TOUR_4) {
            sauvegardeInvulnerable = 6;
        }else {
            sauvegardeInvulnerable = 5;
        }
        return sauvegardeInvulnerable;
    }
    
    @Override
    public boolean isIgnoreTestCommandement() {
        return numeroTour >= TOUR_5;
    }
}

Code:

package com.calculateur.warhammer.data.regles.regle.drukhari;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import com.calculateur.warhammer.data.enumeration.EProfil;
import com.calculateur.warhammer.data.regles.IRegleAttaque;

/**
* Implémentation Règle Artiste de la Lame
* @author phili
*
*/
public class RegleArtisteDeLaLame implements IRegleAttaque{

    private final Set<EProfil> profils;
    
    public RegleArtisteDeLaLame(Set<EProfil> profils) {
        this.profils = profils;
    }
    
    @Override
    public Map<Integer, Integer> getMapJetBlessureBonusPA() {
        Map<Integer, Integer> mapReturn = new HashMap<>();
        if(!profils.contains(EProfil.BETE) && !profils.contains(EProfil.AERODYNE)) {
            mapReturn.put(6, -1);
        }
        return mapReturn;
    }
}

Code:

package com.calculateur.warhammer.data.regles.factory.drukhari;

import static org.junit.jupiter.api.Assertions.fail;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.parallel.Execution;
import org.junit.jupiter.api.parallel.ExecutionMode;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.enumeration.EArme;
import com.calculateur.warhammer.data.enumeration.EProfil;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.IRegleDefense;
import com.calculateur.warhammer.data.regles.factory.regle.AbstractFactoryRegleTest;

@Execution(ExecutionMode.SAME_THREAD)
@ExtendWith(MockitoExtension.class)
public class ReglePuissanceParLaSouffranceFactoryTest extends AbstractFactoryRegleTest{
        
    private final Integer TOUR_MAX = 5;
    
    public ReglePuissanceParLaSouffranceFactoryTest() {
        super(new ReglePuissanceParLaSouffranceFactory());
    }

    @Override
    protected boolean isRegleAttaqueAttendu() {
        return true;
    }

    @Override
    protected boolean isRegleDefenseAttendu() {
        return true;
    }
    
    @Test
    public void tesRegleAttaqueEngagementInfanterie() {
        doTestAttaque(true, EProfil.INFANTERIE);
    }
    
    @Test
    public void tesRegleAttaqueTirInfanterie() {
        doTestAttaque(false, EProfil.INFANTERIE);
    }
    
    @Test
    public void tesRegleAttaqueEngagementMonstre() {
        doTestAttaque(true, EProfil.MONSTRE);
    }
    
    @Test
    public void tesRegleAttaqueTirMonstre() {
        doTestAttaque(false, EProfil.MONSTRE);
    }
    
    @Test
    public void tesRegleAttaqueEngagementVehicule() {
        doTestAttaque(true, EProfil.VEHICULE);
    }
    
    @Test
    public void tesRegleAttaqueTirVehicule() {
        doTestAttaque(false, EProfil.VEHICULE);
    }
    
    private void doTestAttaque(boolean isZoneEngagement,EProfil typeProfil) {
        try {
            for(Integer numeroTour = 1; numeroTour < 6; numeroTour++) {
                initMockAttaque(numeroTour, isZoneEngagement, typeProfil);
                IRegleAttaque regle = factoryRegle.getRegleAttaque(donnees);
                for(EArme typeArme:EArme.values()) {
                    valideRegleAttaque(numeroTour, regle, typeProfil, typeArme);
                }
            }
        }catch(FunctionnalExeption e) {
            fail(e);
        }
    }
    
    private void initMockAttaque(Integer numeroTour,boolean isZoneEngagement,EProfil typeProfil) {
        Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
        
        Mockito.when(contexteAction.isZoneEngagement()).thenReturn(isZoneEngagement);
        Mockito.when(contexteAction.getNumeroTour()).thenReturn(numeroTour);
        
        Mockito.when(donnees.getAttaquant()).thenReturn(attaquant);
        Mockito.when(attaquant.getProfil()).thenReturn(profil);
        Set<EProfil> profils = new HashSet<>(Arrays.asList(typeProfil));
        Mockito.when(profil.getTypesProfils()).thenReturn(profils);
    }
    
    private void valideRegleAttaque(Integer numeroTour,IRegleAttaque regle,EProfil typeProfil,EArme type) {
        boolean isRegle = numeroTour >= 3;
        
        Integer bonusTouche = isRegle?-1:0;
        boolean isIgnoreMalus = isRegle && contexteAction.isZoneEngagement() && type == EArme.LOURDE && (typeProfil == EProfil.VEHICULE || typeProfil == EProfil.MONSTRE);
        
        Assertions.assertThat(regle.getBonusJetTouche()).isEqualTo(bonusTouche);
        Assertions.assertThat(regle.isIgnoreMalusArme(type)).isEqualTo(isIgnoreMalus);
    }
    
    @Test
    public void testRegleDefense() {
        try {
            IRegleDefense regle;
            for(Integer numeroTour = 1; numeroTour <= TOUR_MAX; numeroTour++) {
                initMockDefense(numeroTour);
                regle = factoryRegle.getRegleDefense(donnees);
                testRegleDefense(regle, numeroTour);
            }
        }catch(FunctionnalExeption e) {
            fail(e);
        }
    }
    
    private void initMockDefense(Integer numeroTour) {
        Mockito.when(donnees.getContexteAction()).thenReturn(contexteAction);
        Mockito.when(contexteAction.getNumeroTour()).thenReturn(numeroTour);
    }
    
    private void testRegleDefense(IRegleDefense regle,Integer numeroTour) {
        Integer sauvegardeInvulnerable;
        if(1 <= numeroTour && numeroTour < 4) {
            sauvegardeInvulnerable = 6;
        }else{
            sauvegardeInvulnerable = 5;
        }
        
        boolean isIgnoreTestCommandement = numeroTour >= 5;
        
        Assertions.assertThat(regle.getSauvegardeInvulnerable()).isEqualTo(sauvegardeInvulnerable);
        Assertions.assertThat(regle.isIgnoreTestCommandement()).isEqualTo(isIgnoreTestCommandement);
    }
}

Règle Artiste de la lame

Code:

package com.calculateur.warhammer.data.regles.regle.drukhari;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import com.calculateur.warhammer.data.enumeration.EProfil;
import com.calculateur.warhammer.data.regles.IRegleAttaque;

/**
* Implémentation Règle Artiste de la Lame
* @author phili
*
*/
public class RegleArtisteDeLaLame implements IRegleAttaque{

    private final Set<EProfil> profils;
    
    public RegleArtisteDeLaLame(Set<EProfil> profils) {
        this.profils = profils;
    }
    
    @Override
    public Map<Integer, Integer> getMapJetBlessureBonusPA() {
        Map<Integer, Integer> mapReturn = new HashMap<>();
        if(!profils.contains(EProfil.BETE) && !profils.contains(EProfil.AERODYNE)) {
            mapReturn.put(6, -1);
        }
        return mapReturn;
    }
}

Code:

package com.calculateur.warhammer.data.regles.factory.drukhari;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.IRegleDefense;
import com.calculateur.warhammer.data.regles.factory.donnees.IDonneeFactory;
import com.calculateur.warhammer.data.regles.factory.regle.IFactoryRegle;
import com.calculateur.warhammer.data.regles.regle.drukhari.RegleArtisteDeLaLame;

/**
* Factory de la règle Artiste de la lame.
* @author phili
*
*/
public class RegleArtisteDeLaLameFactory implements IFactoryRegle{

    @Override
    public IRegleAttaque getRegleAttaque(IDonneeFactory donnees) throws FunctionnalExeption {
        return new RegleArtisteDeLaLame(donnees.getAttaquant().getProfil().getTypesProfils());
    }

    @Override
    public IRegleDefense getRegleDefense(IDonneeFactory donnees) throws FunctionnalExeption {
        return null;
    }

    @Override
    public boolean isRegleApplicableAttaque() {
        return true;
    }

    @Override
    public boolean isRegleApplicableDefense() {
        return false;
    }

}

Code:

package com.calculateur.warhammer.data.regles.factory.drukhari;

import static org.junit.jupiter.api.Assertions.fail;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.parallel.Execution;
import org.junit.jupiter.api.parallel.ExecutionMode;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.enumeration.EProfil;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.factory.regle.AbstractFactoryRegleTest;

@Execution(ExecutionMode.SAME_THREAD)
@ExtendWith(MockitoExtension.class)
public class RegleArtisteDeLaLameFactoryTest extends AbstractFactoryRegleTest{

    public RegleArtisteDeLaLameFactoryTest() {
        super(new RegleArtisteDeLaLameFactory());
    }

    @Override
    protected boolean isRegleAttaqueAttendu() {
        return true;
    }

    @Override
    protected boolean isRegleDefenseAttendu() {
        return false;
    }

    @Test
    public void testRegle() {
        try {
            IRegleAttaque regle;
            for(EProfil typeProfil:EProfil.values()) {
                initMock(typeProfil);
                regle = factoryRegle.getRegleAttaque(donnees);
                valideRegle(regle, typeProfil);
            }
        }catch(FunctionnalExeption e) {
            fail(e);
        }
    }
    
    private void initMock(EProfil typeProfil) {
        Mockito.when(donnees.getAttaquant()).thenReturn(attaquant);
        Mockito.when(attaquant.getProfil()).thenReturn(profil);
        Set<EProfil> profils = new HashSet<>();
        profils.add(typeProfil);
        Mockito.when(profil.getTypesProfils()).thenReturn(profils);
    }
    
    private void valideRegle(IRegleAttaque regle,EProfil typeProfil) {
        Map<Integer,Integer> map;
        if(typeProfil == EProfil.AERODYNE || typeProfil == EProfil.BETE) {
            map = Collections.emptyMap();
        }else {
            map = new HashMap<>();
            map.put(6, -1);
        }
        
        Assertions.assertThat(regle.getMapJetBlessureBonusPA()).isEqualTo(map);
    }
}