Javamon

Las Javamon son criaturas java que viven la isla JVM y son instanciadas por maestros programadores para luchar en combate
 
Este es un proyecto para montar un sistema de combate de javamon. El proyecto
 consiste en tres clases:

1- una Principal, la que inicia todo.

2- Una clase llamada Javamon para representar a un Javamon

3- Una clase Combate, que lleva a cabo el combate entre dos Javamones



Principal
La clase principal debe iniciar una par de Javamones, a los que se asignan los atributos de manera aleatoria siempre sumando un máximo de 18 puntos. Luego debe crear una instancia de la clase Combate pasando
 los dos javamones al constructor.

/**
 * Principal
 * @author Pello
 * greetz to all DAM1 sick people, go and get a life
 */
public class Principal {

    public static void main (String args[]) {
        Javamon uno = new Javamon("Pikachu");
        Javamon otro = new Javamon("Bulbasaur");
        
        Combate combate = new Combate(uno,otro);
        
        System.out.println("Y el ganador es: " + combate.resultado().getNombre());
        
        System.out.println("Gracias por usar JavaMon");
    }
}

La clase javamon

Esta clase contiene al bicho, el javamon y sus métodos.

import java.util.Random;

/**
 *
 * @author Pello
 * greetz Vigor jauna, 2DAMeko ikaslea
 */
public class Javamon {
    private String nombre;
    private int fuerza;
    private int defensa;
    private int agilidad;
    private int vida;
    private Random aleatorio = new Random();
    
    /**
     * Javamon
     * constructor con parámetro
     * @param nombre
     */
    public Javamon(String nombre) {
        this.nombre = nombre;
        inicializarAtributos();
    }
    
    /**
     * inicializarAtributos
     * inicializa los atributos del javamon
     */
    private void inicializarAtributos () {
        int puntos_a_repartir = 18;
        // a qué atributo le daremos puntos en cada vuelta
        int aque = 0;
        // máximo de puntos que podemos dar
        int max = 0;
        
        // en principio valen 0
        fuerza = defensa = agilidad = 0;
        while (puntos_a_repartir > 0) {
            aque = aleatorio.nextInt(3);
            switch (aque) {
                case 0:
                    fuerza++;
                    break;
                case 1:
                    defensa++;
                    break;
                case 2:
                    agilidad ++;
                    break;
                default: break; // esto por manía. nevermind
            }
            // y vamos restando...
            puntos_a_repartir--;
        }
        
        // Y la vida dependerá de F y D
        vida = fuerza + defensa + 6;
    }
    
    /**
     * iniciativa
     * representa una tirada de iniciativa
     * @return
     */
    public int iniciativa () {
        return agilidad + aleatorio.nextInt(6);
    }
    
    /**
     * atacar
     * representa una tirada de atacar
     * @return
     */
    public int atacar () {
        return fuerza + aleatorio.nextInt(6);        
    }

    /**
     * defender
     * representa una tirada de defensa
     * @return
     */
    public int defender () {
        return ((agilidad + defensa) /2 ) + aleatorio.nextInt(6);

    }
    
    /**
     * estado
     * un resumen del javamon: vida y atributos
     * @return
     */
    public String estado (){
        return nombre +"(" + vida + ")| F:" + fuerza + "| D:" + defensa + "| A:" + agilidad;
    }

    /**
     * @return the nombre
     */
    public String getNombre() {
        return nombre;
    }

    /**
     * @return the fuerza
     */
    public int getFuerza() {
        return fuerza;
    }

    /**
     * @return the defensa
     */
    public int getDefensa() {
        return defensa;
    }

    /**
     * @return the agilidad
     */
    public int getAgilidad() {
        return agilidad;
    }

    /**
     * @return the vida
     */
    public int getVida() {
        return vida;
    }
    
    /**
     * @param vida
     */
    public void setVida(int vida) {
        this.vida = vida;
    }

}
 

La clase combate

La clase combate desde el constructor debe llamar al método privado combatir
 que en un bucle de llamadas al método asalto determinará quién gana.

Para combatir se hace lo siguiente:

1.Los javamones llaman al método inciativa. El que tenga más valor e inicia el asalto

2.el método asalto tienes dos Javamones como parámetros. El primero ataca y el otro defiende. dentro de él se restan puntos de vida.

3.mientras a los dos les queden puntos de vida se siguen zumbando.

/**
 *
 * @author Pello
 * greetz lafu
 */
public class Combate {
    private Javamon javamon1;
    private Javamon javamon2;
    private int asaltos = 0;
    
    /**
     * Combate
     * constructor de la clase
     * @param javamon1
     * @param javamon2
     */
    public Combate (Javamon javamon1, Javamon javamon2) {
        this.javamon1 = javamon1;
        this.javamon2 = javamon2;
        combatir();
    }
    
