Jogo TCG para representar (class)/(Atributos).

Oba, aqui eu crie uma nova Class elementos ja com valores definidos para cada elemento.

public class Elementos {

    String fogo = "Fogo";
    String gelo = "Gelo";
    String terra = "Terra";
    String ar = "Ar";
}

Ja aqui na nossa Class Monster recebemos um metodo que da uma vantagem de 10% quando um determinado elemento esta como seu adversario.

public class Monster {
        String nome;
        String elemento;
        int agilidade;
        int vida;
        int ataque;

         public void vantagem(String elemento1, String elemento2) {
            if(elemento1 == elemento2) {
                this.ataque = this.ataque + ((this.ataque /100)*10);
            }
        }
}

E por fim o Codigo de inicialização com as Class elemento e Class Monster chamando o metodo vatagem e sendo testado em cada criatura.

public class CreateMonster {
    public static void main(String[] args) {


        // Valores de atributos.
        int vidaMagos = 1000;
        int ataqueMago = 1500;
        int agilidadeMago = 7;

        //Elementos
        Elementos elementos = new Elementos();

        //Lista de criaturas do tipo mago.
        Monster magoDeGelo = new Monster();
            magoDeGelo.nome = "Mago de Gelo";
            magoDeGelo.elemento = elementos.gelo;
            magoDeGelo.vida = vidaMagos;
            magoDeGelo.agilidade = agilidadeMago;
            magoDeGelo.ataque = ataqueMago;

            magoDeGelo.vantagem(elementos.ar, elementos.ar);
            System.out.println(magoDeGelo.nome + " " + magoDeGelo.ataque);                        

        Monster magoDeFogo = new Monster();
            magoDeFogo.nome = "Mago de Fogo";
            magoDeFogo.elemento = elementos.fogo;
            magoDeFogo.vida = vidaMagos;
            magoDeFogo.agilidade = agilidadeMago;
            magoDeFogo.ataque = ataqueMago;

            magoDeFogo.vantagem(elementos.gelo, elementos.gelo);
            System.out.println(magoDeFogo.nome + " " + magoDeFogo.ataque);

        Monster magoDeTerra = new Monster();
            magoDeTerra.nome = "Mago de Terra";
            magoDeTerra.elemento = elementos.terra;
            magoDeTerra.vida = vidaMagos;
            magoDeTerra.agilidade = agilidadeMago;
            magoDeTerra.ataque = ataqueMago;

            magoDeTerra.vantagem(elementos.fogo, elementos.fogo);
            System.out.println(magoDeTerra.nome + " " + magoDeTerra.ataque);

        Monster magoDeAr = new Monster();
            magoDeAr.nome = "Mago de Ar";
            magoDeAr.elemento = elementos.ar;
            magoDeAr.vida = vidaMagos;
            magoDeAr.agilidade = agilidadeMago;
            magoDeAr.ataque = ataqueMago;

            magoDeAr.vantagem(elementos.terra, elementos.terra);
            System.out.println(magoDeAr.nome + " " + magoDeAr.ataque);

    }
}

Oie... Adicionei uma um metodo na nova Class Verificadores que faz uma verificação de batalha.

public class Verificadores {
    //Batalha
            public boolean hit(int ataque1, int vida1) {
                if(ataque1 >= vida1) {
                    return true;
                }else {
                    return false;
                }
            }
}

Segue abaixo um exemplo de batalha usando a Class Verificadores.

Verificadores batalha = new Verificadores();
            boolean resultado = batalha.hit(magoDeAr.ataque, magoDeTerra.vida);
            if(resultado){
                System.out.println("O oponente foi aniquilado");
            }else{
                System.out.println("Seu oponente resistiu a seu ataque");
            }

Aqui no desafio para usar metodos passando como paramentros o objeto criei um metodo dentro da Class Verificadores que drena a vida do oponente.

