// Start is called before the first frame update
void Start()
{
ScenesMaintenerController.Instance.playMainThirdSound();
NucleoController nucleo = NucleoController.instance();
Jogador jogador;
GameObject player;
if (int.Parse(nucleo.jogadores[0].getPontuacao()) >
int.Parse(nucleo.jogadores[1].getPontuacao()))
{
player = playerUm;
jogador = nucleo.jogadores[0];
}
else
{
player = playerDois;
jogador = nucleo.jogadores[1];
}
player = Instantiate(player.gameObject) as GameObject;
player.transform.SetParent(recipiente, false);
player.GetComponent <RectTransform>().localScale = new Vector3(1.5f, 1.5f, 0);
player.GetComponent <RectTransform>().anchoredPosition = new Vector3(0, 100, 0);
player.GetComponent <RectTransform>().Find("Pontos").GetComponent <Text>().text = jogador.getPontuacao();
player.GetComponent <RectTransform>().Find("Tempo").GetComponent <Text>().text = jogador.getTempo();
}
public void umJogador()
{
Jogador jogadorUm = new Jogador(0, 0, "Lomonosov");
NucleoController.instance().jogadores.Add(jogadorUm);
SceneManager.LoadScene(5);
}
public void sendResult()
{
maintenerInstance.stopBalanceamentoSound();
((Clock)clock.GetComponent("Clock")).stopClock();
NucleoController nucleo = NucleoController.instance();
nucleo.rodada++;
ResultScreen.SetActive(true);
if (verifyResult())
{
ResultScreen.GetComponent <ResultScreen>().showBlast();
Debug.Log(tempoJogada);
Debug.Log(NucleoController.preferences["TempoConfiguracao"].getInt());
Debug.Log(((((int)tempoJogada) * 100 / NucleoController.preferences["TempoConfiguracao"].getInt())));
int valorPercentual = 100 - ((((int)tempoJogada) * 100 / NucleoController.preferences["TempoConfiguracao"].getInt()));
Debug.Log(valorPercentual);
int valorPontuado = (nucleo.pontuacaoAcerto * valorPercentual / 100) + 5;
arrumarEstrelas(valorPercentual);
placarTexto.text = valorPontuado + "";
nucleo.jogadores[nucleo.jogada].addPontuacao(valorPontuado);
tituloResposta.text = "Parabéns!";
maintenerInstance.playAcertouSound();
}
else
{
maintenerInstance.playErrouSound();
tituloResposta.text = "Errou!";
placarTexto.text = nucleo.pontuacaoErro + "";
nucleo.jogadores[nucleo.jogada].addPontuacao(nucleo.pontuacaoErro);
}
tempoJogada = 0;//zerou o tempo para ser usado na contagem da tela de resultado
}
// Start is called before the first frame update
void Start()
{
//define quem é o jogador atual, que será instanciado no centro da tela de resultado
if (NucleoController.instance().jogada == 0)
{
currentPlayer = playerUm;
current = 0;
}
else
{
currentPlayer = playerDois;
current = 1;
}
currentPlayer = Instantiate(currentPlayer.gameObject) as GameObject;
currentPlayer.transform.SetParent(screen, false);
currentPlayer.GetComponent <RectTransform>().anchorMin = new Vector2(0.5f, 0.5f);
currentPlayer.GetComponent <RectTransform>().anchorMax = new Vector2(0.5f, 0.5f);
currentPlayer.GetComponent <RectTransform>().anchoredPosition = new Vector3(0, 0, 0);
currentPlayer.GetComponent <RectTransform>().localScale = new Vector3(1.5f, 1.5f, 0);
scoreText = currentPlayer.GetComponent <RectTransform>().Find("Pontos").GetComponent <Text>();
scoreText.text = NucleoController.instance().jogadores[current].getPontuacao();
timeText = currentPlayer.GetComponent <RectTransform>().Find("Tempo").GetComponent <Text>();
timeText.text = NucleoController.instance().jogadores[current].getTempo();
}
private bool verifyOver()
{
if (NucleoController.instance().rodada <= NucleoController.preferences["TurnoConfiguracao"].getInt())
{
return(false);
}
return(true);
}
// Start is called before the first frame update
void Start()
{
//Debug.Log(Application.persistentDataPath);
//Molecula.ImprimirMoleculas();
Equacao.ImprimirEquacoes();
NucleoController.instance().restartAll();
ScenesMaintenerController.Instance.stopAllSounds("music2");
ScenesMaintenerController.Instance.playMainSound();
ScenesMaintenerController.Instance.playBubbleSound();
}
public void doisJogadores()
{
Jogador jogadorUm = new Jogador(0, 0, "Lomonosov");
NucleoController.instance().jogadores.Add(jogadorUm);
Jogador jogadorDois = new Jogador(0, 0, "Lavoisier");
NucleoController.instance().jogadores.Add(jogadorDois);
SceneManager.LoadScene(5);
}
private void adjustSufix()
{
if (int.Parse(NucleoController.instance().jogadores[0].getPontuacao()) < 20)
{
sufix.text = "Não foi desta vez, você precisa estudar mais.";
}
else if (int.Parse(NucleoController.instance().jogadores[0].getPontuacao()) < 50)
{
sufix.text = "Está pegando o jeito!";
}
else
{
sufix.text = "Você arrasou!";
}
}
private void Update()
{
NucleoController nucleo = NucleoController.instance();
if (!ResultScreen.active) //antes da tela de resultado
{
tempoJogada += Time.deltaTime;
nucleo.jogadores[nucleo.jogada].addTempo(Time.deltaTime);
}
else//depois da tela de resultado
{
if (showStars())
{
tempoJogada += Time.deltaTime;
}
}
}
public void sendName()
{
try
{
List <Jogador> jogadores = NucleoController.instance().jogadores;
verifyName();
saveAndContinue();
}
catch (ArgumentException e)
{
inputText.placeholder.GetComponent <Text>().text = e.Message;
inputText.GetComponent <RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, 509.1f);
inputText.placeholder.GetComponent <Text>().color = new Color(255, 0, 0, 128);
Console.WriteLine(e);
}
}
private void saveAndContinue()
{
List <Jogador> jogadores = NucleoController.instance().jogadores;
//salva o jogador da tela atual
NucleoController.instance().salvarJogador(inputText.text);
//caso o array de jogadores seja maior que um, ele ira excluir o jogador atual e renderizar a mesma tela com o prox jogador
//decrementando o array de jogadores
if (jogadores.Count > 1)
{
jogadores.RemoveAt(0);
SceneManager.LoadScene(2);
}
else
{
SceneManager.LoadScene(3);
}
}
public void atualizarQuantidadesMoleculas()
{
List <AtomoQuantificado> atomos =
NucleoController.instance().currentEquation.quantidadeAtomosProduto();
int i = 0;
foreach (AtomoQuantificado produto in atomos)
{
initializeItemView(instancias[i], produto);
i++;
}
atomos = NucleoController.instance().currentEquation.quantidadeAtomosReagente();
foreach (AtomoQuantificado reagente in atomos)
{
initializeItemView(instancias[i], reagente);
i++;
}
}
// Start is called before the first frame update
void Start()
{
ScenesMaintenerController.Instance.playMainSound();
NucleoController nucleo = NucleoController.instance();
nucleo.zerarPontuacoes();
rodada.text = nucleo.rodada.ToString();
if (nucleo.jogadores.Count == 1)
{
jogadorUm = Instantiate(jogadorUm.gameObject) as GameObject;
jogadorUm.transform.SetParent(canvas, false);
jogadorUm.GetComponent <RectTransform>().anchoredPosition = new Vector3(0, 199, 0);
jogadorUm.GetComponent <RectTransform>().Find("Pontos").GetComponent <Text>().text = nucleo.jogadores[0].getPontuacao();
jogadorUm.GetComponent <RectTransform>().Find("Tempo").GetComponent <Text>().text = nucleo.jogadores[0].addTempo(Time.deltaTime);
}
else
{
jogadorUm = GameObject.Instantiate(jogadorUm.gameObject) as GameObject;
jogadorUm.transform.SetParent(canvas, false);
jogadorUm.GetComponent <RectTransform>().Find("Pontos").GetComponent <Text>().text = nucleo.jogadores[0].getPontuacao();
jogadorUm.GetComponent <RectTransform>().Find("Tempo").GetComponent <Text>().text = nucleo.jogadores[0].addTempo(Time.deltaTime);
jogadorDois = GameObject.Instantiate(this.jogadorDois.gameObject) as GameObject;
jogadorDois.transform.SetParent(canvas, false);
jogadorDois.GetComponent <RectTransform>().Find("Pontos").GetComponent <Text>().text = nucleo.jogadores[1].getPontuacao();
jogadorDois.GetComponent <RectTransform>().Find("Tempo").GetComponent <Text>().text = nucleo.jogadores[1].addTempo(Time.deltaTime);
}
if (nucleo.jogadores.Count == 1)
{
playerSelector.GetComponent <RectTransform>().anchoredPosition = new Vector3(0, 202, -1005.874f);
}
else if (nucleo.jogada == 0) //0 corresponde ao jogador um
{
playerSelector.GetComponent <RectTransform>().anchoredPosition = new Vector3(-215, 202, -1005.874f);
}
else
{
playerSelector.GetComponent <RectTransform>().anchoredPosition = new Vector3(197, 202, -1005.874f);
}
}
public void continuar()
{
NucleoController nucleo = NucleoController.instance();
if (!verifyOver())
{
if (nucleo.jogadores.Count > 1)
{
nucleo.passarJogada();
}
SceneManager.LoadScene(5);
}
else if (nucleo.jogadores.Count > 1)
{
SceneManager.LoadScene(7);
}
else
{
SceneManager.LoadScene(2);
}
}
private void Rotate()
{
roulette.GetComponent <Transform>().Rotate(0, 0, trueSpeed * Time.deltaTime);
if (speed > 0)
{
if (speed < 34)
{
moveSpinner(1);
}
else if (speed < 110)
{
moveSpinner(2);
}
else
{
moveSpinner(3);
}
if (speed % 11 == 0)
{
trueSpeed = speed;
}
}
else if (verifyStop())
{
moveSpinner(0);
isRotate = false;
trueSpeed = 0;
NucleoController nucleo = NucleoController.instance();
nucleo.executarAcao(verifyResult());
return;
}
else
{
speed = 11;
}
speed--;
}
public static void atualizarBalanco(String formuleName, int tipo, int value)
{
List <MoleculaForma> moleculas;
if (tipo == 0)
{
moleculas = NucleoController.instance().currentEquation.Produto;
}
else
{
moleculas = NucleoController.instance().currentEquation.Reagente;
}
foreach (var molecula in moleculas)
{
if (molecula.Molecula.moleculaParaInterface() == formuleName)
{
molecula.Balanco = value;
break;
}
}
eventSystem.GetComponent <MoleculeQuanityAdapter>().atualizarQuantidadesMoleculas();
}
private void adjustTitle()
{
congratulationsText.text = "Parabéns, " + NucleoController.instance().jogadores[0].Nome + "!\n" + congratulationsText.text;
}
private void OnDestroy()
{
NucleoController.instance().savePreferences();
}
private void iniciarQuantidadeMoleculas()
{
instanciarMoleculas(NucleoController.instance().currentEquation.quantidadeAtomosProduto(), produtos);
instanciarMoleculas(NucleoController.instance().currentEquation.quantidadeAtomosReagente(), reagentes);
}
void Start()
{
updateItens(NucleoController.instance().currentEquation);
}
private bool verifyResult()
{
return(NucleoController.instance().currentEquation.verificarResultado());
}