Projet Calculateur

[Philou]

Et voilà, les bâtiments sont refondu en vue de la V10.

Rappel Avant:

Code:

package com.calculateur.warhammer.data.identifiable;

/**
* Cette interface représente un batiment à 40K
* @author phili
*
*/
public interface IBatiment{

    /**
     *
     * @return Vrai si le terrain est dificile
     */
    boolean isTerrainDifficile();
    
    /**
     *
     * @return Vrai si le batiment est défendable
     */
    boolean isDefendable();
    
    /**
     *
     * @return Vrai si le batiment est un couvert dense
     */
    boolean isCouvertDense();
    
    /**
     *
     * @return Vrai si le batiment est un couvert léger
     */
    boolean isCouvertLeger();
    
    /**
     *
     * @return Vrai si le batiment est un couvert lourd
     */
    boolean isCouvertLourd();
    
    /**
     *
     * @return Vrai si bâtiment est exaltant
     */
    boolean isExaltant();
}

Mais maintenant, fini tout ça:

Code:

package com.calculateur.warhammer.data.identifiable;

/**
* Cette interface représente un batiment à 40K
* @author phili
*
*/
public interface IBatiment{

    /**
     *
     * @return Vrai si le batiment permet d'avoir au tir une sauvegarde de couvert.
     */
    boolean isSauvegardeCouvert();
    
    /**
     *
     * @return Vrai si au tir, le tireur améliore sa PA.
     */
    boolean isAmeliorationPA();
}

Ce qui simplifie les TU:

Code:

package com.calculateur.warhammer.data.regles;

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.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.IBatiment;

@Execution(ExecutionMode.SAME_THREAD)
@ExtendWith(MockitoExtension.class)
public class RegleAttaqueBatimentTest {

    @Mock
    private IBatiment batiment;
    
    @Test
    public void testAmeliorationPARuineNiveauSol() {
        testAmeliorationPA(false);
    }
    
    @Test
    public void testAmeliorationPARuineEtage() {
        testAmeliorationPA(true);
    }
    
    private void testAmeliorationPA(boolean isAmelioration) {
        Mockito.when(batiment.isAmeliorationPA()).thenReturn(isAmelioration);
        IRegleAttaque regle;
        boolean isVraimentAmelioration;
        Integer bonusPA;
        for(ESimule simule:ESimule.values()) {
            regle = new RegleAttaqueBatiment(batiment, simule);
            isVraimentAmelioration = isAmelioration && simule.isActionTir();
            bonusPA = isVraimentAmelioration?-1:0;
            Assertions.assertThat(regle.getBonusPA()).isEqualTo(bonusPA);
        }
    }
}

Code:

package com.calculateur.warhammer.data.regles;

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.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.IBatiment;

@Execution(ExecutionMode.SAME_THREAD)
@ExtendWith(MockitoExtension.class)
public class RegleDefenseBatimentTest {

    @Mock
    private IBatiment batiment;

    @Test
    public void testSauvegardeDecouvert() {
        testSauvegardeCouvert(false);
    }
    
    @Test
    public void testSauvegardeRuine() {
        testSauvegardeCouvert(true);
    }
    
    private void testSauvegardeCouvert(boolean isSauvegardeCouvert) {
        Mockito.when(batiment.isSauvegardeCouvert()).thenReturn(isSauvegardeCouvert);
        IRegleDefense regle;
        for(ESimule simule:ESimule.values()) {
            regle = new RegleDefenseBatiment(batiment, simule);
            Assertions.assertThat(regle.isSauvegardeCouvert()).isEqualTo(isSauvegardeCouvert && simule.isActionTir());
        }
    }
}

Et l'implémentation:

Code:

package com.calculateur.warhammer.data.regles;

import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.IBatiment;

/**
* Règle pour l'attaquant étant dans un bâtiment
* @author phili
*
*/
public class RegleAttaqueBatiment implements IRegleAttaque {

