[RESOLVIDO] Acessar um valor de outro Script em c#

Desculpa pela noobice galera, mas estou começando agora...
Minha dúvida é a seguinte...


Como acessar um valor que está em outro script.
valorA = 5 (no SCRIPT1)


como faço para  atribuir o valorA do (script1), para o valorB do (script2)?
 
tipo:
valorB (SCRIPT2) = valorA(SCRIP1).
 
Desde já obrigado!

Valor Script1 tem que ser static por ex: public static float vida.
No script2 ficaria assim, o nome do a variavel tal = nome do script1.vida.

levando em conta os Exenplo do amigo acima: 

Código:

class Script1:MonoBehaviour{//duas barras sao comentarios,este é o script1
Script2 sc2;
int res;
void Start(){
sc2=new Script2();
res=sc2.a;
}

}



//---------------------------------------
class Script2:MonoBehaviour{//este é o script2
static int a=6;

}

A variavel não precisa ser estatica, você pode acessar o script como um componente, como realmente ele é:

Código:

   public class Script1 : MonoBehaviour {
      public int valor;
   }

   public class Script2 : MonoBehaviour {
      public Script1 script1;

      void Start () {
         script1.valor = 10;
      }
   }

MUITOOOOOO! Obrigado galera funcionou certinho, vcs são d+.

Só que agora "as vezes" está dando um bug no retorno dos valores (passando valor de outro tema). Vou tentar explicar. Joguei somente o tema 1, retorno blz. Joguei somente o tema 2, retorno blz. Joguei tema1, tema2, tema1, tema2: Neste momento o bug aparece, na hora que aperto start observo no print, que mesmo eu estando no tema1 ele "as vezes" me da o retorno dos valores do terma2, e assim por diante mesmo estando no tema2 ele "as vezes" me passa os valores do tema1, consequentemente na hora de calcular o resultado final fica da diferença.
Vou postar o script se alguém puder me da uma luz eu agradeço muito.

Código:

public class modoJogo1 : MonoBehaviour {


