Duvida com classes

15 respostas
P

Olá pessoal, é a primeira vez que eu estou postando aqui, e preciso da ajuda de vcs para continuar meu desenvolvimento…

No jogo que eu estou criando, o jogo possui algumas raças, e todas elas possuem atributos em comum. Para não precisar criar varias classes com os mesmo atributos, eu preciso que as 4 raças compartilhem os mesmos atributos com valores diferentes, como mostra o exemplo abaixo…

public class Races 
{
	private float base_hp;
	private float base_ep;
	private float base_dmg;
	private float base_amr; //dmg reduction
	private float base_spd; //sqm's per second
	private float base_blt_spd; //sqm's per second
	private int base_blt_pen; //percent chance to bullets penetrates
	private int base_blt_siz; //bullet size in pixels

	Races(float base_hp, float base_ep, float base_dmg, float base_amr, float base_spd, float base_blt_spd, int base_blt_pen, int base_blt_siz)
	{
		this.base_hp = base_hp;
		this.base_ep = base_ep;
		this.base_dmg = base_dmg;
		this.base_amr = base_amr;
		this.base_spd = base_spd;
		this.base_blt_spd = base_blt_spd;
		this.base_blt_pen = base_blt_pen;
		this.base_blt_siz = base_blt_siz;
	}

	//Races(base_hp, base_ep, base_dmg, base_amr, base_spd, base_blt_spd, base_blt_pen, base_blt_siz)

	public Races Human = new Races(100,50,5,3,1,3,10,5);
	public Races Cyborg = new Races(110,44,4,4,0.8f,2.5f,8,5);
	public Races Ninja = new Races(84,40,5,2,1.2f,4,15,3);
	public Races Ogre = new Races(120,30,8,5,0.6f,2,12,8);
}

A pergunta é a seguinte, como eu acesso essas classes de outro lugar, eu fiz assim pois não consegui pensar em outra maneira de fazer.
Eu precisava chamar no “main” algo assim:
Races.human.getBase_hp() OU Races.getBase_hp(human)
alguém me ajuda a criar esta estrutura por favor, pois desta forma que eu fiz não consigo acessar estes objetos de outra classe.

15 Respostas

drsmachado

Será que não seria interessante trabalhar com polimorfismo e/ou herança? Se as raças compartilham atributos, mas estes terão valores diferentes entre si, pode ser uma boa.
Só tome cuidado pois herança poderá engessar muito o teu modelo, prefira usar interfaces (embora seja para criar os beans, pode ser favorável)

JavaDreams

Paulix:
Olá pessoal, é a primeira vez que eu estou postando aqui, e preciso da ajuda de vcs para continuar meu desenvolvimento…

No jogo que eu estou criando, o jogo possui algumas raças, e todas elas possuem atributos em comum. Para não precisar criar varias classes com os mesmo atributos, eu preciso que as 4 raças compartilhem os mesmos atributos com valores diferentes, como mostra o exemplo abaixo…

public class Races 
{
	private float base_hp;
	private float base_ep;
	private float base_dmg;
	private float base_amr; //dmg reduction
	private float base_spd; //sqm's per second
	private float base_blt_spd; //sqm's per second
	private int base_blt_pen; //percent chance to bullets penetrates
	private int base_blt_siz; //bullet size in pixels

	Races(float base_hp, float base_ep, float base_dmg, float base_amr, float base_spd, float base_blt_spd, int base_blt_pen, int base_blt_siz)
	{
		this.base_hp = base_hp;
		this.base_ep = base_ep;
		this.base_dmg = base_dmg;
		this.base_amr = base_amr;
		this.base_spd = base_spd;
		this.base_blt_spd = base_blt_spd;
		this.base_blt_pen = base_blt_pen;
		this.base_blt_siz = base_blt_siz;
	}

	//Races(base_hp, base_ep, base_dmg, base_amr, base_spd, base_blt_spd, base_blt_pen, base_blt_siz)

	public Races Human = new Races(100,50,5,3,1,3,10,5);
	public Races Cyborg = new Races(110,44,4,4,0.8f,2.5f,8,5);
	public Races Ninja = new Races(84,40,5,2,1.2f,4,15,3);
	public Races Ogre = new Races(120,30,8,5,0.6f,2,12,8);
}

