Ejemplo n.º 1
0
    public void UsarHabilidade(Vector3 posCentral)
    {
        //quais alvos selecionar, dependendo se a habilidade afeta alvos do mesmo time ou do time inimigo
        int               timeAlvo        = habilidadeAtual.seMesmoTime ? this.time : (this.time + 1) % 2;
        List <Vector3>    tilesAlcancados = habilidadeAtual.areaDeEfeito;
        List <Personagem> alvos           = new List <Personagem>();
        GerenciadorScript gs = GameObject.Find("Gerenciador").GetComponent <GerenciadorScript>();
        AttackParent      ap = GameObject.Find("Placeholder").GetComponent <AttackParent>();
        List <Action <GerenciadorDialogo> > list = new List <Action <GerenciadorDialogo> >();

        foreach (Vector3 offset in tilesAlcancados)
        {
            //considerando posCentral como centro, tenta ver se encontra um alvo possível em todos os offsets
            //da área de efeito da habilidade
            Personagem alvoPossivel = gs.ObjetoNoTile(posCentral + offset);
            if (alvoPossivel == null)
            {
                continue;
            }
            else if (alvoPossivel.time == timeAlvo)
            {
                list.Add(gd => {
                    gd.IrPara(posCentral + offset);
                });
                list.Add(gd => {
                    ap.Abrir();
                    ap.SetLeftAnimator(Defines.animacoesAtk[this.nome]);
                    ap.SetRightAnimator(Defines.animacoesAtk[alvoPossivel.nome]);
                });
                list.Add(gd => {
                    habilidadeAtual.efeitoUso(this, alvoPossivel);
                });
                list.Add(gd => {
                    ap.Fechar();
                });
            }
        }
        gs.mensagensPendentes.Add(list);
    }
Ejemplo n.º 2
0
    public void UsarItem(Personagem unid)
    {
        GerenciadorScript gs = GameObject.Find("Gerenciador").GetComponent <GerenciadorScript>();
        AttackParent      ap = GameObject.Find("Placeholder").GetComponent <AttackParent>();
        List <Action <GerenciadorDialogo> > list = new List <Action <GerenciadorDialogo> >();

        list.Add(gd => {
            gd.IrPara(unid.transform.position);
        });
        list.Add(gd => {
            ap.Abrir();
            ap.SetLeftAnimator(Defines.animacoesAtk[this.nome]);
            ap.SetRightAnimator(Defines.animacoesAtk[unid.nome]);
        });
        list.Add(gd => {
            itemAtual.efeitoUso(this, unid);
        });
        list.Add(gd => {
            ap.Fechar();
        });
        inventario[posItemAtual] = null;
        gs.mensagensPendentes.Add(list);
    }
Ejemplo n.º 3
0
 // Update is called once per frame
 void Update()
 {
     if (gs.canvasBatalhaAberto)
     {
         return;
     }
     if (cooldown > 0)
     {
         cooldown--;
     }
     else
     {
         if (estado == 1 && cursor.transform.position == transform.position)
         {
             cooldown = cooldownPadrao;
             if (inimigosAcessiveis.Count == 0)
             {
                 cursor.IrParaPosicao(EscolherPosicaoDeAproximacao(alvoEscolhidoParaAtacar));
             }
             else
             {
                 Vector3 posPotencial = EscolherPosicaoDeAtaque(alvoEscolhidoParaAtacar);
                 if (posPotencial == transform.position)
                 {
                     cooldown = cooldown / 5;
                 }
                 cursor.IrParaPosicao(posPotencial);
             }
             estado = 2;
         }
         else if (estado == 2)
         {
             cooldown = cooldownPadrao;
             if (cursor.transform.position == transform.position)
             {
                 cooldown = cooldown / 5;
             }
             Mover();
             estado = 3; //vai mudar dependendo se for atacar ou usar habilidade
         }
         else if (estado == 3)
         {
             cooldown = cooldownPadrao;
             if (inimigosAcessiveis.Count == 0)
             {
                 FinalizarTurno();
             }
             else
             {
                 cursor.MostrarOverlaysAtaque(personagem.TilesAlvosAcessiveis(personagem.arma.alcanceMin, personagem.arma.alcanceMax));
                 cursor.IrParaPosicao(alvoEscolhidoParaAtacar.transform.position);
                 gs.MostrarDadosDoAlvo(alvoEscolhidoParaAtacar);
                 estado = 4;
             }
         }
         else if (estado == 4)
         {
             ap.Abrir();
             ap.SetLeftAnimator(Defines.animacoesAtk[alvoEscolhidoParaAtacar.nome]);
             ap.SetRightAnimator(Defines.animacoesAtk[personagem.nome]);
             gs.canvasBatalhaAberto = true;
             StartCoroutine(SetTimeout(1f, () => personagem.Atacar(alvoEscolhidoParaAtacar), () => {
                 ap.Fechar();
                 gs.canvasBatalhaAberto = false;
                 acabaramDeMeAtacar     = new List <Personagem>();
                 FinalizarTurno();
             }));
         }
     }
 }
