protected override int SetarOpcoes()
    {
        DadosDoJogador dj = GameController.g.Manager.Dados;

        ItemBase[] nI = dj.MeusItens.ToArray();
        Opcoes = new NomeItem[nI.Length];

        for (int i = 0; i < nI.Length; i++)
        {
            Opcoes[i] = nI[i].Nome;
        }

        for (int i = 0; i < 3; i++)
        {
            if (dj.NumberedPositivistStamp(i) > 0)
            {
                seloPositivista[i].color = Color.white;
            }
            quantidadePositivista[i].text = "x" + dj.NumberedPositivistStamp(i);
        }

        if (Opcoes.Length > 0)
        {
            ChangeOption(0);
        }
        else
        {
            TitleUpdate.text = BancoDeTextos.RetornaListaDeTextoDoIdioma(ChaveDeTexto.complementosDoMenuDePause)[0];
            InfoUpdate.text  = BancoDeTextos.RetornaListaDeTextoDoIdioma(ChaveDeTexto.complementosDoMenuDePause)[1];
        }

        return(Opcoes.Length);
    }
Esempio n. 2
0
    private void OnTriggerEnter2D(Collider2D collision)
    {
        KeyVar kv = GameController.g.MyKeys;

        if (collision.tag == "attackCollisor" && !kv.VerificaEnemyShift(ID))
        {
            //kv.SomaAutoCont(ID, 1);
            EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, som));
            EventAgregator.Publish(new StandardSendGameEvent(EventKey.sumContShift, ID, 1));
            EventAgregator.Publish(new StandardSendGameEvent(EventKey.requestChangeEnemyKey, "limparContPentagono" + ID));

            if (kv.VerificaAutoCont(ID) >= contCargasTotais)
            {
                EventAgregator.Publish(new StandardSendGameEvent(EventKey.requestChangeEnemyKey, ID));
                Desativar();
                new MyInvokeMethod().InvokeNoTempoDeJogo(() => {
                    EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, SoundEffectID.exitCheckPoint));
                }, .5f);
            }

            InstanciaLigando.Instantiate(particulaDeAcao, 0.5f * (collision.transform.position + transform.position), 5);
            DadosDoJogador dj = GameController.g.Manager.Dados;

            if (dj.PontosDeMana < dj.MaxMana)
            {
                dj.AdicionarMana(taxaDeRecuperacao);
                EventAgregator.Publish(new StandardSendGameEvent(EventKey.changeMagicPoints, dj.PontosDeMana, dj.MaxMana));
            }
        }
    }
    public void IniciarHud(bool estaNoCheckPoint)
    {
        this.estaNoCheckPoint = estaNoCheckPoint;
        numEncaixes.transform.parent.gameObject.SetActive(true);

        estado = EstadoDaqui.sobreDisponiveis;
        dj     = GameController.g.Manager.Dados;

        emblemasE.IniciarHud(EncaixeDeEmblemaSelecionado);
        emblemasD.IniciarHud(EmblemaDisponivelSelecionado);

        emblemasE.RetirarDestaques();

        if (dj.MeusEmblemas.Count > 0)
        {
            ColocaInfoTexts(dj.MeusEmblemas[0]);
        }
        else
        {
            InfoDeNaoTemEmblema();
        }

        numEncaixes.text = Emblema.NumeroDeEspacosOcupados(dj.MeusEmblemas) + " / " + dj.EspacosDeEmblemas;

        EventAgregator.AddListener(EventKey.UiDeEmblemasChange, OnChangeOption);
    }
    private void OnRequestFillDates(IGameEvent e)
    {
        StandardSendGameEvent ssge = (StandardSendGameEvent)e;
        SaveDates             S    = (SaveDates)ssge.MyObject[0];

        if (S == null)
        {
            Dados = new DadosDoJogador();
            transform.position = new Vector3(4, 47, 0);
        }
        else
        {
            Dados = S.Dados;
            transform.position = S.Posicao;
        }

        particulaDoDanoMortal.SetActive(false);
        particulaDoMorrendo.SetActive(false);
        derrota.DesligarLosangulo();
        atk.ChangeSwirdColor((int)dados.CorDeEspadaSelecionada);

        /*
         * EventAgregator.Publish(new StandardSendGameEvent(EventKey.changeMoneyAmount, Dados.Dinheiro));
         * EventAgregator.Publish(new StandardSendGameEvent(EventKey.changeLifePoints, Dados.PontosDeVida,Dados.MaxVida));
         * EventAgregator.Publish(new StandardSendGameEvent(EventKey.changeMagicPoints, Dados.PontosDeMana, Dados.MaxMana));
         */
        EventAgregator.Publish(EventKey.colorSwordShow);
    }
    public bool VerifiqueCompra()
    {
        if (itensPossiveisDeVender.Length > 0)
        {
            DadosDoJogador d = GameController.g.Manager.Dados;

            if (d.Dinheiro >= itensPossiveisDeVender[OpcaoEscolhida].valorDeVenda)
            {
                EventAgregator.Publish(new StandardSendGameEvent(EventKey.getCoin, -itensPossiveisDeVender[OpcaoEscolhida].valorDeVenda));
                new MyInvokeMethod().InvokeNoTempoReal(() =>
                {
                    EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, SoundEffectID.Shop));
                }, .5f);
                TradeManager.OnBuy(itensPossiveisDeVender[OpcaoEscolhida].nome);

                // itens possivel de vender vs itens para vender


                itensPossiveisDeVender[OpcaoEscolhida].quantidadeDisponivel--;


                KeyVar myKeys = GameController.g.MyKeys;
                int    val    = itensPossiveisDeVender[OpcaoEscolhida].quantidadeDisponivel;
                int    index  = (new List <ItensAVenda>(itensParaVender)).IndexOf(itensPossiveisDeVender[OpcaoEscolhida]);

                myKeys.MudaAutoCont("quantidade disponivel, loja " + ID + " item " + index, val);

                if (val == 0)
                {
                    myKeys.MudaAutoShift("concluido, loja " + ID + " item " + index, true);
                }

                FinalizarHud();
                IniciarHud();


                return(true);
            }
            else
            {
                return(false);
            }
        }
        else
        {
            new MyInvokeMethod().InvokeAoFimDoQuadro(() =>
            {
                EventAgregator.Publish(EventKey.compraConcluida);
            });
            return(true);
        }
    }
    public void IniciarHud()
    {
        partesDeHexagonoObtidas.transform.parent.gameObject.SetActive(true);

        DadosDoJogador dj = GameController.g.Manager.Dados;

        partesDeHexagonoObtidas.sprite   = hexagonoSprites[dj.PartesDeHexagonoObtidas];
        partesDePentagonosObtidas.sprite = pentagonoSprites[dj.PartesDePentagonosObtidas];
        numHexagonosCompletados.text     = dj.HexagonosCompletados.ToString();
        numPentagonosCompletados.text    = dj.PentagonosCompletados.ToString();
        totalDeHp.text = dj.PontosDeVida + " / " + dj.MaxVida;
        totalDeMp.text = dj.PontosDeMana + " / " + dj.MaxMana;
    }