A pergunta é a seguinte, como eu acesso essas classes de outro lugar, eu fiz assim pois não consegui pensar em outra maneira de fazer.
Eu precisava chamar no “main” algo assim:
Races.human.getBase_hp() OU Races.getBase_hp(human)
alguém me ajuda a criar esta estrutura por favor, pois desta forma que eu fiz não consigo acessar estes objetos de outra classe.

Paulix seja bem vindo ao GUJ, sinta-se a vontade para perguntar e veja algumas dicas para postar nos links da minha assinatura.

Muito bom sua ideia para criar o jogo, mas acho que faltou alguns detalhes:
1- você tem as variáveis private dentro de Races mas não colocou os sets e gets
2- eu acho mais simples tirar as 4 raças da classe Races e criar elas como objetos diferentes pois assim ficará orientado a objeto e todos os objetos
poderão ter acesso às habilidades em comum, usando os gets da classe Races.
3- ao meu ver se você cria outros objetos do tipo Races dentro da classe Races, vai acabar em loop infinito pois sempre que criar por exemplo o objeto Human, ele será um objeto que conterá a criação dele e de mais 4 tipos de raças que são criadas e instanciadas dentro da classe. Assim mais um motivo para eu querer controlar os objetos criados dentro de main.
4- não sei se entendi bem a sua preocupação com a quantidade de classes que vai ter que criar, mas olha eu criei somente 2 classes, uma para controlar as Races e outra para controlar o Main que será o controle do jogo. Mas não se esqueça que tem gets e sets dentro da classe Races, pois assim poderá alterar o valor do personagem quando ele evoluir de nível usando os sets por exemplo.

veja os códigos abaixo:

Classe Races

package jogorpg;
public class Races 
{
	private float base_hp;
	private float base_ep;
	private float base_dmg;
	private float base_amr; //dmg reduction
	private float base_spd; //sqm's per second
	private float base_blt_spd; //sqm's per second
	private int base_blt_pen; //percent chance to bullets penetrates
	private int base_blt_siz; //bullet size in pixels

	Races(float base_hp, float base_ep, float base_dmg, float base_amr, float base_spd, float base_blt_spd, int base_blt_pen, int base_blt_siz)
	{
		this.base_hp = base_hp;
		this.base_ep = base_ep;
		this.base_dmg = base_dmg;
		this.base_amr = base_amr;
		this.base_spd = base_spd;
		this.base_blt_spd = base_blt_spd;
		this.base_blt_pen = base_blt_pen;
		this.base_blt_siz = base_blt_siz;
	}

	//Races(base_hp, base_ep, base_dmg, base_amr, base_spd, base_blt_spd, base_blt_pen, base_blt_siz)

	

    public float getBase_hp() {
        return base_hp;
    }

    public void setBase_hp(float base_hp) {
        this.base_hp = base_hp;
    }

    public float getBase_ep() {
        return base_ep;
    }

    public void setBase_ep(float base_ep) {
        this.base_ep = base_ep;
    }

    public float getBase_dmg() {
        return base_dmg;
    }

    public void setBase_dmg(float base_dmg) {
        this.base_dmg = base_dmg;
    }

    public float getBase_amr() {
        return base_amr;
    }

    public void setBase_amr(float base_amr) {
        this.base_amr = base_amr;
    }

    public float getBase_spd() {
        return base_spd;
    }

    public void setBase_spd(float base_spd) {
        this.base_spd = base_spd;
    }

    public float getBase_blt_spd() {
        return base_blt_spd;
    }

    public void setBase_blt_spd(float base_blt_spd) {
        this.base_blt_spd = base_blt_spd;
    }

    public int getBase_blt_pen() {
        return base_blt_pen;
    }

    public void setBase_blt_pen(int base_blt_pen) {
        this.base_blt_pen = base_blt_pen;
    }

    public int getBase_blt_siz() {
        return base_blt_siz;
    }

    public void setBase_blt_siz(int base_blt_siz) {
        this.base_blt_siz = base_blt_siz;
    }

}