    /**
     * combatir
     * método que lleva a cabo el combate
     */
    private void combatir () {
        Javamon primero, segundo;

        do {
            // Contaremos los asaltos.
            asaltos++;
            
            // Segun iniciativa uno ataca y el otro defiende
            if (javamon1.iniciativa() < javamon2.iniciativa()) {
                primero = javamon2;
                segundo = javamon1;
            } else {
                primero = javamon1;
                segundo = javamon2;
            }
            System.out.println(primero.estado() +" ATACA A "+ segundo.estado());
            asalto(primero, segundo);
        // mientras los dos tengan vida, se siguen pegando.
        } while (primero.getVida() > 0 && segundo.getVida() > 0);
            
    }
    
    /**
     * asalto
     * representa un asalto entre un javamon y otro.
     * según a quién le toque el parámetro será uno u otro.
     * El primero es el que ataca
     * @param jm1
     * @param jm2
     */
    private void asalto (Javamon jm1, Javamon jm2) {
        // El daño del asalto será el ataque de uno menos la defensa del otro
        int dano = (jm1.atacar() - jm2.defender());

        // Restamos los puntos de daño de la vida del segundo
        // siempre que se haya hecho daño claro
        if (dano > 0) {
            System.out.println(jm1.getNombre() + " resta " + dano + " daño a " + jm2.getNombre());
            jm2.setVida(jm2.getVida() - dano);
        } else {
            System.out.println(jm2.getNombre() + " neutraliza el ataque!!");
        }
        
    }
    
    /**
     * resultado
     * devuelve el javamon vencedor
     * @return el javamon vencedor
     */
    public Javamon resultado () {
        System.out.println("Total " + asaltos + " asaltos");
        if (javamon1.getVida() > 0) {
            return javamon1;
        } else {
            return javamon2;
        }
    }
    
}




Todo eso ocurren automáticamente, y luego el método principal debe llamar al método
 de combate.resultado() que le devolverá la instancia del Javamon vencedor.

Pikachu(17)| F:7| D:4| A:7 ATACA A Bulbasaur(17)| F:7| D:4| A:7
Bulbasaur neutraliza el ataque!!
Pikachu(17)| F:7| D:4| A:7 ATACA A Bulbasaur(17)| F:7| D:4| A:7
Pikachu resta 2 daño a Bulbasaur
Pikachu(17)| F:7| D:4| A:7 ATACA A Bulbasaur(15)| F:7| D:4| A:7
Pikachu resta 5 daño a Bulbasaur
Bulbasaur(10)| F:7| D:4| A:7 ATACA A Pikachu(17)| F:7| D:4| A:7
Pikachu neutraliza el ataque!!
Bulbasaur(10)| F:7| D:4| A:7 ATACA A Pikachu(17)| F:7| D:4| A:7
Bulbasaur resta 5 daño a Pikachu
Pikachu(12)| F:7| D:4| A:7 ATACA A Bulbasaur(10)| F:7| D:4| A:7
Pikachu resta 1 daño a Bulbasaur
Pikachu(12)| F:7| D:4| A:7 ATACA A Bulbasaur(9)| F:7| D:4| A:7
Bulbasaur neutraliza el ataque!!
Pikachu(12)| F:7| D:4| A:7 ATACA A Bulbasaur(9)| F:7| D:4| A:7
Pikachu resta 2 daño a Bulbasaur
Bulbasaur(7)| F:7| D:4| A:7 ATACA A Pikachu(12)| F:7| D:4| A:7
Pikachu neutraliza el ataque!!
Bulbasaur(7)| F:7| D:4| A:7 ATACA A Pikachu(12)| F:7| D:4| A:7
Bulbasaur resta 2 daño a Pikachu
Pikachu(10)| F:7| D:4| A:7 ATACA A Bulbasaur(7)| F:7| D:4| A:7
Pikachu resta 5 daño a Bulbasaur
Bulbasaur(2)| F:7| D:4| A:7 ATACA A Pikachu(10)| F:7| D:4| A:7
Bulbasaur resta 5 daño a Pikachu
Pikachu(5)| F:7| D:4| A:7 ATACA A Bulbasaur(2)| F:7| D:4| A:7
Pikachu resta 1 daño a Bulbasaur
Pikachu(5)| F:7| D:4| A:7 ATACA A Bulbasaur(1)| F:7| D:4| A:7
Bulbasaur neutraliza el ataque!!
Pikachu(5)| F:7| D:4| A:7 ATACA A Bulbasaur(1)| F:7| D:4| A:7
Bulbasaur neutraliza el ataque!!
Bulbasaur(1)| F:7| D:4| A:7 ATACA A Pikachu(5)| F:7| D:4| A:7
Pikachu neutraliza el ataque!!
Pikachu(5)| F:7| D:4| A:7 ATACA A Bulbasaur(1)| F:7| D:4| A:7
Bulbasaur neutraliza el ataque!!
Pikachu(5)| F:7| D:4| A:7 ATACA A Bulbasaur(1)| F:7| D:4| A:7
Pikachu resta 1 daño a Bulbasaur
Total 18 asaltos
Y el ganador es: Pikachu
Gracias por usar JavaMon
 

by Pello Altadill 01/13/2013 01:11:38 - 937 hits