//Drena Vida
            public boolean drenar(Monster origen, Monster destino) {
                origen.vida +=  (destino.vida / 2);
                return true;
            }
}

Aqui na Class de Inicialização o metodo sendo chamado e utilizado e o resultado boolean sendo usado para fazer a retirada da vida do oponente.

boolean drenar = batalha.drenar(magoDeGelo, magoDeFogo);
            if(drenar) {magoDeFogo.vida -= magoDeFogo.vida / 2;}
            System.out.println(magoDeGelo.vida);
            System.out.println(magoDeFogo.vida);

Com a aula de composição de objetos eu criei uma nova Class Atributos e referenciei ela na Class Monster reduzindo assim o que era escrito no programa principal.

Nova class atributos.

public class Atributos {
    int vidaMagos = 1000;
    int ataqueMago = 1500;
    int agilidadeMago = 7;
    int agilidade = agilidadeMago;
    int vida = vidaMagos;
    int ataque = ataqueMago; 

}

Class Monster referenciando Class Atributos

public class Monster {
        String nome;
        String elemento;
        Atributos atributos = new Atributos();

        //Verificação de Vantagem
        public void vantagem(String elemento1, String elemento2) {
            if(elemento1 == elemento2) {
                this.atributos.ataque += ((this.atributos.ataque /100)*10);
            }
        }

}

Atualização da Class Verificações

public class Verificadores {
    //Batalha
            public boolean hit(int ataque1, int vida1) {
                if(ataque1 >= vida1) {
                    return true;
                }else {
                    return false;
                }
            }
    //Drena Vida
            public boolean drenar(Monster origen, Monster destino) {
                origen.atributos.vida +=  (destino.atributos.vida / 2);
                return true;
            }
}

E por fim a Class Principal

public class CreateMonster {
    public static void main(String[] args) {


        //Elementos
        Elementos elementos = new Elementos();

        //Lista de criaturas do tipo mago.
        Monster magoDeGelo = new Monster();
            magoDeGelo.nome = "Mago de Gelo";
            magoDeGelo.elemento = elementos.gelo;

            magoDeGelo.vantagem(elementos.ar, elementos.ar);
            System.out.println(magoDeGelo.nome + " " + magoDeGelo.atributos.ataque);                        

        Monster magoDeFogo = new Monster();
            magoDeFogo.nome = "Mago de Fogo";
            magoDeFogo.elemento = elementos.fogo;

            magoDeFogo.vantagem(elementos.gelo, elementos.gelo);
            System.out.println(magoDeFogo.nome + " " + magoDeFogo.atributos.ataque);

        Monster magoDeTerra = new Monster();
            magoDeTerra.nome = "Mago de Terra";
            magoDeTerra.elemento = elementos.terra;

            magoDeTerra.vantagem(elementos.fogo, elementos.fogo);
            System.out.println(magoDeTerra.nome + " " + magoDeTerra.atributos.ataque);

        Monster magoDeAr = new Monster();
            magoDeAr.nome = "Mago de Ar";
            magoDeAr.elemento = elementos.ar;


            magoDeAr.vantagem(elementos.terra, elementos.terra);
            System.out.println(magoDeAr.nome + " " + magoDeAr.atributos.ataque);

            Verificadores batalha = new Verificadores();
            boolean resultado = batalha.hit(magoDeAr.atributos.ataque, magoDeTerra.atributos.vida);
            if(resultado){
                System.out.println("O oponente foi aniquilado");
            }else{
                System.out.println("Seu oponente resistiu a seu ataque");
            }

            boolean drenar = batalha.drenar(magoDeGelo, magoDeFogo);
            if(drenar) {magoDeFogo.atributos.vida -= magoDeFogo.atributos.vida / 2;}
            System.out.println(magoDeGelo.atributos.vida);
            System.out.println(magoDeFogo.atributos.vida);
    }
}

Melhorei o codigo usando os Getters e Setters