Classe Main

package jogorpg;

public class Main {
    
    public static void main(String[] args){
        //Criando os objestos
        Races Human = new Races(100,50,5,3,1,3,10,5);
	Races Cyborg = new Races(110,44,4,4,0.8f,2.5f,8,5);
	Races Ninja = new Races(84,40,5,2,1.2f,4,15,3);
	Races Ogre = new Races(120,30,8,5,0.6f,2,12,8);
        
        //Acessando as informações dos objetos
        //Exemplo com Human
        
        System.out.println(Human.getBase_amr());
        System.out.println(Human.getBase_blt_pen());
        System.out.println(Human.getBase_blt_siz());
        System.out.println(Human.getBase_blt_spd());
        System.out.println(Human.getBase_dmg());
        System.out.println(Human.getBase_ep());
        System.out.println(Human.getBase_hp());
        System.out.println(Human.getBase_spd());
    }
    
}

Saída do console:

run: 3.0 10 5 3.0 5.0 50.0 100.0 1.0 CONSTRUÍDO COM SUCESSO (tempo total: 3 segundos)

Bom esse é meu ponto de vista, mas cabe a você decidir qual é a solução mais fácil e/ou melhor.

Abraço

P

JavaDreams, eu tinha pensado nisso… mais eu quero evitar declarar os objetos no main, por causa que nem sempre vou usar os 4 objetos, pois quando a classe character for instanciada, só vou precisar da informação da classe respectiva do personagem, desta forma estaria criando objetos desnecessários…

Eu sei que precisa dos getters and setters, só não coloquei ali no código.
Vou mostar a classe Characters pra vc…

public class Character
{
	String name;
	Races  race;
	float health_points;
	float energy_points;
	float experience;
	int level;
	float damage;
	float armor;
	float speed;

	float bullet_speed;
	int bullet_penetration;
	int bullet_size;

	int dmg_lvl_upgr;
	int arm_lvl_upgr;
	int spd_lvl_upgr;
	int hp_lvl_upgr;
	int ep_lvl_upgr;
	int blt_spd_upgr;
	int blt_pen_upgr;
	int blt_siz_upgr;

	int mov_lvl_upgr;
	int atk_lvl_upgr;

	Character(Races  x)
	{
		name = "";
		race = x;
		experience = 0;
		level = 0;

		health_points = x.getBase_hp();
		energy_points = x.getBase_ep();
		damage = x.getBase_dmg();
		armor = x.getBase_amr();
		speed = x.getBase_spd();
		bullet_speed = x.getBase_blt_spd());
		bullet_penetration = x.getBase_blt_pen();
		bullet_size = x.getBase_blt_siz();
	}
}

entendeu? desta forma eu preciso pegar apenas os atributos da classe que for usada, em C eu faria um struct, mais aqui eu não sei como fazer…
PS: esse código está do jeito que eu acho que “funciona” não sei se esta certo, e também não sei se é a melhor forma a se fazer.

@edit
só pra esclarecer, esses dados viram do “banco de dados”, eu vou ter em modo texto o nome da classe que o personagem é, então bom base nessa informação eu precisaria atribuir valores nos atributos referentes ao balanceamento de cada classe.

RodrigoKaos
Acho mais interessante usar polimorfismo, vc pode criar classes que herdam Races como Humano, Orc, etc. Vc definiria esses valores dentro de cada classe e não pelo construtor
//É só um exemplo --"
public class Races{
       int força;
       int hp;
       
       int getForça();
       int getHp();
}
public class Humano extends Races{
      //Sempre que Humano for instanciado vai ter esse valor no atributo
       int força = 1;
       int hp = 5;
       
}
Races race = new Humano();
P
RodrigoKaos:
Acho mais interessante usar polimorfismo, vc pode criar classes que herdam Races como Humano, Orc, etc. Vc definiria esses valores dentro de cada classe e não pelo construtor
//É só um exemplo --"
public class Races{
       int força;
       int hp;
       
       int getForça();
       int getHp();
}
public class Humano extends Races{
      //Sempre que Humano for instanciado vai ter esse valor no atributo
       int força = 1;
       int hp = 5;
       
}
Races race = new Humano();

