public override void AoClicar(InstanciaCarta c)
{
cartaAtual.Set(c);
Configuracoes.admJogo.DefinirEstado(segurandoCarta);
aoDeixarDeOlhar.Raise();
aoSelecionarCartaAtual.Raise();
}
public void BaixarCarta(Transform c, Transform p, InstanciaCarta instCarta)
{
if (cartasMao.Contains(instCarta))
{
cartasMao.Remove(instCarta);
}
cartasBaixadas.Add(instCarta);
fezAlgumaAcao = true;
magia -= instCarta.custo;
infoUI.AtualizarMagia();
Configuracoes.admJogo.StartCoroutine(Configuracoes.admJogo.DestacarCartaBaixada(instCarta));
instCarta.podeAtacarNesteTurno = false;
//Aqui a gente vai executar os efeitos das cartas, bem como as diferenças em carta e feitiço
if (instCarta.podeAtacarNesteTurno == false)
{
instCarta.gameObject.transform.Find("Sombra").gameObject.SetActive(true);
instCarta.gameObject.transform.Find("Frente da Carta").GetComponent <Image>().sprite = instCarta.infoCarta.spriteNaoPodeAtacar;
}
Configuracoes.DefinirPaiCarta(c, p);
cartaEntrouEmCampo.cartaQueAtivouEvento = instCarta;
Configuracoes.admEfeito.eventoAtivador = cartaEntrouEmCampo;
cartaEntrouEmCampo.Raise();
if (Configuracoes.admJogo.tutorial && instCarta.carta.name == "Boiuna")
{
jogouBoiuna.Raise();
}
if (Configuracoes.admJogo.tutorial && instCarta.carta.name == "Boitatá")
{
jogouBoitata.Raise();
}
Configuracoes.admJogo.TocarSomCartaBaixada();
return;
}
public bool DiferenteTipoDeAtacar(InstanciaCarta instCarta)
{
if (podeAtacar)
{
return(true);
}
else
{
return(false);
}
}
public override void Executar()
{
if (cartaAtual.valor != null)
{
InstanciaCarta c = cartaAtual.valor;
bool temMagiaParaBaixarCarta = Configuracoes.admJogo.jogadorAtual.TemMagiaParaBaixarCarta(c);
if (temMagiaParaBaixarCarta)
{
if (c.infoCarta.carta.tipoCarta.nomeTipo == "Lenda")
{
if (Configuracoes.admJogo.jogadorAtual.lendasBaixadasNoTurno < Configuracoes.admJogo.jogadorAtual.maxLendasTurno) //pode baixar carta
{
//define o pai da carta para ser o grid lá do Cartas Baixadas
Configuracoes.admJogo.jogadorAtual.BaixarCarta(c.transform, gridArea.valor.transform, c);
c.logicaAtual = logicaCartaBaixa;
Configuracoes.admJogo.jogadorAtual.lendasBaixadasNoTurno++;
c.gameObject.SetActive(true);
}
else
{
Configuracoes.admJogo.TocarSomNaoPode();
Configuracoes.RegistrarEvento("Você não pode baixar mais de uma Lenda por turno", Color.white);
}
}
if (c.infoCarta.carta.tipoCarta.nomeTipo == "Feitiço")
{
if (Configuracoes.admJogo.jogadorAtual.podeUsarEfeito)
{
if (Configuracoes.admJogo.jogadorAtual.feiticosBaixadosNoTurno < Configuracoes.admJogo.jogadorAtual.maxFeiticosTurno)
{
jogadorAtivouEfeito.cartaQueAtivouEvento = c;
Configuracoes.admEfeito.eventoAtivador = jogadorAtivouEfeito;
jogadorAtivouEfeito.Raise();
Configuracoes.admJogo.StartCoroutine(Configuracoes.admJogo.DestacarCartaBaixada(c));
}
else
{
Configuracoes.admJogo.TocarSomNaoPode();
Configuracoes.RegistrarEvento("Você não pode baixar mais de um Feitiço por turno", Color.white);
}
}
else
{
Configuracoes.admJogo.TocarSomNaoPode();
Configuracoes.RegistrarEvento("Você não pode utilizar efeitos neste turno", Color.white);
}
}
}
// Dá um SetActive() pra sobrescrever o que tem no SelecaoAtual
c.gameObject.SetActive(true);
}
}
public bool TemMagiaParaBaixarCarta(InstanciaCarta c)
{
bool resultado = false;
if (magia >= c.custo)
{
resultado = true;
}
if (resultado == false)
{
Configuracoes.RegistrarEvento("Você não tem magia o suficiente para baixar esta carta", Color.white);
}
return(resultado);
}
public IEnumerator DestacarCartaBaixada(InstanciaCarta instCarta)
{
// fechando outras cartas em destaque
aoPararDeOlharCarta.Raise();
cartaAtual.Set(instCarta);
GameObject.Find("/Screen Overlay Canvas/Interface do Usuário/Carta Sendo Olhada/Carta sendo olhada").SetActive(true);
Configuracoes.cartaRecemJogada = true;
aoOlharCarta.Raise();
yield return(new WaitForSeconds(1.5f));
Configuracoes.cartaRecemJogada = false;
aoPararDeOlharCarta.Raise();
}
public override void AoOlhar(InstanciaCarta carta)
{
if (carta != cartaAtual.valor && Configuracoes.admJogo.jogadorAtual.cartasMao.Contains(carta))//se for diferente
{
cartaAtual.Set(carta);
aoOlharCarta.Raise();
if (Configuracoes.admJogo.estadoAtual.name != "Usando Efeito" || Configuracoes.admJogo.estadoAtual.name != "Atacando")
{
Configuracoes.admCursor.MudarSprite(cursorClicavel);
}
else
{
Configuracoes.admCursor.MudarSprite(cursorIdle);
}
}
}
public void MatarCarta(InstanciaCarta c, SeguradorDeJogador jogador)
{
if (jogador.cartasBaixadas.Count == 0)
{
return;
}
foreach (InstanciaCarta carta in jogador.cartasBaixadas)
{
if (jogador.cartasBaixadas.Contains(c))
{
c.gameObject.SetActive(false);
jogador.ColocarCartaNoCemiterio(c);
jogador.cartasBaixadas.Remove(c);
break;
}
}
}
public override void AoClicar(InstanciaCarta carta)
{
if (carta.podeAtacarNesteTurno)
{
//Carta vai atacar
if (gridAreaDropavel != null)
{
gridAreaDropavel.valor.GetComponent <Image>().raycastTarget = false;
}
cartaAtacou.cartaQueAtivouEvento = carta;
Configuracoes.admEfeito.eventoAtivador = cartaAtacou;
cartaAtacou.Raise();
Configuracoes.admJogo.DefinirEstado(atacando);
Configuracoes.admJogo.cartaAtacante = carta;
Configuracoes.admJogo.cartaAtacante.gameObject.transform.localScale = new Vector3(0.35f, 0.35f, 1);
}
else
{
Configuracoes.admJogo.TocarSomNaoPode();
}
}
public void ColocarCartaNoCemiterio(InstanciaCarta carta)
{
cartasCemiterio.Add(carta);
carta.logicaAtual = logicaCemiterio;
carta.transform.SetParent(seguradorCartas.gridCemiterio.valor, false);
carta.transform.Find("Sombra").gameObject.SetActive(true);
carta.transform.Find("Fundo da Carta").gameObject.SetActive(false);
carta.gameObject.transform.localScale = new Vector3(0.28f, 0.28f, 1);
carta.transform.Find("Sombra").GetComponent <Image>().color = new Color(0, 0, 0, 0.7F);
cartaMorreu.cartaQueAtivouEvento = carta;
Configuracoes.admEfeito.eventoAtivador = cartaMorreu;
cartaMorreu.Raise();
Vector3 posicao = Vector3.zero;
posicao.x = cartasCemiterio.Count * 10;
posicao.z = cartasCemiterio.Count * 10;
carta.transform.localPosition = posicao;
carta.transform.localRotation = Quaternion.identity;
carta.transform.localScale = Vector3.one;
carta.gameObject.SetActive(true);
}
public override void Executar(float d)
{
if (Input.GetMouseButtonDown(0))
{
List <RaycastResult> resultados = Configuracoes.GetUIObjs();
foreach (RaycastResult r in resultados)
{
//logica para atacar o jogador inimigo
InfoUIJogador infoJogadorInimigo = r.gameObject.GetComponentInParent <InfoUIJogador>();
if (infoJogadorInimigo != null)
{
if (infoJogadorInimigo.jogador == Configuracoes.admJogo.jogadorInimigo)
{
Configuracoes.admJogo.jogadorAtacado = Configuracoes.admJogo.jogadorInimigo;
Configuracoes.admJogo.DefinirEstado(jogadorEmSeuTurno);
Configuracoes.RegistrarEvento("O alvo " + Configuracoes.admJogo.jogadorAtacado.nomeJogador + " foi selecionado para ser atacado", Color.white);
if (gridAreaDropavel != null)
{
gridAreaDropavel.valor.GetComponent <Image>().raycastTarget = true;
}
Configuracoes.admJogo.StartCoroutine(Configuracoes.admJogo.Atacar());
Configuracoes.admJogo.jogadorAtual.fezAlgumaAcao = true;
}
else
{
Configuracoes.admJogo.TocarSomNaoPode();
}
return;
}
//logica para atacar uma carta
InstanciaCarta instCarta = r.gameObject.GetComponentInParent <InstanciaCarta>();
if (instCarta != null)
{
if (instCarta == Configuracoes.admJogo.cartaAtacante)
{
Configuracoes.admJogo.cartaAtacante.gameObject.transform.localScale = new Vector3(0.28f, 0.28f, 1);
Configuracoes.RegistrarEvento("O jogador desistiu de atacar", Color.white);
Configuracoes.admJogo.estadoAtual = jogadorEmSeuTurno;
return;
}
if (instCarta.podeSerAtacada)
{
Configuracoes.admJogo.cartaAtacada = instCarta;
Configuracoes.admJogo.DefinirEstado(jogadorEmSeuTurno);
cartaFoiAtacada.cartaQueAtivouEvento = instCarta;
Configuracoes.admEfeito.eventoAtivador = cartaFoiAtacada;
cartaFoiAtacada.Raise();
Configuracoes.admJogo.StartCoroutine(Configuracoes.admJogo.Atacar());
Configuracoes.admJogo.jogadorAtual.fezAlgumaAcao = true;
if (gridAreaDropavel != null)
{
gridAreaDropavel.valor.GetComponent <Image>().raycastTarget = true;
}
return;
}
else
{
Configuracoes.admJogo.TocarSomNaoPode();
}
}
}
if (gridAreaDropavel != null)
{
gridAreaDropavel.valor.GetComponent <Image>().raycastTarget = true;
}
Configuracoes.admJogo.cartaAtacante.gameObject.transform.localScale = new Vector3(0.28f, 0.28f, 1);
Configuracoes.admJogo.estadoAtual = jogadorEmSeuTurno;
}
}
public override void Executar(float d)
{
//desisti de escolher um alvo
if (Configuracoes.admJogo.efeitoAtual.apenasJogador == false)
{
if (Configuracoes.admJogo.efeitoAtual.alteracaoPoder > 0)
{
if (Configuracoes.admJogo.jogadorAtual.cartasBaixadas.Count == 0)
{
Configuracoes.admJogo.efeitoAtual.cartaQueInvoca.gameObject.transform.localScale = new Vector3(0.28f, 0.28f, 1);
Configuracoes.admJogo.efeitoAtual = null;
Configuracoes.admJogo.DefinirEstado(emSeuTurno);
return;
}
}
if (Configuracoes.admJogo.efeitoAtual.alteracaoPoder < 0)
{
if (Configuracoes.admJogo.jogadorInimigo.cartasBaixadas.Count == 0)
{
Configuracoes.admJogo.efeitoAtual.cartaQueInvoca.gameObject.transform.localScale = new Vector3(0.28f, 0.28f, 1);
Configuracoes.admJogo.efeitoAtual = null;
Configuracoes.admJogo.DefinirEstado(emSeuTurno);
return;
}
}
}
if (Input.GetMouseButtonDown(0))
{
List <RaycastResult> resultados = Configuracoes.GetUIObjs();
foreach (RaycastResult r in resultados)
{
//logica para afetar o jogador inimigo
InstanciaCarta carta = r.gameObject.GetComponentInParent <InstanciaCarta>();
if (carta != null && (Configuracoes.admJogo.jogadorAtual.cartasBaixadas.Contains(carta) || Configuracoes.admJogo.jogadorInimigo.cartasBaixadas.Contains(carta)))
{
if (Configuracoes.admJogo.efeitoAtual.podeUsarEmSi || carta != Configuracoes.admJogo.efeitoAtual.cartaQueInvoca)
{
Configuracoes.admEfeito.eventoAtivador.cartaQueAtivouEvento.efeito.cartaAlvo = carta;
Configuracoes.admJogo.efeitoAtual.cartaAlvo = carta;
Configuracoes.admJogo.DefinirEstado(emSeuTurno);
return;
}
else
{
Configuracoes.admJogo.efeitoAtual.cartaQueInvoca.gameObject.transform.localScale = new Vector3(0.28f, 0.28f, 1);
Configuracoes.admJogo.efeitoAtual = null;
Configuracoes.RegistrarEvento("Desisti de escolher um alvo", Color.white);
Configuracoes.admJogo.DefinirEstado(emSeuTurno);
return;
}
}
else
{
Configuracoes.admJogo.TocarSomNaoPode();
}
}
if (Configuracoes.admJogo.efeitoAtual.cartaAlvo == null)
{
Configuracoes.admJogo.efeitoAtual.cartaQueInvoca.gameObject.transform.localScale = new Vector3(0.28f, 0.28f, 1);
Configuracoes.admJogo.efeitoAtual = null;
Configuracoes.admJogo.DefinirEstado(emSeuTurno);
}
}
}
public override void AoClicar(InstanciaCarta c)
{
}
public override void AoOlhar(InstanciaCarta c)
{
}
public void Set(InstanciaCarta v)
{
valor = v;
}
public IEnumerator Atacar()
{
//Atacar uma carta
if (cartaAtacada != null && cartaAtacante != null)
{
cartaAtacante.gameObject.transform.localScale = new Vector3(0.28f, 0.28f, 1);
int poderCartaAtacanteAntes = cartaAtacante.poder;
int poderCartaAtacadaAntes = cartaAtacada.poder;
StartCoroutine(cartaAtacada.AnimacaoDano(poderCartaAtacanteAntes * -1));
StartCoroutine(cartaAtacante.AnimacaoDano(poderCartaAtacadaAntes * -1));
yield return(new WaitForSeconds(tempoAnimacaoCuraDano));
cartaAtacada.poder -= poderCartaAtacanteAntes;
cartaAtacante.poder -= poderCartaAtacadaAntes;
int poderCartaAtacanteDepois = cartaAtacante.poder;
int poderCartaAtacadaDepois = cartaAtacada.poder;
if (poderCartaAtacadaDepois <= 0)
{
cartaMatou.cartaQueAtivouEvento = cartaAtacante;
Configuracoes.admEfeito.eventoAtivador = cartaMatou;
cartaMatou.Raise();
MatarCarta(cartaAtacada, cartaAtacada.jogadorDono);
}
if (poderCartaAtacanteDepois <= 0)
{
MatarCarta(cartaAtacante, cartaAtacante.jogadorDono);
}
cartaAtacante.infoCarta.CarregarCarta(cartaAtacante.infoCarta.carta);
cartaAtacada.infoCarta.CarregarCarta(cartaAtacada.infoCarta.carta);
if (tutorial && cartaAtacante.carta.name == "Boiuna" && cartaAtacada.carta.name == "Lobisomem")
{
boiunaAtacouLobis.Raise();
}
cartaAtacante.podeAtacarNesteTurno = false;
cartaAtacada = null;
cartaAtacante = null;
}
//Atacar um jogador
if (cartaAtacante != null && jogadorAtacado != null)
{
cartaAtacante.gameObject.transform.localScale = new Vector3(0.28f, 0.28f, 1);
int poderCartaAtacanteAntes = cartaAtacante.poder;
StartCoroutine(jogadorAtacado.infoUI.AnimacaoDano(poderCartaAtacanteAntes * -1));
StartCoroutine(cartaAtacante.AnimacaoDano(-1));
yield return(new WaitForSeconds(tempoAnimacaoCuraDano));
jogadorAtacado.vida -= poderCartaAtacanteAntes;
cartaAtacante.poder--;
jogadorAtacado.infoUI.AtualizarVida();
cartaAtacante.infoCarta.CarregarCarta(cartaAtacante.infoCarta.carta);
if (cartaAtacante.poder <= 0)
{
MatarCarta(cartaAtacante, cartaAtacante.jogadorDono);
}
if (tutorial && cartaAtacante.carta.name == "Boitatá")
{
boitataAtacouJogador.Raise();
}
cartaAtacante.podeAtacarNesteTurno = false;
cartaAtacante = null;
jogadorAtacado = null;
ChecaVidaJogadores();
}
yield return(null);
}
public void PuxarCarta(SeguradorDeJogador jogador)
{
if (jogador.cartasMao.Count < numMaxCartasMao)
{
AdmRecursos ar = Configuracoes.GetAdmRecursos(); //precisamos acessar o admRecursos
GameObject carta = Instantiate(prefabCarta) as GameObject; //instanciamos a carta de acordo com o prefab
ExibirInfoCarta e = carta.GetComponent <ExibirInfoCarta>(); //pegamos todas as informações atribuidas de texto e posição dela
InstanciaCarta instCarta = carta.GetComponent <InstanciaCarta>();
e.CarregarCarta(ar.obterInstanciaCarta(jogador.baralho.cartasBaralho[jogador.baralho.cartasBaralho.Count - 1])); //e por fim dizemos que os textos escritos serão os da carta na mão do jogador
instCarta.carta = e.carta;
instCarta.SetPoderECusto();
e.CarregarCarta(instCarta.carta);
instCarta.logicaAtual = jogador.logicaMao;//define a lógica pra ser a lógica da mão
if (instCarta.carta.efeito != null)
{
Efeito novoEfeito = ScriptableObject.CreateInstance("Efeito") as Efeito;
// novoEfeito = instCarta.carta.efeito;
novoEfeito.name = instCarta.carta.efeito.name;
novoEfeito.afetaApenasSeuJogador = instCarta.carta.efeito.afetaApenasSeuJogador;
novoEfeito.afetaTodasCartas = instCarta.carta.efeito.afetaTodasCartas;
novoEfeito.alteracaoMagia = instCarta.carta.efeito.alteracaoMagia;
novoEfeito.alteracaoPoder = instCarta.carta.efeito.alteracaoPoder;
novoEfeito.alteracaoVida = instCarta.carta.efeito.alteracaoVida;
novoEfeito.apenasJogador = instCarta.carta.efeito.apenasJogador;
novoEfeito.ativacao = instCarta.carta.efeito.ativacao;
novoEfeito.cartaAlvo = instCarta.carta.efeito.cartaAlvo;
novoEfeito.cartaQueInvoca = instCarta;
novoEfeito.condicaoAtivacao = instCarta.carta.efeito.condicaoAtivacao;
novoEfeito.escolheAlvoCarta = instCarta.carta.efeito.escolheAlvoCarta;
novoEfeito.eventoAtivador = instCarta.carta.efeito.eventoAtivador;
novoEfeito.jogadorAlvo = instCarta.carta.efeito.jogadorAlvo;
novoEfeito.jogadorQueInvoca = jogador;
novoEfeito.modoDeExecucao = instCarta.carta.efeito.modoDeExecucao;
novoEfeito.podeUsarEmSi = instCarta.carta.efeito.podeUsarEmSi;
novoEfeito.tipoEfeito = instCarta.carta.efeito.tipoEfeito;
instCarta.efeito = novoEfeito;
if (instCarta.efeito.apenasJogador)
{
//afeta vc
if (instCarta.efeito.afetaApenasSeuJogador)
{
instCarta.efeito.jogadorAlvo = jogador;
}
else//afeta o inimigo
{
if (jogador == jogadorIA)
{
instCarta.efeito.jogadorAlvo = jogadorLocal;
}
else
{
instCarta.efeito.jogadorAlvo = jogadorIA;
}
}
}
}
instCarta.jogadorDono = jogador;
Configuracoes.DefinirPaiCarta(carta.transform, jogador.seguradorCartas.gridMao.valor);//joga as cartas fisicamente na mão do jogador
jogador.cartasMao.Add(instCarta);
jogador.baralho.cartasBaralho.RemoveAt(jogador.baralho.cartasBaralho.Count - 1);
if (jogador == jogadorAtual)
{
carta.transform.Find("Fundo da Carta").gameObject.SetActive(false);
}
else
{
carta.transform.Find("Fundo da Carta").gameObject.SetActive(true);
}
}
}
public override void AoOlhar(InstanciaCarta carta)
{
if (carta != cartaAtual.valor)//se for diferente
{
// impedindo o mouseleave de matar o destaque na carta recém jogada
if (!Configuracoes.cartaRecemJogada)
{
cartaAtual.Set(carta);
aoOlharCarta.Raise();
}
if (Configuracoes.admJogo.estadoAtual == usandoEfeito)
{
if (carta.podeSofrerEfeito)
{
if (Configuracoes.admJogo.jogadorInimigo.cartasBaixadas.Contains(carta))
{
Configuracoes.admCursor.MudarSprite(cursorAlvoVerde);
return;
}
if (Configuracoes.admJogo.jogadorAtual.cartasBaixadas.Contains(carta))
{
Configuracoes.admCursor.MudarSprite(cursorAlvoVerde);
if (carta == Configuracoes.admJogo.efeitoAtual.cartaQueInvoca)
{
if (carta.efeito.podeUsarEmSi)
{
Configuracoes.admCursor.MudarSprite(cursorAlvoVerde);
}
else
{
Configuracoes.admCursor.MudarSprite(cursorAlvoVermelho);
}
}
else
{
Configuracoes.admCursor.MudarSprite(cursorAlvoVerde);
}
}
return;
}
else
{
Configuracoes.admCursor.MudarSprite(cursorAlvoVermelho);
return;
}
}
if (Configuracoes.admJogo.estadoAtual == atacando)
{
if (carta.podeSerAtacada && carta != Configuracoes.admJogo.cartaAtacante)
{
Configuracoes.admCursor.MudarSprite(cursorAlvoVerde);
return;
}
else
{
Configuracoes.admCursor.MudarSprite(cursorAlvoVermelho);
return;
}
}
}
if (carta.podeAtacarNesteTurno && Configuracoes.admJogo.estadoAtual.name == "Em Seu Turno")
{
Configuracoes.admCursor.MudarSprite(cursorClicavel);
}
}
public void CarregarCarta(Carta c)
{
imagemProtegido = transform.Find("Frente da Carta/Protegido").gameObject;
if (c == null)
{
return;
}
carta = c;
InstanciaCarta instCarta = GetComponent <InstanciaCarta>();
c.tipoCarta.Inicializar(this);
FecharPropsIndefinidas();
for (int i = 0; i < propriedades.Length; i++)
{
Propriedades p = c.propriedades[i];
ExibirInfoPropriedades ep = GetPropriedade(p.elemento);
if (ep == null)
{
continue;
}
if (ep.elemento is ElementoNum)
{
ep.texto.text = p.intValor.ToString();
if (instCarta != null)
{
if (ep.elemento.name == "Poder")
{
ep.texto.text = instCarta.poder.ToString();
}
if (ep.elemento.name == "Custo")
{
ep.texto.text = instCarta.custo.ToString();
}
}
ep.texto.gameObject.SetActive(true);
}
else if (p.elemento is ElementoTexto)
{
ep.texto.text = p.stringValor;
if (ep.elemento.name == "Detalhes")
{
ep.texto.text = carta.categoria + ": " + p.stringValor;
}
ep.texto.gameObject.SetActive(true);
}
else if (p.elemento is ElementoImagem)
{
ep.imagem.sprite = p.sprite;
ep.imagem.gameObject.SetActive(true);
}
}
if (carta.efeito == null)
{
gameObject.transform.Find("Frente da Carta").Find("Grid Efeito + Texto").Find("Linha").gameObject.SetActive(false);
gameObject.transform.Find("Frente da Carta").Find("Grid Efeito + Texto").Find("Efeito").gameObject.SetActive(false);
// gameObject.transform.Find("Frente da Carta").Find("Grid Efeito + Texto").gameObject.GetComponent<VerticalLayoutGroup>().childControlHeight = true;
gameObject.transform.Find("Frente da Carta").Find("Grid Efeito + Texto").gameObject.GetComponent <VerticalLayoutGroup>().childAlignment = TextAnchor.MiddleCenter;
gameObject.transform.Find("Frente da Carta").Find("Grid Efeito + Texto").Find("Texto Categoria").gameObject.GetComponent <Text>().resizeTextForBestFit = true;
}
else
{
gameObject.transform.Find("Frente da Carta").Find("Grid Efeito + Texto").Find("Linha").gameObject.SetActive(true);
gameObject.transform.Find("Frente da Carta").Find("Grid Efeito + Texto").Find("Efeito").gameObject.SetActive(true);
gameObject.transform.Find("Frente da Carta").Find("Grid Efeito + Texto").gameObject.GetComponent <VerticalLayoutGroup>().childControlHeight = false;
gameObject.transform.Find("Frente da Carta").Find("Grid Efeito + Texto").Find("Texto Categoria").gameObject.GetComponent <Text>().resizeTextForBestFit = false;
gameObject.transform.Find("Frente da Carta").Find("Grid Efeito + Texto").gameObject.GetComponent <VerticalLayoutGroup>().childAlignment = TextAnchor.UpperCenter;
}
if (carta.tipoCarta == tipoFeitico)
{
this.gameObject.transform.Find("Frente da Carta").GetComponent <Image>().sprite = templateFeitico;
}
else
{
this.gameObject.transform.Find("Frente da Carta").GetComponent <Image>().sprite = templateLenda;
if (instCarta != null && instCarta.podeAtacarNesteTurno == false)
{
this.gameObject.transform.Find("Frente da Carta").GetComponent <Image>().sprite = spriteNaoPodeAtacar;
}
}
if (protegido)
{
imagemProtegido.SetActive(true);
}
else
{
imagemProtegido.SetActive(false);
}
}
public abstract void AoOlhar(InstanciaCarta c);
