//Loop if we return true.
bool CheckMultiple(QuizButton button, int result)
{
bool dupes = false;
foreach (AdditionAnswer item in answers)
{
if (result == item.GetAnswer())
{
dupes = true;
}
}
//No duplicates.
if (dupes == false)
{
answersList.Add(result);
return(false);
}
//Duplicates, but too many to avoid getting more :(
if (answersList.Count >= button.enemyAnswerRange * 2)
{
return(false);
}
return(true);
}
string CreateCorrectAnswer(QuizButton a_running)
{
int numberOne;
int numberTwo;
numberOne = (int)Random.Range(a_running.minNumber, (a_running.maxNumber + 1));
int rand = Random.Range(0, (a_running.secondFixedNumber.Length));
numberTwo = a_running.secondFixedNumber[rand];
CorrectAnswer = numberOne * numberTwo;
//if Answer is too low/too high, or requires rounding to solve, we try again.
if (CorrectAnswer < a_running.minAnswer || CorrectAnswer > a_running.maxAnswer)
{
return(CreateCorrectAnswer(a_running));
}
AnswerList[0] = numberOne;
AnswerList[1] = numberTwo;
return("_ x _ = " + CorrectAnswer.ToString());
}
//Repeatedly run the Rounding function using different digit amounts.
bool PreventRounding(float[] a_numbers, QuizButton a_running, int a_answer)
{
float checkingAnswer = a_answer;
if (a_numbers[0] > a_answer)
{
checkingAnswer = a_numbers[0];
}
if (checkingAnswer > 1000)
{
if (Rounding(a_numbers, a_running.Operator, 1000))
{
return(true);
}
}
if (checkingAnswer > 100)
{
if (Rounding(a_numbers, a_running.Operator, 100))
{
return(true);
}
}
if (checkingAnswer > 10)
{
if (Rounding(a_numbers, a_running.Operator, 10))
{
return(true);
}
}
return(false);
}
internal void ready()
{
if (parent == null)
{
parent = FindObjectOfType <MonsterManager>();
}
button = parent.quizRunning;
container = button.parent;
if (!combatState)
{
combatState = FindObjectOfType <CombatStateManager>();
}
if (button.Operator > operators.Division)
{
if (!combatState.CanContinueFort(button.quizIndex + 1))
{
gameObject.SetActive(false);
return;
}
}
if (!button.Hard && button.quizIndex < (container.buttons.Length - 1))
{
gameObject.SetActive(true);
}
else
{
gameObject.SetActive(false);
}
}
void SetBoxes(QuizButton button)
{
int wrongAnswer = -8;
for (int i = 0; i < AnswerList.Length; i++)
{
wrongAnswer = -8;
if (AnswerList[i] < 0)
{
while (wrongAnswer <= 0 || !NoDuplicateInAnswers(wrongAnswer))
{
int range = (int)Random.Range(button.minNumber, button.maxNumber);
wrongAnswer = AnswerList[i] + range;
}
AnswerList[i] = wrongAnswer;
}
}
for (int i = 0; i < enemyChoices; i++)
{
int index = Random.Range(0, enemyChoices);
while (answers[index].boxAnswer > 0)
{
index = Random.Range(0, enemyChoices);
}
answers[index].SetAnswer(AnswerList[i]);
}
}
//Called by clicking on a button. Creates questions and loads them.
internal void StartLevel(QuizButton a_button)
{
monster.transform.position = initialPosition;
quizRunning = a_button; //The button selected will be used as the basis for calculation and creation.
stateManager.changeState(playStatus.playing);
fightingBoss = quizRunning.boss;
if (!quizRunning.boss)
{
currentEnemy = monster;
boss.gameObject.SetActive(false);
boss.DestroyMonster();
}
else
{
boss.gameObject.SetActive(true);
currentEnemy = boss;
boss.player = player;
boss.parent = this;
monster.DestroyMonster();
}
player.ResetPlayer(quizRunning.boss);
}
internal void GenerateMultiplication(QuizButton button, BossMonster a_boss)
{
if (button.enemyChoices < 2)
{
enemyChoices = 2;
}
else if (button.enemyChoices > 6)
{
enemyChoices = 6;
}
else
{
enemyChoices = button.enemyChoices;
}
ClearEverything();
if (!questionManager)
{
questionManager = FindObjectOfType <questionManager>();
}
questionManager.questionNeeded = CreateCorrectAnswer(button);
boss = a_boss;
SetBoxes(button);
}
/// <summary>
/// Fired when one of the quiz buttons is pressed. Check whether correct answer was selected, and set freezetime to allow for flag sliding animation.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ButtonPressed(object sender, EventArgs e)
{
QuizButton button = (QuizButton)sender;
foreach (QuizButton b in buttons)
{
b.CorrectAnswer = (b == Correct);
}
if (!button.CorrectAnswer)
{
Correct.Highlight();
}
else
{
ScoreFlag();
}
tracker.UpdateStreak(button.CorrectAnswer);
freezeTime = maxFreezeTime;
foreach (QuizButton b in buttons)
{
b.Selectable = false;
b.Hoverable = false;
}
if (currentQuestion >= QuestionCount)
{
EndQuiz();
}
}
internal void End(int earned)
{
winAnimation.GiveShards(earned);
list = FindObjectOfType <equipmentList>();
QuizButton button = monsterM.quizRunning;
int subject;
int index = button.quizIndex;
if ((int)button.Operator > (int)classType.Calculi)
{
subject = (int)classType.Calculi;
}
else
{
subject = (int)button.Operator;
}
int starsUnlocked = list.equip.StarsAcquired[((subject * 10) + index)];
if (button.boss)
{
foreach (Button item in stars)
{
item.gameObject.SetActive(false);
}
}
else
{
foreach (Button item in stars)
{
item.gameObject.SetActive(true);
}
}
stars[0].interactable = (starsUnlocked >= 1);
stars[1].interactable = (starsUnlocked >= 2);
stars[2].interactable = (starsUnlocked >= 3);
bronzeParticle.SetActive(stars[0].interactable);
silverParticle.SetActive(stars[1].interactable);
goldParticle.SetActive(stars[2].interactable);
if (shardsEarned)
{
shardsEarned.text = earned.ToString();
}
}
//Use our current star levels to light up stars, buttons.
public void CheckStars(QuizButton a_button)
{
if (!list)
{
list = FindObjectOfType <equipmentList>();
}
if ((int)a_button.Operator > (int)classType.Calculi)
{
currentSubject = classType.Calculi;
}
else
{
currentSubject = (classType)a_button.Operator;
}
SetupGroups((int)currentSubject);
starsUnlocked = list.equip.StarsAcquired[(((int)currentSubject * 10) + currentLevel)];
if (currentLevel == 4 || currentLevel == 9 || currentLevel == 14)
{
SetHardMode(false);
medal.gameObject.SetActive(true);
medal.SetChangingTalisman(list, talismanManager, currentSubject);
BossButton.gameObject.SetActive(true);
NormalMode.gameObject.SetActive(false);
HardButton.gameObject.SetActive(false);
starOne.gameObject.SetActive(false);
starTwo.gameObject.SetActive(false);
starThree.gameObject.SetActive(false);
bronzestarParticle.gameObject.SetActive(false);
silverstarParticle.gameObject.SetActive(false);
goldstarParticle.gameObject.SetActive(false);
return;
}
NormalMode.gameObject.SetActive(true);
BossButton.gameObject.SetActive(false);
medal.gameObject.SetActive(false);
HardButton.gameObject.SetActive(true);
starOne.gameObject.SetActive(true);
starTwo.gameObject.SetActive(true);
starThree.gameObject.SetActive(true);
starOne.interactable = (starsUnlocked >= 1);
starTwo.interactable = (starsUnlocked >= 2);
HardButton.interactable = ((starsUnlocked >= 2) && currentContainer.buttons[currentLevel].hardMode != null);
starThree.interactable = (starsUnlocked >= 3);
bronzestarParticle.SetActive(starOne.interactable);
silverstarParticle.SetActive(starTwo.interactable);
goldstarParticle.SetActive(starThree.interactable);
}
void MultipleAnswers(QuizButton a_running, float multiple)
{
SelectedAnswer = null;
submit.interactable = false;
DisableMultipleChoiceButtons();
MultipleBackground.SetActive(true);
TransitionButtons(true, a_running);
foreach (MultipleAnswer item in answers)
{
item.setAnswer(-1);
}
int index = Random.Range(0, 6);
answersList = new List <int>
{
enemyAnswerNeeded
};
if (a_running.enemyChoices > 6)
{
a_running.enemyChoices = 6;
}
if (Defend)
{
Defend.gameObject.SetActive(true);
}
answers[index].gameObject.SetActive(true);
answers[index].setAnswer(enemyAnswerNeeded);
for (int i = 1; i < a_running.enemyChoices; i++)
{
int wrongAnswer = -3;
while (wrongAnswer <= a_running.minAnswer || CheckMultiple(a_running, wrongAnswer))
{
int range = Random.Range(-a_running.enemyAnswerRange, a_running.enemyAnswerRange);
wrongAnswer = enemyAnswerNeeded + range;
}
index = Random.Range(0, 6);
while (answers[index].getAnswer() != -1)
{
index = Random.Range(0, 6);
}
answers[index].gameObject.SetActive(true);
answers[index].setAnswer(wrongAnswer);
}
}
internal void GenerateSubtraction(QuizButton button, float Health)
{
bossHealth = Health;
ClearEverything();
MakeQuestion(button, 0);
MakeQuestion(button, 1);
MakeQuestion(button, 2);
SetDraggerButtons();
}
internal void GenerateDivision(QuizButton button)
{
ClearEverything();
answers[0].GetComponentInChildren <Text>().text = MakeQuestion(button, 0);
answers[1].GetComponentInChildren <Text>().text = MakeQuestion(button, 1);
answers[2].GetComponentInChildren <Text>().text = MakeQuestion(button, 2);
SetDraggerButtons();
FindObjectOfType <questionManager>().questionNeeded = "";
}
void ShowQuestion()
{
for (int i = 0; i < roundList.Length; i++) // For every AnswerData in the current QuestionData...
{
GameObject quizButtonGameObject = quizbutonObjectPool.GetObject(); // Spawn an AnswerButton from the object pool
answerButtonGameObjects.Add(quizButtonGameObject);
quizButtonGameObject.transform.SetParent(quizButtonParent);
quizButtonGameObject.transform.localScale = Vector3.one;
QuizButton answerButton = quizButtonGameObject.GetComponent <QuizButton>();
answerButton.SetUp(roundList[i]); // Pass the AnswerData to the AnswerButton so the AnswerButton knows what text to display and whether it is the correct answer
}
}
void TransitionButtons(bool both, QuizButton a_Button = null)
{
if (transitionManager && PlayerPrefs.GetInt("Transitions", 1) == 1)
{
if (a_Button == null || a_Button.boss)
{
if (both)
{
calculator.SetActive(false);
}
else
{
calculator.SetActive(true);
}
transitionManager.TransitionContainers(TransitioningObjects.JustSwap);
return;
}
calculator.SetActive(true);
if (both)
{
transitionManager.TransitionContainers(TransitioningObjects.SwapToMultiple);
}
else
{
transitionManager.TransitionContainers(TransitioningObjects.SwapToCalculator);
}
}
else
{
DisableMultipleChoiceButtons();
foreach (MultipleAnswer item in answers)
{
item.gameObject.SetActive(false);
}
if (both)
{
calculator.SetActive(false);
}
else
{
calculator.SetActive(true);
}
}
}
//Uses given values to calculate a random sum and its components, then store and display them.
string MakeQuestion(QuizButton a_running, int index)
{
float numberRandom;
float numberEither;
numberRandom = (int)Random.Range(a_running.minNumber, (a_running.maxNumber + 1));
runningNumber = a_running.enemyChoices;
if (a_running.enemyChoices < 3)
{
runningNumber = 3;
}
else if (a_running.enemyChoices > 6)
{
runningNumber = 6;
}
int rand = Random.Range(0, (a_running.secondFixedNumber.Length));
numberEither = a_running.secondFixedNumber[rand];
float firstanswer = IsWhole(numberRandom / numberEither);
int answer = IsWhole(firstanswer);
//if Answer is too low/too high, or requires rounding to solve, we try again.
if (answer < a_running.minAnswer || !NoDuplicateInAnswers(answer) || answer > a_running.maxAnswer)
{
return(MakeQuestion(a_running, index));
}
AnswerList[index] = answer;
answers[index].SetAnswer(answer);
string answerWords;
answerWords = " ";
answerWords += numberRandom.ToString("F0");
answerWords += " ÷ " + numberEither.ToString("F0");
return(answerWords);
}
/// <summary>
/// Submit an answer.
/// Called by QuizButton script.
/// </summary>
/// <param name="qb"></param>
public void SubmitAnswer(QuizButton qb)
{
if (state == QuizState.AwaitingAnswer)
{
// Security check to make sure this button is relevant.
// E.g. the fourth button isn't relevant for a question with only three answers.
if ((buttons.IndexOf(qb) + 1) > currentQuestion.Answers.Count)
{
Debug.Log("Ignoring input from this button as no answer has been assigned.");
return;
}
qb.PlaySubmitSound();
state = QuizState.ShowingResult;
StartCoroutine(WaitRevealAnswer(buttons.IndexOf(qb)));
}
}
internal List <float> randomiseBODMASNumbers(QuizButton a_button)
{
int newop;
List <float> returning = new List <float>(a_button.variableCount);
switch (a_button.Operator)
{
case operators.AddSub:
//Randomise as many numbers as required, within range.
for (int i = 0; i < a_button.variableCount; i++)
{
if (a_button.Operator == operators.AddSub)
{
int test = (int)Random.Range(a_button.minNumber, (a_button.maxNumber));
returning.Add(test);
}
}
break;
case operators.AddSubMult:
newop = Random.Range(0, a_button.secondFixedNumber.Length);
returning.Add(a_button.secondFixedNumber[newop]);
newop = Random.Range(1, 12);
returning.Add(newop);
returning.Add((int)Random.Range(a_button.minNumber, (a_button.maxNumber + 1)));
break;
default:
returning.Add((int)Random.Range(a_button.minNumber, (a_button.maxNumber + 1)));
newop = Random.Range(0, a_button.secondFixedNumber.Length);
returning.Add(a_button.secondFixedNumber[newop]);
newop = Random.Range(1, 12);
returning.Add(newop);
newop = Random.Range(1, 12);
returning.Add(newop);
break;
}
return(returning);
}
internal bool SetMultiple(int answer, QuizButton a_running, float multiple, bool BossAttacking = false)
{
enemyAnswerNeeded = answer;
if (!BossAttacking)
{
if (attacks > 0)
{
attacking = false;
attacks--;
}
else
{
attacks = attacksPherPhase;
attacking = true;
}
}
else
{
attacking = false;
}
bool enemyPhase = false;
if (attacking)
{
enemyPhase = true;
attacks = attacksPherPhase;
MultipleAnswers(a_running, multiple);
}
else
{
enemyPhase = false;
attacks--;
TransitionButtons(false, a_running);
}
if (a_running)
{
player.SetTime(enemyPhase, a_running.enemPhaseTime);
}
player.EndTurn(enemyPhase);
return(enemyPhase);
}
//Uses given values to calculate a random sum and its components, then store and display them.
bool MakeQuestion(QuizButton a_running, int index)
{
if (a_running.enemyChoices < 2)
{
choices = 2;
}
else if (a_running.enemyChoices > 3)
{
choices = 3;
}
else
{
choices = a_running.enemyChoices;
}
int[] numberRandom = new int[2];
for (int i = 0; i < 2; i++)
{
numberRandom[i] = (int)Random.Range(a_running.minNumber, (a_running.maxNumber + 1));
}
int answer = numberRandom[0] - numberRandom[1];
//if Answer is too low/too high, or requires rounding to solve, we try again.
if (answer < a_running.minAnswer || !NoDuplicateInAnswers(answer) || answer > a_running.maxAnswer)
{
return(MakeQuestion(a_running, index));
}
answers[index] = answer;
string answerWords;
answerWords = " ";
answerWords += numberRandom[0].ToString("F0");
answerWords += "-" + numberRandom[1].ToString("F0");
questions[index] = answerWords;
return(true);
}
/// <summary>
/// Removes the flag at the end of the flag queue, adds a new flag and randomly selects new answers.
/// Move on to results screen if all questions have been answered
/// </summary>
private void NextFlag()
{
if (Correct != null)
{
AddRandomFlag();
}
SetFlagLocations();
currentQuestion++;
if (currentQuestion > QuestionCount)
{
return;
}
QuestionCounter.Text = currentQuestion + "/" + QuestionCount;
Correct = buttons[rng.Next(0, 4)];
List <Flag> choosenAnswers = new List <Flag>();
choosenAnswers.Add(GetCurrentFlag());
foreach (QuizButton b in buttons)
{
if (Correct == b)
{
b.Label.Text = GetCurrentFlag().Country;
}
else
{
Flag falseFlag;
do
{
falseFlag = Program.Flags.GetRandomFlag();
} while (choosenAnswers.Contains(falseFlag));
choosenAnswers.Add(falseFlag);
b.Label.Text = falseFlag.Country;
}
}
}
//Start playing with the button's level..
public void StartGame()
{
if (!HardMode)
{
currentContainer.buttons[currentLevel].buttonUsed(phases.next);
gameObject.SetActive(false);
}
else
{
QuizButton button = currentContainer.buttons[currentLevel].hardMode;
button.quizIndex = currentContainer.buttons[currentLevel].quizIndex;
if (button == null)
{
return;
}
button.Hard = true;
button.buttonUsed(phases.None);
gameObject.SetActive(false);
}
}
//Called from player if we won.
//If we won, 1 star.
//If we were at 100% health, 2 stars.
//If it was hardmode, 3.
public void SetStars(bool fullHealth, QuizButton a_button)
{
if (!list)
{
list = FindObjectOfType <equipmentList>();
}
if (a_button.boss)
{
return;
}
currentLevel = a_button.quizIndex;
if ((int)a_button.Operator > (int)classType.Calculi)
{
currentSubject = classType.Calculi;
}
else
{
currentSubject = (classType)a_button.Operator;
}
starsUnlocked = list.equip.StarsAcquired[(((int)currentSubject * 10) + currentLevel)];
if (starsUnlocked == 0)
{
starsUnlocked = 1;
}
if (fullHealth && starsUnlocked < 2)
{
starsUnlocked = 2;
}
if (a_button.Hard)
{
starsUnlocked = 3;
}
list.equip.StarsAcquired[(((int)currentSubject * 10) + currentLevel)] = starsUnlocked;
CheckStars(a_button);
SetButtons();
}
internal void StartTransition(QuizButton a_button, phases a_startingPhase)
{
button = a_button;
if (a_startingPhase == phases.None)
{
EndMovement();
return;
}
textBackground.SetActive(true);
textDisplay.gameObject.SetActive(true);
timer = 0;
calculator.AbleCalculator(false);
previousLevelWords = a_button.previousLevelString;
previousTime = a_button.previousTime;
nextLevelWords = a_button.nextLevelString;
nextime = a_button.nextime;
enemyWords = a_button.enemyString;
enemyTime = a_button.enemyTime;
SetMovementStartAndSpeed(a_startingPhase);
phase = a_startingPhase;
if (FindObjectOfType <equipmentList>().skipping)
{
enemyTime = 0;
previousTime = 0;
nextime = 0;
healthbars.skipRefill();
}
}
internal void CalculateBODMAS(QuizButton a_running, int failures)
{
mainOp = a_running.Operator;
variableCount = a_running.variableCount;
variablesUsed = new List <float>(variableCount);
variablesUsed = questionManager.randomiseBODMASNumbers(a_running);
List <float> summingNumbers = new List <float>(5);
List <operators> summingOps;
summingOps = questionManager.ChooseOperators(a_running.Operator, (variableCount - 1));
StoredOps = new List <operators>(summingOps);
//Randomise as many numbers as required, within range.
for (int i = 0; i < variableCount; i++)
{
summingNumbers.Add((int)variablesUsed[i]);
}
if (a_running.Operator == operators.AddSubMultDiv)
{
AnswerNeeded = summingNumbers[0] / summingNumbers[1];
switch (summingOps[1])
{
case operators.Addition:
AnswerNeeded = AnswerNeeded + summingNumbers[2];
break;
case operators.Subtraction:
AnswerNeeded = AnswerNeeded - summingNumbers[2];
break;
}
AnswerNeeded = AnswerNeeded * summingNumbers[3];
}
else
{
while (summingOps.Count > 0)
{
if (summingOps.Contains(operators.Division))
{
int i = summingOps.IndexOf(operators.Division);
summingNumbers[i] /= summingNumbers[(i + 1)];
summingNumbers.RemoveAt(i + 1);
summingOps.RemoveAt(i);
continue;
}
if (summingOps.Contains(operators.Multiplication))
{
int i = summingOps.IndexOf(operators.Multiplication);
summingNumbers[i] *= summingNumbers[(i + 1)];
summingNumbers.RemoveAt(i + 1);
summingOps.RemoveAt(i);
continue;
}
if (summingOps.Contains(operators.Addition))
{
int i = summingOps.IndexOf(operators.Addition);
summingNumbers[i] += summingNumbers[(i + 1)];
summingNumbers.RemoveAt(i + 1);
summingOps.RemoveAt(i);
continue;
}
if (summingOps.Contains(operators.Subtraction))
{
int i = summingOps.IndexOf(operators.Subtraction);
summingNumbers[i] -= summingNumbers[(i + 1)];
summingNumbers.RemoveAt(i + 1);
summingOps.RemoveAt(i);
continue;
}
}
AnswerNeeded = summingNumbers[0];
}
bool whole = questionManager.IsWhole(AnswerNeeded);
//if Answer is too low/too high, or requires rounding to solve, we try again.
if ((AnswerNeeded <= a_running.minAnswer || AnswerNeeded > a_running.maxAnswer || !whole) && failures < 20)
{
int failed = failures + 1;
CalculateBODMAS(a_running, failed);
return;
}
if (failures >= 20)
{
Debug.Log("Failed");
}
ResetAll();
if (a_running.Operator == operators.AddSubMultDiv)
{
operatorsText[3].text = "(";
operatorsText[0].text = " / ";
operatorsText[1].text = " + ";
operatorsText[2].text = ") x ";
operatorsText[2].gameObject.SetActive(true);
FortressButtons[3].gameObject.SetActive(true);
}
else
{
operatorsText[3].text = "";
for (int i = 0; i < 3; i++)
{
if (i < (variableCount - 1))
{
switch (StoredOps[i])
{
case operators.Addition:
operatorsText[i].text = "+ ";
break;
case operators.Subtraction:
operatorsText[i].text = "- ";
break;
case operators.Multiplication:
operatorsText[i].text = "x ";
break;
case operators.Division:
operatorsText[i].text = "/ ";
break;
default:
break;
}
}
}
operatorsText[2].gameObject.SetActive(false);
FortressButtons[3].gameObject.SetActive(false);
}
AnswerText.text = " = " + AnswerNeeded.ToString();
SetDraggers();
Defend.interactable = false;
}
public ShowQuizViewMessage(QuizButton quizButton)
: base(null, Command.SHOW_QUIZ_VIEW)
{
this.quizButton = quizButton;
}
public void SelectSegment(QuizButton qb)
{
qb.IsSelected = true;
}
public QuizState(int QuestionCount) : base()
{
this.QuestionCount = QuestionCount;
//Set UI elements
flags = new FlagContainer[queueSize];
buttons = new QuizButton[4];
//Set question counter
QuestionCounter = new TextLabel()
{
Font = new Font("Arial", 30, FontStyle.Bold),
DrawMode = UI.DrawMode.Centered,
Location = new Point(currentFlagX, 40)
};
//Set scoring
results = new ResultsState()
{
Questions = QuestionCount,
ScorePerAnswer = scorePerFlag
};
tracker = new StreakTracker()
{
Location = new Point(150, buttonTop + buttonHeight + (buttonSpacing / 2))
};
scoreLabel = new TextLabel()
{
Font = new Font("Arial", 30, FontStyle.Bold),
DrawMode = UI.DrawMode.Centered,
Location = new Point(Program.Width - 200, buttonTop + buttonHeight + (buttonSpacing / 2)),
Text = "0"
};
scoreAddLabel = new FadeLabel()
{
Font = new Font("Arial", 20, FontStyle.Bold),
DrawMode = UI.DrawMode.Centered,
Location = new Point(Program.Width - 200, buttonTop + buttonHeight + (buttonSpacing / 2)),
Text = "0",
Color = Color.Green,
FadeTime = .8f,
FadeDeltaY = -100
};
currentFlagY = QuestionCounter.Location.Y + ((buttonTop - QuestionCounter.Location.Y) / 2);
//Set curve for flag movement
bezier = new BezierCurve(new PointF[] { new PointF(1, -.4f), new PointF(0.8f, 1) }, maxFreezeTime);
//Set answer selection
rng = new Random();
//Add and correctly position buttons
int[] buttonX = { Program.Width / 2 - (buttonWidth + buttonSpacing / 2), Program.Width / 2 + buttonSpacing / 2 };
int[] buttonY = { buttonTop, buttonTop + buttonHeight + buttonSpacing };
for (int i = 0; i < 4; i++)
{
buttons[i] = new QuizButton(buttonX[i % 2], buttonY[i / 2], buttonWidth, buttonHeight, i + 1);
buttons[i].OnSelect += ButtonPressed;
}
//Fill the flag queue
for (int i = 0; i < 5; i++)
{
AddRandomFlag();
}
//Select random answers
NextFlag();
//Remove the flag at end of queue
flags[queueSize - 1] = null;
timer = new Stopwatch();
timer.Start();
}
//Uses given values to calculate a random sum and its components, then store and display them.
internal bool MakeQuestion(QuizButton a_running, bool bossAttacking = false)
{
if (calculator == null)
{
calculator = FindObjectOfType <Calculator>();
}
if (container == null)
{
container = FindObjectOfType <multipleContainer>();
}
button = a_running;
float[] numbers = new float[button.variableCount];
answer = -2;
string oper = "";
int rand = 1;
//Randomise as many numbers as required, within range.
for (int i = 0; i < a_running.variableCount; i++)
{
numbers[i] = (int)Random.Range(button.minNumber, (button.maxNumber + 1));
}
float multiple = 1;
switch (a_running.Operator)
{
case operators.Addition:
answer = numbers[0];
for (int i = 1; i < a_running.variableCount; i++)
{
answer += numbers[i];
oper = "+ ";
}
break;
case operators.Subtraction:
answer = numbers[0];
for (int i = 1; i < a_running.variableCount; i++)
{
answer -= numbers[i];
oper = "- ";
}
break;
case operators.Multiplication:
//If operator is 'x', second number is one of two possible numbers
if (a_running.boss && a_running.validNumbers != 0)
{
rand = Random.Range(0, (a_running.validNumbers));
}
else
{
rand = Random.Range(0, (a_running.secondFixedNumber.Length));
}
numbers[1] = a_running.secondFixedNumber[rand];
multiple = numbers[1];
answer = numbers[0] * numbers[1];
oper = "x ";
break;
case operators.Division:
rand = Random.Range(0, (a_running.secondFixedNumber.Length));
numbers[1] = a_running.secondFixedNumber[rand];
multiple = numbers[1];
answer = numbers[0] / numbers[1];
oper = "÷ ";
break;
default:
return(CalculateBODMAS(a_running, 0, bossAttacking));
}
bool rounding = a_running.preventRounding;
if (a_running.preventRounding) //if box is ticked, need to make sure numbers don't require rounding up.
{
rounding = PreventRounding(numbers, a_running, (int)answer);
}
bool whole = IsWhole(answer);
//if Answer is too low/too high, or requires rounding to solve, we try again.
if (answer < a_running.minAnswer || answer > a_running.maxAnswer || rounding || !whole || answer == previousAnswer)
{
return(MakeQuestion(a_running, bossAttacking));
}
previousAnswer = answer;
string answerNeeded = answer.ToString("F0");
bool enemyPhase = container.SetMultiple((int)answer, a_running, multiple, bossAttacking);
string answerWords;
answerWords = " ";
answerWords += numbers[0].ToString("F0");
for (int i = 1; i < a_running.variableCount; i++)
{
answerWords += oper + numbers[i].ToString("F0");
answer += numbers[i];
}
answerWords += "= ";
questionNeeded = answerWords;
calculator.answerNeeded = answerNeeded;
return(enemyPhase);
}
bool CalculateBODMAS(QuizButton a_running, int failures, bool bossAttacking)
{
List <float> randomised = new List <float>(5);
List <float> summingNumbers = new List <float>(5);
ops = ChooseOperators(a_running.Operator, (a_running.variableCount - 1));
randomised = randomiseBODMASNumbers(a_running);
string[] operatorStrings = new string[ops.Count];
for (int i = 0; i < operatorStrings.Length; i++)
{
switch (ops[i])
{
case operators.Addition:
operatorStrings[i] = "+ ";
break;
case operators.Subtraction:
operatorStrings[i] = "- ";
break;
case operators.Multiplication:
operatorStrings[i] = "x ";
break;
case operators.Division:
operatorStrings[i] = "/ ";
break;
default:
break;
}
}
//Randomise as many numbers as required, within range.
for (int i = 0; i < a_running.variableCount; i++)
{
summingNumbers.Add(randomised[i]);
}
if (a_running.Operator == operators.AddSubMultDiv)
{
float total;
total = summingNumbers[0] / summingNumbers[1];
switch (ops[1])
{
case operators.Addition:
total = total + summingNumbers[2];
break;
case operators.Subtraction:
total = total - summingNumbers[2];
break;
}
total = total * summingNumbers[3];
answer = total;
}
else
{
for (int i = 0; i < ops.Count; i++)
{
switch (ops[i])
{
case operators.Addition:
summingNumbers[0] += summingNumbers[i + 1];
break;
case operators.Subtraction:
summingNumbers[0] -= summingNumbers[i + 1];
break;
case operators.Multiplication:
summingNumbers[0] *= summingNumbers[i + 1];
break;
default:
break;
}
if (summingNumbers[0] < 0)
{
return(CalculateBODMAS(a_running, failures, bossAttacking));
}
}
answer = summingNumbers[0];
}
bool whole = IsWhole(answer);
//if Answer is too low/too high, or requires rounding to solve, we try again.
if ((answer <= a_running.minAnswer || answer > a_running.maxAnswer || !whole) && failures < 20)
{
int failed = failures + 1;
return(CalculateBODMAS(a_running, failed, bossAttacking));
}
if (failures >= 20)
{
Debug.Log("Failed");
}
string answerNeeded = answer.ToString("F0");
bool enemyPhase = container.SetMultiple((int)answer, a_running, 1, bossAttacking);
string answerWords;
if (a_running.Operator == operators.AddSubMultDiv)
{
answerWords = BODMASDivisionQuestion(operatorStrings, randomised);
}
else
{
answerWords = " ";
answerWords += randomised[0].ToString("F0");
for (int i = 1; i < a_running.variableCount; i++)
{
answerWords += operatorStrings[(i - 1)] + randomised[i].ToString("F0");
}
}
answerWords += "= ";
calculator.answerNeeded = answerNeeded;
questionNeeded = answerWords;
return(enemyPhase);
}