Esempio n. 7
0
    void Recupera()
    {
        DadosDoJogador dj = GameController.g.Manager.Dados;

        tempoDecorrido = 0;

        if (dj.PontosDeMana < dj.MaxMana)
        {
            dj.AdicionarMana(taxaDeRecuperacao);
            EventAgregator.Publish(new StandardSendGameEvent(EventKey.changeMagicPoints, dj.PontosDeMana, dj.MaxMana));

            InstanciaLigando.Instantiate(particulaDaAcao, GameController.g.Manager.transform.position);
        }
    }
Esempio n. 8
0
    public void IniciarHud(System.Action <int> acaoDeFora)
    {
        Acao += acaoDeFora;
        DadosDoJogador dj = GameController.g.Manager.Dados;

        if (dj.MeusEmblemas.Count > 0)
        {
            IniciarHUD(dj.MeusEmblemas.Count, TipoDeRedimensionamento.emGrade);
        }
        else
        {
            itemDoContainer.SetActive(false);
        }
    }
Esempio n. 9
0
    void SetarDadosIniciaisDaHud(DadosDoJogador dados)
    {
        maxBasicLifeBar   = dados.BaseMaxLife;
        maxBasicMagicBar  = dados.BaseMaxMana;
        addLifeBarAmount  = dados.AddLifeBarAmount;
        addMagicBarAmount = dados.AddMagicBarAmount;

        OnChangeVisibleAddLifeBar(new StandardSendGameEvent(EventKey.nulo, dados.HexagonosCompletados));//addlife precisa ser feito
        OnChangeVisibleUpdateLifeBar(new StandardSendGameEvent(EventKey.nulo, dados.HexagonosCompletados));
        OnChangeVisibleUpdateMagicBar(new StandardSendGameEvent(EventKey.nulo, dados.PentagonosCompletados));

        OnChangeMoneyAmount(new StandardSendGameEvent(EventKey.changeMoneyAmount, dados.Dinheiro));
        OnChangeLifePoints(new StandardSendGameEvent(EventKey.changeLifePoints, dados.PontosDeVida, dados.MaxVida));
        OnChangemagicPoints(new StandardSendGameEvent(EventKey.changeMagicPoints, dados.PontosDeMana, dados.MaxMana));
    }
