1
2
3
4
5
6
7
8
9
10
11
12
13
public interface Dao<T> {
    
    Optional<T> get(long id);
    
    List<T> getAll();
    
    void save(T t);
    
    void update(T t, String[] params);
    
    void delete(T t);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.developpez.dao;

import java.sql.Connection;
import com.developpez.jdbc.ConnectionPostgreSQL;

public abstract class DAO<T> {

    public Connection connect = ConnectionPostgreSQL.getInstance();
    
    /**
     * Permet de récupérer un objet via son ID
     * @param id
     * @return
     */
    public abstract T find(long id);
    
    /**
     * Permet de créer une entrée dans la base de données
     * par rapport à un objet
     * @param obj
     */
    public abstract T create(T obj);
    
    /**
     * Permet de mettre à jour les données d'une entrée dans la base 
     * @param obj
     */
    public abstract T update(T obj);
    
    /**
     * Permet la suppression d'une entrée de la base
     * @param obj
     */
    public abstract void delete(T obj);
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.calculateur.warhammer.base.entity;

/**
 * Représente une entité en BDD
 * @author phili
 *
 */
public interface IEntity <I>{

	/**
	 * 
	 * @return L'identifiant en BDD
	 */
	I getId();
	
	/**
	 * Set l'id en BDD
	 * @param id L'id à setter
	 */
	void setId(I id);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package com.calculateur.warhammer.base.dao;

import java.util.List;

import com.calculateur.warhammer.base.entity.IEntity;
import com.calculateur.warhammer.base.exception.DAOException;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;

/**
 * DAO pour une entité en BDD
 * @author phili
 *
 * @param <I> Type de l'id de l'entité
 * @param <E> L'entité
 */
public interface IDAO <I,E extends IEntity<I>>{

	/**
	 * Sauvegarde l'entité en BDD (Création)
	 * @param entity L'entité à sauvegarder
	 * @return L'entité à créer
	 * @throws DAOException Si problèeme en BDD
	 * @throws FunctionnalExeption Si problème à la vérification avant d'insérer en BDD
	 */
	E save(E entity)throws DAOException,FunctionnalExeption;
	
	/**
	 * Met à jour l'entit en BDD
	 * @param entity L'entité à modifier
	 * @return L'entité modifiée
	 * @throws DAOException Si problème en BDD
	 * @throws FunctionnalExeption Si problème avant de vérifier l'entité
	 */
	E update(E entity)throws DAOException,FunctionnalExeption;
	
	/**
	 * 
	 * @param id Id de l'entité
	 * @return L'id correspondant à l'entité (null sinon)
	 * @throws DAOException Si problème en BDD
	 */
	E getById(I id) throws DAOException;
	
	/**
	 * 
	 * @return La liste des entité présente en BDD
	 * @throws DAOException Si problème en BDD
	 */
	List<E> getAll() throws DAOException;
	
	/**
	 * Efface en BDD l'entité correspondant à l'identifiant
	 * @param id L'id de l'entité
	 * @throws DAOException Si problème en BDD
	 */
	void delete(I id)throws DAOException;
	
	/**
	 * 
	 * @return Le nombre d'occurence en BDD
	 * @throws DAOException
	 */
	Long count()throws DAOException;	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
package com.calculateur.warhammer.base.dao;

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

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

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

import com.calculateur.warhammer.base.entity.IEntity;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.base.traduction.AbstractTraductionTest;

public abstract class AbstractDAOTest <I, E extends IEntity<I>,DAO extends IDAO<I, E>>{

	protected final String STRING_TEST = "TEST";
	
	protected final String STRING_TEST2 = "TEST2";
	
	protected final String EMPTY_STRING = "";
	
	protected abstract DAO getDAO();
	
	protected abstract List<E> getErrorsEntities();
	
	protected abstract I getIdWithNothingInDatabase();
	
	protected abstract E getEntityForInsertion();
	
	protected abstract void compareEntities(E base,E aComparer);
	
	protected abstract void updateEntity(E toUpdate);
	
	protected abstract void assertUpdate(E anEntity);
	
	protected abstract void testSupplementaires(E entityTest);
	
	@Test
	public void testDAO() {
		DAO dao = getDAO();
		//Test insertion avec erreur
		for(E entityWithError:getErrorsEntities()) {
			try {
				dao.save(entityWithError);
			}catch(Exception e) {
				Assertions.assertThat(e).isInstanceOf(FunctionnalExeption.class);
				verifieErreurFonctionnelle((FunctionnalExeption)e);
			}
		}
		try {
			final Long initial = dao.count();
			//Sauver
			E entity = getEntityForInsertion();
			entity = dao.save(entity);
			Long courant = dao.count();
			Assertions.assertThat(courant - initial).isEqualTo(1L);
			//Get By Id
			E aEntity = dao.getById(entity.getId());
			compareEntities(entity, aEntity);
			E aEntity2 = dao.getById(getIdWithNothingInDatabase());
			Assertions.assertThat(aEntity2).isNull();
			//Liste tout
			List<E> entities = dao.getAll();
			Assertions.assertThat(entities).hasSize(courant.intValue());
			//Test update
			updateEntity(entity);
			entity = dao.update(entity);
			aEntity = dao.getById(entity.getId());
			assertUpdate(aEntity);
			//Test supplémentaire
			testSupplementaires(aEntity);
			//Test delete
			dao.delete(entity.getId());
			courant = dao.count();
			Assertions.assertThat(initial - courant).isEqualTo(0L);
		}catch (Exception e) {
			fail(e.getMessage());
		}
	}
	
	private void verifieErreurFonctionnelle(FunctionnalExeption e) {
		for(Locale locale :AbstractTraductionTest.LOCALES_APPLICATION) {
			e.traduireLibelles(locale);
			Assertions.assertThat(e.getErreursTraduites().isEmpty()).isFalse();
		}
	}
	
