예제 #1
0
 public override void AoClicar(InstanciaCarta c)
 {
     cartaAtual.Set(c);
     Configuracoes.admJogo.DefinirEstado(segurandoCarta);
     aoDeixarDeOlhar.Raise();
     aoSelecionarCartaAtual.Raise();
 }
예제 #2
0
    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;
    }
예제 #3
0
 public bool DiferenteTipoDeAtacar(InstanciaCarta instCarta)
 {
     if (podeAtacar)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
예제 #4
0
    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);
        }
    }
예제 #5
0
    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);
    }
예제 #6
0
    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();
    }
예제 #7
0
 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);
         }
     }
 }
예제 #8
0
 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;
         }
     }
 }
예제 #9
0
 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();
     }
 }
예제 #10
0
    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);
    }
예제 #11
0
    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;
        }
    }
예제 #12
0
 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);
         }
     }
 }
예제 #13
0
 public override void AoClicar(InstanciaCarta c)
 {
 }
예제 #14
0
 public override void AoOlhar(InstanciaCarta c)
 {
 }
예제 #15
0
 public void Set(InstanciaCarta v)
 {
     valor = v;
 }
예제 #16
0
    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);
    }
예제 #17
0
    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);
            }
        }
    }
예제 #18
0
    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);
        }
    }
예제 #19
0
    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);
        }
    }
예제 #20
0
 public abstract void AoOlhar(InstanciaCarta c);