void ColocarValoresNoInfografico(Criatura criatura)
{
GenerationText.text = criatura.Generation.ToString();
ComidaText.text = criatura.FoodAmount.ToString();
GenesText.text = criatura.Genes.Velocidade + "\n" + criatura.Genes.Visao + "\n" + criatura.Genes.VontadeDeAcasalamento + "\n" + criatura.Genes.Inteligencia + "\n" + criatura.Genes.Saude;
StartCoroutine(KeepInfogrValuesUpdated(criatura));
}
private bool AddCreature(Criatura criatura, Draggable draggable)
{
if (criatura1)
{
if (criatura2)
{
return(false);
}
else
{
img2.OnReceivingCreature(criatura);
criatura2 = criatura;
}
}
else
{
img1.OnReceivingCreature(criatura);
criatura1 = criatura;
}
draggable.criatura.SetActive(false); //desliga o bicho
draggable.combinator.transform.DOScale(originalSize * sizeScaler, delay);
draggable.combinator.transform.DOScale(originalSize, delay);
return(true);
}
/// <summary>
/// Función que se llama cuando se ataca a un ente mágico.
/// </summary>
/// <param name="criaturaAtacante">Criatura atacante.</param>
/// <param name="magicaObjetivo">Magica objetivo.</param>
public void AtacarMagica(Criatura criaturaAtacante, Magica magicaObjetivo)
{
JugadorPartida objetivo = ObtenerDueñoEnte(magicaObjetivo);
controladorEnte.AtacarMagica(criaturaAtacante, magicaObjetivo);
controladorJugador.QuitarVidaJugador(objetivo, criaturaAtacante.Ataque);
}
//Para gerar o filho
private void TerFilho(Criatura outro)
{
//deduzir comida
GastarComida(MinFoodParaAcasalar + (100 - Genes.VontadeDeAcasalamento) * CustoDeAcasalamento);
outro.GastarComida(MinFoodParaAcasalar + (100 - outro.Genes.VontadeDeAcasalamento) * CustoDeAcasalamento);
DNA dnaDoFilho = new DNA(outro.Genes.ToArray(), Genes.ToArray(), manager.MutationChance, manager.MutationRate);
Criatura filho = Instantiate(prefabDoFilho, transform.position, transform.rotation, transform.parent).GetComponent <Criatura>();
filho.transform.localScale = Vector3.one * 0.5f;
filho.Genes = dnaDoFilho;
filho.Generation += Generation > outro.Generation ? Generation : outro.Generation;
filho.FoodAmount = 2 * MinFoodParaAcasalar + (100 - Genes.VontadeDeAcasalamento) * CustoDeAcasalamento + (100 - outro.Genes.VontadeDeAcasalamento) * CustoDeAcasalamento;
//tira os pais do modo apaixonado
Apaixonado = false;
Passivo = false;
outro.Apaixonado = false;
outro.Passivo = false;
//coloca o casal pra descansar
IndisponivelParaNamoro = true;
Invoke("VoltarAoRomance", descansoPosBebe);
outro.IndisponivelParaNamoro = true;
outro.Invoke("VoltarAoRomance", descansoPosBebe);
}
/// <summary>
/// Muestra la accion (ataque, defensa, activar) correspondiente al ente en la batalla.
/// </summary>
/// <param name="idEnte">Identifier ente.</param>
public void MostrarAccion(int idEnte)
{
Ente ente = Recursos.EntesCreadosEnElJuego[idEnte];
if (ente.GetType() == typeof(Magica))
{
//Si la magica es de tipo trampa no debe salir la opcion de activar voluntariamente
if (EntePreparado(ente) && !EsMagicaTrampa(ente))
{
AccionesPopUp.Instance.MostrarAccionEfecto();
AccionesPopUp.Instance.RegistrarCallBack(ActivarEfectoMagica, idEnte);
}
}
else
{
Criatura criatura = (Criatura)ente;
if (criatura.PosicionCriatura.Equals(PosicionCriatura.ATAQUE))
{
if (!CriaturaHaAtacado(criatura))
{
AccionesPopUp.Instance.MostrarAccionDefensa();
}
}
else
{
AccionesPopUp.Instance.MostrarAccionAtaque();
}
AccionesPopUp.Instance.RegistrarCallBack(CambiarPosicionCriatura, idEnte);
}
}
/// <summary>
/// Permite jugar un ente para el bot.
/// </summary>
/// <returns><c>true</c>, if ente was jugared, <c>false</c> otherwise.</returns>
bool JugarEnte()
{
bool movimientoHecho = false;
for (int i = 0; i < NumEntesEnLaMesa() && !movimientoHecho; i++)
{
Ente cl = EntesEnLaMesa() [i];
if (Controlador.Instance.EntePuedeUsarse(cl))
{
// attack a random target with a creature
if (cl.GetType() == typeof(Magica))
{
if (!((Magica)cl).EfectoActivado)
{
if (!Controlador.Instance.EsMagicaTrampa(cl))
{
Controlador.Instance.ActivarEfectoMagica(cl.ID);
movimientoHecho = true;
}
}
}
else
{
Criatura criatura = (Criatura)cl;
if (criatura.PosicionCriatura.Equals(PosicionCriatura.ATAQUE))
{
if (!Controlador.Instance.CriaturaHaAtacado(criatura))
{
JugadorPartida enemigo = Controlador.Instance.OtroJugador(this);
if (enemigo.NumEntesEnLaMesa() > 0)
{
int index = Random.Range(0, enemigo.NumEntesEnLaMesa());
Ente enteObjetivo = enemigo.EntesEnLaMesa() [index];
if (enteObjetivo.GetType() == typeof(Criatura) || (enteObjetivo.GetType() == typeof(Magica) && !((Magica)enteObjetivo).EfectoActivado))
{
Controlador.Instance.AtacarEnte(cl.ID, enteObjetivo.ID);
movimientoHecho = true;
}
}
else
{
Controlador.Instance.AtacarJugador(cl.ID, enemigo.ID);
movimientoHecho = true;
}
}
}
else
{
Controlador.Instance.CambiarPosicionCriatura(criatura.ID);
movimientoHecho = true;
}
}
}
}
if (movimientoHecho)
{
InsertDelay(1f);
}
return(movimientoHecho);
}
/// <summary>
/// Función que permite que la criatura ataque al jugador.
/// </summary>
/// <param name="idCriaturaAtacante">Identifier criatura atacante.</param>
/// <param name="idJugadorObjetivo">Identifier jugador objetivo.</param>
public void AtacarJugador(int idCriaturaAtacante, int idJugadorObjetivo)
{
Criatura atacante = (Criatura)Recursos.EntesCreadosEnElJuego[idCriaturaAtacante];
JugadorPartida jugador = Controlador.Instance.Local.ID == idJugadorObjetivo ? Controlador.Instance.Local : Controlador.Instance.Enemigo;
atacante.HaAtacado = true;
controladorJugador.AtacarJugador(atacante, jugador);
}
/// <summary>
/// Jugar una carta de la mano en el tablero no mágica
/// </summary>
/// <param name="cartaJugada"></param>
/// <param name="tablePos"></param>
/// <param name="posicionAtaque"></param>
public void JugarCartaMano(JugadorPartida jugador, CartaPartida cartaJugada, int tablePos, bool posicionAtaque)
{
//ELIMINATE
RestarManaCarta(jugador, cartaJugada);
Criatura newCreature = new Criatura(jugador.Area, cartaJugada.AssetCarta, posicionAtaque == true ? PosicionCriatura.ATAQUE : PosicionCriatura.DEFENSA);
JugarCarta(jugador, cartaJugada, newCreature, tablePos);
}
public virtual void Comer(Criatura cliente)
{
if (!Comido)
{
StartCoroutine(ReduceToZero(transform, FadeRate));
Comido = true;
}
}
public CreatureData(Criatura criatura)
{
ID = criatura.ID;
position = new float[3];
position[0] = criatura.transform.position.x;
position[1] = criatura.transform.position.y;
position[2] = criatura.transform.position.z;
}
public override void Comer(Criatura cliente)
{
if (!Comido)
{
cliente.FoodAmount += valorNutricional;
base.Comer(cliente);
}
}
private static void PrintCriatura(Criatura criatura)
{
Console.WriteLine($"Uma nova criatura foi construída: " +
$"\nNome: {criatura.nome}" +
$"\nAtributos: {PrintAtributos(criatura)}" +
$"\nRaridade: {criatura.raridade}" +
$"\nAfiliação: {criatura.afiliacao}");
}
public void OnReceivingCreature(Criatura criatura)
{
var spriteRenderer = criatura.GetComponent <SpriteRenderer>();
m_Image.enabled = true;
m_Image.sprite = spriteRenderer.sprite;
m_Image.color = spriteRenderer.color;
}
/// <summary>
/// Permite quitar vida a una criatura.
/// </summary>
/// <param name="objetivo">Objetivo.</param>
/// <param name="daño">Daño.</param>
public void QuitarVidaCriatura(Criatura objetivo, int daño)
{
new DealDamageCommand(objetivo.ID, daño, objetivo.Defensa).AñadirAlaCola();
objetivo.Defensa -= daño;
if (CriaturaMuerta(objetivo))
{
MuerteEnte(objetivo.ID);
}
}
/// <summary>
/// Permite atacar a una criatura a partir de otro ente
/// </summary>
/// <param name="idAtacante"></param>
/// <param name="idObjetivo"></param>
public void AtacarCriatura(Criatura atacante, Criatura objetivo)
{
atacante.AtaquesRestantesEnTurno--;
new CreatureAttackCommand(objetivo.ID, atacante.ID, atacante.Ataque, objetivo.Defensa).AñadirAlaCola();
objetivo.Defensa -= atacante.Ataque;
if (CriaturaMuerta(objetivo))
{
MuerteEnte(objetivo.ID);
}
}
/// <summary>
/// Permite atacar de cara al jugador.
/// </summary>
/// <param name="atacante">Atacante.</param>
/// <param name="jugadorObjetivo">Jugador objetivo.</param>
public void AtacarJugador(Criatura atacante, JugadorPartida jugadorObjetivo)
{
atacante.AtaquesRestantesEnTurno--;
new CreatureAttackCommand(jugadorObjetivo.ID, atacante.ID, atacante.Ataque, jugadorObjetivo.Defensa).AñadirAlaCola();
jugadorObjetivo.Defensa -= atacante.Ataque;
if (JugadorMuerto(jugadorObjetivo))
{
MuerteJugador(jugadorObjetivo);
}
}
private static string PrintAtributos(Criatura criatura)
{
var retorno = new StringBuilder();
foreach (var atributo in criatura.atributos)
{
retorno.Append($"\nTipo: {atributo.Nome}");
retorno.Append($"\nValor: {atributo.Valor}");
}
return(retorno.ToString());
}
public override void Comer(Criatura cliente)
{
if (!Comido)
{
Criatura minhaCriatura = GetComponent <Criatura>();
GetComponent <NavMeshAgent>().enabled = false;
//cliente.FoodAmount += minhaCriatura.FoodAmount;
cliente.FoodAmount += valorNutricional;
minhaCriatura.enabled = false;
base.Comer(cliente);
}
}
IEnumerator KeepInfogrValuesUpdated(Criatura criatura)
{
while (Input.GetButton("Fire1"))
{
if (criatura == null)
{
Infografico.SetActive(false);
}
IdadeText.text = (int)(Time.time - criatura.BirthTime) + "/" + criatura.Genes.Saude * criatura.TempoDeVida;
ComidaText.text = criatura.FoodAmount.ToString();
yield return(new WaitForEndOfFrame());
}
}
/// <summary>
/// Permite dañar una criatura sin mostrar un ataque visual, en caso de que se encuentre en defensa y
/// muera se quita vida al jugador, en ataque siempre se quita vida al jugador.
/// </summary>
/// <param name="criaturaObjetivo">Criatura objetivo.</param>
/// <param name="daño">Daño.</param>
public void DañarCriatura(Criatura criaturaObjetivo, int daño)
{
JugadorPartida objetivo = ObtenerDueñoEnte(criaturaObjetivo);
controladorEnte.QuitarVidaCriatura(criaturaObjetivo, daño);
if (criaturaObjetivo.PosicionCriatura.Equals(PosicionCriatura.ATAQUE))
{
controladorJugador.QuitarVidaJugador(objetivo, daño);
}
else if (criaturaObjetivo.PosicionCriatura.Equals(PosicionCriatura.DEFENSA) && controladorEnte.CriaturaMuerta(criaturaObjetivo))
{
controladorJugador.QuitarVidaJugador(objetivo, criaturaObjetivo.Defensa);
}
}
/// <summary>
/// Cambia la posicion de una criatura.
/// </summary>
/// <param name="idCriatura">Identifier criatura.</param>
public void CambiarPosicionCriatura(int idCriatura)
{
Criatura criatura = (Criatura)Recursos.EntesCreadosEnElJuego[idCriatura];
if (criatura.PosicionCriatura.Equals(PosicionCriatura.ATAQUE))
{
criatura.PosicionCriatura = PosicionCriatura.DEFENSA;
new ChangeCreaturePosition(idCriatura, PosicionCriatura.DEFENSA).AñadirAlaCola();
}
else
{
criatura.PosicionCriatura = PosicionCriatura.ATAQUE;
new ChangeCreaturePosition(idCriatura, PosicionCriatura.ATAQUE).AñadirAlaCola();
}
}
/// <summary>
/// Permite atacar a una criatura, mostrándose la animación de ataque.
/// </summary>
/// <param name="criaturaAtacante">Criatura atacante.</param>
/// <param name="criaturaObjetivo">Criatura objetivo.</param>
public void AtacarCriatura(Criatura criaturaAtacante, Criatura criaturaObjetivo)
{
JugadorPartida objetivo = ObtenerDueñoEnte(criaturaObjetivo);
controladorEnte.AtacarCriatura(criaturaAtacante, criaturaObjetivo);
if (criaturaObjetivo.PosicionCriatura.Equals(PosicionCriatura.ATAQUE))
{
controladorJugador.QuitarVidaJugador(objetivo, criaturaAtacante.Ataque);
controladorEnte.QuitarVidaCriatura(criaturaAtacante, criaturaObjetivo.Ataque);
}
else if (criaturaObjetivo.PosicionCriatura.Equals(PosicionCriatura.DEFENSA) && controladorEnte.CriaturaMuerta(criaturaObjetivo))
{
controladorJugador.QuitarVidaJugador(objetivo, System.Math.Abs(criaturaObjetivo.Defensa));
}
}
public Criatura Buscar(int c)
{
using (SqlConnection conn = new SqlConnection(@"Initial Catalog=HNI;Data Source = localhost; Integrated Security=SSPI"))
{
string strSQL = @"SELECT * FROM Criatura where Id = '" + c + "'";
using (SqlCommand cmd = new SqlCommand(strSQL))
{
conn.Open();
cmd.Connection = conn;
cmd.CommandText = strSQL;
var dataReader = cmd.ExecuteReader();
var dt = new DataTable();
dt.Load(dataReader);
conn.Close();
foreach (DataRow row in dt.Rows)
{
var cri = new Criatura()
{
Id = Convert.ToInt32(row["Id"]),
Nome = row["Nome"].ToString(),
Imagem = row["Imagem"].ToString(),
Descricao = row["Desc"].ToString(),
Mana = Convert.ToInt32(row["Mana"]),
Hp = Convert.ToInt32(row["Hp"]),
AtkF = Convert.ToInt32(row["AtkF"]),
AtkM = Convert.ToInt32(row["AtkM"]),
Def = Convert.ToInt32(row["Def"]),
Exp = Convert.ToInt32(row["Exp"]),
Ouro = Convert.ToInt32(row["Ouro"]),
Agressividade = row["Agressividade"].ToString(),
Perigo = row["Perigo"].ToString(),
Bando = row["Bando"].ToString(),
Classificacao = row["Classificacao"].ToString()
};
return(cri);
}
}
}
Criatura ca = new Criatura();
return(ca);
}
private bool AddCreature(Criatura criatura, Draggable draggable)
{
if (!criatura1)
{
Debug.Log("chegou aqui");
img1.OnReceivingCreature(criatura);
criatura1 = criatura;
}
else
{
return(false);
}
draggable.criatura.SetActive(false); //desliga o bicho
draggable.analyzer.transform.DOScale(originalSize * sizeScaler, delay);
draggable.analyzer.transform.DOScale(originalSize, delay);
return(true);
}
/// <summary>
/// Función que permite atacar a un ente.
/// </summary>
/// <param name="idAtacante">Identifier atacante.</param>
/// <param name="idObjetivo">Identifier objetivo.</param>
public void AtacarEnte(int idAtacante, int idObjetivo)
{
Ente atacante = Recursos.EntesCreadosEnElJuego[idAtacante];
Ente objetivo = Recursos.EntesCreadosEnElJuego[idObjetivo];
if (atacante.GetType() == typeof(Criatura))
{
((Criatura)atacante).HaAtacado = true;
}
if (objetivo.GetType() == typeof(Criatura))
{
Criatura criaturaObjetivo = (Criatura)objetivo;
AtacarCriatura((Criatura)atacante, criaturaObjetivo);
}
else
{
ActivarEfectoMagica(idObjetivo, idAtacante);
}
}
/// <summary>
/// Activa el efecto de una mágica, en función de su tipo hará una cosa u otra.
/// </summary>
/// <param name="idMagica">Identifier magica.</param>
/// <param name="idAtacante">Identifier atacante.</param>
public void ActivarEfectoMagica(int idMagica, int idAtacante)
{
Criatura criaturaAtacante = null;
JugadorPartida jugador = null;
Magica magica = (Magica)Recursos.EntesCreadosEnElJuego[idMagica];
if (idAtacante != -1)
{
criaturaAtacante = (Criatura)Recursos.EntesCreadosEnElJuego [idAtacante];
AtacarMagica(criaturaAtacante, magica);
}
new ActivateEffectCommand(idMagica).AñadirAlaCola();
magica.EfectoActivado = true;
switch (magica.AssetCarta.Efecto)
{
case Efecto.Destructor:
jugador = Controlador.Instance.ObtenerDueñoEnte(magica);
DamageAllCreatures(Controlador.Instance.OtroJugador(jugador), 100);
break;
case Efecto.Espejo:
DealDamageToTarget(criaturaAtacante, criaturaAtacante.AssetCarta.Ataque);
break;
case Efecto.Mana:
jugador = Controlador.Instance.ObtenerDueñoEnte(magica);
GiveManaBonus(jugador, Random.Range(1, 3));
break;
case Efecto.Vida:
jugador = Controlador.Instance.ObtenerDueñoEnte(magica);
GiveHealth(jugador, Random.Range(60, 181));
break;
default:
break;
}
//MuerteEnte(magica.ID);
}
private void Update()
{
if (!GraphShown)
{
//se houver clique
if (Input.GetButtonDown("Fire1"))
{
//enviar ray da posição do mouse
var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out RaycastHit hit))
{
Criatura criatura = hit.transform.GetComponent <Criatura>();
if (criatura)
{
//focar na criatura
movement.DefinirTarget(criatura.transform);
//colocar os valores do gene na UI
ColocarValoresNoInfografico(criatura);
//exibi-la
Infografico.SetActive(true);
}
}
}
else if (Input.GetButtonUp("Fire1"))
{
movement.ResetTarget();
Infografico.SetActive(false);
}
}
else
{
Infografico.SetActive(false);
}
}
public void Reset()
{
this.criatura = new Criatura();
}
/// <summary>
/// Permite atacar a una mágica.
/// </summary>
/// <param name="atacante">Atacante.</param>
/// <param name="objetivo">Objetivo.</param>
public void AtacarMagica(Criatura atacante, Magica objetivo)
{
atacante.AtaquesRestantesEnTurno--;
new CreatureAttackCommand(objetivo.ID, atacante.ID, atacante.Ataque, objetivo.Defensa).AñadirAlaCola();
//MuerteEnte(objetivo.ID);
}
//Chamado em intervalos que dependem da sua inteligencia
private void Pensar()
{
//o personagem está "ocupado", adiar
if (Apaixonado)
{
Invoke("Pensar", 3f);
}
else
{
//cobrar o preço energético
GastarComida(Genes.GetCost() * custoEnergeticoMultiplyer);
//FoodAmount -= Genes.GetCost();
TargetTransform = null;
TargetType = "";
//se não estiver DESESPERADO por comida, procura predador
if (FoodAmount > Genes.GetCost() * custoEnergeticoMultiplyer)
{
Transform inimigo = SearchFor("Inimigo", Genes.Visao * QualidadeDaVisao);
if (inimigo != null)
{
//fugir
TargetPos = (transform.position - inimigo.position).normalized * Genes.Visao * QualidadeDaVisao / 2;
}
}
//se tiver comida o suficiente, procurar parceiro
if (PodeReproduzir() && TargetType == "")
{
Transform parceiroT = SearchFor("Parceiro", Genes.Visao * QualidadeDaVisao * 2);
if (parceiroT != null)
{
Criatura parceiro = parceiroT.GetComponent <Criatura>();
//enviar msg para o parceiro
if (parceiro.QuerCasarComigo(transform))
{
//o parceiro aceitou!
Apaixonado = true;
//andar até ele
TargetTransform = parceiroT;
TargetType = "Parceiro";
//emitir corações
LoveParticles.Play();
}
}
}
//se não tiver comida suficiente ou não achar parceiro, procurar comida
if (FoodAmount < MaxFoodAmount && !Apaixonado && TargetType == "")
{
Transform comidaT = SearchFor("Comida", Genes.Visao * QualidadeDaVisao);
if (comidaT != null)
{
//achou comida!
Comida comida = comidaT.GetComponent <Comida>();
if (comida.Comido == false)
{
TargetTransform = comidaT;
TargetType = "Comida";
}
}
}
//se não conseguir comida nem namoro, vagar
if (TargetTransform == null)
{
if (TargetType == "Inimigo")
{
DeterminarDestino(TargetPos);
}
else
{
TargetType = "";
TargetPos = new Vector3(
transform.position.x + Random.Range(-VagarDistancia, VagarDistancia),
transform.position.y,
transform.position.z + Random.Range(-VagarDistancia, VagarDistancia));
DeterminarDestino(TargetPos);
}
}
else
{
DeterminarDestino(TargetTransform.position);
}
//pensar novamente depois
//"2" é o tempo mínimo de descanso
Invoke("Pensar", 2 + ((100 - Genes.Inteligencia) / 10));
}
}
