[TDD] Desafio básico de design: Modelagem de "batalha" em um jogo de RPG

opa, achei o desafio interessante, fiz umas bagaças aqui, ficou bem simples

Classes

public class Character {
    private final String name;
    private final int energy;
    private final int power;

public Character(String name, int energy, int power) {
        this.name = name;
        this.energy = energy;
        this.power = power;
    }

public int getEnergy() {
        return energy;
    }

public String getName() {
        return name;
    }

public int getPower() {
        return power;
    }
    public int getAttack(AttackFactor factor){
        return (int) ((power / 3) * factor.getAttackFactor());   
    }

public enum AttackFactor {

MISS(0, 3, 0), NORMAL(4, 70, 1), LUCKY(71, 96, 1.2), CRITICAL(97, 100, 2);

private int minimum;
    private int maximum;
    private double factor;
    private static final Random RANDOM = new Random();

private AttackFactor(int minimum, int maximum, double factor) {
        this.minimum = minimum;
        this.maximum = maximum;
        this.factor = factor;
    }

public double getAttackFactor() {
        return factor;
    }

public static AttackFactor getRandomAttackFactor() {
        int randomFactor = RANDOM.nextInt(101);
        for (AttackFactor factor : AttackFactor.values()) {
            if(randomFactor >= factor.minimum && randomFactor <= factor.maximum){
                return factor;
            }
        }
        return null;
    }
}

e os testes

public class AttackTest {
    Character player;
    