Não privei a class atributos, pois não era necessario

public class Atributos {
    int vidaMagos = 1000;
    int ataqueMago = 1500;
    int agilidadeMago = 7;
    int agilidade = agilidadeMago;
    int vida = vidaMagos;
    int ataque = ataqueMago;

}

A Class Elementos foi privada e agora é chamada direto pela Class Monster

ublic class Elementos {
    private String fogo = "Fogo";
    private String gelo = "Gelo";
    private String terra = "Terra";
    private String ar = "Ar";

    public String getFogo(){

        return this.fogo;
    }
    //
    public String getGelo() {

        return this.gelo;

    }
    //
    public String getTerra() {

        return this.terra;

    }
    //
    public String getAr() {

        return this.ar;
    }

}

A Class Monster ficou privada e linka para a Atributos e para a Elementos

public class Monster {
        private String nome;
        private Elementos elementos = new Elementos();
        private Atributos atributos = new Atributos();

        public Elementos getElemento() {
            return this.elementos;
        }

        public String getNome(){
            return this.nome;
        }
        public void setNome(String nome) {
            this.nome = nome;
        } 
        public Atributos getAtributo() {
            return this.atributos;
        }

        public void setAtributos(Atributos atributos) {
            this.atributos = atributos;
        }

        //Verificação de Vantagem
        public void vantagem(String elemento1, String elemento2) {
            if(elemento1 == elemento2) {
                this.getAtributo().ataque += ((this.getAtributo().ataque /100)*10);
            }
        }

}

E a Class Main Chama os elementos pela monster e usa Getter e Setter.

public class CreateMonster {
    public static void main(String[] args) {


        //Lista de criaturas do tipo mago.
        Monster magoDeGelo = new Monster();
            magoDeGelo.setNome("Mago de Fogo");
            magoDeGelo.getElemento().getGelo();



        Monster magoDeFogo = new Monster();
            magoDeFogo.setNome("Mago de Fogo");
            magoDeFogo.getElemento().getFogo();



        Monster magoDeTerra = new Monster();
            magoDeTerra.setNome("Mago de Terra");
            magoDeTerra.getElemento().getTerra();



        Monster magoDeAr = new Monster();
            magoDeAr.setNome("Mago de Ar");
            magoDeAr.getElemento().getAr();

            //
            magoDeFogo.vantagem(magoDeGelo.getElemento().getGelo(), magoDeGelo.getElemento().getGelo());
            System.out.println(magoDeFogo.getNome() + " " + magoDeFogo.getAtributo().ataque);

            magoDeTerra.vantagem(magoDeFogo.getElemento().getFogo(), magoDeFogo.getElemento().getFogo());
            System.out.println(magoDeTerra.getNome() + " " + magoDeTerra.getAtributo().ataque);

            magoDeGelo.vantagem(magoDeAr.getElemento().getAr(), magoDeAr.getElemento().getAr());
            System.out.println(magoDeGelo.getNome() + " " + magoDeGelo.getAtributo().ataque);

            magoDeAr.vantagem(magoDeTerra.getElemento().getTerra(), magoDeTerra.getElemento().getTerra());
            System.out.println(magoDeAr.getNome() + " " + magoDeAr.getAtributo().ataque);

            Verificadores batalha = new Verificadores();
            boolean resultado = batalha.hit(magoDeAr.getAtributo().ataque, magoDeTerra.getAtributo().vida);
            if(resultado){
                System.out.println("O oponente foi aniquilado");
            }else{
                System.out.println("Seu oponente resistiu a seu ataque");
            }

            boolean drenar = batalha.drenar(magoDeGelo, magoDeFogo);
            if(drenar) {magoDeFogo.getAtributo().vida -= magoDeFogo.getAtributo().vida / 2;}
            System.out.println(magoDeGelo.getAtributo().vida);
            System.out.println(magoDeFogo.getAtributo().vida);
    }
}