O desafio é bem simples, há um cenário e os testes para que vocês façam e demonstrem e/ou expliquem suas decisões de projeto.
Produto: Um jogo RPG chamado Breath of Fantasy Estória: O esquema de batalha -> Criar o esquema de batalha para o jogo.Descrição:
A batalha é baseada em turnos, a cada momento um personagem ataca e o outro recebe o ataque. O personagem tem pontos de energia e pontos de poder. Essas duas propriedades contém números inteiros. Por exemplo, se o herói (pontos de energia:60, pontos de poder:45) ataca um inimigo (pontos de energia:60, pontos de poder:45) o inimigo terá seus pontos de energia diminuídos. O dano sofrido, ou seja, os pontos de energia perdidos pelo inimigo, dependem do fator sorte. O fator sorte é um número randômico de 0 a 100 que é dado a cada turno da batalha.
Há quatro tipos de ataques que dependem logicamente do fator sorte:
[list]Quando a sorte está em 0-3 então o ataque é Perdido -> não causa dano;[/list]
[list]Quando a sorte está em 4-70 então o ataque é Normal -> causa 1/3 de seus pontos de poder de danos;[/list]
[list]Quando a sorte está em 71-96 então o ataque é Sorte -> causa 1/3 de seus pontos de poder mais 20% desses 1/3;[/list]
[list]E quando a sorte está em 97-100 então o ataque é Crítico -> causa o dobro de um ataque normal.[/list]
[size=16][color=blue]Crie testes que provem que com os personagens acima (herói e inimigo) :[/color][/size]
Quando houver um ataque Perdido não há dano;
Quando houver um ataque Normal haverá um dano de 1/3 dos pontos de poder;
Quando houver um ataque Sorte haverá um dano de 1/3 + 20% de 1/3;
E quando houver um ataque Crítico haverá um dano de duas vezes o dano de um ataque normal.
public class Power {
private int power;
private Luck luck;
public Power(int power,Luck luck) {
this.power = power;
this.luck = luck;
}
public int getPowerAttack() {
return (int) ((power / 3) * luck.nextAttackLuckFactor());
}
}
public class Energy {
private int energy;
public Energy(int energy){
this.energy = energy;
}
public int getEnergyPoints(){
return energy;
}
public void decrease(int attack) {
energy -= attack;
}
}
public class UnitCharacter {
private final Energy energy;
private final Power power;
public UnitCharacter(final String name,final Energy energy,final Power power) {
this.energy = energy;
this.power = power;
}
public void attack(final UnitCharacter other) {
other.energy.decrease(power.getPowerAttack());
}
public int getEnergyPoints() {
return energy.getEnergyPoints();
}
}
public interface Luck {
double nextAttackLuckFactor();
}
public class LuckAttack implements Luck {
private final Random random = new Random();
private final static double MISS = 0;
private final static double NORMAL = 1;
private final static double LUCKY = 1.2;
private final static double CRITICAL = 2;
@Override
public double nextAttackLuckFactor(){
int randomFactor = random.nextInt(101);
if (randomFactor > 0 & randomFactor <=3){
return MISS;
} else if (randomFactor > 3 & randomFactor <= 70){
return NORMAL;
} else if (randomFactor > 70 & randomFactor <= 96){
return LUCKY;
} else {
return CRITICAL;
}
}
}
public class TestAttack {
@Test
public void validateMissAttack(){
Luck missLuck = new Luck() {
@Override
public double nextAttackLuckFactor() {
return 0;
}
};
UnitCharacter hero = new UnitCharacter("hero",new Energy(60),new Power(45,missLuck));
UnitCharacter enemy = new UnitCharacter("enemy",new Energy(60),new Power(45,missLuck));
hero.attack(enemy);
Assert.assertEquals(enemy.getEnergyPoints(), 60);
}
@Test
public void validateNormalAttack(){
Luck normalLuck = new Luck() {
@Override
public double nextAttackLuckFactor() {
return 1;
}
};
UnitCharacter hero = new UnitCharacter("hero",new Energy(60),new Power(45,normalLuck));
UnitCharacter enemy = new UnitCharacter("enemy",new Energy(60),new Power(45,normalLuck));
hero.attack(enemy);
Assert.assertEquals(enemy.getEnergyPoints(), 45);
}
@Test
public void validateLuckyAttack(){
Luck luckyLuck = new Luck() {
@Override
public double nextAttackLuckFactor() {
return 1.2;
}
};
UnitCharacter hero = new UnitCharacter("hero",new Energy(60),new Power(45,luckyLuck));
UnitCharacter enemy = new UnitCharacter("enemy",new Energy(60),new Power(45,luckyLuck));
hero.attack(enemy);
Assert.assertEquals(enemy.getEnergyPoints(), 42);
}
@Test
public void validateCriticalAttack(){
Luck criticalLuck = new Luck() {
@Override
public double nextAttackLuckFactor() {
return 2;
}
};
UnitCharacter hero = new UnitCharacter("hero",new Energy(60),new Power(45,criticalLuck));
UnitCharacter enemy = new UnitCharacter("enemy",new Energy(60),new Power(45,criticalLuck));
hero.attack(enemy);
Assert.assertEquals(enemy.getEnergyPoints(), 30);
}
}
Poste a sua solução!
Post original : TDD em prática desenvolvendo um jogo