    @Before
    public void setUp(){
        player = new Character("Player", 60, 45);
    }
    @Test
    public void testUserMissesAttackAnEnemy(){
        assertTrue(player.getAttack(AttackFactor.MISS) == 0);
    }
    @Test
    public void testUserAttackAnEnemy(){
        assertTrue(player.getAttack(AttackFactor.NORMAL) == 15);
    }
    @Test
    public void testUserHasLuckyAttackingAnEnemy(){
        assertTrue(player.getAttack(AttackFactor.LUCKY) == 18);
    }
    @Test
    public void testUserCriticalAttackingAnEnemy(){
        assertTrue(player.getAttack(AttackFactor.CRITICAL) == 30);
    }
}

public class AttackFactorTest {

MyRandom myRandom = new MyRandom();

@Before
    public void setUp() {
        try {
            Field field = AttackFactor.class.getDeclaredField("RANDOM");
            field.setAccessible(true);
            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
            field.set(null, myRandom);
        } catch (IllegalArgumentException ex) {
            Logger.getLogger(AttackFactorTest.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(AttackFactorTest.class.getName()).log(Level.SEVERE, null, ex);
        } catch (NoSuchFieldException ex) {
            Logger.getLogger(AttackFactorTest.class.getName()).log(Level.SEVERE, null, ex);
        } catch (SecurityException ex) {
            Logger.getLogger(AttackFactorTest.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

@Test
    public void testReturnMissed() {
        myRandom.setRandomNumber(0);
        assertSame(AttackFactor.MISS, AttackFactor.getRandomAttackFactor());
        myRandom.setRandomNumber(1);
        assertSame(AttackFactor.MISS, AttackFactor.getRandomAttackFactor());
        myRandom.setRandomNumber(2);
        assertSame(AttackFactor.MISS, AttackFactor.getRandomAttackFactor());
        myRandom.setRandomNumber(3);
        assertSame(AttackFactor.MISS, AttackFactor.getRandomAttackFactor());
    }

@Test
    public void testReturnNormal() {
        for (int i = 4; i < 71; i++) {
            myRandom.setRandomNumber(i);
            assertSame(AttackFactor.NORMAL, AttackFactor.getRandomAttackFactor());
        }
    }

@Test
    public void testReturnLucky() {
        for (int i = 71; i < 97; i++) {
            myRandom.setRandomNumber(i);
            assertSame(AttackFactor.LUCKY, AttackFactor.getRandomAttackFactor());
        }
    }

@Test
    public void testReturnCritical() {
        for (int i = 97; i < 101; i++) {
            myRandom.setRandomNumber(i);
            assertSame(AttackFactor.CRITICAL, AttackFactor.getRandomAttackFactor());
        }
    }

private class MyRandom extends Random {

private int randomNumber;

public void setRandomNumber(int randomNumber) {
            this.randomNumber = randomNumber;
        }

@Override
        public int nextInt(int n) {
            return randomNumber;
        }
    }
}

Gostei muito dos codigos do autor do topico, mas não fiz as classes separadas pra não ficar igual

JavaTeenager Membro desde: 07/11/2006 14:10:54 Mensagens: 184 Offline

Interessante o desafio! Vou olhar com mais calma depois!

Virtual Machine Man Membro desde: 29/08/2006 21:50:17 Mensagens: 523 Offline

Felagund wrote:Gostei muito dos codigos do autor do topico, mas não fiz as classes separadas pra não ficar igual

Seu código ficou muito bom, mesmo com esse código alienigena rsrsrsr

dreampeppers99 wrote:

Felagund wrote:Gostei muito dos codigos do autor do topico, mas não fiz as classes separadas pra não ficar igual

Seu código ficou muito bom, mesmo com esse código alienigena rsrsrsr
modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);

asuhduhasdasduhuhasuhd, reflection

, é pra poder sobrescrever a variavel Random dentro do enum assim posso simular o comportamento.
Nunca tinha usado isso, achei esse codigo no Stack Overflow

. Até pensei em deixar aberto para definir o Random, mas em termos de Design não seria o ideal

This message was edited 2 times. Last update was at 27/04/2011 15:46:58

Felagund wrote:
asuhduhasdasduhuhasuhd, reflection , é pra poder sobrescrever a variavel Random dentro do enum assim posso simular o comportamento.
Nunca tinha usado isso, achei esse codigo no Stack Overflow . Até pensei em deixar aberto para definir o Random, mas em termos de Design não seria o ideal

Me lembra as máscaras de bits da época dos compiladores e outros.

O código ficou muito bom.

Entusiasta Java Membro desde: 16/10/2007 09:38:21 Mensagens: 18 Offline

Muito interessante mesmo. Tambem gosto muito de games.Muito bom!

dreampeppers99 wrote:
Eu (tentei) fiz foi isso mesmo o mock para o fator sorte!

Mas há uma diferença aqui. A classe Luck é uma classe de negócio, portanto, precisa ser testada. A classe Random é uma classe do Java, seu comportamento é garantido. Você não deve fazer mocks para o que deve ser testado, só para o que não deve. A menos, claro, que haja um outro JUnit só para a classe Luck.

Virtual Machine Man Membro desde: 29/08/2006 21:50:17 Mensagens: 523 Offline

ViniGodoy wrote:

dreampeppers99 wrote:
Eu (tentei) fiz foi isso mesmo o mock para o fator sorte!

Mas há uma diferença aqui. A classe Luck é uma classe de negócio, portanto, precisa ser testada. A classe Random é uma classe do Java, seu comportamento é garantido. Você não deve fazer mocks para o que deve ser testado, só para o que não deve. A menos, claro, que haja um outro JUnit só para a classe Luck.

Faz total sentido, eu até poderia ter criado um wrapper ou algo assim pra ser o meu Random e passar esse random para o LuckAttack como o mock, obrigado pela dica.

Virtual Machine Man Membro desde: 29/08/2006 21:50:17 Mensagens: 523 Offline

edao69 wrote:Muito interessante mesmo. Tambem gosto muito de games.Muito bom!

Interessante vai ser sua implementação Eder

tenta aí !

Vou pensar em algo para postar, mas uma das coisas mais interessantes desta proposta é ter enfatizado o uso de testes.

Virtual Machine Man Membro desde: 29/08/2006 21:50:17 Mensagens: 523 Offline

Edufa wrote:Vou pensar em algo para postar, mas uma das coisas mais interessantes desta proposta é ter enfatizado o uso de testes.

Extamente testes para fazer só o necessário nada mais.

Notícias, artigos e o maior fórum brasileiro sobre Java