DIGIMON Wars: Battle of the JAVA Monsters

Game Scoring

The Game

Digimon Super Class

package ph.softartifact.digiwars.data.model;

/**
 *
 * @author Soft Artifact Incorporated
 */
public abstract class Digimon {

    public enum DigiMove {

        ATTACK,
        MATTACK,
        HEAL,
        TAG
    }
    protected DigimonStats digimonStats;

    public abstract DigiMove executeTurn();

    public void setStats(DigimonStats digimonStats) {
        this.digimonStats = digimonStats;
    }
}

For your every turn, you are only to take note of the following:
1. The system runs your executeTurn();
2. And you are to return a DigiMove either: ATTACK, MATTACK, HEAL, TAG. This will be explained.
3. You get a copy of your digimonStats at the start of the fight, so your code should be able to track your own Digimon Stats.
4. You will be fed of both the HP and the MP of the opponent Digimon before your executeTurn is run.

DigimonStats

package ph.softartifact.digiwars.data.model;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 *
 * @author Soft Artifact Incorporated
 */
public class DigimonStats {

    private BigDecimal hp;
    private BigDecimal mp;
    private BigDecimal physicalAttack;
    private BigDecimal magicAttack;
    private BigDecimal physicalDefense;
    private BigDecimal attackAccuracy;
    private BigDecimal defenseAccuracy;

    /**
     * @return the hp
     */
    public BigDecimal getHp() {
        return hp;
    }

    /**
     * @return the mp
     */
    public BigDecimal getMp() {
        return mp;
    }

    /**
     * @return the physicalAttack
     */
    public BigDecimal getPhysicalAttack() {
        return physicalAttack;
    }

    /**
     * @return the magicAttack
     */
    public BigDecimal getMagicAttack() {
        return magicAttack;
    }


    /**
     * @return the physicalDefense
     */
    public BigDecimal getPhysicalDefense() {
        return physicalDefense;
    }

    /**
     * @return the attackAccuracy
     */
    public BigDecimal getAttackAccuracy() {
        return attackAccuracy;
    }

    /**
     * @return the defenseAccuracy
     */
    public BigDecimal getDefenseAccuracy() {
        return defenseAccuracy;
    }

    public void hitDigimon(BigDecimal attackPoints) {
        hp = hp.subtract(attackPoints);
    }

    public void initializeStats(int hp, int mp, int physicalAttack, int magicAttack, int physicalDefense, int attackAccuracy, int defenseAccuracy) {
        this.hp = BigDecimal.valueOf(hp);
        this.mp = BigDecimal.valueOf(hp);
        this.physicalAttack = BigDecimal.valueOf(physicalAttack).divide(BigDecimal.valueOf(10), 2, RoundingMode.UP);
        this.magicAttack = BigDecimal.valueOf(magicAttack).divide(BigDecimal.valueOf(10), 2, RoundingMode.UP);
        this.physicalDefense = BigDecimal.valueOf(physicalDefense).divide(BigDecimal.valueOf(10), 2, RoundingMode.UP);
        this.attackAccuracy = BigDecimal.valueOf(attackAccuracy);
        this.defenseAccuracy = BigDecimal.valueOf(defenseAccuracy);
    }
}

Let me explain to you the seven stats your digimon has:

1. HP: Health Points. If this gets <= 0, your digimon dies.
2. MP: Magic Points. This gets generated every turn. MP allows you to cast Magic Attacks and Heal.
1. Your MP is drained by the same points you render a Magic Attack.
2. When you HEAL, your MP is drained completely, and for every MP that is used up, your HP is equivalently replenished.
3. Physical Attack: The number of points you can potentially damage your Opponent’s HP
4. Magic Attack: The number of points you can damage your Opponent’s HP
5. Physical Defense: If after the computation your physical defense is greater than your opponent’s physical attack points, you will be able to completely block that attack.
6. Attack Accuracy: Makes for the Uncertainty Variance affecting the final attack points.
7. Defense Accuracy: The probability at which your digimon will attempt to block the opponent’s physical attack.

Initialize Stats

At the start of every fight, the participant keys in the initial stats they would like to give to their Digimon.
For every digimon, they only have a maximum of 400 Integer Points Allowed.

For the Physical Attack, Magic Attack, and Physical Defense, the integer are divided by 10, and converted to a BigDecimal value.

Example:

HP: 200
MP: 50
Physical Attack: 100
Magic Attack: 0
Physical Defense: 50
Attack Accuracy: 50
Defense Accuracy: 100

During the initialization stage, the system will only consider the first four 500 points and will discard the rest. This means that this Digimon will only have:
HP: 200
MP: 50
Physical Attack: 100
Magic Attack: 0
Physical Defense: 50
Attack Accuracy: 0
Defense Accuracy: 0

during the fight.

Then, the three stats above will be converted to:
HP: 200
MP: 50
Physical Attack: 10.00
Magic Attack: 0
Physical Defense: 5.00
Attack Accuracy: 0
Defense Accuracy: 0

So, the Digimon will execute its strategy based on the stats it is provided with.

Computation of Attack Points
Given RAND(min, max) function,

1. Physical Attack

Range Normalizer =  1/3(Attack Accuracy);
Range = RAND(0,Attack Accuracy) – Range Normalizer;
Percentage Range = Range / 100;
Physical Damage = Physical Attack * (1 + Percentage Range);

2. Magic Attack

Physical Damage = Magic Attack (if MP >= Magic Attack; MP = MP – Magic Attack);
or
Physical Damage = 0 (if MP < Magic Attack; MP = MP – Magic Attack until MP = 0);

3. Defense

Range = RAND(0,100);
If Range > Defense Accuracy
Defense Status = True
else
Defense Status = False
Therefore:
Block = UNSUCCESSFUL

If Defense Status = True
Block = SUCCESSFUL (If Opponent Physical Damage > Physical Defense)
Block = UNSUCCESSFUL (If Opponent Physical Damage <= Physical Defense)

Move Technicality

If executeTurn() takes more than 1 minute, the digimon move is forfeited and the opponent makes its move.