Mais assim quando eu precisar dos valores, vou precisar instanciar um objeto da classe certa.. além de precisar de 5 classes pra isso, como eu faço pra instanciar um objeto de uma classe de acordo com o conteúdo de uma variável string?
Enquanto eu tiver poucas raças, da pra fazer, mais conforme for aumentando a quantidade, além de eu precisar de várias classes, também fica inviável fazer com um if ou switch a seleção da classe necessária...

drsmachado
Paulix:
RodrigoKaos:
Acho mais interessante usar polimorfismo, vc pode criar classes que herdam Races como Humano, Orc, etc. Vc definiria esses valores dentro de cada classe e não pelo construtor
//É só um exemplo --"
public class Races{
       int força;
       int hp;
       
       int getForça();
       int getHp();
}
public class Humano extends Races{
      //Sempre que Humano for instanciado vai ter esse valor no atributo
       int força = 1;
       int hp = 5;
       
}
Races race = new Humano();

Mais assim quando eu precisar dos valores, vou precisar instanciar um objeto da classe certa.. além de precisar de 5 classes pra isso, como eu faço pra instanciar um objeto de uma classe de acordo com o conteúdo de uma variável string?
Enquanto eu tiver poucas raças, da pra fazer, mais conforme for aumentando a quantidade, além de eu precisar de várias classes, também fica inviável fazer com um if ou switch a seleção da classe necessária...


Vai precisar estudar Reflection...

P

drsmachado, já me deu uma luz… vou pesquisar sobre, obrigado

@edit, obrigado cara, era exatamente isso que eu precisava
agora posso declarar apenas o objeto necessário usando isso, sem precisar desperdiçar memória
vlw ^^

S

Assumindo que todas as raças possuam os mesmos métodos que se comportam da mesma maneira eu preferiria utilizar enum. Isso facilitaria muito caso você precise adicionar novas raças.

JavaDreams

1- Se for fazer no main, então pega a entrada do usuário quando ele escolher um char e aí cria somente o personagem que for referente ao retorno da opção que o user escolheu:

Tipo assim:

Menu de escolha de personagem
1 - Humano
2 - Cyborg
3 - Ninja
4 - Ogro

opcao = Integer.parseInt(scaner.nextLine());

Agora instancia só o objeto referente ao que o user escolheu assim:

if(opcao == 1){

public Races Human = new Races(100,50,5,3,1,3,10,5);

}

if(opcao == 2){

public Races Cyborg = new Races(110,44,4,4,0.8f,2.5f,8,5);

}

if(opcao == 3){

public Races Ninja = new Races(84,40,5,2,1.2f,4,15,3);

}

if(opcao == 4){

public Races Ogre = new Races(120,30,8,5,0.6f,2,12,8);

}

Dessa forma sempre que criar uma nova classe você só adiciona um novo if e uma nova classe

2 - Se quiser usar com herança e polimorfismo, então terá que abstrair os atributos e métodos em comum que você identificar nas classes
Também será uma boa usar um banco de dados ou array que já fique com os valores pré-definidos, pois assim mantém esses valores em um lugar somente
e sempre que criar um novo objeto você seta eles.

3- Reflection e Enum são muito bons mas na minha opinião recomendo usar depois que conseguir fazer de um dos modos acima, mas no final a escolha é sua.

Espero ter colaborado um pouco também.

P

isso vai ser transparente para o usuário…
a informação String virá do banco de dados, eu preciso declarar o objeto apenas para chamar a raça necessária, pois os atributos da raça serão usados para definir os status do personagem.
este enum eu não sei como funciona, tenho que da uma pesquisada.

JavaDreams

Paulix:
isso vai ser transparente para o usuário…
a informação String virá do banco de dados, eu preciso declarar o objeto apenas para chamar a raça necessária, pois os atributos da raça serão usados para definir os status do personagem.
este enum eu não sei como funciona, tenho que da uma pesquisada.

Então controla de main em duas partes.

Use uma classe responsável por só mostrar as informações, menus e relacionados para o user.

Use outra classe ou o próprio main para controlar as instâncias dos objetos.