    private final IBatiment batiment;

    private final ESimule simule;

    public RegleAttaqueBatiment(IBatiment batiment, ESimule simule) {
        this.batiment = batiment;
        this.simule = simule;
    }
    
    @Override
    public Integer getBonusPA() {
        return (batiment.isAmeliorationPA() && simule.isActionTir())?-1:IRegleAttaque.super.getBonusPA();
    }
}

Code:

package com.calculateur.warhammer.data.regles;

import com.calculateur.warhammer.data.enumeration.ESimule;
import com.calculateur.warhammer.data.identifiable.IBatiment;

public class RegleDefenseBatiment implements IRegleDefense{

    private final IBatiment batiment;

    private final ESimule simule;

    public RegleDefenseBatiment(IBatiment batiment, ESimule simule) {
        this.batiment = batiment;
        this.simule = simule;
    }
    
    @Override
    public boolean isSauvegardeCouvert() {
        return batiment.isSauvegardeCouvert() && simule.isActionTir();
    }
}

J'en ai aussi profité pour simplifier ce qui est autour du bâtiment.
Déjà, suppression du bâtiment de la BDD.
Ensuite, simplification de la couche DTO (Data Transfert Object) qui est ce qui est donné (sous forme de JSON) au client.

J'ai déja enuméré par DTO les 2 règles existantes:

Code:

package com.calculateur.warhammer.dto;

import java.util.Arrays;
import java.util.Optional;

import com.calculateur.warhammer.base.builder.IBuilder;
import com.calculateur.warhammer.dto.contrat.IEnumDTO;

/**
* Enumération qui décrit une règle de batiment.
* @author phili
*
*/
public enum EDescriptionRegleBatimentDTO implements IEnumDTO,IBuilder<DescriptionRegleBatimentDTO>{
    
    SAUVEGARDE_COUVERT(1,"batiment.sauvegarde.couvert"),
    AMELIORATION_PA(2,"batiment.amelioration.pa");

    private final Integer id;
    
    private final String cleTraduction;
    
    private EDescriptionRegleBatimentDTO(Integer id, String cleTraduction) {
        this.id = id;
        this.cleTraduction = cleTraduction;
    }

    @Override
    public Integer getId() {
        return id;
    }

    @Override
    public String getCleTraduction() {
        return cleTraduction;
    }

    @Override
    public DescriptionRegleBatimentDTO build() {
        DescriptionRegleBatimentDTO dto = new DescriptionRegleBatimentDTO();
        dto.setEnumeration(this);
        return dto;
    }
    
    public static EDescriptionRegleBatimentDTO getByCleTraduction(String cle) {
        Optional<EDescriptionRegleBatimentDTO> o = Arrays.asList(EDescriptionRegleBatimentDTO.values()).stream().filter(e -> e.getCleTraduction().equals(cle)).findFirst();
        return o.isPresent()?o.get():null;
    }
}

Ce qui permet de le sortir à l'extérieur pour un futur JSON:

Code:

package com.calculateur.warhammer.dto;

/**
* DTO pour décrire la règle d'un bâtiment.
* @author phili
*
*/
public class DescriptionRegleBatimentDTO extends AbstractLibelleEtDescriptionParEnumerationDTO<EDescriptionRegleBatimentDTO>{

    /**
     *
     */
    private static final long serialVersionUID = 1L;

    private static final String RESOURCES_TRADUCTION = "com.calculateur.warhammer.dto.description_regle_batiment.description_regle_batiment";
    
    @Override
    public String getResourceBudleAsString() {
        return RESOURCES_TRADUCTION;
    }

}

C'est donc une énumération pour DTO qui implémentera l'interface de règle:

Code:

package com.calculateur.warhammer.dto;

import java.util.Arrays;
import java.util.Optional;

import com.calculateur.warhammer.base.builder.IBuilder;
import com.calculateur.warhammer.data.identifiable.IBatiment;
import com.calculateur.warhammer.dto.contrat.IEnumDTO;

