446 lines
17 KiB
C#
446 lines
17 KiB
C#
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text.RegularExpressions;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
using UnityEngine.SceneManagement;
|
|
|
|
public class Quiz4Controller : MonoBehaviour {
|
|
|
|
// References to answers
|
|
private List<GameObject> answers;
|
|
|
|
// References to answers halo prefabs
|
|
private List<GameObject> answersHaloEffects;
|
|
|
|
public Text counterText;
|
|
|
|
public Text scoreText;
|
|
|
|
public Text questionText;
|
|
|
|
public Button btnNextQuestion;
|
|
|
|
public GameObject haloEffect;
|
|
|
|
public GameObject[] answerModels;
|
|
|
|
private int scoreValue;
|
|
|
|
private int questionIdx = 0;
|
|
|
|
private const int initialScore = 0;
|
|
|
|
private const int numberOfAnswers = 4;
|
|
|
|
private const int scoreCorrectAnswer = 10;
|
|
|
|
private const int scoreIncorrectAnswer = -10;
|
|
|
|
private const int scoreForProfessorAtom = 10;
|
|
|
|
private const float counterInitialValue = 90;
|
|
|
|
private const float counterDisplayAnswersInitialValue = 1.5f;
|
|
|
|
private float counterValue;
|
|
|
|
private float counterDisplayAnswersValue;
|
|
|
|
private bool counterDisplayAnswersStarted = false;
|
|
|
|
// List of selected answers
|
|
private List<int> selectedAnswers;
|
|
|
|
// List of questions and correct answers
|
|
List<Question> questions = new List<Question>() {
|
|
new Question("1. Neki od ovih prozora imaju 2-3 puta manje toplotnih gubitaka za razliku od drugih, koji su to?", new int[] {1, 4},
|
|
new Answer[] {
|
|
new Answer(AnswerObjectModel.NOVI_PROZOR, "Novi prozor"),
|
|
new Answer(AnswerObjectModel.STARI_PROZOR, "Stari prozor"),
|
|
new Answer(AnswerObjectModel.SLOMLJENI_PROZOR, "Slomljeni prozor"),
|
|
new Answer(AnswerObjectModel.PROZOR_SA_ROLETNOM, "Prozor sa roletnom")}),
|
|
new Question("2. Na jedan od načina možete uštedjeti i do 10 litara vode po osobi dnevno, uz koji predmet?", new int[] {3, 4},
|
|
new Answer[] {
|
|
new Answer(AnswerObjectModel.UPALJENA_CESMA, "Upaljena česma"),
|
|
new Answer(AnswerObjectModel.PROZOR_SA_ROLETNOM, "Spuštene roletne"),
|
|
new Answer(AnswerObjectModel.UGASENA_CESMA, "Ugašena česma"),
|
|
new Answer(AnswerObjectModel.PROFESOR_ATOM_10, "Profesor Atom +10")}),
|
|
new Question("3. Korištenjem jednog od sljedećih predmeta, u svjetlost se pretvara svega 5% uložene energije, dok se ostatak pretvara u toplotu, koji je to?", new int[] {1},
|
|
new Answer[]{
|
|
new Answer(AnswerObjectModel.ZARNA_SIJALICA, "Žarne sijalice"),
|
|
new Answer(AnswerObjectModel.BICIKLO, "Biciklo"),
|
|
new Answer(AnswerObjectModel.VENTILATOR, "Ventilator"),
|
|
new Answer(AnswerObjectModel.KANTA_ZA_RECIKLIRANJE, "Kanta za recikliranje")}),
|
|
new Question("4. Neki od navedenih predmeta uključeni u utičnicu, iako nisu u u funkciji, i dalje se znatno griju i troše električnu energiju.", new int[] {3},
|
|
new Answer[]{
|
|
new Answer(AnswerObjectModel.NOVI_PROZOR, "Prozor"),
|
|
new Answer(AnswerObjectModel.KLIMA, "Klima"),
|
|
new Answer(AnswerObjectModel.ADAPTER, "Adapter"),
|
|
new Answer(AnswerObjectModel.MASINA_ZA_VES, "Veš mašina")}),
|
|
new Question("5. Šta možemo ugraditi na radijatore da nam pomogne smanjiti troškove grijanja za 7-15%?", new int[] {1, 3},
|
|
new Answer[]{
|
|
new Answer(AnswerObjectModel.TERMOSTAT_25, "Termostat"),
|
|
new Answer(AnswerObjectModel.PREKIDAC_ZA_SVJETLO, "Prekidač za svjetlo"),
|
|
new Answer(AnswerObjectModel.PROFESOR_ATOM_10, "Profesor Atom +10"),
|
|
new Answer(AnswerObjectModel.ADAPTER, "Adapter")}),
|
|
new Question("6. Ako je vani temperatura 33°C, koja je optimalna temperatura u kući? ", new int[] {4},
|
|
new Answer[]{
|
|
new Answer(AnswerObjectModel.KUCICA_17, "Kućica 17°C"),
|
|
new Answer(AnswerObjectModel.KUCICA_22, "Kućica 22°C"),
|
|
new Answer(AnswerObjectModel.KUCICA_33, "Kućica 33°C"),
|
|
new Answer(AnswerObjectModel.KUCICA_26, "Kućica 26°C")}),
|
|
new Question("7. Kakvim načinom pranja posuđa, i uz koji uređaj od navedenih, trošimo 60% manje električne energije i do 85% manje vode?", new int[] {2, 3},
|
|
new Answer[]{
|
|
new Answer(AnswerObjectModel.RUCNO_PRANJE_SUDJA, "Ručno pranje suđa"),
|
|
new Answer(AnswerObjectModel.MASINA_ZA_SUDJE, "Pranje u mašini za suđe"),
|
|
new Answer(AnswerObjectModel.PROFESOR_ATOM_10, "Profesor Atom +10"),
|
|
new Answer(AnswerObjectModel.STRIK, "Štrik")}),
|
|
new Question("8. Koji uređaj u «stand by» načinu rada troši i do 24% energije u odnosu na potrošnju energije kada je upaljen?", new int[] {4},
|
|
new Answer[]{
|
|
new Answer(AnswerObjectModel.RADIJATOR, "Radijator"),
|
|
new Answer(AnswerObjectModel.VENTILATOR, "Ventilator"),
|
|
new Answer(AnswerObjectModel.BICIKLO, "Biciklo"),
|
|
new Answer(AnswerObjectModel.TELEVIZOR, "Televizor")}),
|
|
new Question("9. Jednom godišnje stručna osoba treba provjeriti prohodnost čega? Loša prohodnost doprinosi većoj potrošnji energije za grijanje.", new int[] {1},
|
|
new Answer[]{
|
|
new Answer(AnswerObjectModel.DIMNJAK, "Dimnjak"),
|
|
new Answer(AnswerObjectModel.AUTO, "Auto"),
|
|
new Answer(AnswerObjectModel.NOVI_PROZOR, "Prozor"),
|
|
new Answer(AnswerObjectModel.UPALJENA_CESMA, "Česma sa vodom")}),
|
|
new Question("10. Uvijek odaberite program s najnižom temperaturom vode koji još uvijek obezbjeđuje dobar kvalitet pranja, za šta od navedenog? ", new int[] {1, 4},
|
|
new Answer[]{
|
|
new Answer(AnswerObjectModel.PROFESOR_ATOM_10, "Profesor Atom +10"),
|
|
new Answer(AnswerObjectModel.STRIK, "Štrik"),
|
|
new Answer(AnswerObjectModel.RUCNO_PRANJE_VESA, "Pranje na ruke"),
|
|
new Answer(AnswerObjectModel.MASINA_ZA_VES, "Mašina za veš")})
|
|
};
|
|
|
|
// Positions for answers 1, 2, 3 and 4
|
|
private Vector3[] answerPositions = new Vector3[]
|
|
{
|
|
new Vector3(-10, 10, -5),
|
|
new Vector3(-10, 5, -7),
|
|
new Vector3(10, 5, -7),
|
|
new Vector3(10, 10, -5)
|
|
};
|
|
|
|
private Vector3 answerScale = new Vector3(0.15f, 0.15f, 0.15f);
|
|
|
|
/// <summary>
|
|
/// Use this for initialization
|
|
/// </summary>
|
|
void Start () {
|
|
scoreValue = initialScore;
|
|
UpdateScore(true);
|
|
questionIdx = 0;
|
|
// Set counter to 90s
|
|
counterValue = counterInitialValue;
|
|
UpdateCounter();
|
|
|
|
selectedAnswers = new List<int>();
|
|
answersHaloEffects = new List<GameObject>();
|
|
answers = new List<GameObject>();
|
|
|
|
// Instantiate answers and halo effects
|
|
InstantiateAnswers();
|
|
InstantiateHaloPrefabs();
|
|
|
|
UpdateScene();
|
|
btnNextQuestion.GetComponent<Button>().onClick.AddListener(LoadNextQuestion);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// // Update is called once per frame
|
|
/// </summary>
|
|
void Update()
|
|
{
|
|
if (counterValue > 0)
|
|
{
|
|
// We pause timer to show correct answers
|
|
/*
|
|
if (!counterDisplayAnswersStarted)
|
|
{
|
|
counterValue -= Time.deltaTime;
|
|
UpdateCounter();
|
|
}*/
|
|
|
|
counterValue -= Time.deltaTime;
|
|
UpdateCounter();
|
|
}
|
|
else
|
|
{
|
|
if (questionIdx == questions.Count)
|
|
{
|
|
SceneManager.LoadScene("EntryScene");
|
|
return;
|
|
}
|
|
else
|
|
LoadNextQuestion();
|
|
}
|
|
if (counterDisplayAnswersValue > 0 && counterDisplayAnswersStarted)
|
|
counterDisplayAnswersValue -= Time.deltaTime;
|
|
else
|
|
{
|
|
if (questionIdx == questions.Count)
|
|
{
|
|
SceneManager.LoadScene("EntryScene");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
UpdateScene();
|
|
counterDisplayAnswersStarted = false;
|
|
}
|
|
}
|
|
|
|
// Select answers event handler
|
|
if (Input.GetMouseButtonDown(0))
|
|
{
|
|
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
|
|
RaycastHit hit;
|
|
|
|
if (Physics.Raycast(ray, out hit, 100))
|
|
{
|
|
if (counterDisplayAnswersStarted)
|
|
return;
|
|
Debug.Log(hit.transform.gameObject.name);
|
|
// answerArrayIdx: [1, 40]
|
|
int answerArrayIdx = GetAnswerIdx(hit.transform.gameObject.name);
|
|
// answerIdx: [1, 4]
|
|
int answerIdx = answerArrayIdx - numberOfAnswers * questionIdx;
|
|
// Answer not selected - select it
|
|
if (!selectedAnswers.Contains(answerIdx))
|
|
{
|
|
SetGlowEffect(answerArrayIdx, true);
|
|
selectedAnswers.Add(answerIdx);
|
|
}
|
|
// Answer selected - unselect it
|
|
else
|
|
{
|
|
SetGlowEffect(answerArrayIdx, false);
|
|
selectedAnswers.Remove(answerIdx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds Halo prefabs to all answers
|
|
/// </summary>
|
|
private void InstantiateHaloPrefabs()
|
|
{
|
|
for (int i = 0; i < answers.Count; i++)
|
|
{
|
|
GameObject answerPrefab = Instantiate(haloEffect) as GameObject;
|
|
answerPrefab.SetActive(false);
|
|
answerPrefab.transform.SetParent(answers[i].transform, false);
|
|
answersHaloEffects.Add(answerPrefab);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Instantiates all answer objects
|
|
/// </summary>
|
|
private void InstantiateAnswers()
|
|
{
|
|
for(int qIdx = 0; qIdx < questions.Count; ++qIdx)
|
|
{
|
|
for(int ansIdx = 0; ansIdx < numberOfAnswers; ++ansIdx)
|
|
{
|
|
Answer ans = questions[qIdx].getPossibleAnswers()[ansIdx];
|
|
string answerName = "Answer" + (qIdx * numberOfAnswers + ansIdx + 1).ToString();
|
|
InstantiateAnswerObject(answerName, ansIdx, ans.getAnswerModel(), ans.getAnswerCaption());
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Instantiates answer object according to its type and sets its transform
|
|
/// </summary>
|
|
/// <param name="answerName"></param>
|
|
/// <param name="answerIdx"></param>
|
|
/// <param name="model"></param>
|
|
/// <param name="answerCaption"></param>
|
|
private void InstantiateAnswerObject(string answerName, int answerIdx, AnswerObjectModel model, string answerCaption)
|
|
{
|
|
GameObject answerGameObject = Instantiate(answerModels[(int)model]) as GameObject;
|
|
answerGameObject.SetActive(true);
|
|
answerGameObject.name = answerName;
|
|
answerGameObject.transform.position = answerPositions[answerIdx];
|
|
answerGameObject.transform.localScale = answerScale;
|
|
answerGameObject.GetComponent<ObjectController>().modelCaption.text = answerCaption;
|
|
answers.Add(answerGameObject);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Next question btn click event handler
|
|
/// </summary>
|
|
void LoadNextQuestion()
|
|
{
|
|
if (counterDisplayAnswersStarted)
|
|
return;
|
|
|
|
UpdateScore();
|
|
selectedAnswers.Clear();
|
|
ClearCurrentSceneGlowEffect();
|
|
// Start display answers counter
|
|
counterDisplayAnswersValue = counterDisplayAnswersInitialValue;
|
|
counterDisplayAnswersStarted = true;
|
|
ShowAnswers();
|
|
questionIdx = questionIdx + 1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates score value
|
|
/// </summary>
|
|
private void UpdateScore(bool initialization = false)
|
|
{
|
|
if (!initialization)
|
|
{
|
|
scoreValue += GetScore();
|
|
if (scoreValue < 0)
|
|
scoreValue = 0;
|
|
}
|
|
scoreText.text = scoreValue.ToString("D3");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates counter value - called from Update() method
|
|
/// </summary>
|
|
private void UpdateCounter()
|
|
{
|
|
counterText.text = counterValue.ToString("f0");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shows correct answers
|
|
/// </summary>
|
|
private void ShowAnswers()
|
|
{
|
|
for(int i = numberOfAnswers * questionIdx; i < numberOfAnswers * (questionIdx + 1); i++)
|
|
{
|
|
MarkAnswer(questions[questionIdx].getCorrectAnswers().Contains(i - questionIdx * numberOfAnswers + 1), i);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates scene with new question and related answers
|
|
/// </summary>
|
|
private void UpdateScene()
|
|
{
|
|
RemoveMarks();
|
|
// Set new question
|
|
questionText.text = questions[questionIdx].getQuestionText();
|
|
// Set answers for selected question
|
|
for(int i = 0; i < answers.Count; i++)
|
|
{
|
|
if (i >= numberOfAnswers * questionIdx && i < numberOfAnswers * (questionIdx + 1))
|
|
{
|
|
answers[i].SetActive(true);
|
|
}
|
|
else
|
|
answers[i].SetActive(false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hides correct/incorrect images for currently shown answers
|
|
/// </summary>
|
|
private void RemoveMarks()
|
|
{
|
|
for(int i = 0; i < numberOfAnswers; i++) {
|
|
int answerIdx = questionIdx * numberOfAnswers + i;
|
|
answers[answerIdx].GetComponent<ObjectController>().imageCorrect.enabled = false;
|
|
answers[answerIdx].GetComponent<ObjectController>().imageIncorrect.enabled = false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets visibility of correct/incorrect overlay images
|
|
/// </summary>
|
|
/// <param name="isCorrect"></param>
|
|
/// <param name="idx"></param>
|
|
private void MarkAnswer(bool isCorrect, int idx)
|
|
{
|
|
answers[idx].GetComponent<ObjectController>().imageCorrect.enabled = isCorrect;
|
|
answers[idx].GetComponent<ObjectController>().imageIncorrect.enabled = !isCorrect;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clears glow from all currently shown answers
|
|
/// </summary>
|
|
private void ClearCurrentSceneGlowEffect()
|
|
{
|
|
for (int i = 0; i < numberOfAnswers; i++)
|
|
{
|
|
int prefabIdx = questionIdx * numberOfAnswers + i;
|
|
answersHaloEffects[prefabIdx].SetActive(false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clears/Adds glow from a specific answer GameObject
|
|
/// </summary>
|
|
/// <param name="prefabIdx"></param>
|
|
private void SetGlowEffect(int prefabIdx, bool showGlowEffect)
|
|
{
|
|
answersHaloEffects[prefabIdx - 1].SetActive(showGlowEffect);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns answer index (X) from answer's name (AnswerX)
|
|
/// </summary>
|
|
/// <param name="gameObjName">GameObject's name</param>
|
|
/// <returns></returns>
|
|
private int GetAnswerIdx(string gameObjName)
|
|
{
|
|
string resultString = Regex.Match(gameObjName, @"\d+").Value;
|
|
return System.Int32.Parse(resultString);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns score for a particular question
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private int GetScore() {
|
|
int score = 0;
|
|
// Correct answers
|
|
int[] correctAnswers = questions[questionIdx].getCorrectAnswers();
|
|
// Selected answers: selectedAnswers
|
|
for (int ansIdx = 1; ansIdx <= numberOfAnswers; ++ansIdx)
|
|
{
|
|
// Correct and selected
|
|
if (correctAnswers.Contains(ansIdx) && selectedAnswers.Contains(ansIdx))
|
|
score += scoreCorrectAnswer;
|
|
// Correct and not selected
|
|
else if (correctAnswers.Contains(ansIdx) && !selectedAnswers.Contains(ansIdx))
|
|
score += scoreIncorrectAnswer;
|
|
// Incorrect and selected
|
|
else if (!correctAnswers.Contains(ansIdx) && selectedAnswers.Contains(ansIdx))
|
|
score += scoreIncorrectAnswer;
|
|
// Incorrect and not selected
|
|
else
|
|
score += scoreCorrectAnswer;
|
|
}
|
|
int profAtomIdx = questions[questionIdx].getProfessorAtomIdx();
|
|
if (profAtomIdx != -1 && selectedAnswers.Contains(profAtomIdx))
|
|
score += scoreForProfessorAtom;
|
|
return score;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compares selected answers with correct answers
|
|
/// </summary>
|
|
/// <param name="selectedAnswers">List of selected answers</param>
|
|
/// <param name="correctAnswers">Array of correct answers</param>
|
|
/// <returns></returns>
|
|
private bool IsAnswerCorrect(List<int> selectedAnswers, int[] correctAnswers)
|
|
{
|
|
HashSet<int> correctAnswersSet = new HashSet<int>(new List<int>(correctAnswers));
|
|
return correctAnswersSet.SetEquals(selectedAnswers);
|
|
}
|
|
|
|
}
|