Assim você faz orientado a objeto, e não vai precisar instanciar um objeto só para mostrar para o usuário informações.

Se usar Collections na classe de informações, consegue resolver de boa.

Fica a dica.

S

Paulix:
isso vai ser transparente para o usuário…
a informação String virá do banco de dados, eu preciso declarar o objeto apenas para chamar a raça necessária, pois os atributos da raça serão usados para definir os status do personagem.
este enum eu não sei como funciona, tenho que da uma pesquisada.

A vantagem de usar enum é que fica muito mais fácil adicionar novas raças ao invés de ter de criar uma classe para cada raça.

Com enum seria assim:

class Player {

	String race;
	int hp;
	int mp;

	Player(Races r) {
		race = r.getRace();
		hp = r.getHp();
		mp = r.getMp();
		
	}

	public static void main(String[] args) throws IOException {	
		Player p = new Player(Races.HUMAN);
	}

}

enum Races {

	HUMAN("Human", 30, 10), ORC("Orc", 40, 5);

	String race;
	int hp;
	int mp;

	Races(String race, int hp, int mp) {
		this.race = race;
		this.hp = hp;
		this.mp = mp;
	}

	public String getRace() {
		return race;
	}

	public int getHp() {
		return hp;
	}

	public int getMp() {
		return mp;
	}

}

Metade do caminho já está feito. Falta agora você encapsular os métodos e atributos e achar uma forma de obter o enum desejado a partir de uma String.

JavaDreams

Se eu fosse fazer um jogo pensaria mais em OO, pois no futuro quem me garante que talvez não vou precisar
abstrair uma classe para cada personagem.

O objetivo principal de fazer OO é que no início você pode até ter um trabalho um pouco maior do que outros
métodos mais simples ou mais rápidos. Mas no final você acaba ganhando muito mais coisas como facilidade
para manutenção ou upgrade do código, distribuição, dentre outros motivos pelos quais eu gosto de sempre usar
uma classe definida para cada coisa.

Se achar que tem algo que está em comum entre as classes então abstraia e mande para herança com a Classe Mãe/SuperClasse

Esses são os lados da moeda, então se está só fazendo pesquisa e estudos faça do jeito que for mais simples/rápido para você.
Caso contrário é bom usar OO mesmo.

S

JavaDreams:
Se eu fosse fazer um jogo pensaria mais em OO, pois no futuro quem me garante que talvez não vou precisar
abstrair uma classe para cada personagem.

O objetivo principal de fazer OO é que no início você pode até ter um trabalho um pouco maior do que outros
métodos mais simples ou mais rápidos. Mas no final você acaba ganhando muito mais coisas como facilidade
para manutenção ou upgrade do código, distribuição, dentre outros motivos pelos quais eu gosto de sempre usar
uma classe definida para cada coisa.

Se achar que tem algo que está em comum entre as classes então abstraia e mande para herança com a Classe Mãe/SuperClasse

Esses são os lados da moeda, então se está só fazendo pesquisa e estudos faça do jeito que for mais simples/rápido para você.
Caso contrário é bom usar OO mesmo.

Já joguei muito RPG (leia-se muito) e jamais cheguei a ver classes que se comportavam de maneira diferente. A única coisa que eu vejo que muda de uma classe para outra são as skills e os items que cada classe pode utilizar.

No caso, você pode facilmente adicionar um flag nos items e skills (que é o que alguns jogos fazem).

O que poderia ser feito seria adicionar o enum como sendo atributo de Player (afinal um player TEM uma race) e deixar lá os métodos que os diferenciam.

No entanto, se eu fosse fazer um jogo eu procuraria alguma forma de não amarrar coisas como classes, skills, races, etc… no código.

P