public enum EBatimentDTO implements IBatiment,IEnumDTO,IBuilder<BatimentDTO>{
    AUCUN(1,"batiment.aucun",false,false),
    CRATERE(2,"batiment.cratere",true,false),
    DECOMBRES(3,"batiment.decombres",true,false),
    BARRICADES(4,"batiment.barricades",true,false),
    PIPELINE(5,"batiment.pipeline",true,false),
    DEBRIS_CHAMPS_BATAILLE(6,"batiment.debris.champs.bataille",true,false),
    COLLINES(7,"batiment.colline",true,false),
    FORET(8,"batiment.foret",true,false),
    RUINE(9,"batiment.ruine",true,false),
    RUINE_HAUTEUR(10,"batiment.ruine.hauteur",true,true);

    private Integer id;
    
    private String cleTraduction;
    
    private boolean isCouvert;
    
    private boolean isAmeliorationPA;
    
    private EBatimentDTO(Integer id, String cleTraduction, boolean isCouvert, boolean isAmeliorationPA) {
        this.id = id;
        this.cleTraduction = cleTraduction;
        this.isCouvert = isCouvert;
        this.isAmeliorationPA = isAmeliorationPA;
    }

    @Override
    public Integer getId() {
        return id;
    }

    @Override
    public String getCleTraduction() {
        return cleTraduction;
    }

    @Override
    public boolean isSauvegardeCouvert() {
        return isCouvert;
    }

    @Override
    public boolean isAmeliorationPA() {
        return isAmeliorationPA;
    }

    @Override
    public BatimentDTO build() {
        BatimentDTO dto = new BatimentDTO();
        dto.setEnumeration(this);
        return dto;
    }
    
    public static EBatimentDTO getByCleTraduction(String cle) {
        Optional<EBatimentDTO>  o = Arrays.asList(EBatimentDTO.values()).stream().filter(e -> e.getCleTraduction().equals(cle)).findFirst();
        return o.isPresent()?o.get():null;
    }
}

Que l'on s'empresse également de sortir:

Code:

package com.calculateur.warhammer.dto;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

public class BatimentDTO extends AbstractLibelleParEnumerationDTO<EBatimentDTO>{

    /**
     *
     */
    private static final long serialVersionUID = 1L;

    private static final String RESOURCES_TRADUCTION = "com.calculateur.warhammer.dto.batiment.batiment";
    
    private List<DescriptionRegleBatimentDTO> descriptions;
    
    @Override
    public String getResourceBudleAsString() {
        return RESOURCES_TRADUCTION;
    }

    @Override
    public void traduireLibelles(Locale locale) {
        super.traduireLibelles(locale);
        for(DescriptionRegleBatimentDTO description:descriptions) {
            description.traduireLibelles(locale);
        }
    }
    
    @Override
    public void setEnumeration(EBatimentDTO enumeration) {
        super.setEnumeration(enumeration);
        descriptions = new ArrayList<>();
        if(enumeration != null) {
            if(enumeration.isSauvegardeCouvert()) {
                descriptions.add(EDescriptionRegleBatimentDTO.SAUVEGARDE_COUVERT.build());
            }
            if(enumeration.isAmeliorationPA()) {
                descriptions.add(EDescriptionRegleBatimentDTO.AMELIORATION_PA.build());
            }
        }
    }
    
    public List<DescriptionRegleBatimentDTO> getDescriptions() {
        return descriptions;
    }
    
    public void setDescriptions(List<DescriptionRegleBatimentDTO> descriptions) {
        this.descriptions = descriptions;
    }
}

Ce qui donne après une légère refonte du client:

  batimant-v10-1.jpg (Size: 158.35 KB / Downloads: 1)

  batimant-v10-2.jpg (Size: 155.75 KB / Downloads: 1)

Do List:
Les jets de dés.