	protected String getToLongString(int size) {
		StringBuilder sb = new StringBuilder();
		while(sb.length() <= size) {
			sb.append(STRING_TEST);
		}
		return sb.toString();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
package com.calculateur.warhammer.dao.dao;

import java.util.List;

import javax.inject.Inject;
import javax.inject.Named;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;


import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import com.calculateur.warhammer.base.dao.IDAO;
import com.calculateur.warhammer.base.entity.IEntity;
import com.calculateur.warhammer.base.exception.DAOException;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.dao.verification.VerificationUtils;


/**
 * Template Method pour les DAO avec JPA
 * @author phili
 *
 * @param <I> Type de l'id
 * @param <E> Type de l'entité
 */
public abstract class AbstractDAO<I,E extends IEntity<I>> implements IDAO<I, E>{

	@PersistenceContext
	protected EntityManager em;
	
	@Inject
	@Named("transactionManager")
	protected PlatformTransactionManager transactionManager;
	
	/**
	 * 
	 * @return La classe sous forme de String pour les Query JPQL
	 */
	protected abstract String getEntityClass();
	
	/**
	 * 
	 * @return Le libellé de l'entité pour les query JPQL
	 */
	protected abstract String getEntityLibelle();
	
	/**
	 * 
	 * @return Le resource Bundle d'erreur pour les erreurs fonctionnelles
	 */
	protected abstract String getErrorBundle();
	
	/**
	 * 
	 * @return L'entité sous forme de classe
	 */
	protected abstract Class<E> getClassEntity();
	
	@Override
	public E save(E entity) throws DAOException, FunctionnalExeption {
		VerificationUtils.verifie(entity, getErrorBundle());
		TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
		try {
			em.persist(entity);
			transactionManager.commit(status);
			return entity;
		}catch (Exception e) {
			transactionManager.rollback(status);
			throw new DAOException(e);
		}
	}
	
	@Override
	public E update(E entity) throws DAOException, FunctionnalExeption {
		VerificationUtils.verifie(entity, getErrorBundle());
		TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
		try {
			E rEntity = em.merge(entity);
			transactionManager.commit(status);
			return rEntity;
		}catch (Exception e) {
			transactionManager.rollback(status);
			throw new DAOException(e);
		}
	}
	
	@Override
	public E getById(I id) throws DAOException {
		try {
			return em.find(getClassEntity(), id);
		}catch(Exception e) {
			throw new DAOException(e);
		}
	}
	
	@SuppressWarnings("unchecked")
	@Override
	public List<E> getAll() throws DAOException {
		try {
			Query query = em.createQuery(getJpqlAll());
			return query.getResultList();
		}catch(Exception e) {
			throw new DAOException(e);
		}
	}
	
	/**
	 * 
	 * @return Le JPQL pour avoir toutes les entités
	 */
	private String getJpqlAll() {
		StringBuilder sb = new StringBuilder("SELECT ");
		sb.append(getEntityLibelle());
		sb.append(" FROM ");
		sb.append(getEntityClass());
		sb.append(" ");
		sb.append(getEntityLibelle());
		return sb.toString();
	}
	
	@Override
	public void delete(I id) throws DAOException {
		TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
		try {
			Query queryDelete = getDeleteQuery(id);
			queryDelete.executeUpdate();
			transactionManager.commit(status);
		}catch(Exception e) {
			transactionManager.rollback(status);
			throw new DAOException(e);
		}
		
	}
	
	/**
	 * On laisse la possibilité de surcharger cette méthode au cas où l'id soit complexe (clé sur 2 colonnes par exemple).
	 * @param id L'id de l'entité à supprimer en BDD.
	 * @return La query pour effacer l'entité (le paramètrage est fait.
	 */
	protected Query getDeleteQuery(I id) {
		Query query = em.createQuery(getDeleteJpql());
		query.setParameter("id", id);
		return query;
	}
	
	/**
	 * On laisse la possibilité de surcharger cette méthode au cas où l'id soit complexe (clé sur 2 colonnes par exemple).
	 * @return JPQL pour suprimer une entité
	 */
	protected String getDeleteJpql() {
		StringBuilder sb = new StringBuilder("DELETE ");
		sb.append(" FROM ");
		sb.append(getEntityClass());
		sb.append(" ");
		sb.append(getEntityLibelle());
		sb.append(" WHERE ");
		sb.append(getEntityLibelle());
		sb.append(".id = : id");
		return sb.toString();
	}
	
	@Override
	public Long count() throws DAOException {
		try {
			Query query = em.createQuery(getJpqlCount());
			return (Long) query.getSingleResult();
		}catch (Exception e) {
			throw new DAOException(e);
		}
	}
	
	/**
	 * 
	 * @return Le JPQL pour compter ce qui est en BDD.
	 */
	private String getJpqlCount() {
		StringBuilder sb = new StringBuilder("SELECT DISTINCT(COUNT(");
		sb.append(getEntityLibelle());
		sb.append(")) FROM ");
		sb.append(getEntityClass());
		sb.append(" ");
		sb.append(getEntityLibelle());
		return sb.toString();
	}
}

1
2
3
4
@Inject
@Named("transactionManager")
protected PlatformTransactionManager transactionManager;

1
2
3
4
5
6
7
8
9
10
TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
try {
	em.persist(entity);
	transactionManager.commit(status);
	return entity;
}catch (Exception e) {
	transactionManager.rollback(status);
	throw new DAOException(e);
}

1
2
TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());

1
2
transactionManager.commit(status);

1
2
transactionManager.rollback(status);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
package com.calculateur.warhammer.entity.entity;

import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;

import org.hibernate.validator.constraints.Length;

import com.calculateur.warhammer.base.entity.IEntity;

@Entity
@Table(name = "CAMP")
public class CampEntity implements IEntity<Integer>{

	@Id
	@Column(name = "ID_CAMP",nullable = false)
	@NotNull(message = "id.null")
	private Integer id;
	
	@Column(name = "NOM_CAMP",length = 50,nullable = false)
	@NotNull(message = "nom.null")
	@NotEmpty(message = "nom.empty")
	@Length(max = 50,message = "nom.size")
	private String nom;
	
	@Column(name = "CLE_TRADUCTION_CAMP",length = 50,nullable = false)
	@NotNull(message = "cle.traduction.null")
	@NotEmpty(message = "cle.traduction.empty")
	@Length(max = 50,message = "cle.traduction.size")
	private String cleTraduction;
	
	@OneToMany(mappedBy = "camp",fetch = FetchType.LAZY)
	private Set<FactionEntity> factions;
	
	@Override
	public Integer getId() {
		return id;
	}

	@Override
	public void setId(Integer id) {
		this.id = id;
	}
	
	public String getNom() {
		return nom;
	}
	
	public void setNom(String nom) {
		this.nom = nom;
	}
	
	public String getCleTraduction() {
		return cleTraduction;
	}

	public void setCleTraduction(String cleTraduction) {
		this.cleTraduction = cleTraduction;
	}
	
	public Set<FactionEntity> getFactions() {
		return factions;
	}
	