To confuso agora…
mais vou explicar exatamente o que “deveria” acontecer…
O main será o laço principal do jogo, onde será instanciado o objeto Player (o que controlaria todos os status do personagem).
Os dados do jogador (objeto) vem do banco de dados, entretanto a unica coisa que vem definida são o nível dos aprimoramentos, nome do jogador e classe.
Os atributos do Player, serão definidos pelo aprimoramentos do jogador multiplicado pelos valores da classe Upgrades, + os atributos base da respectiva Raça.
Portanto, todos os atributos do jogador, serão definidos quando o objeto for instanciado, ele deve pegar os valores base da raça, os valores dos aprimoramentos, fazer os calculos e determinar os atributos do personagem.
Aqui está o problema, quando vou instanciar o Player, eu preciso passar como parametro a Raça dele (que vem do banco de dados como String), de uma forma que essa raça instancie apenas o objeto da Raça necessária para fornecer os dados para o cálculo, sem precisar declarar todas as raças existentes.

Aqui vai alguns trechos do código…
Classe Player

public class Player 
{
	String name;
	Race_Controller  race;
	float health_points;
	float energy_points;
	float experience;
	int level;
	float damage;
	float armor;
	float speed;
	float critical_chance;
	float critical_damage;

	float bullet_speed;
	int bullet_penetration;
	int bullet_size;

	int dmg_lvl_upgr;
	int arm_lvl_upgr;
	int spd_lvl_upgr;
	int hp_lvl_upgr;
	int ep_lvl_upgr;
	int crit_chance;
	int crit_dmg;
	int blt_spd_upgr;
	int blt_pen_upgr;
	int blt_siz_upgr;

	int mov_lvl_upgr;
	int atk_lvl_upgr;

	Player(String name, Race_Controller race, Float exp, int dmg_upgr, int arm_upgr, int spd_upgr, int hp_upgr, int ep_upgr, int crit_chance, int crit_dmg, int blt_spd, int blt_pen, int blt_siz)
	{
		Upgrades lvlcalc = new Upgrades();
		this.name = name;
		this.race = race;
		experience = exp;
		level = 0;

		health_points = race.getBase_hp() + hp_upgr * lvlcalc.hp_upgr;
		energy_points = race.getBase_ep() + ep_upgr * lvlcalc.ep_upgr;
		damage = race.getBase_dmg() + dmg_upgr * lvlcalc.dmg_upgr;
		armor = race.getBase_arm() + arm_upgr * lvlcalc.arm_upgr;
		speed = race.getBase_spd() + spd_upgr * lvlcalc.spd_upgr;
		critical_chance = race.getBase_crit_chance() + crit_chance * lvlcalc.crit_chance_upgr;
		critical_damage = race.getBase_crit_dmg() + crit_dmg * lvlcalc.crit_dmg_upgr;
		bullet_speed = race.getBase_blt_spd() + blt_spd * lvlcalc.blt_spd_upgr;
		bullet_penetration = race.getBase_blt_pen() + blt_pen * lvlcalc.blt_pen_upgr;
		bullet_size = race.getBase_blt_siz() + blt_siz * lvlcalc.blt_siz_upgr;
	}

	public String getName()
	{
		return name;
	}

	public float getHealth_points()
	{
		return health_points;
	}

	public float getEnergy_points()
	{
		return energy_points;
	}

	public void addExp(float x)
	{
		experience += x;
	}

	public int getLevel()
	{
		return 0;
	}

	public float getDamage()
	{
		return damage;
	}

	public float getAmor()
	{
		return armor;
	}

	public float getSpeed()
	{
		return speed;
	}

	public float getCritical_chance()
	{
		return critical_chance;
	}

	public float getCritical_damage()
	{
		return critical_damage;
	}

	public float getBullet_speed()
	{
		return bullet_speed;
	}

	public int getBullet_penetration()
	{
		return bullet_penetration;
	}

	public int getBullet_size()
	{
		return bullet_size;
	}
}

Classe Race_Controller

public class Race_Controller 
{
	private float base_hp;
	private float base_ep;
	private float base_dmg;
	private float base_arm; //dmg reduction
	private float base_spd; //sqm's per second
	private float base_crit_chance; //critical chance
	private float base_crit_dmg; //critical multiplier
	private float base_blt_spd; //sqm's per second
	private int base_blt_pen; //percent chance to bullets penetrates
	private int base_blt_siz; //bullet size in pixels