Esempio n. 10
0
    public void ModificouCorDaEspada(int plus, DadosDoJogador dados)
    {
        if (CorDeEspadaSelecionada + plus < 5 && CorDeEspadaSelecionada + plus > -1)
        {
            CorDeEspadaSelecionada += plus;
        }
        else if (CorDeEspadaSelecionada + plus >= 5)
        {
            CorDeEspadaSelecionada = 0;
        }
        else if (CorDeEspadaSelecionada + plus <= -1)
        {
            CorDeEspadaSelecionada = 4;
        }

        switch (CorDeEspadaSelecionada)
        {
        case 1:
            if (!dados.EspadaAzul)
            {
                ModificouCorDaEspada(plus, dados);
            }
            break;

        case 2:
            if (!dados.EspadaVerde)
            {
                ModificouCorDaEspada(plus, dados);
            }
            break;

        case 3:
            if (!dados.EspadaDourada)
            {
                ModificouCorDaEspada(plus, dados);
            }
            break;

        case 4:
            if (!dados.EspadaVermelha)
            {
                ModificouCorDaEspada(plus, dados);
            }
            break;
        }

        ChangeSwirdColor(CorDeEspadaSelecionada);
    }
Esempio n. 11
0
    private void OnRequestFillDates(IGameEvent e)
    {
        StandardSendGameEvent ssge = (StandardSendGameEvent)e;
        SaveDates             S    = (SaveDates)ssge.MyObject[0];
        DadosDoJogador        dados;

        if (S == null)
        {
            dados = new DadosDoJogador();
        }
        else
        {
            dados = S.Dados;
        }

        SetarDadosIniciaisDaHud(dados);
    }
Esempio n. 12
0
    protected override int SetarOpcoes()
    {
        DadosDoJogador J = GameController.g.Manager.Dados;

        bool[] updates = new bool[14]
        {
            true, true, true, true, true, true, J.TemMagicAttack, J.TemDash, J.TemDownArrowJump, J.TemDoubleJump, J.EspadaAzul,
            J.EspadaVerde, J.EspadaDourada, J.EspadaVermelha
        };

        int cont = 0;

        for (int i = 0; i < 14; i++)
        {
            if (updates[i])
            {
                cont++;
            }
        }


        Opcoes = new ChaveDeTextoDosUpdates[cont];


        int localCont = 0;

        for (int i = 0; i < cont; i++)
        {
            while (!updates[localCont])
            {
                localCont++;
            }

            Opcoes[i] = (ChaveDeTextoDosUpdates)localCont;
            localCont++;

            //Opcoes[i] = BancoDeTextos.RetornaListaDeTextoDoIdioma(ChaveDeTexto.androidUpdateMenu)[localCont];
        }



        ChangeOption(0);
        return(Opcoes.Length);
    }
    public void IniciarHud(System.Action <int> acaoStandard)
    {
        Acao += acaoStandard;
        emblemasEquipados = new List <Emblema>();
        DadosDoJogador dados   = GameController.g.Manager.Dados;
        int            ocupado = 0;

        for (int i = 0; i < dados.MeusEmblemas.Count; i++)
        {
            if (dados.MeusEmblemas[i].EstaEquipado)
            {
                ocupado += dados.MeusEmblemas[i].EspacosNecessarios;
                emblemasEquipados.Add(dados.MeusEmblemas[i]);
            }
        }


        IniciarHUD(emblemasEquipados.Count + dados.EspacosDeEmblemas - ocupado, TipoDeRedimensionamento.horizontal);
    }