Ejemplo n.º 4
0
    // Update is called once per frame
    void Update()
    {
        if (gs.canvasBatalhaAberto)
        {
            return;
        }
        if (entrada == Teclas.CANCEL)
        {
            //todo objeto, ao tratar um input, o consome para que não o trate novamente no próximo frame
            entrada = 0;
            if (acaoDoCursor == NADA)
            {
                //outro cancelar ("ESC") retorna o cursor anteriormente selecionada
                novaPosicao = posicaoInicialDaUnidade;
                podeMover   = false;
                gs.SairMenuBatalha();
            }
            else if (acaoDoCursor == SELECIONADO)
            {
                LimparOverlays();
                if (ultimaUnidade != null)
                {
                    ultimaUnidade.PararDePiscar();
                }
                ultimaUnidade = null;
                acaoDoCursor  = NADA;
            }
            else if (acaoDoCursor == MOVIDO)
            {
                //tratado em DesfazerAcaoAtual() pois no status MOVIDO o controle estará no menu de batalha
            }
            else if (acaoDoCursor == PROCURA_ALVO_ATAQUE)
            {
                novaPosicao  = ultimaUnidade.transform.position;
                acaoDoCursor = MOVIDO;
                gerenciadorInput.cursorAtivo = 1;
                gs.ReiniciarLabelsAlvo();
            }
            else if (acaoDoCursor == PROCURA_ALVO_TROCA)
            {
                novaPosicao  = ultimaUnidade.transform.position;
                acaoDoCursor = MOVIDO;
                gerenciadorInput.cursorAtivo = 2;
                gs.ReiniciarLabelsAlvo();
                LimparOverlays();
                menuInventario.Reabrir();
            }
            else if (acaoDoCursor == PROCURA_ALVO_ITEM)
            {
                novaPosicao  = ultimaUnidade.transform.position;
                acaoDoCursor = MOVIDO;
                gerenciadorInput.cursorAtivo = 2;
                gs.ReiniciarLabelsAlvo();
                LimparOverlays();
                menuInventario.Reabrir();
            }
            else if (acaoDoCursor == PROCURA_ALVO_HAB)
            {
                gameObject.GetComponent <SpriteRenderer>().sprite = Resources.Load <Sprite>("GUI/cursor0");
                novaPosicao  = ultimaUnidade.transform.position;
                acaoDoCursor = MOVIDO;
                gerenciadorInput.cursorAtivo = 4;
                gs.ReiniciarLabelsAlvo();
                LimparOverlays();
                menuHabilidades.Reabrir();
            }
        }

        if (entrada == Teclas.ACTION)
        {
            entrada = 0;
            bool finalizado = false;
            if (acaoDoCursor == NADA)
            {
                //acho que apagar depois?
                LimparOverlays();
                //seria bom substituir por algum tipo de Find
                foreach (Personagem p in gs.personagens)
                {
                    if (p.transform.position == transform.position)
                    {
                        if (gs.SeAtual(p))
                        {
                            SelecionarUnidade(p);
                            //print("pode ir");
                        }
                        else
                        {
                            //TODO: mostrar status da unidade que tentou selecionar
                            //print ("não pode");
                        }
                    }
                }
            }
            else if (acaoDoCursor == SELECIONADO)
            {
                //apenas permitir movimento para tiles acessíveis pela unidade
                if (acessiveisUltimaUnidade.Contains(transform.position))
                {
                    //apenas aceitar nova movimentação se a unidade já tiver graficamente voltado a seu posto
                    if (ultimaUnidade.transform.position == posicaoInicialDaUnidade)
                    {
                        ultimaUnidade.destinoFinal = transform.position;
                        ultimaUnidade.PrepararCaminho();
                        acaoDoCursor = MOVIDO;
                        LimparOverlays();
                        ultimaUnidade.PararDePiscar();
                        gs.EntrarMenuBatalha();
                        gerenciadorInput.cursorAtivo = 1;
                    }
                }
                else
                {
                    //TODO: tocar som de erro?
                }
            }
            else if (acaoDoCursor == MOVIDO)
            {
                //nesse ponto o cursor não está ativo - o jogador está no menu de batalha
            }
            else if (acaoDoCursor == PROCURA_ALVO_ATAQUE)
            {
                //se o cursor ainda não tiver chegado num tile válido, aguardar até isso acontecer
                if (transform.position == novaPosicao)
                {
                    ap.Abrir();
                    gs.canvasBatalhaAberto = true;
                    Personagem alvo = gs.ObjetoNoTile(transform.position);
                    ap.SetLeftAnimator(Defines.animacoesAtk[ultimaUnidade.nome]);
                    ap.SetRightAnimator(Defines.animacoesAtk[alvo.nome]);
                    StartCoroutine(SetTimeout(1f, () => {
                        ultimaUnidade.Atacar(alvo);
                        Liberar();
                        LimparOverlays();
                    }, () => {
                        ap.Fechar();
                        gs.canvasBatalhaAberto = false;
                        gs.SairMenuBatalha();
                        gs.ReiniciarLabelsAlvo();
                        ultimaUnidade.PosTurno();
                        gs.ProximoSeEmBatalha();
                        finalizado = true;
                    }));
                }
            }
            else if (acaoDoCursor == PROCURA_ALVO_TROCA)
            {
                //se o cursor ainda não tiver chegado num tile válido, aguardar até isso acontecer
                if (transform.position == novaPosicao)
                {
                    Item       trocado   = ultimaUnidade.inventario[indiceItemSelecionado];
                    Personagem recebedor = gs.ObjetoNoTile(transform.position);
                    if (recebedor.AdicionarAoInventario(trocado) != -1)
                    {
                        //simples envio de item - o destinatário já recebeu, nesse ponto
                        ultimaUnidade.DescartarItem(indiceItemSelecionado);
                        Liberar();
                        LimparOverlays();
                        gs.SairMenuBatalha();
                        menuInventario.FecharMenu();
                        gs.ReiniciarLabelsAlvo();
                        ultimaUnidade.PosTurno();
                        gs.ProximoSeEmBatalha();
                        finalizado = true;
                    }
                    else
                    {
                        LimparOverlays();
                        gerenciadorInput.cursorAtivo = 3;
                        menuInventarioTroca.AbrirMenu(ultimaUnidade, recebedor, indiceItemSelecionado);
                        //gerenciadorInput.GetComponent<GerenciadorInput>().cursorAtivo = 3;
                    }
                }
            }
            else if (acaoDoCursor == PROCURA_ALVO_ITEM)
            {
                if (transform.position == novaPosicao)
                {
                    //informar onde o cursor está para o personagem - este vai definir quais alvos serão afetados
                    //acessando a variável areaDeEfeito da habilidadeAtual
                    ultimaUnidade.UsarItem(gs.ObjetoNoTile(transform.position));
                    menuInventario.FecharMenu();
                    Liberar();
                    LimparOverlays();
                    gs.SairMenuBatalha();
                    gs.ReiniciarLabelsAlvo();
                    ultimaUnidade.PosTurno();
                    gs.ProximoSeEmBatalha();
                    finalizado = true;
                }
            }
            else if (acaoDoCursor == PROCURA_ALVO_HAB)
            {
                if (transform.position == novaPosicao)
                {
                    //informar onde o cursor está para o personagem - este vai definir quais alvos serão afetados
                    //acessando a variável areaDeEfeito da habilidadeAtual
                    ultimaUnidade.pt -= ultimaUnidade.habilidadeAtual.custo;
                    gameObject.GetComponent <SpriteRenderer>().sprite = Resources.Load <Sprite>("GUI/cursor0");
                    ultimaUnidade.UsarHabilidade(transform.position);
                    Liberar();
                    LimparOverlays();
                    gs.SairMenuBatalha();
                    gs.ReiniciarLabelsAlvo();
                    ultimaUnidade.PosTurno();
                    gs.ProximoSeEmBatalha();
                    finalizado = true;
                }
            }
            //se o cursor foi acionado quando o cursor ainda não havia chegado à posição para qual foi movido,
            //manter o input até o próximo frame, para nova tentativa
            if (transform.position != novaPosicao && !finalizado)
            {
                entrada = Teclas.ACTION;
            }
        }

        if (podeMover && entrada == Teclas.DPAD)
        {
            entrada = 0;
            if (acaoDoCursor == PROCURA_ALVO_ATAQUE)
            {
                //fazer o cursor circular pelos alvos permitidos
                if (direcao.x < 0 || direcao.y > 0)
                {
                    indiceAlvoSelecionado++;
                }
                else if (direcao.x > 0 || direcao.y < 0)
                {
                    indiceAlvoSelecionado--;
                }
                List <Vector3> alvos = ultimaUnidade.AlvosAcessiveisFiltrados(ultimaUnidade.arma.alcanceMin,
                                                                              ultimaUnidade.arma.alcanceMax,
                                                                              false);
                indiceAlvoSelecionado = (alvos.Count + indiceAlvoSelecionado) % alvos.Count;
                novaPosicao           = alvos[indiceAlvoSelecionado];
                //obtém o alvo apontado pelo cursor, e mostra seus dados no canvas do alvo
                gs.MostrarDadosDoAlvo(gs.ObjetoNoTile(alvos[indiceAlvoSelecionado]));
            }
            else if (acaoDoCursor == PROCURA_ALVO_TROCA)
            {
                //fazer o cursor circular pelos alvos permitidos
                if (direcao.x < 0 || direcao.y > 0)
                {
                    indiceAlvoSelecionado++;
                }
                else if (direcao.x > 0 || direcao.y < 0)
                {
                    indiceAlvoSelecionado--;
                }
                List <Vector3> alvos = ultimaUnidade.AlvosAcessiveisFiltrados(1, 1, true);
                indiceAlvoSelecionado = (alvos.Count + indiceAlvoSelecionado) % alvos.Count;
                novaPosicao           = alvos[indiceAlvoSelecionado];
                //obtém o alvo apontado pelo cursor, e mostra seus dados no canvas do alvo
                gs.MostrarDadosDoAlvo(gs.ObjetoNoTile(alvos[indiceAlvoSelecionado]));
            }
            else if (acaoDoCursor == PROCURA_ALVO_ITEM)
            {
                //fazer o cursor circular pelos alvos permitidos
                if (direcao.x < 0 || direcao.y > 0)
                {
                    indiceAlvoSelecionado++;
                }
                else if (direcao.x > 0 || direcao.y < 0)
                {
                    indiceAlvoSelecionado--;
                }
                List <Vector3> alvos = ultimaUnidade.AlvosAcessiveisFiltrados(0, 1, true);
                indiceAlvoSelecionado = (alvos.Count + indiceAlvoSelecionado) % alvos.Count;
                novaPosicao           = alvos[indiceAlvoSelecionado];
                //obtém o alvo apontado pelo cursor, e mostra seus dados no canvas do alvo
                gs.MostrarDadosDoAlvo(gs.ObjetoNoTile(alvos[indiceAlvoSelecionado]));
            }
            else if (acaoDoCursor == PROCURA_ALVO_HAB)
            {
                //fazer o cursor circular pelos alvos permitidos
                if (direcao.x < 0 || direcao.y > 0)
                {
                    indiceAlvoSelecionado++;
                }
                else if (direcao.x > 0 || direcao.y < 0)
                {
                    indiceAlvoSelecionado--;
                }
                Habilidade     atual = ultimaUnidade.habilidadeAtual;
                List <Vector3> alvos = ultimaUnidade.AlvosAcessiveisFiltrados(
                    atual.alcanceMin, atual.alcanceMax, ultimaUnidade.habilidadeAtual.seMesmoTime);
                indiceAlvoSelecionado = (alvos.Count + indiceAlvoSelecionado) % alvos.Count;
                novaPosicao           = alvos[indiceAlvoSelecionado];
                //obtém o alvo apontado pelo cursor, e mostra seus dados no canvas do alvo
                gs.MostrarDadosDoAlvo(gs.ObjetoNoTile(alvos[indiceAlvoSelecionado]));
            }
            else
            {
                novoX = transform.position.x + direcao.x;
                novoY = transform.position.y + direcao.y;
                Vector3Int talvezNovaPosicao1 = new Vector3Int((int)novoX, (int)novoY, 0);
                Vector3Int talvezNovaPosicao2 = new Vector3Int((int)transform.position.x, (int)novoY, 0);
                Vector3Int talvezNovaPosicao3 = new Vector3Int((int)novoX, (int)transform.position.y, 0);
                foreach (var pos in new List <Vector3Int> {
                    talvezNovaPosicao1, talvezNovaPosicao2, talvezNovaPosicao3
                })
                {
                    if (acessoCursor.GetTile(pos))
                    {
                        novaPosicao = pos;
                        break;
                    }
                }
                Personagem talvezSobCursor = gs.ObjetoNoTile(novaPosicao);
                if (talvezSobCursor)
                {
                    gs.MostrarMenuBatalhaInativo(talvezSobCursor);
                }
                else
                {
                    gs.SairMenuBatalha();
                }
            }
            podeMover = false;
        }

        if (transform.position == novaPosicao)
        {
            podeMover = true;
        }
        else
        {
            transform.position = Vector3.MoveTowards(transform.position, novaPosicao, velCursor * Time.deltaTime);
        }
    }