	public void setFactions(Set<FactionEntity> factions) {
		this.factions = factions;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.calculateur.warhammer.dao.dao;

import javax.inject.Named;

import com.calculateur.warhammer.entity.entity.CampEntity;

/**
 * DAO de CampEntity
 * @author phili
 *
 */
@Named("campDAO")
public class CampDAO extends AbstractDAO<Integer, CampEntity>{

	private static final String ENTITY_CLASS = "CampEntity";
	
	private static final String ENTITY_LIBELLE = "campEntity";
	
	private static final String RES = "com.calculateur.warhammer.entity.camp.camp";
	
	@Override
	protected String getEntityClass() {
		return ENTITY_CLASS;
	}

	@Override
	protected String getEntityLibelle() {
		return ENTITY_LIBELLE;
	}

	@Override
	protected String getErrorBundle() {
		return RES;
	}

	@Override
	protected Class<CampEntity> getClassEntity() {
		return CampEntity.class;
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
package com.calculateur.warhammer.dao.dao;

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

import javax.inject.Inject;
import javax.inject.Named;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;

import com.calculateur.warhammer.base.dao.AbstractDAOTest;
import com.calculateur.warhammer.base.dao.IDAO;
import com.calculateur.warhammer.dao.builder.CampEntityBuilder;
import com.calculateur.warhammer.dao.configuration.ConfigurationTestBDDH2;
import com.calculateur.warhammer.entity.entity.CampEntity;

@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = {ConfigurationTestBDDH2.class})
public class CampDAOTest extends AbstractDAOTest<Integer, CampEntity, IDAO<Integer,CampEntity>>{
	
	private static final Integer ID_INSERTION = 100;
	private static final Integer ID_NOT_IN_DATABASE = 101;
	
	@Inject
	@Named("campDAO")
	private IDAO<Integer, CampEntity> campDAO;

	
	
	@Override
	protected IDAO<Integer, CampEntity> getDAO() {
		return campDAO;
	}

	@Override
	protected List<CampEntity> getErrorsEntities() {
		List<CampEntity> entities = new ArrayList<>();
		//Id
		entities.add(CampEntityBuilder.getInstance().addId(null).addNom(STRING_TEST).addCleTraduction(STRING_TEST).build());
		//Nom
		entities.add(CampEntityBuilder.getInstance().addId(ID_INSERTION).addNom(null).addCleTraduction(STRING_TEST).build());
		entities.add(CampEntityBuilder.getInstance().addId(ID_INSERTION).addNom(EMPTY_STRING).addCleTraduction(STRING_TEST).build());
		entities.add(CampEntityBuilder.getInstance().addId(ID_INSERTION).addNom(getToLongString(50)).addCleTraduction(STRING_TEST).build());
		//Clé de traduction
		entities.add(CampEntityBuilder.getInstance().addId(ID_INSERTION).addNom(STRING_TEST).addCleTraduction(null).build());
		entities.add(CampEntityBuilder.getInstance().addId(ID_INSERTION).addNom(STRING_TEST).addCleTraduction(EMPTY_STRING).build());
		entities.add(CampEntityBuilder.getInstance().addId(ID_INSERTION).addNom(STRING_TEST).addCleTraduction(getToLongString(50)).build());
		return entities;
	}

	@Override
	protected Integer getIdWithNothingInDatabase() {
		return ID_NOT_IN_DATABASE;
	}

	@Override
	protected CampEntity getEntityForInsertion() {
		return CampEntityBuilder.getInstance().addId(ID_INSERTION).addNom(STRING_TEST).addCleTraduction(STRING_TEST).build();
	}

	@Override
	protected void compareEntities(CampEntity base, CampEntity aComparer) {
		Assertions.assertThat(aComparer.getId()).isEqualTo(base.getId());
		
	}

	@Override
	protected void updateEntity(CampEntity toUpdate) {
		toUpdate.setNom(STRING_TEST2);
		toUpdate.setCleTraduction(STRING_TEST2);
		
	}

	@Override
	protected void assertUpdate(CampEntity anEntity) {
		Assertions.assertThat(anEntity.getNom()).isEqualTo(STRING_TEST2);
		Assertions.assertThat(anEntity.getCleTraduction()).isEqualTo(STRING_TEST2);
	}

	@Override
	protected void testSupplementaires(CampEntity entityTest) {
		//Rien
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
package com.calculateur.warhammer.entity.entity;

import javax.persistence.Column;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.ForeignKey;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

import com.calculateur.warhammer.base.entity.IEntity;
import com.calculateur.warhammer.entity.pk.FactionPK;

/**
 * Entité pour les faction en BDD
 * 
 * @author phili
 *
 */
@Entity
@Table(name = "FACTION")
public class FactionEntity implements IEntity<FactionPK> {

	@EmbeddedId
	@NotNull(message = "faction.pk.null")
	private FactionPK id;

	@Column(name = "NOM",nullable = false,length = 50)
	@NotNull(message="faction.nom.null")
	@NotEmpty(message="faction.nom.empty")
	@Size(max = 50, message = "faction.nom.size")
	private String nom;

	@Column(name = "CLE_TRADUCTION",nullable = false,length = 50)
	@NotNull(message="faction.cle.traduction.null")
	@NotEmpty(message="faction.cle.traduction.empty")
	@Size(max = 50, message = "faction.cle.traduction.size")
	private String cleTraduction;

	@ManyToOne(fetch = FetchType.EAGER)
	@JoinColumn(name = "ID_CAMP",foreignKey = @ForeignKey(name = "FK_CAMP"),nullable = false,updatable = false,insertable = false)
	@NotNull(message = "faction.camp.null")
	private CampEntity camp;
	
	@Override
	public FactionPK getId() {
		return id;
	}

	@Override
	public void setId(FactionPK id) {
		this.id = id;
	}

	public String getNom() {
		return nom;
	}

	public void setNom(String nom) {
		this.nom = nom;
	}

	public String getCleTraduction() {
		return cleTraduction;
	}

	public void setCleTraduction(String cleTraduction) {
		this.cleTraduction = cleTraduction;
	}

	public CampEntity getCamp() {
		return camp;
	}

	public void setCamp(CampEntity camp) {
		this.camp = camp;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package com.calculateur.warhammer.dao.contrat;

import java.util.List;

import com.calculateur.warhammer.base.dao.IDAO;
import com.calculateur.warhammer.base.exception.DAOException;
import com.calculateur.warhammer.entity.entity.FactionEntity;
import com.calculateur.warhammer.entity.pk.FactionPK;

/**
 * DAO spéciale pour les factions
 * @author phili
 *
 */
public interface IFactionDAO extends IDAO<FactionPK, FactionEntity>{

	/**
	 * 
	 * @param idCamp Id du camp
	 * @return La liste des factions pour l'id du camp
	 * @throws DAOException Si erreur lors de la recherche
	 */
	List<FactionEntity> getFactions(Integer idCamp)throws DAOException;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
package com.calculateur.warhammer.dao.dao;

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

import javax.inject.Inject;
import javax.inject.Named;
import javax.persistence.Query;

import com.calculateur.warhammer.base.dao.IDAO;
import com.calculateur.warhammer.base.exception.DAOException;
import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.dao.contrat.IFactionDAO;
import com.calculateur.warhammer.dao.verification.VerificationUtils;
import com.calculateur.warhammer.entity.entity.CampEntity;
import com.calculateur.warhammer.entity.entity.FactionEntity;
import com.calculateur.warhammer.entity.pk.FactionPK;

@Named("factionDAO")
public class FactionDAO extends AbstractDAO<FactionPK, FactionEntity> implements IFactionDAO {

	private static final String ENTITY_CLASS = "FactionEntity";

	private static final String ENTITY_LIBELLE = "factionEntity";

	private static final String RES = "com.calculateur.warhammer.entity.faction.faction";

	private static final String JPQL_DELETE = "DELETE FROM FactionEntity factionEntity WHERE factionEntity.id.idCamp = :idCamp AND factionEntity.id.idFaction = :idFaction";

	private static final String JPQL_SELECT_BY_CAMP = "SELECT DISTINCT(factionEntity) FROM FactionEntity factionEntity WHERE factionEntity.id.idCamp = :idCamp";

	@Inject
	@Named("campDAO")
	private IDAO<Integer, CampEntity> campDAO;

	@SuppressWarnings("unchecked")
	@Override
	public List<FactionEntity> getFactions(Integer idCamp) throws DAOException {
		try {
			Query query = em.createQuery(JPQL_SELECT_BY_CAMP);
			query.setParameter("idCamp", idCamp);
			return query.getResultList();
		} catch (Exception e) {
			throw new DAOException(e);
		}
	}

	@Override
	protected String getEntityClass() {
		return ENTITY_CLASS;
	}

	@Override
	protected String getEntityLibelle() {
		return ENTITY_LIBELLE;
	}

	@Override
	protected String getErrorBundle() {
		return RES;
	}

	@Override
	protected Class<FactionEntity> getClassEntity() {
		return FactionEntity.class;
	}

	// Surcharge à cause de l'id
	@Override
	protected Query getDeleteQuery(FactionPK id) {
		Query query = em.createQuery(JPQL_DELETE);
		query.setParameter("idCamp", id.getIdCamp());
		query.setParameter("idFaction", id.getIdFaction());
		return query;
	}

	@Override
	public FactionEntity save(FactionEntity entity) throws DAOException, FunctionnalExeption {
		verificationSupplementaire(entity);
		return super.save(entity);
	}

	@Override
	public FactionEntity update(FactionEntity entity) throws DAOException, FunctionnalExeption {
		verificationSupplementaire(entity);
		return super.update(entity);
	}

	/**
	 * Vérifications supplémentaires sur la clé primaire et le camp.
	 * 
	 * @param entity Entité à vérifier
	 * @throws FunctionnalExeption Si erreur fonctionnelle détectée
	 * @throws DAOException        Si erreur avec la BDD
	 */
	private void verificationSupplementaire(FactionEntity entity) throws FunctionnalExeption, DAOException {
		List<String> errors = new ArrayList<>();
		// Ce ne sera pas vérifié directement, il faut ruser
		if (entity.getId() != null) {
			VerificationUtils.verifie(entity.getId(), RES);
		}
		if (entity.getId() != null && entity.getId().getIdCamp() != null && entity.getCamp() != null) {
			verificationCoherenceCamp(entity, entity.getId(), errors);
		}
		if (!errors.isEmpty()) {
			throw new FunctionnalExeption(errors, RES);
		}
	}

	private void verificationCoherenceCamp(FactionEntity entity, FactionPK id, List<String> errors)
			throws DAOException {
		if (entity.getCamp().getId() == null) {
			errors.add("faction.camp.id.null");
		} else {
			verificationCoherenceCleComposee(entity, id, errors);
		}
	}

	private void verificationCoherenceCleComposee(FactionEntity entity, FactionPK id, List<String> errors)
			throws DAOException {
		if (id.getIdCamp().intValue() != entity.getCamp().getId().intValue()) {
			errors.add("faction.camp.id.error");
		}
		CampEntity aCamp = campDAO.getById(entity.getCamp().getId());
		if (aCamp == null) {
			errors.add("faction.camp.camp.null");
		}
	}		
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package com.calculateur.warhammer.dao.dao;

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

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import javax.inject.Inject;
import javax.inject.Named;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;

import com.calculateur.warhammer.base.dao.AbstractDAOTest;
import com.calculateur.warhammer.base.dao.IDAO;
import com.calculateur.warhammer.base.exception.DAOException;
import com.calculateur.warhammer.dao.builder.CampEntityBuilder;
import com.calculateur.warhammer.dao.builder.FactionEntityBuilder;
import com.calculateur.warhammer.dao.builder.pk.FactionPKBuilder;
import com.calculateur.warhammer.dao.configuration.ConfigurationTestBDDH2;
import com.calculateur.warhammer.dao.contrat.IFactionDAO;
import com.calculateur.warhammer.entity.entity.CampEntity;
import com.calculateur.warhammer.entity.entity.FactionEntity;
import com.calculateur.warhammer.entity.pk.FactionPK;

@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = {ConfigurationTestBDDH2.class})
public class FactionDAOTest extends AbstractDAOTest<FactionPK, FactionEntity, IFactionDAO>{

	private static final Integer ID_CAMP_IMPERIUM = 1;
	private static final Integer ID_CAMP_CHAOS = 2;
	
	private static final Integer ID_NON_UTILISE = 1000;
	private static final Integer ID_TEST = 8;
	
	@Inject
	@Named("factionDAO")
	private IFactionDAO factionDAO;
	
	@Inject
	@Named("campDAO")
	private IDAO<Integer, CampEntity> campDAO;
	
	private CampEntity campImperium;
	
	@BeforeEach
	public void beforeTest() throws DAOException{
		campImperium = campDAO.getById(ID_CAMP_IMPERIUM);
	}
	
	@Override
	protected IFactionDAO getDAO() {
		return factionDAO;
	}

	@Override
	protected List<FactionEntity> getErrorsEntities() {
		List<FactionEntity> list = new ArrayList<>();
		//Id
		FactionEntityBuilder builder = FactionEntityBuilder.getInstance().addNom(STRING_TEST).addCleTraduction(STRING_TEST).addCamp(campImperium);
		list.add(builder.addId(null).build());
		list.add(builder.addId(FactionPKBuilder.getInstance().addIdCamp(null).addIdFaction(ID_TEST).build()).build());
		list.add(builder.addId(FactionPKBuilder.getInstance().addIdCamp(ID_CAMP_IMPERIUM).addIdFaction(null).build()).build());
		
		FactionPK id = FactionPKBuilder.getInstance().addIdCamp(ID_CAMP_IMPERIUM).addIdFaction(ID_TEST).build();
		//Nom
		list.add(FactionEntityBuilder.getInstance().addId(id).addNom(null).addCleTraduction(STRING_TEST).addCamp(campImperium).build());
		list.add(FactionEntityBuilder.getInstance().addId(id).addNom(EMPTY_STRING).addCleTraduction(STRING_TEST).addCamp(campImperium).build());
		list.add(FactionEntityBuilder.getInstance().addId(id).addNom(getToLongString(50)).addCleTraduction(STRING_TEST).addCamp(campImperium).build());
		//Cle traduction
		list.add(FactionEntityBuilder.getInstance().addId(id).addNom(STRING_TEST).addCleTraduction(null).addCamp(campImperium).build());
		list.add(FactionEntityBuilder.getInstance().addId(id).addNom(STRING_TEST).addCleTraduction(EMPTY_STRING).addCamp(campImperium).build());
		list.add(FactionEntityBuilder.getInstance().addId(id).addNom(STRING_TEST).addCleTraduction(getToLongString(50)).addCamp(campImperium).build());
		//Camp
		list.add(FactionEntityBuilder.getInstance().addId(id).addNom(STRING_TEST).addCleTraduction(STRING_TEST).addCamp(null).build());
		CampEntity aCamp = CampEntityBuilder.getInstance().addId(null).addNom(STRING_TEST).addCleTraduction(STRING_TEST).build();
		list.add(FactionEntityBuilder.getInstance().addId(id).addNom(STRING_TEST).addCleTraduction(STRING_TEST).addCamp(aCamp).build());
		aCamp = CampEntityBuilder.getInstance().addId(ID_CAMP_CHAOS).addNom(STRING_TEST).addCleTraduction(STRING_TEST).build();
		list.add(FactionEntityBuilder.getInstance().addId(id).addNom(STRING_TEST).addCleTraduction(STRING_TEST).addCamp(aCamp).build());
		id = FactionPKBuilder.getInstance().addIdCamp(ID_NON_UTILISE).addIdFaction(ID_TEST).build();
		aCamp = CampEntityBuilder.getInstance().addId(ID_NON_UTILISE).addNom(STRING_TEST).addCleTraduction(STRING_TEST).build();
		list.add(FactionEntityBuilder.getInstance().addId(id).addNom(STRING_TEST).addCleTraduction(STRING_TEST).addCamp(aCamp).build());
		return list;
	}

	@Override
	protected FactionPK getIdWithNothingInDatabase() {
		return FactionPKBuilder.getInstance().addIdCamp(ID_CAMP_IMPERIUM).addIdFaction(ID_NON_UTILISE).build();
	}

	@Override
	protected FactionEntity getEntityForInsertion() {
		FactionPK id = FactionPKBuilder.getInstance().addIdCamp(ID_CAMP_IMPERIUM).addIdFaction(ID_TEST).build();
		return FactionEntityBuilder.getInstance().addId(id).addNom(STRING_TEST).addCleTraduction(STRING_TEST).addCamp(campImperium).build();
	}

	@Override
	protected void compareEntities(FactionEntity base, FactionEntity aComparer) {
		Assertions.assertThat(base.getId().getIdCamp()).isEqualTo(aComparer.getId().getIdCamp());
		Assertions.assertThat(base.getId().getIdFaction()).isEqualTo(aComparer.getId().getIdFaction());		
	}

	@Override
	protected void updateEntity(FactionEntity toUpdate) {
		toUpdate.setNom(STRING_TEST2);
		toUpdate.setCleTraduction(STRING_TEST2);
	}

	@Override
	protected void assertUpdate(FactionEntity anEntity) {
		Assertions.assertThat(anEntity.getNom()).isEqualTo(STRING_TEST2);
		Assertions.assertThat(anEntity.getCleTraduction()).isEqualTo(STRING_TEST2);
	}

	@Override
	protected void testSupplementaires(FactionEntity entityTest) {
		try {
			List<FactionEntity> list = factionDAO.getFactions(ID_CAMP_IMPERIUM);
			List<FactionEntity> aList = list.stream().filter(f -> f.getId().getIdFaction().equals(ID_TEST)).map(f -> f).collect(Collectors.toList());
			Assertions.assertThat(aList).isNotEmpty();
			Assertions.assertThat(aList).hasSize(1);
		} catch (DAOException e) {
			fail(e);
		}
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.calculateur.warhammer.data.identifiable;

/**
 * Cette interface permet de contractualiser un identifiable. Celui-ci est identifié par un id entier
 * @author phili
 *
 */
public interface IIdentifiable {

	/**
	 * 
	 * @return L'id de l'identifiable
	 */
	Integer getId();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
package com.calculateur.warhammer.data.identifiable;

import java.util.Set;

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

/**
 * Un profil à warhammer 40K
 * @author phili
 *
 */
public interface IProfil extends IIdentifiable{

	/**
	 * 
	 * @return Le mouvelment
	 */
	Integer getMouvement();
	
	/**
	 * 
	 * @return La CC
	 */
	Integer getCapaciteDeCombat();
	
	/**
	 * 
	 * @return La CT
	 */
	Integer getCapaciteTir();
	
	/**
	 * 
	 * @return La Force
	 */
	Integer getForce();
	
	/**
	 * 
	 * @return L'endurance
	 */
	Integer getEndurance();
	
	/**
	 * 
	 * @return Le nombre de point de vie
	 */
	Integer getNombrePointDeVie();
	
	/**
	 * 
	 * @return Le nombre d'attaque de base
	 */
	Integer getNombreAttaque();
	
	/**
	 * 
	 * @return Le nombre d'attaque par D3
	 */
	Integer getNombreAttaqueParD3();
	
	/**
	 * 
	 * @return Le nombre d'attaque par D6
	 */
	Integer getNombreAttaqueParD6();
	
	/**
	 * 
	 * @return Le commandement
	 */
	Integer getCommandement();
	
	/**
	 * 
	 * @return La sauvegarde
	 */
	Integer getSauvegarde();
	
	/**
	 * 
	 * @return La sauvegarde Invulnérable
	 */
	Integer getSauvegardeInvulnerable();
	
	/**
	 * 
	 * @return Les types du profil
	 */
	Set<EProfil> getTypesProfils();
	
	/**
	 * 
	 * @return Vrai si c'est un volant
	 */
	Boolean isVolant();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package com.calculateur.warhammer.data.identifiable;

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

	/**
	 * 
	 * @return Vrai si le batiment est identifiable
	 */
	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();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package com.calculateur.warhammer.data.identifiable;

/**
 * L'arme utilisé
 * @author phili
 *
 */
public interface IArme extends IIdentifiable{

	/**
	 * 
	 * @return La PA de l'arme
	 */
	Integer getPA();
	
	/**
	 * 
	 * @return Le nombre de D3 qu'il faut lancer pour avoir la PA
	 */
	Integer getPAParD3();
	
	/**
	 * 
	 * @return Le nomnbre de D6 qu'il faut lancer pour avoir la PA
	 */
	Integer getPAParD6();
	
	/**
	 * 
	 * @return Les dégats de base
	 */
	Integer getDegâts();
	
	/**
	 * 
	 * @return Le nombre de D3 qu'il faut avoir pour avoir les dégâts
	 */
	Integer getDegatsParD3();
	
	/**
	 * 
	 * @return Nombre d'attaque par D6
	 */
	Integer getDegatsParD6();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
package com.calculateur.warhammer.data.identifiable;

import com.calculateur.warhammer.data.enumeration.EArmeTir;

/**
 * Les spécifications pour l'arme de tir
 * @author phili
 *
 */
public interface IArmeDeTir extends IArme{

	/**
	 * 
	 * @return Portée minimale de l'arme
	 */
	Integer getPorteeMinimale();
	
	/**
	 * 
	 * @return Portée maximale de l'arme
	 */
	Integer getPorteeMaximale();
	
	/**
	 * 
	 * @return Portée maximale de l'arme
	 */
	EArmeTir getType();
	
	/**
	 * 
	 * @return Nombre d'attaque de base
	 */
	Integer getNombreAttaqueBase();
	
	/**
	 * 
	 * @return Le nombre de D3 qu'il faut lancer pour attaque
	 */
	Integer getNombreAttaqueD3();
	
	/**
	 * 
	 * @return Le nombre de D6 qu'il faut lancer pour une attaque
	 */
	Integer getNombreAttaqueD6();
	
	/**
	 * 
	 * @return le nombre minimum qu'il faut lancer pour un daka
	 */
	Integer getNombreDakaMin();
	
	/**
	 * 
	 * @return le nombre maximum qu'il faut lancer pour un Daka
	 */
	Integer getNombreDakaMax();
	
	/**
	 * 
	 * @return Vrai si il faut faire un jet de touche
	 */
	Boolean isJetTouche();
	
	/**
	 * 
	 * @return Vrai si l'arme est Blast
	 */
	Boolean isBlast();
	
	/**
	 * 
	 * @return Vrai si l'arme peut tirer sans ligne de vue
	 */
	boolean isTirIndirect();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package com.calculateur.warhammer.data.identifiable;

/**
 * Cette Interface représente les armes de corps à corps
 * @author phili
 *
 */
public interface IArmeDeCorpsACorps extends IArme{

	/**
	 * 
	 * @return Bonus d'attaques aditionnel
	 */
	Integer getBonusAttaqueFixe();
	
	/**
	 * 
	 * @return Bonus aditionnel donné par un nombre de D3
	 */
	Integer getBonusAttaqueD3();
	
	/**
	 * 
	 * @return Bonus aditionnel donné par un nombre de D6
	 */
	Integer getBonusAttaqueD6();
	
	/**
	 * 
	 * @return Bonus Additionnel en force donné par l'arme (F + bonus)
	 */
	Integer getBonusAditionForce();
	
	/**
	 * 
	 * @return Bonus multiplicatif donné par l'arme Bonus * (F + bonus aditionnel)
	 */
	Integer getBonusMultiplicationForce();
	
	/**
	 * 
	 * @return Bonus Additionnel en force donné par l'arme après avoir jeté un vombre de D3
	 */
	Integer getBonusAditionForceD3();
	
	/**
	 * 
	 * @return Bonus Additionnel en force donné par l'arme après avoir jeté un vombre de D6
	 */
	Integer getBonusAditionForceD6();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
package com.calculateur.warhammer.data.regles;

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

/**
 * Règle d'attaque
 * @author phili
 */
public interface IRegleAttaque{

	//Règle mouvement
	/**
	 * 
	 * @return Vrai si celui-ci ignore les malus du mouvement d'avance au tir
	 */
	boolean isIgnoreMouvementAvanceAuTir();
	
	/**
	 * 
	 * @return Vrai si celui-ci ignore les malus du mouvement normal au tir
	 */
	boolean isIgnoreMouvementNormalAuTir();
	
	/**
	 * 
	 * @return Vrai si pour une arme à tir rapide, la figurine tir toujours 2 fois
	 */
	boolean isMaitriseArmeTirRapide();
	
	//Jet de touche
	/**
	 * 
	 * @return Vrai si le jet de touche a un bonus.
	 */
	Integer getBonusJetTouche();
	
	/**
	 * 
	 * @return Les scores relançables
	 */
	Set<Integer> getScoreJetToucheRelancable();
	
	/**
	 * 
	 * @return Jet minimum pour toucher
	 */
	Integer getJetMinimumPourToucher();
	
	/**
	 * 
	 * @return La map qui donne un jet de blessures mortelles, et on s'arrête après le jet de touche. <br/> 
	 * Le second chiffre donne le nombre de blessures mortelles
	 */
	Map<Integer, Integer> getMapJetToucheBlessuresMortelleEtOnArrete();
	
	/**
	 * 
	 * @return La Map de blessures Mortelles et on continue la séquence. C'est donc des blessures mortelles en plus.<br/>
	 * Le second chiffre est le nombre de blessures mortelles
	 */
	Map<Integer,Integer> getMapJetToucheBlessuresMortellesEtContinue();
	
	/**
	 * 
	 * @return La map score qui donne des attaques en plus. Le second chiffre est le nombre d'attaqye
	 */
	Map<Integer,Integer> getMapJetToucheAttaqueSupplementaire();
	
	//Force
	/**
	 * 
	 * @return Le bonus de force de l'adversaire
	 */
	Integer getBonusForce();
	
	//Endurance
	/**
	 * 
	 * @return Malus appliqué à une cible sur l'endurance
	 */
	Integer getMalusEndurance();
	
	//Jet de blessures
	/**
	 * 
	 * @return le bonus au jet de touche
	 */
	Integer getBonusJetBlessures();
	
	/**
	 * 
	 * @return Jet de blessures relançable
	 */
	Set<Integer> getScoreJetBlessureRelancable();
	
	/**
	 * 
	 * @return Jet minimum pour blesser
	 */
	Integer getJetMinumumPourBlesser();
	
	/**
	 * 
	 * @return La map qui donne un jet de blessures mortelles, et on s'arrête après le jet de blessure. <br/> 
	 * Le second chiffre donne le nombre de blessures mortelles
	 */
	Map<Integer, Integer> getMapJetBlessuresBlessuresMortelleEtOnArrete();
	
	/**
	 * 
	 * @return La Map de blessures Mortelles et on continue la séquence. C'est donc des blessures mortelles en plus.<br/>
	 * Le second chiffre est le nombre de blessures mortelles
	 */
	Map<Integer,Integer> getMapJetBlessuresBlessuresMortellesEtContinue();
	
	/**
	 * 
	 * @return La map qui pour un jet de touche, donne un bonus à la PA.<br/>
	 * Le second chiffre est le bonus à la PA
	 */
	Map<Integer,Integer> getMapJetBlessureBonusPA();
	
	//Attaques
	Integer getBonusNombreAttaque();
	
	//Commandement
	/**
	 * 
	 * @return Le malus que la règle donne aux test d'attritions
	 */
	Integer getMalusSurAttrition();
	
	//Sauvegarde
	/**
	 * 
	 * @return Vrai si l'attaquant ignore la sauvegarde invulnérable
	 */
	boolean isIgnoreSauvegardeInvulnerable();
	
	/**
	 * 
	 * @return Vrai si on fait ignorer la sauvegarde de couvert
	 */
	boolean isIgnoreSauvegardeCouvert();
	
	//Se relève
	/**
	 * 
	 * @return Vrai si la cible ne peut pas ignorer les blessures
	 */
	boolean isIgnoreIgnoreBlessure();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package com.calculateur.warhammer.data.regles;

import java.util.Set;

import com.calculateur.warhammer.data.enumeration.EBlessure;

/**
 * Règle pour se défendre
 * @author phili
 *
 */
public interface IRegleDefense {

	//Jet de touche
	/**
	 * 
	 * @return Malus que subit l'attaquant au jet de touche
	 */
	Integer getMalusJetTouche();
	
	/**
	 * 
	 * @return Le jet minimum pour être touché
	 */
	Integer getJetMinimumPourEtreTouche();
	
	//Force
	/**
	 * 
	 * @return Malus que l'attaquant subit à la sauvegarde
	 */
	Integer getMalusForce();
	
	//Endurance
	/**
	 * 
	 * @return Bonus en endurance dont bénéficie le défenseur
	 */
	Integer getBonusEndurance();
	
	//Jet blessure
	/**
	 * 
	 * @return Jet minimum pour être blessé
	 */
	Integer getJetMinimumPourEtreBlesse();
	
	/**
	 * 
	 * @return Malus au jet de blessure
	 */
	Integer getMalusJetBlessure();
	
	//PV
	/**
	 * 
	 * @return Le nombre maximum de PV que la figurine peut perdre par phase
	 */
	Integer getNombrePointsViesMaximumPerdable();
	
	//Attaques
	/**
	 * 
	 * @return Malus que l'attaquant subit au nombre d'attaque.
	 */
	Integer getMalusNombreAttaque();
	
	//Sauvegarde
	/**
	 * 
	 * @return Vrai si il y a une sauvegarde de couvert
	 */
	boolean isSauvegardeCouvert();
	
	//Commandement
	/**
	 * 
	 * @return Vrai si la défense ignore le test de commandement
	 */
	boolean isIgnoreTestCommandement();
	
	/**
	 * 
	 * @return Bonus aux tests de commandement
	 */
	Integer getBonusCommandement();
	
	/**
	 * 
	 * @return Vrai si le test d'attrition est ignoré
	 */
	boolean isIgnoreTestAttrition();
	
	/**
	 * 
	 * @return Vrai si les malus au tests d'attrition sont ignorés
	 */
	boolean isIgnoreMalusAttrition();
	
	//Se relève
	/**
	 * 
	 * @return Le score pour se relever après la mort
	 */
	Integer getJetSeReleve();
	
	/**
	 * 
	 * @return Les relance du jet pour se relever
	 */
	Set<Integer> getRelancesSeReleve();
	
	//Ignore blessures
	/**
	 * 
	 * @param typeBlessures
	 * @return Le jet pour ignorer une blessure
	 */
	Integer getJetSoreIgnoreBlessure(EBlessure typeBlessures);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

package com.calculateur.warhammer.data.regles;

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

import com.calculateur.warhammer.data.identifiable.IIdentifiable;

/**
 * Règles d'attaque de base pour un identifiable (c'est à dire aucune)
 * 
 * @author phili
 *
 */
public class RegleAttaqueBase<I extends IIdentifiable> implements IRegle<I>, IRegleAttaque {

	private static final Integer NO_BONUS = 0;

	private static final Integer NO_JET_MINIMUM = 0;

	private final I identifiable;

	public RegleAttaqueBase(I identifiable) {
		this.identifiable = identifiable;
	}

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

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

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

	@Override
	public Integer getBonusJetTouche() {
		return NO_BONUS;
	}

	@Override
	public Set<Integer> getScoreJetToucheRelancable() {
		return Collections.emptySet();
	}

	@Override
	public Integer getJetMinimumPourToucher() {
		return NO_JET_MINIMUM;
	}

	@Override
	public Map<Integer, Integer> getMapJetToucheBlessuresMortelleEtOnArrete() {
		return Collections.emptyMap();
	}

	@Override
	public Map<Integer, Integer> getMapJetToucheBlessuresMortellesEtContinue() {
		return Collections.emptyMap();
	}

	@Override
	public Map<Integer, Integer> getMapJetToucheAttaqueSupplementaire() {
		return Collections.emptyMap();
	}

	@Override
	public Integer getBonusForce() {
		return NO_BONUS;
	}

	@Override
	public Integer getMalusEndurance() {
		return NO_BONUS;
	}

	@Override
	public Integer getBonusJetBlessures() {
		return NO_BONUS;
	}

	@Override
	public Set<Integer> getScoreJetBlessureRelancable() {
		return Collections.emptySet();
	}

	@Override
	public Integer getJetMinumumPourBlesser() {
		return NO_JET_MINIMUM;
	}

	@Override
	public Map<Integer, Integer> getMapJetBlessuresBlessuresMortelleEtOnArrete() {
		return Collections.emptyMap();
	}

	@Override
	public Map<Integer, Integer> getMapJetBlessuresBlessuresMortellesEtContinue() {
		return Collections.emptyMap();
	}

	@Override
	public Map<Integer, Integer> getMapJetBlessureBonusPA() {
		return Collections.emptyMap();
	}

	@Override
	public Integer getBonusNombreAttaque() {
		return NO_BONUS;
	}

	@Override
	public Integer getMalusSurAttrition() {
		return NO_BONUS;
	}

	@Override
	public I getIdentifiable() {
		return identifiable;
	}

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
package com.calculateur.warhammer.data.regles;

import java.util.Collections;
import java.util.Set;

import com.calculateur.warhammer.data.enumeration.EBlessure;
import com.calculateur.warhammer.data.identifiable.IIdentifiable;

public class RegleDefenseBase<I extends IIdentifiable> implements IRegle<I>,IRegleDefense  {

	private static final Integer NO_BONUS = 0;

	private static final Integer NO_JET_MINIMUM = 0;

	private final I identifiable;
	
	public RegleDefenseBase(I identifiable) {
		this.identifiable = identifiable;
	}
	
	@Override
	public Integer getMalusJetTouche() {
		return NO_BONUS;
	}

	@Override
	public Integer getJetMinimumPourEtreTouche() {
		return NO_JET_MINIMUM;
	}

	@Override
	public Integer getMalusForce() {
		return NO_BONUS;
	}

	@Override
	public Integer getBonusEndurance() {
		return NO_BONUS;
	}

	@Override
	public Integer getJetMinimumPourEtreBlesse() {
		return NO_JET_MINIMUM;
	}

	@Override
	public Integer getMalusJetBlessure() {
		return NO_BONUS;
	}

	@Override
	public Integer getNombrePointsViesMaximumPerdable() {
		return NO_BONUS;
	}

	@Override
	public Integer getMalusNombreAttaque() {
		return NO_BONUS;
	}

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

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

	@Override
	public Integer getBonusCommandement() {
		return NO_BONUS;
	}

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

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

	@Override
	public Integer getJetSeReleve() {
		return NO_BONUS;
	}

	@Override
	public Set<Integer> getRelancesSeReleve() {
		return Collections.emptySet();
	}

	@Override
	public Integer getJetSoreIgnoreBlessure(EBlessure typeBlessures) {
		return NO_JET_MINIMUM;
	}

	@Override
	public I getIdentifiable() {
		return identifiable;
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
package com.calculateur.warhammer.data.regles;

import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * Un décorateur qui prend un ensemble de règles d'attaque et fait un traitement
 * pour sortir la bonne règle au bon moment.
 * 
 * @author phili
 *
 */
public class RegleAttaqueDecorateur implements IRegleAttaque {

	private final List<IRegleAttaque> regles;

	public RegleAttaqueDecorateur(List<IRegleAttaque> regles) {
		this.regles = regles;
	}

	@Override
	public boolean isIgnoreMouvementAvanceAuTir() {
		return regles.stream().anyMatch(r -> r.isIgnoreMouvementAvanceAuTir());
	}

	@Override
	public boolean isIgnoreMouvementNormalAuTir() {
		return regles.stream().anyMatch(r -> r.isIgnoreMouvementNormalAuTir());
	}

	@Override
	public boolean isMaitriseArmeTirRapide() {
		return regles.stream().anyMatch(r -> r.isMaitriseArmeTirRapide());
	}

	@Override
	public Integer getBonusJetTouche() {
		return regles.stream().mapToInt(r -> r.getBonusJetTouche()).sum();
	}

	@Override
	public Set<Integer> getScoreJetToucheRelancable() {
		Set<Integer> sReturn = new HashSet<>();
		regles.stream().forEach(r -> sReturn.addAll(r.getScoreJetToucheRelancable()));
		return sReturn;
	}

	@Override
	public Integer getJetMinimumPourToucher() {
		Integer result = 0;
		Integer aResult = regles.stream().filter(r -> r.getJetMinimumPourToucher() > 0)
				.mapToInt(r -> r.getJetMinimumPourToucher()).min().getAsInt();
		return (aResult != null) ? aResult : result;
	}

	@Override
	public Map<Integer, Integer> getMapJetToucheBlessuresMortelleEtOnArrete() {
		Map<Integer, Integer> mReturn = new HashMap<>();
		Integer value;
		for (IRegleAttaque regle : regles) {
			for (Entry<Integer, Integer> entry : regle.getMapJetToucheBlessuresMortelleEtOnArrete().entrySet()) {
				value = mReturn.computeIfAbsent(entry.getKey(), k -> 0);
				value += entry.getValue();
				mReturn.put(entry.getKey(), value);
			}
		}
		return mReturn;
	}

	@Override
	public Map<Integer, Integer> getMapJetToucheBlessuresMortellesEtContinue() {
		Map<Integer, Integer> mReturn = new HashMap<>();
		Integer value;
		for (IRegleAttaque regle : regles) {
			for (Entry<Integer, Integer> entry : regle.getMapJetToucheBlessuresMortellesEtContinue().entrySet()) {
				value = mReturn.computeIfAbsent(entry.getKey(), k -> 0);
				value += entry.getValue();
				mReturn.put(entry.getKey(), value);
			}
		}
		return mReturn;
	}

	@Override
	public Map<Integer, Integer> getMapJetToucheAttaqueSupplementaire() {
		Map<Integer, Integer> mReturn = new HashMap<>();
		Integer value;
		for (IRegleAttaque regle : regles) {
			for (Entry<Integer, Integer> entry : regle.getMapJetToucheAttaqueSupplementaire().entrySet()) {
				value = mReturn.computeIfAbsent(entry.getKey(), k -> 0);
				value += entry.getValue();
				mReturn.put(entry.getKey(), value);
			}
		}
		return mReturn;
	}

	@Override
	public Integer getBonusForce() {
		return regles.stream().mapToInt(r -> r.getBonusForce()).sum();
	}

	@Override
	public Integer getMalusEndurance() {
		return regles.stream().mapToInt(r -> r.getMalusEndurance()).sum();
	}

	@Override
	public Integer getBonusJetBlessures() {
		return regles.stream().mapToInt(r -> r.getBonusJetBlessures()).sum();
	}

	@Override
	public Set<Integer> getScoreJetBlessureRelancable() {
		Set<Integer> sReturn = new HashSet<>();
		regles.stream().forEach(r -> sReturn.addAll(r.getScoreJetBlessureRelancable()));
		return sReturn;
	}

	@Override
	public Integer getJetMinumumPourBlesser() {
		Integer result = 0;
		Integer aResult = regles.stream().filter(r -> r.getJetMinumumPourBlesser() > 0)
				.mapToInt(r -> r.getJetMinumumPourBlesser()).min().getAsInt();
		return (aResult != null) ? aResult : result;
	}

	@Override
	public Map<Integer, Integer> getMapJetBlessuresBlessuresMortelleEtOnArrete() {
		Map<Integer, Integer> mReturn = new HashMap<>();
		Integer value;
		for (IRegleAttaque regle : regles) {
			for (Entry<Integer, Integer> entry : regle.getMapJetBlessuresBlessuresMortelleEtOnArrete().entrySet()) {
				value = mReturn.computeIfAbsent(entry.getKey(), k -> 0);
				value += entry.getValue();
				mReturn.put(entry.getKey(), value);
			}
		}
		return mReturn;
	}

	@Override
	public Map<Integer, Integer> getMapJetBlessuresBlessuresMortellesEtContinue() {
		Map<Integer, Integer> mReturn = new HashMap<>();
		Integer value;
		for (IRegleAttaque regle : regles) {
			for (Entry<Integer, Integer> entry : regle.getMapJetBlessuresBlessuresMortellesEtContinue().entrySet()) {
				value = mReturn.computeIfAbsent(entry.getKey(), k -> 0);
				value += entry.getValue();
				mReturn.put(entry.getKey(), value);
			}
		}
		return mReturn;
	}

	@Override
	public Map<Integer, Integer> getMapJetBlessureBonusPA() {
		Map<Integer, Integer> mReturn = new HashMap<>();
		Integer value;
		for (IRegleAttaque regle : regles) {
			for (Entry<Integer, Integer> entry : regle.getMapJetBlessureBonusPA().entrySet()) {
				value = mReturn.computeIfAbsent(entry.getKey(), k -> 0);
				value += entry.getValue();
				mReturn.put(entry.getKey(), value);
			}
		}
		return mReturn;
	}

	@Override
	public Integer getBonusNombreAttaque() {
		return regles.stream().mapToInt(r -> r.getBonusNombreAttaque()).sum();
	}

	@Override
	public Integer getMalusSurAttrition() {
		return regles.stream().mapToInt(r -> r.getMalusSurAttrition()).sum();
	}

	@Override
	public boolean isIgnoreSauvegardeInvulnerable() {
		return regles.stream().anyMatch(r -> r.isIgnoreSauvegardeInvulnerable());
	}

	@Override
	public boolean isIgnoreSauvegardeCouvert() {
		return regles.stream().anyMatch(r -> r.isIgnoreSauvegardeInvulnerable());
	}

	@Override
	public boolean isIgnoreIgnoreBlessure() {
		return regles.stream().anyMatch(r -> r.isIgnoreIgnoreBlessure());
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
package com.calculateur.warhammer.data.regles;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

import com.calculateur.warhammer.data.enumeration.EBlessure;

/**
 * Décorateur de règle pour la défense
 * @author phili
 *
 */
public class RegleDefenseDecorateur implements IRegleDefense{

	private final List<IRegleDefense> regles;
	
	public RegleDefenseDecorateur(List<IRegleDefense> regles) {
		this.regles = regles;
	}
	
	@Override
	public Integer getMalusJetTouche() {
		return regles.stream().mapToInt(r -> r.getMalusJetTouche()).sum();
	}

	@Override
	public Integer getJetMinimumPourEtreTouche() {
		Integer iReturn = 0;
		Integer result = regles.stream().filter(r -> r.getJetMinimumPourEtreTouche() > 0).mapToInt(r -> r.getJetMinimumPourEtreTouche()).max().getAsInt();
		return (result != null)?result:iReturn;
	}

	@Override
	public Integer getMalusForce() {
		return regles.stream().mapToInt(r -> r.getMalusForce()).sum();
	}

	@Override
	public Integer getBonusEndurance() {
		return regles.stream().mapToInt(r -> r.getBonusEndurance()).sum();
	}

	@Override
	public Integer getJetMinimumPourEtreBlesse() {
		Integer iReturn = 0;
		Integer result = regles.stream().filter(r -> r.getJetMinimumPourEtreBlesse() > 0).mapToInt(r -> r.getJetMinimumPourEtreBlesse()).max().getAsInt();
		return (result != null)?result:iReturn;
	}

	@Override
	public Integer getMalusJetBlessure() {
		return regles.stream().mapToInt(r -> r.getMalusJetBlessure()).sum();
	}

	@Override
	public Integer getNombrePointsViesMaximumPerdable() {
		Integer iReturn = 0;
		Integer result = regles.stream().filter(r -> r.getNombrePointsViesMaximumPerdable() > 0).mapToInt(r -> r.getNombrePointsViesMaximumPerdable()).min().getAsInt();
		return (result != null)?result:iReturn;
	}

	@Override
	public Integer getMalusNombreAttaque() {
		return regles.stream().mapToInt(r -> r.getMalusNombreAttaque()).sum();
	}

	@Override
	public boolean isSauvegardeCouvert() {
		return regles.stream().anyMatch(r -> r.isSauvegardeCouvert());
	}

	@Override
	public boolean isIgnoreTestCommandement() {
		return regles.stream().anyMatch(r -> r.isIgnoreTestCommandement());
	}

	@Override
	public Integer getBonusCommandement() {
		return regles.stream().mapToInt(r -> r.getBonusCommandement()).sum();
	}

	@Override
	public boolean isIgnoreTestAttrition() {
		return regles.stream().anyMatch(r -> r.isIgnoreTestAttrition());
	}

	@Override
	public boolean isIgnoreMalusAttrition() {
		return regles.stream().anyMatch(r -> r.isIgnoreMalusAttrition());
	}

	@Override
	public Integer getJetSeReleve() {
		Integer iReturn = 0;
		Integer result = regles.stream().filter(r -> r.getJetSeReleve() > 0).mapToInt(r -> r.getJetSeReleve()).min().getAsInt();
		return (result != null)?result:iReturn;
	}

	@Override
	public Set<Integer> getRelancesSeReleve() {
		Set<Integer> sReturn = new HashSet<>();
		regles.stream().forEach(r -> sReturn.addAll(r.getRelancesSeReleve()));
		return sReturn;
	}

	@Override
	public Integer getJetSoreIgnoreBlessure(EBlessure typeBlessures) {
		Integer iReturn = 0;
		Integer result = regles.stream().filter(r -> r.getJetSoreIgnoreBlessure(typeBlessures) > 0).mapToInt(r -> r.getJetSoreIgnoreBlessure(typeBlessures)).min().getAsInt();
		return (result != null)?result:iReturn;
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package com.calculateur.warhammer.data.regles;

import com.calculateur.warhammer.data.enumeration.EMouvement;
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 extends RegleAttaqueBase<IBatiment> {

	private final IBatiment batiment;

	private final ESimule simule;

	private final EMouvement mouvementPrecedent;

	private final boolean isTirContreChargeAvant;

	private static final Integer BONUS_TOUCHE = -1;
	private static final Integer NO_BONUS = 1;

	public RegleAttaqueBatiment(IBatiment batiment, ESimule simule, EMouvement mouvementPrecedent,
			boolean isTirContreChargeAvant) {
		super(batiment);
		this.batiment = batiment;
		this.simule = simule;
		this.mouvementPrecedent = mouvementPrecedent;
		this.isTirContreChargeAvant = isTirContreChargeAvant;
	}

	@Override
	public Integer getBonusJetTouche() {
		Integer iReturn;
		if (mouvementPrecedent == EMouvement.IMMOBILE) {
			boolean isDefendable = batiment.isDefendable()
					&& (simule == ESimule.TIR_CONTRE_CHARGE || (!isTirContreChargeAvant && simule == ESimule.CORPS_A_CORPS_APRES_ACTIVATION));
			boolean isCouvertLourd = batiment.isCouvertLourd() && simule == ESimule.CORPS_A_CORPS_APRES_ACTIVATION && mouvementPrecedent == EMouvement.IMMOBILE;
			iReturn = (isDefendable || isCouvertLourd)?BONUS_TOUCHE:NO_BONUS;
		} else {
			iReturn = NO_BONUS;
		}
		return iReturn;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.calculateur.warhammer.data.regles;

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

public class RegleDefenseBatiment extends RegleDefenseBase<IBatiment>{

	private final IBatiment batiment;

	private final ESimule simule;
	
	private static final Integer BONUS_TOUCHE = -1;
	private static final Integer BONUS_COMMANDEMENT = 1;
	private static final Integer NO_BONUS = 0;

	public RegleDefenseBatiment(IBatiment batiment, ESimule simule) {
		super(batiment);
		this.batiment = batiment;
		this.simule = simule;
	}

	@Override
	public Integer getMalusJetTouche() {
		return (simule == ESimule.TIR_PHASE_TIR && batiment.isCouvertDense()) ? BONUS_TOUCHE
				: NO_BONUS;
	}

	@Override
	public boolean isSauvegardeCouvert() {
		return simule == ESimule.TIR_PHASE_TIR ? batiment.isCouvertLeger() : false;
	}

	@Override
	public Integer getBonusCommandement() {
		return batiment.isExaltant() ? BONUS_COMMANDEMENT : NO_BONUS;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.calculateur.warhammer.data.regles.factory;

import com.calculateur.warhammer.base.exception.FunctionnalExeption;
import com.calculateur.warhammer.data.regles.IRegleAttaque;
import com.calculateur.warhammer.data.regles.IRegleDefense;

/**
 * Factory qui va créer la règle
 * @author phili
 *
 */
public interface FactoryRegle {

	/**
	 * 
	 * @param parametres Les paramère nécessaires propre à la faction
	 * @return Les régles d'attaques de la faction
	 * @throws FactoryReglesException Si une exception s'est produite lors de la fabrication des rècles
	 * @throws FunctionnalExeption Si après vérification, il manque une règle
	 */
	IRegleAttaque getRegleAttaque(String parametres)throws FactoryReglesException,FunctionnalExeption;
	
	/**
	 * 
	 * @param parametres Les paramère nécessaires propre à la faction
	 * @return Les régles de défense la faction
	 * @throws FactoryReglesException Si une exception s'est produite lors de la fabrication des rècles
	 * @throws FunctionnalExeption Si après vérification, il manque une règle
	 */
	IRegleDefense getRegleDefense(String parametres)throws FactoryReglesException,FunctionnalExeption;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.calculateur.warhammer.data.regles.factory;

/**
 * Factory pour fabriquer la Factory de règle.
 * @author phili
 *
 */
public interface FactoryFactoryRegle {

	/**
	 * 
	 * @param aClass Class de factory
	 * @return La factory de règles
	 * @throws FactoryReglesException
	 */
	FactoryRegle getFactory(String aClass)throws FactoryReglesException;
}