	Race_Controller(float base_hp, float base_ep, float base_dmg, float base_arm, float base_spd, float base_crit_chance, float base_crit_dmg, float base_blt_spd, int base_blt_pen, int base_blt_siz)
	{
		this.base_hp = base_hp;
		this.base_ep = base_ep;
		this.base_dmg = base_dmg;
		this.base_arm = base_arm;
		this.base_spd = base_spd;
		this.base_crit_chance = base_crit_chance;
		this.base_crit_dmg = base_crit_dmg;
		this.base_blt_spd = base_blt_spd;
		this.base_blt_pen = base_blt_pen;
		this.base_blt_siz = base_blt_siz;
	}

	public float getBase_hp()
	{
		return base_hp;
	}

	public float getBase_ep()
	{
		return base_ep;
	}

	public float getBase_dmg()
	{
		return base_dmg;
	}

	public float getBase_arm()
	{
		return base_arm;
	}

	public float getBase_spd()
	{
		return base_spd;
	}

	public float getBase_crit_chance()
	{
		return base_crit_chance;
	}

	public float getBase_crit_dmg()
	{
		return base_crit_dmg;
	}

	public float getBase_blt_spd()
	{
		return base_blt_spd;
	}

	public int getBase_blt_pen()
	{
		return base_blt_pen;
	}

	public int getBase_blt_siz()
	{
		return base_blt_siz;
	}
}

Classe Races

public class Races
{
	//Races(base_hp, base_ep, base_dmg, base_amr, base_spd, base_crit_chance, base_crit_dmg, base_blt_spd, base_blt_pen, base_blt_siz)

	public Race_Controller Human()
	{
		Race_Controller x = new Race_Controller(100,50,5,3,1,5,20,3,10,5);
		return x;
	}

	public Race_Controller Cyborg()
	{
		Race_Controller x = new Race_Controller(110,44,4,4,7,15,0.8f,2.5f,8,5);
		return x;
	}

	public Race_Controller Ninja()
	{
		Race_Controller x = new Race_Controller(84,40,5,2,1.2f,3,35,4,15,3);
		return x;
	}

	public Race_Controller Ogre()
	{
		Race_Controller x = new Race_Controller(120,30,8,5,0.6f,5,50,2,12,8);
		return x;
	}
}

Classe Upgrades

public class Upgrades 
{
	float hp_upgr = 4; //hp per level
	float ep_upgr = 4; //ep per level
	float dmg_upgr = 1; //dmg per level
	float arm_upgr = 1; //dmg reduction per level
	float spd_upgr = 0.2f; //sqm's per second
	float crit_chance_upgr = 1.2f; //critical chance per level
	float crit_dmg_upgr = 4; //critical damage multiplier
	float blt_spd_upgr = 0.4f; //sqm's per second
	int blt_pen_upgr = 4; //percent chance to bullets penetrates
	int blt_siz_upgr = 1; //bullet size in pixels
}

Main

public class Main {

	public static void main(String[] args) 
	{
		Races x = new Races();
		Player character = new Player("Teste", x.Human(), 1000f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);

		System.out.println("Name = " + character.getName());
		System.out.println("HP = " + character.getHealth_points());
		System.out.println("EP = " + character.getEnergy_points());
		//System.out.println("Level = " + character.getLevel());
		System.out.println("Damage = " + character.getDamage());
		System.out.println("Armor = " + character.getAmor());
		System.out.println("Speed = " + character.getSpeed());
		System.out.println("Critical Chance = " + character.getCritical_chance());
		System.out.println("Critical Damage = " + character.getCritical_damage());
		System.out.println("Bullet Speed = " + character.getBullet_speed());
		System.out.println("Bullet Penetration = " + character.getBullet_penetration());
		System.out.println("Bullet Size = " + character.getBullet_size());
	}
}

Como vcs podem ver, nesta linha

Player character = new Player("Teste", x.Human(), 1000f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);

ele funciona certinho, o problema é que eu preciso chamar x.Raça().
atualmente foi assim que eu consegui resolver, mais acho que preciso usar reflection pra buscar por texto o que eu preciso passar como parametro ali.
além disso, não sei se estou fazendo da melhor maneira, pois sou iniciante em java

Criado 24 de agosto de 2013
Ultima resposta 29 de ago. de 2013
Respostas 15
Participantes 5