    private    int            TInotaPerguntas, TInotaAcertos, TInotaErros;                                                    

---------------------------------------------------------------------------------
    void Start () {

        TInotaPerguntas = temaInfo.notaPerguntas;      //Retorno da quantidade de perguntas, acertos e erros
        TInotaAcertos    = temaInfo.notaAcertos;       //gravados no "script temaInfo".
        TInotaErros     = temaInfo.notaErros;


---------------------------------------------------------------------------------
// Função responsável por calcular os valores e salvar os dados no "script temaInfo".

    void    calcularNotaFinal()

    {
       testeFinalizado = true;

       notaPerguntas   = Mathf.RoundToInt(qtdRespondida + TInotaPerguntas);        //"TINOTAPERGUNTAS" variável que usei para trazer o retorno da                                                           
       notaAcertos     = Mathf.RoundToInt(qtdAcertos + TInotaAcertos);             // quantidade de perguntas que já joguei no jogo anterior.
       notaErros       = Mathf.RoundToInt (notaPerguntas - notaAcertos);
       notaPorcentagem = Mathf.RoundToInt (notaAcertos * porcentagem / notaPerguntas);

        PlayerPrefs.SetInt ("notaPerguntas_" + idTema.ToString(), (int)notaPerguntas);                                      
        PlayerPrefs.SetInt ("notaAcertos_" + idTema.ToString(), (int)notaAcertos);
        PlayerPrefs.SetInt ("notaErros_" + idTema.ToString(), (int)notaErros);
        PlayerPrefs.SetInt ("notaPorcentagem_" + idTema.ToString(), (int)notaPorcentagem);

        notaPerguntasTxt.text = notaPerguntas.ToString();                                                           
        notaAcertosTxt.text = notaAcertos.ToString();
        notaErrosTxt.text = notaErros.ToString ();
        notaPorcentagemTxt.text = notaPorcentagem.ToString ();


Esse temaInfo, seria qual script? Ele é acessado em todos os modos de jogo? Caso sim, talvez seja isso por ser acessado por vários scripts, algo talvez esteja o modificando... Explique melhor seu problema! Uma dica, caso os scripts forem parecidos, crie uma classe com uma list de todos os modos de jogos, fica mais otimizado!

recagonlei escreveu:Esse temaInfo, seria qual script? Ele é acessado em todos os modos de jogo? Caso sim, talvez seja isso por ser acessado por vários scripts, algo talvez esteja o modificando... Explique melhor seu problema! Uma dica, caso os scripts forem parecidos, crie uma classe com uma list de todos os modos de jogos, fica mais otimizado!

Vou explicar o que estou tentando fazer, e se puderem me dizer como fazer isso de uma forma mais simples eu agradeço.
O meu jogo tem uma variável “qtdPerguntas” que recebe a quantidade de perguntas respondidas. Como o jogo tem 10 questões, no final da partida “qtdPerguntas = 10”, agora que vem o beo.
Quero que quando o jogo for reiniciado a contagem de perguntas continue de onde parou.
Fiz uma variável “totalPerguntas” para armazenar o total de perguntas respondidas.
Então....
quero fazer isso:  >>>>>>  totalPerguntas  = “qtdPerguntas da partida anterior” + qtdPerguntas da partida atual; <<<<<<<<

E assim infinitamente, desse modo ficariam registradas todas as perguntas respondidas no jogo. Mas não estou conseguindo.
Se alguém tiver um luz no final do túnel para me ajudar eu agradeço muito.

De um modo mais simples você faria:
Declare o script que tem a variavel "qtdPerguntas" ex:

Código:

public NomeDoSeuScriptQueTemAvariavel m_questionAmmountScript;

Depois disso, você associa o script no inspector e ele estará declarado ao "modoJogo1"
Depois nessa parte:

Código:

[...]   
void calcularNotaFinal(){
    m_questionAmmount.totalPerguntas += m_questionAmmount.qtdPerguntas;
[...]


Dessa forma você terá a soma no método final e pronto!

recagonlei escreveu:De um modo mais simples você faria:
Declare o script que tem a variavel "qtdPerguntas" ex:

Código:

public NomeDoSeuScriptQueTemAvariavel m_questionAmmountScript;

Depois disso, você associa o script no inspector e ele estará declarado ao "modoJogo1"
Depois nessa parte:

Código:

[...]   
void calcularNotaFinal(){
    m_questionAmmount.totalPerguntas += m_questionAmmount.qtdPerguntas;
[...]


Dessa forma você terá a soma no método final e pronto!

Desculpe minha ignorância quanto a estes conhecimentos recagonlei, mas não compreendi direito. Vou te passar os script e se vc puder mostrar neles eu te agradeço pelo resto da vida, pois já tem mais de semana q não consigo dormir tentando achar uma solução para este problema.

Código:


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;

public class modoJogo1 : MonoBehaviour {

    [Header("Configuração dos Textos")]
    public    Image         perguntaIMG;
    public    Text          nomeTemaTxt, perguntaTxt, infoRespostaTxt, notaFinalTxt, msg1Txt, msg2Txt;

    [Header("Configuração dos Textos Alternativas")]
    public    Text         altAtxt;
    public    Text         altBtxt, altCtxt, altDtxt ;

    [Header("Configuração das Imagens Alternativas")]
    public    Image         altAimg;
    public    Image         altBimg, altCimg, altDimg;

    [Header("Configuração das Barras")]
    public    GameObject    barraProgresso;
    public    GameObject    barraTempo;

    [Header("Configuração dos Botões")]
    public    Button[]    botoes;
    public    Color       corAcerto, corErro;

    [Header("Configuração do Modo de Jogo")]
    public    bool         perguntasComIMG;
    public    bool         perguntasAleatorias, utilizarAlternativas, utilizarAlternativasIMG, jogarComTempo, mostarCorreta;
    public    float        tempoResponder;
    public    int          qtdPiscar;

    [Header("Configuração das Perguntas")]
    public    string[]    perguntas;
    public    Sprite[]    perguntasIMG;
    public    string[]    correta;
    public    int         qtdPerguntas;
    public    List<int>   listaPerguntas;

    [Header("Configuração das Alternativas")]
    public    string[]    alternativasA;
    public    string[]    alternativasB, alternativasC, alternativasD;

    [Header("Configuração das Alternativas IMG")]
    public    Sprite[]    alternativasAimg;
    public    Sprite[]    alternativasBimg, alternativasCimg, alternativasDimg;

    [Header("Configuração dos Painéis")]
    public    GameObject[]    paineis;
    public    GameObject[]    estrela;

    [Header("Configuração das Mensagens")]
    public    string[]        mensagem1;
    public    string[]        mensagem2;
    public    Color[]            corMensagem;

//===================================================================================================================================
    [Header("Configuração BTNs Resultado")]                                                                            //PAINEL RESULTADO
    public    Text        notaPerguntasTxt;                                                                            
    public    Text        notaAcertosTxt, notaErrosTxt, notaPorcentagemTxt;                   

//===================================================================================================================================
    private    int        TInotaPerguntas, TInotaAcertos;                                                                 //PAINEL SCHULT
//===================================================================================================================================
   
     private    int       porcentagem, notaPerguntas, notaAcertos, notaErros, notaPorcentagem;                            //PAINEL RESULTADO
//===================================================================================================================================

    private    int        idResponder, qtdAcertos, notaMin1Estrela, notaMin2Estrelas, notaMin3Estrelas, notaMin4Estrelas, notaMin5Estrelas, notaMin6Estrelas, notaMin7Estrelas, notaMin8Estrelas, notaMin9Estrelas, notaMin10Estrelas, nEstrelas, idTema, idBtnCorreto;
    private    float      qtdRespondida, percProgresso, percTempo, notaFinal, valorQuestao, tempTime;
    private    bool       exibindoCorreta, testeFinalizado;

    private    soundController    soundController;    


    // Use this for initialization

    void Start () {

        TInotaPerguntas = temaInfo.TInotaPerguntas;   print ("TInotaPerguntas " + TInotaPerguntas);
        TInotaAcertos   = temaInfo.TInotaAcertos;     print ("TInotaAcertos " + TInotaAcertos);

//===================================================================================================================================
    porcentagem = 100;                                                                                                 //PAINEL RESULTADO
//===================================================================================================================================

//===================================================================================================================================
       
        notaPerguntas    = PlayerPrefs.GetInt ("notaPerguntas");                                                            //PAINEL RECORD
        notaAcertos      = PlayerPrefs.GetInt ("notaAcertos");
        notaErros        = PlayerPrefs.GetInt ("notaErros");
        notaPorcentagem  = PlayerPrefs.GetInt ("notaPorcentagem");
//===================================================================================================================================

        soundController = FindObjectOfType(typeof(soundController)) as soundController;

        idTema = PlayerPrefs.GetInt("idTema");
        notaMin1Estrela = PlayerPrefs.GetInt("notaMin1Estrela");
        notaMin2Estrelas = PlayerPrefs.GetInt("notaMin2Estrelas");
        notaMin3Estrelas = PlayerPrefs.GetInt("notaMin3Estrelas");
        notaMin4Estrelas = PlayerPrefs.GetInt("notaMin4Estrelas");
        notaMin5Estrelas = PlayerPrefs.GetInt("notaMin5Estrelas");
        notaMin6Estrelas = PlayerPrefs.GetInt("notaMin6Estrelas");
        notaMin7Estrelas = PlayerPrefs.GetInt("notaMin7Estrelas");
        notaMin8Estrelas = PlayerPrefs.GetInt("notaMin8Estrelas");
        notaMin9Estrelas = PlayerPrefs.GetInt("notaMin9Estrelas");
        notaMin10Estrelas = PlayerPrefs.GetInt("notaMin10Estrelas");

        nomeTemaTxt.text = PlayerPrefs.GetString("nomeTema");

        barraTempo.SetActive (false);

        if (perguntasComIMG == true) 

        {
        montarListaPerguntasIMG();
        }
        else 
        {
        montarListaPerguntas ();
        }
        progressaoBarra();
       
       controleBarraTempo();

        paineis [0].SetActive (true);
        paineis [1].SetActive (false);
    }


    // Update is called once per frame

    void Update () {

        if (jogarComTempo == true && exibindoCorreta == false && testeFinalizado == false)
        {
            tempTime += Time.deltaTime;

            controleBarraTempo();

            if (tempTime >= tempoResponder) { proximaPergunta(); }
        }
    }


    // ESTA FUNÇÃO É A RESPONSÁVEL POR MONTAR A LISTA DE PERGUNTAS A SEREM RESPONDIDAS

    public    void        montarListaPerguntas()
    {

        // FAZ A VALIDADE DE PERGUNTAS PARA O TESTE EM RELAÇÃO A QUANTIDADE DE PERGUNTAS EXISTENTES
        if(qtdPerguntas > perguntas.Length) { qtdPerguntas = perguntas.Length;    }
        valorQuestao = 10 / (float)qtdPerguntas;

        // EM CASO DE JOGO COM PERGUNTAS ALEATÓRIAS
        if(perguntasAleatorias == true) 
        {
            bool    addPerguntas = true;
            while(listaPerguntas.Count < qtdPerguntas) 
                {
                addPerguntas = true;

                int rand = Random.Range (0, perguntas.Length);

                foreach (int idP    in    listaPerguntas)

                {
                    if(idP == rand) 
                    {
                        addPerguntas = false;
                    }
                }
                if(addPerguntas == true) {    listaPerguntas.Add(rand);}
            }


            } // EM CASO DE MODO DE JOGO ONDE AS PERGUNTAS NÃO SÃO ALEATÓRIAS
        else
        {
            for (int i = 0; i < qtdPerguntas; i++) 
                {
                listaPerguntas.Add (i);
                }
        }

        perguntaTxt.text = perguntas [listaPerguntas [idResponder]];

        if (utilizarAlternativas == true && utilizarAlternativasIMG == false) 
        {
            altAtxt.text = alternativasA [listaPerguntas [idResponder]];
            altBtxt.text = alternativasB [listaPerguntas [idResponder]];
            altCtxt.text = alternativasC [listaPerguntas [idResponder]];
            altDtxt.text = alternativasD [listaPerguntas [idResponder]];
        } 
        else     if(utilizarAlternativas == true && utilizarAlternativasIMG == true) 
        {    
            altAimg.sprite = alternativasAimg[listaPerguntas [idResponder]];
            altBimg.sprite = alternativasBimg[listaPerguntas [idResponder]];
            altCimg.sprite = alternativasCimg[listaPerguntas [idResponder]];
            altDimg.sprite = alternativasDimg[listaPerguntas [idResponder]];
        }
    }

    // ESTA FUNÇÃO É A RESPONSÁVEL POR MONTAR A LISTA DE PERGUNTAS COM IMAGEM A SEREM RESPONDIDAS
    public    void        montarListaPerguntasIMG()
    {

        // FAZ A VALIDADE DE PERGUNTAS PARA O TESTE EM RELAÇÃO A QUANTIDADE DE PERGUNTAS EXISTENTES
        if(qtdPerguntas > perguntasIMG.Length) { qtdPerguntas = perguntasIMG.Length;    }    

        valorQuestao = 10 / (float)qtdPerguntas;

        // EM CASO DE JOGO COM PERGUNTAS ALEATÓRIAS
        if(perguntasAleatorias == true) 
        {
            bool    addPerguntas = true;

            while (listaPerguntas.Count < qtdPerguntas) 
            {
                addPerguntas = true;

                int rand = Random.Range (0, perguntasIMG.Length);

                foreach (int idP    in    listaPerguntas)
                {
                    if(idP == rand) 
                    {
                        addPerguntas = false;
                    }
                }
                if(addPerguntas == true) {    listaPerguntas.Add(rand);}
            }
              

        } // EM CASO DE MODO DE JOGO ONDE AS PERGUNTAS NÃO SÃO ALEATÓRIAS
        else
        {
            for (int i = 0; i < qtdPerguntas; i++) 
                {
                listaPerguntas.Add (i);
                }
        }

        perguntaIMG.sprite = perguntasIMG[listaPerguntas[idResponder]];

        if (utilizarAlternativas == true && utilizarAlternativasIMG == false) 
        {
            altAtxt.text = alternativasA [listaPerguntas [idResponder]];
            altBtxt.text = alternativasB [listaPerguntas [idResponder]];
            altCtxt.text = alternativasC [listaPerguntas [idResponder]];
            altDtxt.text = alternativasD [listaPerguntas [idResponder]];
        } 
        else     if(utilizarAlternativas == true && utilizarAlternativasIMG == true) 
        {    
            altAimg.sprite = alternativasAimg[listaPerguntas [idResponder]];
            altBimg.sprite = alternativasBimg[listaPerguntas [idResponder]];
            altCimg.sprite = alternativasCimg[listaPerguntas [idResponder]];
            altDimg.sprite = alternativasDimg[listaPerguntas [idResponder]];
        }
    }

        // ESTA FUNÇÃO É RESPONSÁVEL POR PROCESSAR A RESPOSTA DADA PELO JOGADOR

        public    void    responder(string alternativa)
    {


        // VERIFICA SE NO MODO DE JOGO ESTÁ SETADO PARA EXIBIR AS ALTERNATIVAS CORRETAS, CASO ESTEJA, ELE RETORNA EM CASO DE MAIS DE UM CLIQUE
        if(exibindoCorreta == true) { return; }

        // FAZ A VERIFICAÇÃO SE A RESPOSTA ESTÁ CORRETA E INCREMENTA UM NA QUANTIDADE DE ACERTOS
        if (correta [listaPerguntas [idResponder]] == alternativa)
        {
            qtdAcertos += 1;
            soundController.playAcerto();
        }
       else
        {
           soundController.playErro();
        }

        // EM CASO DO MODO DE JOGO COM EXIBIÇÃO DA CORRETA, INDICA QUAL BOTÃO CONTÉM A RESPOSTA CORRETA

        switch(correta[listaPerguntas[idResponder]]) 
        {
        case "A":
            idBtnCorreto = 0;
            break;
        case "B":
            idBtnCorreto = 1;
            break;
        case "C":
            idBtnCorreto = 2;
            break;
        case "D":
            idBtnCorreto = 3;
            break;
        }

        // EM CASO DE MODO DE JOGO EXIBINDO A RESPOSTA CORRETA, ALTERA A COR DOS BOTÕES E FAZ A CHAMADA DA FUNÇÃO DE ANIMAÇÃO

        if (mostarCorreta == true) 
        {
            foreach(Button b in botoes) 
            {
                b.image.color = corErro;
            }

            exibindoCorreta = true;

            botoes[idBtnCorreto].image.color = corAcerto;

            StartCoroutine("mostrarAlternativaCorreta");
        } 
        else // CASO O MODO DE JOGO NÃO ESTEJA PARA EXIBIR A CORRETA, CHAMA A PRÓXIMA PERGUNTA     
        {
        proximaPergunta();
        }
    }
     

    // FUNÇÃO RESPONSÁVEL POR PROCESSAR AS PERGUNTAS, FAZ A CHAMADA DE UMA NOVA OU ENCERRA O TESTE

    public    void        proximaPergunta()
    {
        idResponder += 1;
        tempTime = 0;

        // PAINÉIS DAS PERGUNTAS E RESPOSTAS
        paineis [2].SetActive (true);
        paineis [3].SetActive (false); 

        // FUNÇÃO RESPONSÁVEL POR PROCESSAR A BARRA infoResposta(respondendo 1 de 25 perguntas).
        qtdRespondida += 1;
        progressaoBarra ();
  
        EventSystem.current.SetSelectedGameObject(null);

        // CASO AINDA HAJA PERGUNTAS A SEREM RESPONDIDAS, PROCESSA A NOVA PERGUNTA
        if (idResponder < listaPerguntas.Count)
        {
            if(perguntasComIMG == true) 
            {
                perguntaIMG.sprite = perguntasIMG[listaPerguntas[idResponder]];
            } 
            else 
            {
                perguntaTxt.text = perguntas [listaPerguntas [idResponder]];
            }
            if (utilizarAlternativas == true && utilizarAlternativasIMG == false) 

            {
                altAtxt.text = alternativasA [listaPerguntas [idResponder]];
                altBtxt.text = alternativasB [listaPerguntas [idResponder]];
                altCtxt.text = alternativasC [listaPerguntas [idResponder]];
                altDtxt.text = alternativasD [listaPerguntas [idResponder]];
            } 
            else     if(utilizarAlternativas == true && utilizarAlternativasIMG == true) 
            {    
                altAimg.sprite = alternativasAimg[listaPerguntas [idResponder]];
                altBimg.sprite = alternativasBimg[listaPerguntas [idResponder]];
                altCimg.sprite = alternativasCimg[listaPerguntas [idResponder]];
                altDimg.sprite = alternativasDimg[listaPerguntas [idResponder]];
            }
       }
        else // CASO O TESTE TENHA SIDO FINALIZADO, CHAMA A FUNÇÃO QUE CALCULA A NOTA FINAL
        {
            calcularNotaFinal();
        }
    }

    // FUNÇÃO QUE CONTROLA A BARRA DE PROGRESSO DO JOGO
    void    progressaoBarra()
    {
        infoRespostaTxt.text = "Respondeu " + qtdRespondida + " de " + listaPerguntas.Count + " perguntas";
        percProgresso = qtdRespondida / listaPerguntas.Count;
        barraProgresso.transform.localScale = new    Vector3 (percProgresso, 1, 1);
    }

    // FUNÇÃO QUE CONTROLA A BARRA DE TEMPO DO MODO DE JOGO COM TEMPO
    void controleBarraTempo()
    {
        if (jogarComTempo == true)     { barraTempo.SetActive (true); }

        percTempo = ((tempTime - tempoResponder) / tempoResponder) * -1;

        if (percTempo < 0) { percTempo = 0; }

        barraTempo.transform.localScale = new Vector3 (percTempo, 1, 1);
    }

    // FUNÇÃO RESPONSÁVEL POR CALCULAR A NOTA FINAL DO TESTE
    void    calcularNotaFinal()
    {
        testeFinalizado = true;
        notaFinal       = Mathf.RoundToInt(valorQuestao * qtdAcertos);              

//===================================================================================================================================

        notaPerguntas   = Mathf.RoundToInt(qtdRespondida + TInotaPerguntas);                                            //PAINEL RESULTADO
        notaAcertos     = Mathf.RoundToInt(qtdAcertos + TInotaAcertos);
        notaErros       = Mathf.RoundToInt (notaPerguntas - notaAcertos);
        notaPorcentagem = Mathf.RoundToInt (notaAcertos * porcentagem / notaPerguntas);
//===================================================================================================================================

//===================================================================================================================================
       
        PlayerPrefs.SetInt ("notaPerguntas_" + idTema.ToString(), (int)notaPerguntas);                                       //PAINEL RECORD
        PlayerPrefs.SetInt ("notaAcertos_" + idTema.ToString(), (int)notaAcertos);
        PlayerPrefs.SetInt ("notaErros_" + idTema.ToString(), (int)notaErros);
        PlayerPrefs.SetInt ("notaPorcentagem_" + idTema.ToString(), (int)notaPorcentagem);
//===================================================================================================================================

        if (notaFinal > PlayerPrefs.GetInt ("notaFinal_" + idTema.ToString())) 
        { 
            PlayerPrefs.SetInt ("notaFinal_" + idTema.ToString(), (int)notaFinal);
        }


        if(notaFinal == 10) { nEstrelas = 10; soundController.playVinheta(); }
        else if(notaFinal >= notaMin10Estrelas) { nEstrelas = 10; }
        else if(notaFinal >= notaMin9Estrelas) { nEstrelas = 9; }
        else if(notaFinal >= notaMin8Estrelas) { nEstrelas = 8; }
        else if(notaFinal >= notaMin7Estrelas) { nEstrelas = 7; }
        else if(notaFinal >= notaMin6Estrelas) { nEstrelas = 6; }
        else if(notaFinal >= notaMin5Estrelas) { nEstrelas = 5; }
        else if(notaFinal >= notaMin4Estrelas) { nEstrelas = 4; }
        else if(notaFinal >= notaMin3Estrelas) { nEstrelas = 3; }
        else if(notaFinal >= notaMin2Estrelas) { nEstrelas = 2; }
        else if(notaFinal >= notaMin1Estrela) { nEstrelas = 1; }

        notaFinalTxt.text = notaFinal.ToString ();
//===================================================================================================================================

        notaPerguntasTxt.text = notaPerguntas.ToString();                                                            //PAINEL RESULTADO
        notaAcertosTxt.text = notaAcertos.ToString();
        notaErrosTxt.text = notaErros.ToString ();
        notaPorcentagemTxt.text = notaPorcentagem.ToString ();
//===================================================================================================================================
      
        notaFinalTxt.color = corMensagem[nEstrelas];
       
        msg1Txt.text = mensagem1 [nEstrelas];
        msg1Txt.color = corMensagem [nEstrelas];
        msg2Txt.text = mensagem2 [nEstrelas];

        foreach (GameObject e in estrela) 
        {
            e.SetActive (false);
        }

        for (int i = 0; i < nEstrelas; i++) 
        {
            estrela [i].SetActive (true);
        }

        paineis [0].SetActive (false);
        paineis [1].SetActive (true);
    }

    // CORROUTINE QUE FAZ A ANIMAÇÃO DE PISCAR DO BOTÃO DA ALTERNATIVA CORRETA
    IEnumerator    mostrarAlternativaCorreta()
    {
        for (int i = 0; i < qtdPiscar; i++) 
        {
            botoes[idBtnCorreto].image.color = corAcerto;
            yield return new WaitForSeconds(0.2f);
            botoes[idBtnCorreto].image.color = Color.white;
            yield return new WaitForSeconds(0.2f);
        }

        foreach(Button b in botoes) 
        {
            b.image.color = Color.white;
        }

        exibindoCorreta = false;
        proximaPergunta();
    }
}





oilson escreveu:

recagonlei escreveu:De um modo mais simples você faria:
Declare o script que tem a variavel "qtdPerguntas" ex:

Código:

public NomeDoSeuScriptQueTemAvariavel m_questionAmmountScript;

Depois disso, você associa o script no inspector e ele estará declarado ao "modoJogo1"
Depois nessa parte:

Código:

[...]   
void calcularNotaFinal(){
    m_questionAmmount.totalPerguntas += m_questionAmmount.qtdPerguntas;
[...]


Dessa forma você terá a soma no método final e pronto!

Desculpe minha ignorância quanto a estes conhecimentos recagonlei, mas não compreendi direito. Vou te passar os script e se vc puder mostrar neles eu te agradeço pelo resto da vida, pois já tem mais de semana q não consigo dormir tentando achar uma solução para este problema.

Código:


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;

public class modoJogo1 : MonoBehaviour {

    [Header("Configuração dos Textos")]
    public    Image         perguntaIMG;
    public    Text          nomeTemaTxt, perguntaTxt, infoRespostaTxt, notaFinalTxt, msg1Txt, msg2Txt;

    [Header("Configuração dos Textos Alternativas")]
    public    Text         altAtxt;
    public    Text         altBtxt, altCtxt, altDtxt ;

    [Header("Configuração das Imagens Alternativas")]
    public    Image         altAimg;
    public    Image         altBimg, altCimg, altDimg;

    [Header("Configuração das Barras")]
    public    GameObject    barraProgresso;
    public    GameObject    barraTempo;

    [Header("Configuração dos Botões")]
    public    Button[]    botoes;
    public    Color       corAcerto, corErro;

    [Header("Configuração do Modo de Jogo")]
    public    bool         perguntasComIMG;
    public    bool         perguntasAleatorias, utilizarAlternativas, utilizarAlternativasIMG, jogarComTempo, mostarCorreta;
    public    float        tempoResponder;
    public    int          qtdPiscar;

    [Header("Configuração das Perguntas")]
    public    string[]    perguntas;
    public    Sprite[]    perguntasIMG;
    public    string[]    correta;
    public    int         qtdPerguntas;
    public    List<int>   listaPerguntas;

    [Header("Configuração das Alternativas")]
    public    string[]    alternativasA;
    public    string[]    alternativasB, alternativasC, alternativasD;

    [Header("Configuração das Alternativas IMG")]
    public    Sprite[]    alternativasAimg;
    public    Sprite[]    alternativasBimg, alternativasCimg, alternativasDimg;

    [Header("Configuração dos Painéis")]
    public    GameObject[]    paineis;
    public    GameObject[]    estrela;

    [Header("Configuração das Mensagens")]
    public    string[]        mensagem1;
    public    string[]        mensagem2;
    public    Color[]            corMensagem;

//===================================================================================================================================
    [Header("Configuração BTNs Resultado")]                                                                            //PAINEL RESULTADO
    public    Text        notaPerguntasTxt;                                                                            
    public    Text        notaAcertosTxt, notaErrosTxt, notaPorcentagemTxt;                   

//===================================================================================================================================
    private    int        TInotaPerguntas, TInotaAcertos;                                                                 //PAINEL SCHULT
//===================================================================================================================================
   
     private    int       porcentagem, notaPerguntas, notaAcertos, notaErros, notaPorcentagem;                            //PAINEL RESULTADO
//===================================================================================================================================

    private    int        idResponder, qtdAcertos, notaMin1Estrela, notaMin2Estrelas, notaMin3Estrelas, notaMin4Estrelas, notaMin5Estrelas, notaMin6Estrelas, notaMin7Estrelas, notaMin8Estrelas, notaMin9Estrelas, notaMin10Estrelas, nEstrelas, idTema, idBtnCorreto;
    private    float      qtdRespondida, percProgresso, percTempo, notaFinal, valorQuestao, tempTime;
    private    bool       exibindoCorreta, testeFinalizado;

    private    soundController    soundController;    


    // Use this for initialization

    void Start () {

        TInotaPerguntas = temaInfo.TInotaPerguntas;   print ("TInotaPerguntas " + TInotaPerguntas);
        TInotaAcertos   = temaInfo.TInotaAcertos;     print ("TInotaAcertos " + TInotaAcertos);

//===================================================================================================================================
    porcentagem = 100;                                                                                                 //PAINEL RESULTADO
//===================================================================================================================================

//===================================================================================================================================
       
        notaPerguntas    = PlayerPrefs.GetInt ("notaPerguntas");                                                            //PAINEL RECORD
        notaAcertos      = PlayerPrefs.GetInt ("notaAcertos");
        notaErros        = PlayerPrefs.GetInt ("notaErros");
        notaPorcentagem  = PlayerPrefs.GetInt ("notaPorcentagem");
//===================================================================================================================================

        soundController = FindObjectOfType(typeof(soundController)) as soundController;

        idTema = PlayerPrefs.GetInt("idTema");
        notaMin1Estrela = PlayerPrefs.GetInt("notaMin1Estrela");
        notaMin2Estrelas = PlayerPrefs.GetInt("notaMin2Estrelas");
        notaMin3Estrelas = PlayerPrefs.GetInt("notaMin3Estrelas");
        notaMin4Estrelas = PlayerPrefs.GetInt("notaMin4Estrelas");
        notaMin5Estrelas = PlayerPrefs.GetInt("notaMin5Estrelas");
        notaMin6Estrelas = PlayerPrefs.GetInt("notaMin6Estrelas");
        notaMin7Estrelas = PlayerPrefs.GetInt("notaMin7Estrelas");
        notaMin8Estrelas = PlayerPrefs.GetInt("notaMin8Estrelas");
        notaMin9Estrelas = PlayerPrefs.GetInt("notaMin9Estrelas");
        notaMin10Estrelas = PlayerPrefs.GetInt("notaMin10Estrelas");

        nomeTemaTxt.text = PlayerPrefs.GetString("nomeTema");

        barraTempo.SetActive (false);

        if (perguntasComIMG == true) 

        {
        montarListaPerguntasIMG();
        }
        else 
        {
        montarListaPerguntas ();
        }
        progressaoBarra();
       
       controleBarraTempo();

        paineis [0].SetActive (true);
        paineis [1].SetActive (false);
    }


    // Update is called once per frame

    void Update () {

        if (jogarComTempo == true && exibindoCorreta == false && testeFinalizado == false)
        {
            tempTime += Time.deltaTime;

            controleBarraTempo();

            if (tempTime >= tempoResponder) { proximaPergunta(); }
        }
    }


    // ESTA FUNÇÃO É A RESPONSÁVEL POR MONTAR A LISTA DE PERGUNTAS A SEREM RESPONDIDAS

    public    void        montarListaPerguntas()
    {

        // FAZ A VALIDADE DE PERGUNTAS PARA O TESTE EM RELAÇÃO A QUANTIDADE DE PERGUNTAS EXISTENTES
        if(qtdPerguntas > perguntas.Length) { qtdPerguntas = perguntas.Length;    }
        valorQuestao = 10 / (float)qtdPerguntas;

        // EM CASO DE JOGO COM PERGUNTAS ALEATÓRIAS
        if(perguntasAleatorias == true) 
        {
            bool    addPerguntas = true;
            while(listaPerguntas.Count < qtdPerguntas) 
                {
                addPerguntas = true;

                int rand = Random.Range (0, perguntas.Length);

                foreach (int idP    in    listaPerguntas)

                {
                    if(idP == rand) 
                    {
                        addPerguntas = false;
                    }
                }
                if(addPerguntas == true) {    listaPerguntas.Add(rand);}
            }


            } // EM CASO DE MODO DE JOGO ONDE AS PERGUNTAS NÃO SÃO ALEATÓRIAS
        else
        {
            for (int i = 0; i < qtdPerguntas; i++) 
                {
                listaPerguntas.Add (i);
                }
        }

        perguntaTxt.text = perguntas [listaPerguntas [idResponder]];

        if (utilizarAlternativas == true && utilizarAlternativasIMG == false) 
        {
            altAtxt.text = alternativasA [listaPerguntas [idResponder]];
            altBtxt.text = alternativasB [listaPerguntas [idResponder]];
            altCtxt.text = alternativasC [listaPerguntas [idResponder]];
            altDtxt.text = alternativasD [listaPerguntas [idResponder]];
        } 
        else     if(utilizarAlternativas == true && utilizarAlternativasIMG == true) 
        {    
            altAimg.sprite = alternativasAimg[listaPerguntas [idResponder]];
            altBimg.sprite = alternativasBimg[listaPerguntas [idResponder]];
            altCimg.sprite = alternativasCimg[listaPerguntas [idResponder]];
            altDimg.sprite = alternativasDimg[listaPerguntas [idResponder]];
        }
    }

    // ESTA FUNÇÃO É A RESPONSÁVEL POR MONTAR A LISTA DE PERGUNTAS COM IMAGEM A SEREM RESPONDIDAS
    public    void        montarListaPerguntasIMG()
    {

        // FAZ A VALIDADE DE PERGUNTAS PARA O TESTE EM RELAÇÃO A QUANTIDADE DE PERGUNTAS EXISTENTES
        if(qtdPerguntas > perguntasIMG.Length) { qtdPerguntas = perguntasIMG.Length;    }    

        valorQuestao = 10 / (float)qtdPerguntas;

        // EM CASO DE JOGO COM PERGUNTAS ALEATÓRIAS
        if(perguntasAleatorias == true) 
        {
            bool    addPerguntas = true;

            while (listaPerguntas.Count < qtdPerguntas) 
            {
                addPerguntas = true;

                int rand = Random.Range (0, perguntasIMG.Length);

                foreach (int idP    in    listaPerguntas)
                {
                    if(idP == rand) 
                    {
                        addPerguntas = false;
                    }
                }
                if(addPerguntas == true) {    listaPerguntas.Add(rand);}
            }
              

        } // EM CASO DE MODO DE JOGO ONDE AS PERGUNTAS NÃO SÃO ALEATÓRIAS
        else
        {
            for (int i = 0; i < qtdPerguntas; i++) 
                {
                listaPerguntas.Add (i);
                }
        }

        perguntaIMG.sprite = perguntasIMG[listaPerguntas[idResponder]];

        if (utilizarAlternativas == true && utilizarAlternativasIMG == false) 
        {
            altAtxt.text = alternativasA [listaPerguntas [idResponder]];
            altBtxt.text = alternativasB [listaPerguntas [idResponder]];
            altCtxt.text = alternativasC [listaPerguntas [idResponder]];
            altDtxt.text = alternativasD [listaPerguntas [idResponder]];
        } 
        else     if(utilizarAlternativas == true && utilizarAlternativasIMG == true) 
        {    
            altAimg.sprite = alternativasAimg[listaPerguntas [idResponder]];
            altBimg.sprite = alternativasBimg[listaPerguntas [idResponder]];
            altCimg.sprite = alternativasCimg[listaPerguntas [idResponder]];
            altDimg.sprite = alternativasDimg[listaPerguntas [idResponder]];
        }
    }

        // ESTA FUNÇÃO É RESPONSÁVEL POR PROCESSAR A RESPOSTA DADA PELO JOGADOR

        public    void    responder(string alternativa)
    {


        // VERIFICA SE NO MODO DE JOGO ESTÁ SETADO PARA EXIBIR AS ALTERNATIVAS CORRETAS, CASO ESTEJA, ELE RETORNA EM CASO DE MAIS DE UM CLIQUE
        if(exibindoCorreta == true) { return; }

        // FAZ A VERIFICAÇÃO SE A RESPOSTA ESTÁ CORRETA E INCREMENTA UM NA QUANTIDADE DE ACERTOS
        if (correta [listaPerguntas [idResponder]] == alternativa)
        {
            qtdAcertos += 1;
            soundController.playAcerto();
        }
       else
        {
           soundController.playErro();
        }

        // EM CASO DO MODO DE JOGO COM EXIBIÇÃO DA CORRETA, INDICA QUAL BOTÃO CONTÉM A RESPOSTA CORRETA

        switch(correta[listaPerguntas[idResponder]]) 
        {
        case "A":
            idBtnCorreto = 0;
            break;
        case "B":
            idBtnCorreto = 1;
            break;
        case "C":
            idBtnCorreto = 2;
            break;
        case "D":
            idBtnCorreto = 3;
            break;
        }

        // EM CASO DE MODO DE JOGO EXIBINDO A RESPOSTA CORRETA, ALTERA A COR DOS BOTÕES E FAZ A CHAMADA DA FUNÇÃO DE ANIMAÇÃO

        if (mostarCorreta == true) 
        {
            foreach(Button b in botoes) 
            {
                b.image.color = corErro;
            }

            exibindoCorreta = true;

            botoes[idBtnCorreto].image.color = corAcerto;

            StartCoroutine("mostrarAlternativaCorreta");
        } 
        else // CASO O MODO DE JOGO NÃO ESTEJA PARA EXIBIR A CORRETA, CHAMA A PRÓXIMA PERGUNTA     
        {
        proximaPergunta();
        }
    }
     

    // FUNÇÃO RESPONSÁVEL POR PROCESSAR AS PERGUNTAS, FAZ A CHAMADA DE UMA NOVA OU ENCERRA O TESTE

    public    void        proximaPergunta()
    {
        idResponder += 1;
        tempTime = 0;

        // PAINÉIS DAS PERGUNTAS E RESPOSTAS
        paineis [2].SetActive (true);
        paineis [3].SetActive (false); 

        // FUNÇÃO RESPONSÁVEL POR PROCESSAR A BARRA infoResposta(respondendo 1 de 25 perguntas).
        qtdRespondida += 1;
        progressaoBarra ();
  
        EventSystem.current.SetSelectedGameObject(null);

        // CASO AINDA HAJA PERGUNTAS A SEREM RESPONDIDAS, PROCESSA A NOVA PERGUNTA
        if (idResponder < listaPerguntas.Count)
        {
            if(perguntasComIMG == true) 
            {
                perguntaIMG.sprite = perguntasIMG[listaPerguntas[idResponder]];
            } 
            else 
            {
                perguntaTxt.text = perguntas [listaPerguntas [idResponder]];
            }
            if (utilizarAlternativas == true && utilizarAlternativasIMG == false) 

            {
                altAtxt.text = alternativasA [listaPerguntas [idResponder]];
                altBtxt.text = alternativasB [listaPerguntas [idResponder]];
                altCtxt.text = alternativasC [listaPerguntas [idResponder]];
                altDtxt.text = alternativasD [listaPerguntas [idResponder]];
            } 
            else     if(utilizarAlternativas == true && utilizarAlternativasIMG == true) 
            {    
                altAimg.sprite = alternativasAimg[listaPerguntas [idResponder]];
                altBimg.sprite = alternativasBimg[listaPerguntas [idResponder]];
                altCimg.sprite = alternativasCimg[listaPerguntas [idResponder]];
                altDimg.sprite = alternativasDimg[listaPerguntas [idResponder]];
            }
       }
        else // CASO O TESTE TENHA SIDO FINALIZADO, CHAMA A FUNÇÃO QUE CALCULA A NOTA FINAL
        {
            calcularNotaFinal();
        }
    }

    // FUNÇÃO QUE CONTROLA A BARRA DE PROGRESSO DO JOGO
    void    progressaoBarra()
    {
        infoRespostaTxt.text = "Respondeu " + qtdRespondida + " de " + listaPerguntas.Count + " perguntas";
        percProgresso = qtdRespondida / listaPerguntas.Count;
        barraProgresso.transform.localScale = new    Vector3 (percProgresso, 1, 1);
    }

    // FUNÇÃO QUE CONTROLA A BARRA DE TEMPO DO MODO DE JOGO COM TEMPO
    void controleBarraTempo()
    {
        if (jogarComTempo == true)     { barraTempo.SetActive (true); }

        percTempo = ((tempTime - tempoResponder) / tempoResponder) * -1;

        if (percTempo < 0) { percTempo = 0; }

        barraTempo.transform.localScale = new Vector3 (percTempo, 1, 1);
    }

    // FUNÇÃO RESPONSÁVEL POR CALCULAR A NOTA FINAL DO TESTE
    void    calcularNotaFinal()
    {
        testeFinalizado = true;
        notaFinal       = Mathf.RoundToInt(valorQuestao * qtdAcertos);              

//===================================================================================================================================

        notaPerguntas   = Mathf.RoundToInt(qtdRespondida + TInotaPerguntas);                                            //PAINEL RESULTADO
        notaAcertos     = Mathf.RoundToInt(qtdAcertos + TInotaAcertos);
        notaErros       = Mathf.RoundToInt (notaPerguntas - notaAcertos);
        notaPorcentagem = Mathf.RoundToInt (notaAcertos * porcentagem / notaPerguntas);
//===================================================================================================================================

//===================================================================================================================================
       
        PlayerPrefs.SetInt ("notaPerguntas_" + idTema.ToString(), (int)notaPerguntas);                                       //PAINEL RECORD
        PlayerPrefs.SetInt ("notaAcertos_" + idTema.ToString(), (int)notaAcertos);
        PlayerPrefs.SetInt ("notaErros_" + idTema.ToString(), (int)notaErros);
        PlayerPrefs.SetInt ("notaPorcentagem_" + idTema.ToString(), (int)notaPorcentagem);
//===================================================================================================================================

        if (notaFinal > PlayerPrefs.GetInt ("notaFinal_" + idTema.ToString())) 
        { 
            PlayerPrefs.SetInt ("notaFinal_" + idTema.ToString(), (int)notaFinal);
        }


        if(notaFinal == 10) { nEstrelas = 10; soundController.playVinheta(); }
        else if(notaFinal >= notaMin10Estrelas) { nEstrelas = 10; }
        else if(notaFinal >= notaMin9Estrelas) { nEstrelas = 9; }
        else if(notaFinal >= notaMin8Estrelas) { nEstrelas = 8; }
        else if(notaFinal >= notaMin7Estrelas) { nEstrelas = 7; }
        else if(notaFinal >= notaMin6Estrelas) { nEstrelas = 6; }
        else if(notaFinal >= notaMin5Estrelas) { nEstrelas = 5; }
        else if(notaFinal >= notaMin4Estrelas) { nEstrelas = 4; }
        else if(notaFinal >= notaMin3Estrelas) { nEstrelas = 3; }
        else if(notaFinal >= notaMin2Estrelas) { nEstrelas = 2; }
        else if(notaFinal >= notaMin1Estrela) { nEstrelas = 1; }

        notaFinalTxt.text = notaFinal.ToString ();
//===================================================================================================================================

        notaPerguntasTxt.text = notaPerguntas.ToString();                                                            //PAINEL RESULTADO
        notaAcertosTxt.text = notaAcertos.ToString();
        notaErrosTxt.text = notaErros.ToString ();
        notaPorcentagemTxt.text = notaPorcentagem.ToString ();
//===================================================================================================================================
      
        notaFinalTxt.color = corMensagem[nEstrelas];
       
        msg1Txt.text = mensagem1 [nEstrelas];
        msg1Txt.color = corMensagem [nEstrelas];
        msg2Txt.text = mensagem2 [nEstrelas];

        foreach (GameObject e in estrela) 
        {
            e.SetActive (false);
        }

        for (int i = 0; i < nEstrelas; i++) 
        {
            estrela [i].SetActive (true);
        }

        paineis [0].SetActive (false);
        paineis [1].SetActive (true);
    }

    // CORROUTINE QUE FAZ A ANIMAÇÃO DE PISCAR DO BOTÃO DA ALTERNATIVA CORRETA
    IEnumerator    mostrarAlternativaCorreta()
    {
        for (int i = 0; i < qtdPiscar; i++) 
        {
            botoes[idBtnCorreto].image.color = corAcerto;
            yield return new WaitForSeconds(0.2f);
            botoes[idBtnCorreto].image.color = Color.white;
            yield return new WaitForSeconds(0.2f);
        }

        foreach(Button b in botoes) 
        {
            b.image.color = Color.white;
        }

        exibindoCorreta = false;
        proximaPergunta();
    }
}





 Script temaInfo.

Código:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class temaInfo : MonoBehaviour {

    private        soundController    soundController;
    private        temaScene        temaScene;

//=================================================================================================================================
    public static int TInotaPerguntas;                                                                                      //PAINEL SCKUL
    public static int TInotaAcertos;
//=================================================================================================================================

    [Header("Configuração do Tema")]
    public    int        idTema;
    public    string     nomeTema;
    public    Color    corTema;
    public    bool    requerNotaMinima;
    public    int     notaMinimaNecessaria;

    [Header("Configuração das Estrelas")]
    public    int     notaMin1Estrela;
    public    int     notaMin2Estrelas, notaMin3Estrelas, notaMin4Estrelas, notaMin5Estrelas, notaMin6Estrelas, notaMin7Estrelas, notaMin8Estrelas, notaMin9Estrelas;

//===================================================================================================================================
    private    int     notaAcertos;                                                                                        //PAINEL RECORD
    private    int     notaPerguntas, notaErros, notaPorcentagem;

//===================================================================================================================================
    [Header("Configuração do Botão")]
    public    Text            idTemaTxt;
    public    GameObject[]    estrela;
    private   int             notaFinal;

//===================================================================================================================================
    public    Text    notaAcertosTxt, notaPerguntasTxt, notaErrosTxt, notaPorcentagemTxt;                                      //PAINEL RECORD
//===================================================================================================================================
    private    Button             btnTema;


        // Use this for initialization

    void Start () {

//=================================================================================================================================

        TInotaPerguntas = PlayerPrefs.GetInt("notaPerguntas_" + idTema.ToString());                                       //PAINEL SCHULT
        TInotaAcertos     = PlayerPrefs.GetInt("notaAcertos_" + idTema.ToString());
//=================================================================================================================================

        soundController = FindObjectOfType(typeof(soundController)) as soundController;

        notaFinal = PlayerPrefs.GetInt("notaFinal_" + idTema.ToString());
        temaScene = FindObjectOfType (typeof(temaScene)) as temaScene;
        idTemaTxt.text = idTema.ToString();
//===================================================================================================================================

        notaAcertos             = PlayerPrefs.GetInt("notaAcertos_" + idTema.ToString());                                //PAINEL RECORD
        notaAcertosTxt.text     = notaAcertos.ToString();
        notaPerguntas           = PlayerPrefs.GetInt("notaPerguntas_" + idTema.ToString());

        notaPerguntasTxt.text     = notaPerguntas.ToString();
        notaErros                 = PlayerPrefs.GetInt("notaErros_" + idTema.ToString());                                            
        notaErrosTxt.text         = notaErros.ToString();
        notaPorcentagem           = PlayerPrefs.GetInt("notaPorcentagem_" + idTema.ToString());                                            
        notaPorcentagemTxt.text   = notaPorcentagem.ToString();
//===================================================================================================================================

        estrelas(); // CHAMA O MÉTODO ESTRELAS QUE CALCULA QUANTAS ESTRELAS GANHAMOS

        btnTema = GetComponent<Button>();

        verificarNotaMinima();
    }

    void    verificarNotaMinima()
    {
        btnTema.interactable = false;

        if(requerNotaMinima == true) 
        {
            int    notaTemaAnterior = PlayerPrefs.GetInt("notaFinal_" + (idTema - 1).ToString());
           
        if (notaTemaAnterior >= notaMinimaNecessaria) 
            {
                btnTema.interactable = true;    
            }
        } 
        else 
        {
            btnTema.interactable = true;
        }
    }

    public    void    selecionarTema()
    {
        soundController.playButton();

        temaScene.nomeTemaTxt.text = nomeTema;
        temaScene.nomeTemaTxt.color = corTema;

        PlayerPrefs.SetInt("idTema", idTema);                
        PlayerPrefs.SetString("nomeTema", nomeTema);
        PlayerPrefs.SetInt("notaMin1Estrela", notaMin1Estrela);
        PlayerPrefs.SetInt("notaMin2Estrelas", notaMin2Estrelas);
        PlayerPrefs.SetInt("notaMin3Estrelas", notaMin3Estrelas);
        PlayerPrefs.SetInt("notaMin4Estrelas", notaMin4Estrelas);
        PlayerPrefs.SetInt("notaMin5Estrelas", notaMin5Estrelas);
        PlayerPrefs.SetInt("notaMin6Estrelas", notaMin6Estrelas);
        PlayerPrefs.SetInt("notaMin7Estrelas", notaMin7Estrelas);
        PlayerPrefs.SetInt("notaMin8Estrelas", notaMin8Estrelas);
        PlayerPrefs.SetInt("notaMin9Estrelas", notaMin9Estrelas);

        temaScene.btnJogar.interactable = true;
    }
    public    void    estrelas()
    {
        foreach (GameObject e in estrela) 
        {
           e.SetActive (false);
        }
        int    nEstrelas = 0;


        if(notaFinal == 10) { nEstrelas = 10; }
        else if(notaFinal >= notaMin9Estrelas) { nEstrelas = 9; }
        else if(notaFinal >= notaMin8Estrelas) { nEstrelas = 8; }
        else if(notaFinal >= notaMin7Estrelas) { nEstrelas = 7; }
        else if(notaFinal >= notaMin6Estrelas) { nEstrelas = 6; }
        else if(notaFinal >= notaMin5Estrelas) { nEstrelas = 5; }
        else if(notaFinal >= notaMin4Estrelas) { nEstrelas = 4; }
        else if(notaFinal >= notaMin3Estrelas) { nEstrelas = 3; }
        else if(notaFinal >= notaMin2Estrelas) { nEstrelas = 2; }
        else if(notaFinal >= notaMin1Estrela) { nEstrelas = 1; }

        for (int i = 0; i < nEstrelas; i++) 
        {
            estrela [i].SetActive (true);
        }
    }
      

}





Na parte onde está:

Código:

// FUNÇÃO RESPONSÁVEL POR PROCESSAR A BARRA infoResposta(respondendo 1 de 25 perguntas).
        qtdRespondida += 1;
        totalAmmount += 1;

Coloque a variável junto com a quantidade de perguntas respondidas e apenas não zere ela, que conforme tu for jogando ela vai acumulando...

recagonlei escreveu:Na parte onde está:

Código:

// FUNÇÃO RESPONSÁVEL POR PROCESSAR A BARRA infoResposta(respondendo 1 de 25 perguntas).
        qtdRespondida += 1;
        totalAmmount += 1;

Coloque a variável junto com a quantidade de perguntas respondidas e apenas não zere ela, que conforme tu for jogando ela vai acumulando...

Desculpa mano sou muito noob ainda "apenas não zere ela", como faço isso. Não entendi!

oilson escreveu:

recagonlei escreveu:Na parte onde está:

Código:

// FUNÇÃO RESPONSÁVEL POR PROCESSAR A BARRA infoResposta(respondendo 1 de 25 perguntas).
        qtdRespondida += 1;
        totalAmmount += 1;

Coloque a variável junto com a quantidade de perguntas respondidas e apenas não zere ela, que conforme tu for jogando ela vai acumulando...

Desculpa mano sou muito noob ainda "apenas não zere ela", como faço isso. Não entendi!

Essa variável qtdRespondida é zerada toda vez que inicia de novo, não é? Não volta no valor zero? Só não fazer o mesmo com o outro valor, que no caso não é alterado caso não for mexido, apenas deixe-o assim...

recagonlei escreveu:

oilson escreveu:

recagonlei escreveu:Na parte onde está:

Código:

// FUNÇÃO RESPONSÁVEL POR PROCESSAR A BARRA infoResposta(respondendo 1 de 25 perguntas).
        qtdRespondida += 1;
        totalAmmount += 1;

Coloque a variável junto com a quantidade de perguntas respondidas e apenas não zere ela, que conforme tu for jogando ela vai acumulando...

Desculpa mano sou muito noob ainda "apenas não zere ela", como faço isso. Não entendi!

Essa variável qtdRespondida é zerada toda vez que inicia de novo, não é? Não volta no valor zero? Só não fazer o mesmo com o outro valor, que no caso não é alterado caso não for mexido, apenas deixe-o assim...

Todas as duas estão zerando e começando do zero de novo. Toda vez que vou jogar um outro tema ou fecho o jogo e começo de novo.

Você deve declarar essa variável em um script que seja o principal, que será declarado apenas uma vez, não em cada tema... E depois acessado pelos temas que atualizam o valor e depois salve com o PlayerPrefs

recagonlei escreveu:Você deve declarar essa variável em um script que seja o principal, que será declarado apenas uma vez, não em cada tema... E depois acessado pelos temas que atualizam o valor e depois salve com o PlayerPrefs

 Maninho me diz uma coisa vc sabe se tem como na hora de salvar as informações com o PlayerPrefs. Eu pedir para ele verificar se tem algum valor lá, se tiver ele deve adicionar o valor ao que está lá e só depois grava?

Tipo isso:

Código:

 totalPerguntas = Mathf.RoundToInt(qtdRespondida); 

        if (totalPerguntas =< PlayerPrefs.GetInt ("totalPerguntas_" + idTema.ToString())) 
      //se totalPerguntas for igual ou menor que o valor que está salvo em totalPerguntas_
        { 
        totalPerguntas = PlayerPrefs.GetInt "totalPerguntas_" + qtdRespondida);
     //totalPerguntas será igual o valor que está salvo em PlayerPrefs.GetInt "totalPerguntas_" mais a qtdRespondida.

    //agora salve este calculo em:
         PlayerPrefs.SetInt ("totalPerguntas" + idTema.ToString(), (int)totalPerguntas);
        }



oilson escreveu:

recagonlei escreveu:Você deve declarar essa variável em um script que seja o principal, que será declarado apenas uma vez, não em cada tema... E depois acessado pelos temas que atualizam o valor e depois salve com o PlayerPrefs

 Maninho me diz uma coisa vc sabe se tem como na hora de salvar as informações com o PlayerPrefs. Eu pedir para ele verificar se tem algum valor lá, se tiver ele deve adicionar o valor ao que está lá e só depois grava?

Tipo isso:

Código:

 totalPerguntas = Mathf.RoundToInt(qtdRespondida); 

        if (totalPerguntas =< PlayerPrefs.GetInt ("totalPerguntas_" + idTema.ToString())) 
      //se totalPerguntas for igual ou menor que o valor que está salvo em totalPerguntas_
        { 
        totalPerguntas = PlayerPrefs.GetInt "totalPerguntas_" + qtdRespondida);
     //totalPerguntas será igual o valor que está salvo em PlayerPrefs.GetInt "totalPerguntas_" mais a qtdRespondida.

    //agora salve este calculo em:
         PlayerPrefs.SetInt ("totalPerguntas" + idTema.ToString(), (int)totalPerguntas);
        }



Faça o calculo dessa maneira:

Código:

        totalPerguntas = PlayerPrefs.GetInt ("totalPerguntas_" + idTema.ToString()) + qtdRespondida);

MUITO obrigado galera pelo apoio, principalmente para o ""recagonlei"" pela paciência que teve, segui as dicas e consegui resolver o problema. Vc são d+.... Se fossem mulheres eu daria um beijo em cada uma de gratis....kkkkk , mas como são machos perderam... Quem sabe na próxima vida.