Ejemplo n.º 1
0
    public static void Inicializacao(string nome, GameObject objeto)
    {
        //mudar tudo isso se forem carregados dados na segunda fase - usar PlayerPrefs?
        Personagem unid = objeto.GetComponent <Personagem>();

        unid.andar = Andar(tiposDeAndar[nome]);
        unid.pv    = atributosIniciais[nome][0];
        unid.SetMPVBase(atributosIniciais[nome][0]);
        unid.pt = atributosIniciais[nome][1];
        unid.SetMPTBase(atributosIniciais[nome][1]);
        unid.SetAtaqueBase(atributosIniciais[nome][2]);
        unid.SetDefesaBase(atributosIniciais[nome][3]);
        unid.SetAgilidadeBase(atributosIniciais[nome][4]);
        unid.SetMovimentoBase(atributosIniciais[nome][5]);
        unid.nivel       = atributosIniciais[nome][6];
        unid.nivelBase   = atributosIniciais[nome][6];
        unid.crescimento = crescimentoPorNivel[nome];
        if (itensIniciais.ContainsKey(nome))
        {
            foreach (string item in itensIniciais[nome])
            {
                unid.AdicionarAoInventario(DefinesItens.itens[item]);
                //unid.inventario[i] = DefinesItens.itens[itensIniciais[nome][i]];
            }
        }
        else
        {
            unid.inventario = new Item[TAMANHO_INVENTARIO];
        }

        //Inimigos normalmente entram na segunda opção - as armas são o próprio nome
        if (armasIniciais.ContainsKey(nome))
        {
            unid.arma = DefinesArmas.armas[armasIniciais[nome]];
            //também adicionar uma representação como item da arma inicial ao inventário
            unid.AdicionarAoInventario(DefinesItens.itens[unid.arma.nome]);
        }
        else
        {
            unid.arma = DefinesArmas.armas[nome];
        }

        if (habilidadesIniciais.ContainsKey(nome))
        {
            foreach (string hab in habilidadesIniciais[nome])
            {
                unid.AdicionarHabilidade(DefinesHabilidades.habilidades[hab]);
            }
        }
        else
        {
            unid.inventario = new Item[TAMANHO_INVENTARIO];
        }
    }
 // Update is called once per frame
 void Update()
 {
     if (entrada == Teclas.CANCEL)
     {
         entrada = 0;
         gerenciadorInput.cursorAtivo = 0;
         canvasAlvo.GetComponent <Canvas>().enabled = true;
         //o jogo ficará circulando entre os alvos permitidos, então começaremos
         //movendo para o primeiro alvo encontrado (viés para o canto inferior esquerdo)
         cursor.GetComponent <ControleCursor>().IrParaPrimeiroAlvoTroca();
         cursor.GetComponent <ControleCursor>().MostrarOverlaysItem();
         //cursor.GetComponent<ControleCursor>().indiceItemSelecionado = posItemSelecionado;
         gameObject.GetComponent <Canvas>().enabled = false;
     }
     else if (entrada == Teclas.ACTION)
     {
         entrada = 0;
         Item itemADevolver = destino.inventario[posItemSelecionado];
         Item itemAFornecer = origem.inventario[posItemOferecido];
         origem.DescartarItem(posItemOferecido);
         origem.AdicionarAoInventario(itemADevolver);
         destino.DescartarItem(posItemSelecionado);
         destino.AdicionarAoInventario(itemAFornecer);
         FecharMenu();
         cursor.GetComponent <ControleCursor>().Liberar();
         gs.SairMenuBatalha();
         origem.PosTurno();
         gs.ProximoSeEmBatalha();
         GameObject.Find("CanvasInventario").GetComponent <GerenciadorInventario>().FecharMenu();
     }
     else if (entrada == Teclas.DPAD)
     {
         entrada            = 0;
         posItemSelecionado = posItemSelecionado - (int)direcao.y;
         posItemSelecionado = (slots.Length + posItemSelecionado) % slots.Length;
         MostrarItens();
     }
 }
Ejemplo n.º 3
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);
        }
    }