public StatisticsPoint(CardUtil.EntityEnum correctEntity, Card card, Dictionary <CardUtil.EntityEnum, CardUtil.ColorEnum> entityToColor, bool useCorrectColor)
{
CorrectEntity = correctEntity;
Card = card;
EntityToColor = entityToColor;
UseCorrectColor = useCorrectColor;
Missed = true;
}
public StatisticsPoint(float timeElapsed, CardUtil.EntityEnum correctEntity, CardUtil.EntityEnum guessedEntity, Card card, Dictionary <CardUtil.EntityEnum, CardUtil.ColorEnum> entityToColor, bool useCorrectColor)
{
TimeElapsed = timeElapsed;
CorrectEntity = correctEntity;
GuessedEntity = guessedEntity;
Card = card;
EntityToColor = entityToColor;
UseCorrectColor = useCorrectColor;
Missed = false;
}
//Must be called after AddPickedCard
public void AddMissed(CardUtil.EntityEnum correctEntity)
{
StatisticsList.Add(new StatisticsPoint(correctEntity, card, entityToColor, useCorrectColor));
TotalMissed++;
if (useCorrectColor)
{
TotalMissedWithCorrectlyColored++;
}
else
{
TotalMissedWithIncorrectlyColored++;
}
}
IEnumerator CpuGuess(Cpu cpu)
{
float delayModifier = 0;
if (cpu.delayModiferDict != null)
{
cpu.delayModiferDict.TryGetValue(correctEntity.Value, out delayModifier);
}
float delayBeforeAnswer = RandomUtil.nonUniformDistributedRandom(cpu.delayLowerRangeBeforeAnswer + delayModifier, cpu.delayUpperRangeBeforeAnswer + delayModifier, x => (float)(1f - Math.Pow(x - 1, 4)));
yield return(new WaitForSeconds(delayBeforeAnswer));
CardUtil.EntityEnum inCorrectEntity = correctEntity.Value == CardUtil.EntityEnum.Banana ? CardUtil.EntityEnum.Coco : CardUtil.EntityEnum.Banana;
float chanceOfCorrectModifier = 0;
if (cpu.chanceOfCorrectModiferDict != null)
{
cpu.chanceOfCorrectModiferDict.TryGetValue(correctEntity.Value, out chanceOfCorrectModifier);
}
float randomPercent = RandomUtil.nonUniformDistributedRandom(0, 100, x => (float)Math.Pow(x - 1, 4));
CardUtil.EntityEnum entityToGuess;
if (useCorrectColor)
{
if (cpu.chanceOfCorrectForCorrectlyColored + chanceOfCorrectModifier >= randomPercent)
{
entityToGuess = correctEntity.Value;
}
else
{
entityToGuess = inCorrectEntity;
}
}
else
{
if (cpu.chanceOfCorrectForIncorrectlyColored + chanceOfCorrectModifier >= randomPercent)
{
entityToGuess = correctEntity.Value;
}
else
{
entityToGuess = inCorrectEntity;
}
}
Guess(entityToGuess, cpu);
}
//Must be called after AddPickedCard
public float AddGuess(float endTime, CardUtil.EntityEnum correctEntity, CardUtil.EntityEnum guessedEntity)
{
float timeElapsed = endTime - startTime;
StatisticsList.Add(new StatisticsPoint(timeElapsed, correctEntity, guessedEntity, card, entityToColor, useCorrectColor));
Total++;
AverageTimeElapsed = (AverageTimeElapsed * (Total - 1) + timeElapsed) / Total;
if (correctEntity == guessedEntity)
{
TotalCorrect++;
AverageTimeElapsedForCorrectOnes = (AverageTimeElapsedForCorrectOnes * (TotalCorrect - 1) + timeElapsed) / TotalCorrect;
if (useCorrectColor)
{
TotalCorrectWithCorrectlyColored++;
AverageTimeElapsedForCorrectOnesWithCorrectlyColored = (AverageTimeElapsedForCorrectOnesWithCorrectlyColored * (TotalCorrectWithCorrectlyColored - 1) + timeElapsed) / TotalCorrectWithCorrectlyColored;
}
else
{
TotalCorrectWithIncorrectlyColored++;
AverageTimeElapsedForCorrectOnesWithIncorrectlyColored = (AverageTimeElapsedForCorrectOnesWithIncorrectlyColored * (TotalCorrectWithIncorrectlyColored - 1) + timeElapsed) / TotalCorrectWithIncorrectlyColored;
}
}
else
{
TotalIncorrect++;
AverageTimeElapsedForIncorrectOnes = (AverageTimeElapsedForIncorrectOnes * (TotalIncorrect - 1) + timeElapsed) / TotalIncorrect;
if (useCorrectColor)
{
TotalIncorrectWithCorrectlyColored++;
AverageTimeElapsedForIncorrectOnesWithCorrectlyColored = (AverageTimeElapsedForIncorrectOnesWithCorrectlyColored * (TotalIncorrectWithCorrectlyColored - 1) + timeElapsed) / TotalIncorrectWithCorrectlyColored;
}
else
{
TotalIncorrectWithIncorrectlyColored++;
AverageTimeElapsedForIncorrectOnesWithIncorrectlyColored = (AverageTimeElapsedForIncorrectOnesWithIncorrectlyColored * (TotalIncorrectWithIncorrectlyColored - 1) + timeElapsed) / TotalIncorrectWithIncorrectlyColored;
}
}
return(timeElapsed);
}
public void Guess(CardUtil.EntityEnum entity, Participant _participant = null)
{
if (gameOver || cardInDelay)
{
return;
}
Participant participant = _participant == null ? player1 : _participant;
if (participant.guessed)
{
return;
}
participant.guessed = true;
float timeToGuess = participant.Stats.AddGuess(Time.time, correctEntity.Value, entity);
if (entity == correctEntity)
{
participant.points++;
//Clear coroutine so other cpus will stop guessing
cpuCoroutines.ForEach(co => StopCoroutine(co));
cpuCoroutines.Clear();
if (participant != player1 && !player1.guessed)
{
player1.Stats.AddMissed(correctEntity.Value);
}
if (GameSettingsUtil.GetGameType() == GameSettingsUtil.GameTypeEnum.Two && participant != player2 && !player2.guessed)
{
player2.Stats.AddMissed(correctEntity.Value);
}
GameUtil.cpuList.ForEach(cpu =>
{
if (participant != cpu && !cpu.guessed)
{
cpu.Stats.AddMissed(correctEntity.Value);
}
});
if (participant == player1 || (GameSettingsUtil.GetGameType() == GameSettingsUtil.GameTypeEnum.Two && participant == player2))
{
correctStreak++;
if (useCorrectColor)
{
GameProgressionUtil.UpdateGameProgression(rep => rep.totalCorrectCorrectlyColoredGuesses++);
}
else
{
GameProgressionUtil.UpdateGameProgression(rep => rep.totalCorrectIncorrectlyColoredGuesses++);
}
if (correctEntity == CardUtil.EntityEnum.Coco)
{
GameProgressionUtil.UpdateGameProgression(rep => rep.totalTimesCocoWasPicked++);
}
if (correctEntity == CardUtil.EntityEnum.Chomp)
{
GameProgressionUtil.UpdateGameProgression(rep => rep.totalTimesChompWasPicked++);
}
if (timeToGuess < 1f)
{
GameProgressionUtil.UpdateGameProgression(rep => rep.totalCorrectGuessesUnderOneSecond++);
}
if (timeToGuess < .5f)
{
GameProgressionUtil.UpdateGameProgression(rep => rep.totalCorrectGuessesUnderHalfASecond++);
}
gameAudioManager.PlayCorrectGuess();
}
else
{
Cpu cpu = (Cpu)participant;
gameAudioManager.PlayAVoice(cpu.voiceCorrect);
}
}
else
{
if (SettingsUtil.IsPenaltiesAllowed())
{
participant.penalties++;
if (participant.points - participant.penalties < 0 && !SettingsUtil.IsNegativeScoresAllowed())
{
participant.penalties--;
}
}
if (participant == player1 || (GameSettingsUtil.GetGameType() == GameSettingsUtil.GameTypeEnum.Two && participant == player2))
{
correctStreak = 0;
gameAudioManager.PlayIncorrectGuess();
}
else
{
Cpu cpu = (Cpu)participant;
gameAudioManager.PlayAVoice(cpu.voiceIncorrect);
}
}
if (participant == player1)
{
SetButtonsEnabled(player1Buttons, entity == correctEntity);
}
if (participant == player2)
{
SetButtonsEnabled(player2Buttons, entity == correctEntity);
}
participant.finalScore = participant.points - participant.penalties;
UpdateScoresAndNameText();
CheckForGameOver();
bool player2Guessed = GameSettingsUtil.GetGameType() == GameSettingsUtil.GameTypeEnum.Two && player2.guessed;
if (entity == correctEntity || ((GameSettingsUtil.GetGameType() == GameSettingsUtil.GameTypeEnum.Single || player2Guessed) && player1.guessed && GameUtil.cpuList.All(cpu => cpu.guessed)))
{
if (cardGameObject != null)
{
DestroyImmediate(cardGameObject.gameObject);
cardGameObject = null;
}
if (!gameOver)
{
StartCoroutine(NewRoundWithDelay());
}
}
}
public void GuessForPlayer2(CardUtil.EntityEnum entity)
{
Guess(entity, player2);
}
private void NewRound()
{
Card card = generateCard();
CardUtil.EntityEnum[] allEntities = new CardUtil.EntityEnum[CardUtil.Entities_2Card.Count];
CardUtil.Entities_2Card.CopyTo(allEntities);
CardUtil.EntityEnum[] currentEntities = card.cardEntities.Select(e => e.entity).ToArray();
CardUtil.EntityEnum[] otherEntities = allEntities.Where(e => !currentEntities.Contains(e)).ToArray();
useCorrectColor = false;
HashSet <CardUtil.ColorEnum> colorsUsed = new HashSet <CardUtil.ColorEnum>();
Dictionary <CardUtil.EntityEnum, CardUtil.ColorEnum> entityToColor = new Dictionary <CardUtil.EntityEnum, CardUtil.ColorEnum>();
Array.ForEach(card.cardEntities, cardEntity =>
{
int index = useCorrectColor ? UnityEngine.Random.Range(0, otherEntities.Length) : UnityEngine.Random.Range(0, otherEntities.Length + 1);
index--;
CardUtil.ColorEnum color;
do
{
if (index < otherEntities.Length)
{
index++;
}
else
{
index = 0;
}
if (index >= otherEntities.Length)
{
useCorrectColor = true;
}
color = CardUtil.EntityColorMap[index >= otherEntities.Length ? cardEntity.entity : otherEntities[index]];
} while (colorsUsed.Contains(color));
colorsUsed.Add(color);
entityToColor[cardEntity.entity] = color;
Debug.Log(cardEntity.entity + ": " + color);
cardEntity.image.color = CardUtil.ColorColorMap[color];
});
if (currentEntities.Contains(CardUtil.EntityEnum.Banana) && entityToColor[CardUtil.EntityEnum.Banana] == CardUtil.ColorEnum.Yellow)
{
GameProgressionUtil.UpdateGameProgression(rep => rep.totalTimesYellowBananaWasSeen++);
}
correctEntity = null;
List <CardUtil.EntityEnum> incorrectEntities = new List <CardUtil.EntityEnum>();
foreach (KeyValuePair <CardUtil.EntityEnum, CardUtil.ColorEnum> entry in entityToColor)
{
CardUtil.EntityEnum entity = entry.Key;
CardUtil.ColorEnum color = entry.Value;
CardUtil.EntityEnum otherEntity = CardUtil.ColorEntityMap[color];
if (entity == otherEntity)
{
correctEntity = entity;
break;
}
incorrectEntities.Add(entity);
incorrectEntities.Add(otherEntity);
}
if (correctEntity == null)
{
correctEntity = allEntities.Except(incorrectEntities).First();
}
cardGameObject = Instantiate(card, cardContainer.transform);
//Enable all buttons
SetButtonsEnabled(player1Buttons, true);
SetButtonsEnabled(player2Buttons, true);
//Set up stats
float time = Time.time;
player1.Stats.AddPickedCard(time, card, entityToColor, useCorrectColor);
player1.guessed = false;
if (GameSettingsUtil.GetGameType() == GameSettingsUtil.GameTypeEnum.Two)
{
player2.Stats.AddPickedCard(time, card, entityToColor, useCorrectColor);
player2.guessed = false;
}
GameUtil.cpuList.ForEach(cpu =>
{
cpu.Stats.AddPickedCard(time, card, entityToColor, useCorrectColor);
});
GameUtil.cpuList.ForEach(cpu =>
{
cpu.guessed = false;
});
//Cpu starts guessing
GameUtil.cpuList.ForEach(cpu =>
{
cpuCoroutines.Add(StartCoroutine(CpuGuess(cpu)));
});
}
