public void TesteSomaValorMag()
{
calculador = new CalculadorNumero();
ValorMag valorMagIgual1 = new ValorMag(50, 2);
ValorMag valorMagIgual2 = new ValorMag(60, 2);
ValorMag resultadoMagIgual = calculador.SomaValorMag(valorMagIgual1, valorMagIgual2);
Assert.IsTrue(resultadoMagIgual.Valor == 11);
Assert.IsTrue(resultadoMagIgual.Magnitude == 3);
Assert.IsTrue(resultadoMagIgual.ValorReal == "110");
ValorMag valorMagPerto1 = new ValorMag(50, 4);
ValorMag valorMagPerto2 = new ValorMag(50, 3);
ValorMag resultadoMagPerto = calculador.SomaValorMag(valorMagPerto1, valorMagPerto2);
Assert.IsTrue(resultadoMagPerto.Valor == 55);
Assert.IsTrue(resultadoMagPerto.Magnitude == 4);
Assert.IsTrue(resultadoMagPerto.ValorReal == "5500");
ValorMag valorMagLonge1 = new ValorMag(50, 3);
ValorMag valorMagLonge2 = new ValorMag(50, 8);
ValorMag resultadoMagLonge = calculador.SomaValorMag(valorMagLonge1, valorMagLonge2);
Assert.IsTrue(resultadoMagLonge.Valor == 50);
Assert.IsTrue(resultadoMagLonge.Magnitude == 8);
Assert.IsTrue(resultadoMagLonge.ValorReal == "50000000");
}
public ValorMag RetornaMaiorValorMag(ValorMag num1, ValorMag num2)
{
if (num1.Magnitude != num2.Magnitude)
{
if (num1.Magnitude > num2.Magnitude)
{
return(num1);
}
else
{
return(num2);
}
}
else
{
if (num1.Valor > num2.Valor)
{
return(num1);
}
else
{
return(num2);
}
}
}
public ValorMag MultiplicaValorMag(ValorMag numero, double multiplicador)
{
if (multiplicador == 1)
{
return(numero);
}
else if (numero == new ValorMag() || multiplicador == 0)
{
return(new ValorMag(0, 1));
}
else
{
return(MultiplicaValorMag(numero, new ValorMag(Convert.ToString(multiplicador))));
}
//double valorFinal = numero.Valor * multiplicador;
//int magFinal = numero.Magnitude;
//if (valorFinal < 10)
//{
// magFinal = magFinal - 1;
// valorFinal = valorFinal * 10;
//}
//else if (valorFinal > 99)
//{
// while (valorFinal > 99)
// {
// valorFinal = valorFinal / 100;
// magFinal = magFinal + 1;
// }
//}
//ValorMag resultado = new ValorMag((int)Math.Floor(valorFinal), magFinal);
//return resultado;
}
public ValorMag DivideValorMag(ValorMag valorMag1, ValorMag valorMag2)
{
if (valorMag1.ValorReal == "0")
{
return(new ValorMag("0"));
}
else if (valorMag2.ValorReal == "0")
{
return(new ValorMag("0"));
}
else if (valorMag2.ValorReal == "1")
{
return(valorMag1);
}
else
{
int magFinal = ((valorMag1.Magnitude - 2) - (valorMag2.Magnitude - 2)) + 2;
double valorFinal = ((double)valorMag1.Valor / (double)valorMag2.Valor);
while (valorFinal < 10)
{
valorFinal = valorFinal * 10;
magFinal = magFinal - 1;
}
return(new ValorMag((int)Math.Floor(valorFinal), magFinal));
}
}
public ValorMag MultiplicaValorMag(ValorMag valorMag1, ValorMag valorMag2)
{
if (valorMag1.ToString() == "1m2" || valorMag1.ToString() == "10m1")
{
return(valorMag2);
}
else if (valorMag2.ToString() == "1m2" || valorMag2.ToString() == "10m1")
{
return(valorMag1);
}
else if (valorMag1.Valor == 0 || valorMag2.Valor == 0)
{
return(new ValorMag(0, 1));
}
else
{
int magFinal = (valorMag1.Magnitude + valorMag2.Magnitude) - 2;
int valorFinal = (valorMag1.Valor * valorMag2.Valor);
while (valorFinal > 99)
{
valorFinal = valorFinal / 10;
magFinal = magFinal + 1;
}
return(new ValorMag(valorFinal, magFinal));
}
}
public void TesteLongParaValorMag()
{
conversor = new Conversor();
ValorMag resultado = conversor.StringParaValorMag("2500000000");
Assert.AreEqual(25, resultado.Valor);
Assert.AreEqual(10, resultado.Magnitude);
}
public Ideia()
{
this.Pontos = 1;
this.Ki = 0;
this.Base = 0;
this.Misterio = new ValorMag();
this.Irrealidade = new ValorMag();
this.Nexo = new ValorMag();
this.BonusMP = new ValorMag();
}
public void TesteGeraValorMag()
{
GeradorValorMag gerador = new GeradorValorMag();
ValorMag valorMag1 = new ValorMag(10, 3);
ValorMag valorMag2 = new ValorMag(10, 5);
ValorMag resultado = gerador.GerarEntre(valorMag1, valorMag2, rnd);
Assert.IsTrue(Convert.ToInt32(resultado.ValorReal) >= Convert.ToInt32(valorMag1.ValorReal));
Assert.IsTrue(Convert.ToInt32(resultado.ValorReal) <= Convert.ToInt32(valorMag2.ValorReal));
}
public Criatividade()
{
this.Pontos = 1;
this.Singularidade = new ValorMag();
this.Tutor = new ValorMag();
this.Visualizacao = new ValorMag();
this.Invencao = new ValorMag();
this.Realidade = new ValorMag();
this.BonusMP = new ValorMag();
}
public ValorMag SubtraiValorMag(ValorMag valorMag1, ValorMag valorMag2)
{
if (valorMag1.ToString() == valorMag2.ToString())
{
return(new ValorMag());
}
int valorFinal = 0;
int magnitudeFinal = 0;
int valor1 = valorMag1.Valor;
int valor2 = valorMag2.Valor;
int mag1 = valorMag1.Magnitude;
int mag2 = valorMag2.Magnitude;
if (mag1 == mag2)
{
magnitudeFinal = mag1;
valorFinal = valor1 - valor2;
if (valorFinal < 0)
{
valorFinal = valorFinal * 10;
magnitudeFinal = magnitudeFinal - 1;
}
}
else if (mag1 - mag2 == 1 || mag1 - mag2 == -1)
{
magnitudeFinal = Math.Max(mag1, mag2);
if (magnitudeFinal == mag1)
{
valorFinal = valor1 - (valor2 / 10);
}
else
{
valorFinal = valor2 - (valor1 / 10);
}
}
else
{
magnitudeFinal = Math.Max(mag1, mag2);
if (magnitudeFinal == mag1)
{
valorFinal = valor1;
}
else
{
valorFinal = valor2;
}
}
ValorMag resultado = new ValorMag(valorFinal, magnitudeFinal);
return(resultado);
}
public void TesteRetornaMenorValorMag()
{
calculador = new CalculadorNumero();
ValorMag num1 = new ValorMag(99, 5);
ValorMag num2 = new ValorMag(26, 7);
ValorMag resultado = calculador.RetornaMenorValorMag(num1, num2);
Assert.AreEqual(num1.ValorReal, resultado.ValorReal);
}
public void TesteStringParaValorMag()
{
conversor = new Conversor();
string numero = "584797,5683";
int valor = 58;
int mag = 6;
ValorMag resultado = conversor.StringParaValorMag(numero);
Assert.AreEqual(valor, resultado.Valor);
Assert.AreEqual(mag, resultado.Magnitude);
}
public void TesteMultiplicaValorMagPorValorMag()
{
calculador = new CalculadorNumero();
ValorMag valorMag1 = new ValorMag(10, 3);
ValorMag valorMag2 = new ValorMag(10, 5);
ValorMag resultado = calculador.MultiplicaValorMag(valorMag1, valorMag2);
Assert.AreEqual(10, resultado.Valor);
Assert.AreEqual(7, resultado.Magnitude);
Assert.AreEqual("1000000", resultado.ValorReal);
}
public Materia()
{
this.Pontos = 1;
this.Colapso = new ValorMag();
this.Impulso = new ValorMag();
this.Resistencia = new ValorMag();
this.Vitalidade = new ValorMag();
this.BonusCP = 0;
this.BonusHP = new ValorMag();
this.Carga = new ValorMag();
}
public void TesteMultiplicaValorMagDouble()
{
calculador = new CalculadorNumero();
ValorMag numero = new ValorMag(82, 6);
double multiplicador = 0.12;
ValorMag resultado = calculador.MultiplicaValorMag(numero, multiplicador);
Assert.AreEqual(98, resultado.Valor);
Assert.AreEqual(5, resultado.Magnitude);
}
public ValorMag SomaValorMag(ValorMag valorMag1, ValorMag valorMag2)
{
int valorFinal = 0;
int magnitudeFinal = 0;
int valor1 = valorMag1.Valor;
int valor2 = valorMag2.Valor;
int mag1 = valorMag1.Magnitude;
int mag2 = valorMag2.Magnitude;
if (mag1 == mag2)
{
magnitudeFinal = mag1;
valorFinal = valor1 + valor2;
if (valorFinal > 99)
{
valorFinal = valorFinal / 10;
magnitudeFinal = magnitudeFinal + 1;
}
}
else if (mag1 - mag2 == 1 || mag1 - mag2 == -1)
{
magnitudeFinal = Math.Max(mag1, mag2);
if (magnitudeFinal == mag1)
{
valorFinal = valor1 + (valor2 / 10);
}
else
{
valorFinal = valor2 + (valor1 / 10);
}
}
else
{
magnitudeFinal = Math.Max(mag1, mag2);
if (magnitudeFinal == mag1)
{
valorFinal = valor1;
}
else
{
valorFinal = valor2;
}
}
ValorMag resultado = new ValorMag(valorFinal, magnitudeFinal);
return(resultado);
}
public ValorMag MultiplicaValorMag(ValorMag valorMag1, int multiplicador)
{
if (multiplicador == 1)
{
return(valorMag1);
}
else if (valorMag1 == new ValorMag() || multiplicador == 0)
{
return(new ValorMag(0, 1));
}
else
{
return(MultiplicaValorMag(valorMag1, new ValorMag(Convert.ToString(multiplicador))));
}
}
public ValorMag DivideValorMag(ValorMag valorMag1, int divisor)
{
if (divisor == 0)
{
return(new ValorMag("0"));
}
if (divisor == 1)
{
return(valorMag1);
}
else
{
return(DivideValorMag(valorMag1, new ValorMag(Convert.ToString(divisor))));
}
}
public ValorMag RetornaMenorValorMag(List <ValorMag> lista)
{
if (lista.Count > 0)
{
ValorMag resultado = lista[0];
foreach (ValorMag item in lista)
{
resultado = RetornaMenorValorMag(resultado, item);
}
return(resultado);
}
else
{
return(new ValorMag());
}
}
public void TesteRetornaMenorValorMagDeLista()
{
calculador = new CalculadorNumero();
List <ValorMag> lista = new List <ValorMag>
{
new ValorMag(10, 7),
new ValorMag(15, 5),
new ValorMag(35, 8),
new ValorMag(10, 9),
new ValorMag(99, 2),
new ValorMag(58, 5),
new ValorMag(20, 3)
};
ValorMag resultado = calculador.RetornaMenorValorMag(lista);
Assert.AreEqual(99, resultado.Valor);
Assert.AreEqual(2, resultado.Magnitude);
Assert.AreEqual("99", resultado.ValorReal);
}
public Ser RemoveModificador(ModDivideValorMag mod, Ser ser)
{
PropertyInfo propriedade = ser.GetType().GetProperty(mod.Alvo);
if (propriedade.PropertyType == typeof(ValorMag))
{
CalculadorNumero calculador = new CalculadorNumero();
ValorMag resultado = new ValorMag();
resultado = calculador.MultiplicaValorMag((ValorMag)propriedade.GetValue(ser, null), mod.Valor);
propriedade.SetValue(ser, resultado);
return(ser);
}
else
{
throw new System.ArgumentException("Propriedade não é ValorMag.", mod.Alvo);
}
}
public Resistencia Gerar(Random rnd)
{
GeradorInteiro rng = new GeradorInteiro();
GeradorValorMag genValorMag = new GeradorValorMag();
GeradorBoolean genBoolean = new GeradorBoolean();
GeradorString genString = new GeradorString();
CalculadorNumero calculador = new CalculadorNumero();
Resistencia resultado = new Resistencia();
ValorMag min = genValorMag.GerarEntre(new ValorMag(10, 0), new ValorMag(99, 10), rnd);
ValorMag max = calculador.SomaValorMag(min, genValorMag.GerarEntre(new ValorMag(10, 0), new ValorMag(99, 10), rnd));
char tipo;
if (genBoolean.GeraComChance(50, rnd))
{
tipo = '+';
}
else
{
tipo = '-';
}
resultado.Nome = genString.GerarTamanhoEspecifico(3, 10, rnd);
if (tipo == '+')
{
resultado.Positiva = genValorMag.GerarEntre(min, max, rnd);
resultado.Negativa = new ValorMag();
}
else
{
resultado.Positiva = new ValorMag();
resultado.Negativa = genValorMag.GerarEntre(min, max, rnd);
}
return(resultado);
}
public Deslocamento(string tipo)
{
this.Tipo = tipo;
Valor = new ValorMag();
}
public Resistencia()
{
this.Nome = "Vazio";
this.Positiva = new ValorMag();
this.Negativa = new ValorMag();
}
public Resistencia(string nome, ValorMag positiva, ValorMag negativa)
{
this.Nome = nome;
this.Positiva = positiva;
this.Negativa = negativa;
}
//Calcula subatributos BASE de um ser sem modificadores
public Ser CalculaSubatributos(Ser ser)
{
GeradorValorMag genValorMag = new GeradorValorMag();
CalculadorNumero calculador = new CalculadorNumero();
Random rnd = new Random();
//Iniciativa = Destreza.Iniciativa
ser.Iniciativa = ser.Destreza.Iniciativa;
//Destria = Pontos Destreza / 10 (até o maximo da espécie)
if (ser.Destreza.Pontos / 10 > ser.Especies[0].DestriaMax)
{
ser.Destria = ser.Especies[0].DestriaMax;
}
else if (ser.Destreza.Pontos / 10 < ser.Especies[0].DestriaMin)
{
ser.Destria = ser.Especies[0].DestriaMin;
}
else
{
ser.Destria = ser.Destreza.Pontos / 10;
}
//Acao = vigor + vitalidade * dinamica
ser.Acao = calculador.SomaValorMag(ser.Forca.Vigor, ser.Materia.Vitalidade);
ser.Acao = calculador.MultiplicaValorMag(ser.Acao, Convert.ToDouble(ser.Destreza.Dinamica));
//Reacao = Vitalidade * Dinamica
ser.Reacao = calculador.MultiplicaValorMag(ser.Materia.Vitalidade, Convert.ToDouble(ser.Destreza.Dinamica));
//Turno = valor minimo da especie dominante + 20% da maior especie
ser.Turno = ser.Especies[0].TurnoMin + (int)calculador.CalculaPorcentagem(20, (long)(from e in ser.Especies select e.TurnoMin).Max());
//Altura = aleatorio a partir da especie dominante
if (ser.Altura.Valor == 0)
{
ser.Altura = genValorMag.GerarEntre(ser.Especies[0].AlturaMin, ser.Especies[0].AlturaMax, rnd);
}
ser.Comprimento = new ValorMag(Convert.ToString(ser.Materia.Pontos));
//Largura = Aleatorio entre largura min e largura max da especie dominante
if (ser.Largura.Valor == 0)
{
ser.Largura = genValorMag.GerarEntre(ser.Especies[0].LarguraMin, ser.Especies[0].LarguraMax, rnd);
}
//Massa = Volume * Densidade da Especie
ValorMag volume = calculador.MultiplicaValorMag(ser.Altura, ser.Comprimento);
volume = calculador.MultiplicaValorMag(volume, ser.Largura);
ser.Massa = calculador.MultiplicaValorMag(volume, ser.Especies[0].Densidade);
//Instinto = (Ideia + Destreza) / 2
ser.Instinto = calculador.SomaValorMag(ser.Ideia.Porcentagem, ser.Destreza.Porcentagem);
ser.Instinto = calculador.DivideValorMag(ser.Instinto, 2);
//Raciocinio = (Intelecto + Criatividade) / 2
ser.Raciocinio = calculador.SomaValorMag(ser.Intelecto.Porcentagem, ser.Criatividade.Porcentagem);
ser.Raciocinio = calculador.DivideValorMag(ser.Raciocinio, 2);
//Subconsciencia = (Existencia + Ideia) / 2
ser.Subconsciencia = calculador.SomaValorMag(ser.Existencia.Porcentagem, ser.Ideia.Porcentagem);
ser.Subconsciencia = calculador.DivideValorMag(ser.Subconsciencia, 2);
//Autocontrole = (Intelecto + Existencia) / 2
ser.Autocontrole = calculador.SomaValorMag(ser.Intelecto.Porcentagem, ser.Existencia.Porcentagem);
ser.Autocontrole = calculador.DivideValorMag(ser.Subconsciencia, 2);
//Anatomia = (Materia + Força + Destreza) /3
ser.Anatomia = calculador.SomaValorMag(ser.Materia.Porcentagem, ser.Forca.Porcentagem);
ser.Anatomia = calculador.SomaValorMag(ser.Anatomia, ser.Destreza.Porcentagem);
ser.Anatomia = calculador.DivideValorMag(ser.Anatomia, 3);
//Animo = (Criatividade + Existencia)/2
ser.Animo = calculador.SomaValorMag(ser.Criatividade.Porcentagem, ser.Existencia.Porcentagem);
ser.Animo = calculador.DivideValorMag(ser.Animo, 2);
//Movimento = (Destreza + Forca*2) /3
ser.Movimento = calculador.MultiplicaValorMag(ser.Forca.Porcentagem, 2);
ser.Movimento = calculador.SomaValorMag(ser.Movimento, ser.Destreza.Porcentagem);
ser.Movimento = calculador.DivideValorMag(ser.Movimento, 3);
//Precisao = (Forca*2 + Destreza) / 3
ser.Precisao = calculador.MultiplicaValorMag(ser.Forca.Porcentagem, 2);
ser.Precisao = calculador.SomaValorMag(ser.Movimento, ser.Destreza.Porcentagem);
ser.Precisao = calculador.DivideValorMag(ser.Movimento, 3);
//Composição = Dureza + Resistencia
Conversor conver = new Conversor();
ser.Composicao = conver.StringParaValorMag(Convert.ToString(ser.Forca.Dureza));
ser.Composicao = calculador.SomaValorMag(ser.Composicao, ser.Materia.Resistencia);
//HP MP AP SP
//HP = Materia
//AP = Força Materia Destreza Intelecto Existência
//MP = Criatividade + Ideia
//SP = ((15*(pontos de todos atributos-7))*7) (somar tracinhos)
ser.BonusHP = ser.Materia.BonusHP;
ser.BonusCP = ser.Forca.BonusCP + ser.Materia.BonusCP;
ser.BonusCP = ser.BonusCP + ser.Destreza.BonusCP;
ser.BonusCP = ser.BonusCP + ser.Intelecto.BonusCP;
ser.BonusCP = Math.Floor(ser.BonusCP + ser.Existencia.BonusCP);
ser.BonusMP = calculador.SomaValorMag(ser.Criatividade.BonusMP, ser.Ideia.BonusMP);
ser.BonusSP = CalculaBonusSP(ser);
return(ser);
}