Esempio n. 14
0
    void EscolheQualCorMostrar()
    {
        bool           foi = false;
        DadosDoJogador d   = GameController.g.Manager.Dados;

        for (int i = 1; i < colorButtons.Length; i++)
        {
            //Debug.Log(GameController.g.Manager.Dados.SwordAvailable((SwordColor)i)+" : "+(SwordColor)i);
            if (d.SwordAvailable((SwordColor)i))
            {
                colorButtons[i].gameObject.SetActive(true);
                foi = true;
            }
            else
            {
                if (colorButtons[i])
                {
                    colorButtons[i].gameObject.SetActive(false);
                }
            }
        }

        if (colorButtons[0])
        {
            colorButtons[0].gameObject.SetActive(foi);
        }

        if (foi)
        {
            for (int i = 0; i < colorButtons.Length; i++)
            {
                if (d.CorDeEspadaSelecionada == (SwordColor)i)
                {
                    colorButtons[i].GetComponent <Image>().sprite = DoSelecionado;
                }
                else
                {
                    colorButtons[i].GetComponent <Image>().sprite = doPadrao;
                }
            }
        }
    }
    public static void AddItem(DadosDoJogador d, NomeItem n, int quantidade)
    {
        bool foi = false;

        for (int i = 0; i < d.MeusItens.Count; i++)
        {
            if (d.MeusItens[i].Nome == n)
            {
                foi = true;
                d.MeusItens[i].Quantidade += quantidade;
            }
        }

        if (!foi)
        {
            d.MeusItens.Add(new ItemBase()
            {
                Nome = n, Quantidade = quantidade
            });
        }
    }
Esempio n. 16
0
    // Update is called once per frame
    public void Update(Controlador controlador, int pontosDeMana, bool noChao, DadosDoJogador dados)
    {
        if (CommandReader.PressionadoBotao(2, controlador) && noChao)
        {
            if (!particulaDaCura.activeSelf)
            {
                tempoEmRecuperacao -= Time.deltaTime;
            }

            if (tempoEmRecuperacao < 0)
            {
                TempoPressionado += Time.deltaTime;

                if (EmTempoDeRecarga && pontosDeMana >= custoParaRecarga)
                {
                    if (!particulaDaCura.activeSelf)
                    {
                        EventAgregator.Publish(new StandardSendGameEvent(EventKey.disparaSom, somDoIniciaCura));
                    }

                    particulaDaCura.SetActive(true);
                }
                else if (pontosDeMana < custoParaRecarga)
                {
                    tempoEmRecuperacao = coolDownRecharge;
                    //som de não tem magia
                }

                if (TempoPressionado > tempoParaRecarga)
                {
                    TempoPressionado   = 0;
                    tempoEmRecuperacao = coolDownRecharge;
                    particulaDaCura.SetActive(false);
                    VerifiqueRecarga(pontosDeMana);
                }
            }
        }
        else if (!CommandReader.PressionadoBotao(2, controlador))
        {
            tempoEmRecuperacao -= Time.deltaTime;
        }


        if (CommandReader.ButtonUp(2, controlador))
        {
            if (dados.TemDownArrowJump && CommandReader.VetorDirecao(controlador).z < -0.25f && !noChao)
            {
                VerifiqueDownArrowJump(pontosDeMana);
            }
            else if (TempoPressionado > tempoDaParticula)
            {
                tempoEmRecuperacao = coolDownRecharge;
                EventAgregator.Publish(new StandardSendGameEvent(null, EventKey.curaCancelada));
            }
            else
            {
                if (tempoEmRecuperacao <= -1 && dados.TemMagicAttack)
                {
                    VerifiqueMagicAttack(pontosDeMana);
                }
            }

            TempoPressionado = 0;
            particulaDaCura.SetActive(false);
        }
    }