protected override void RefreshAllValues()
{
GameIsOngoing = true;
Guesses.Clear();
NumberOfWrongGuesses = 0;
WordToGuess = string.Empty;
}
private void AddWrongAnswers(int maxAnswer, List <GameAnswer> gameAnswers)
{
string guess;
int igameAns = maxAnswer;
if (maxAnswer > gameAnswers.Count)
{
igameAns = gameAnswers.Count;
}
int maxIteration = gameAnswers.Count * 5;
int iterations = 0;
Random r = new Random(DateTime.Now.Second);
while (Guesses.Count <= igameAns)
{
if (maxIteration > iterations)
{
break;
}
guess = gameAnswers.ElementAt(r.Next(0, gameAnswers.Count - 1)).AnswerString;
if (!Guesses.Contains(guess))
{
Guesses.Add(guess);
}
iterations++;
}
if (Guesses.Count < igameAns)
{
ForceAnswers(gameAnswers, igameAns);
}
}
public int CalculateScore(int CurrentGuess)
{
int runningTotal = 0;
//Guesses.Add(CurrentGuess);
Guesses.Add($"{CurrentGuess} @ {DifficultyLevel}");
if (CurrentGuess == SecretNumber && CurrentGuessCount == 1)
{
Score += 10;
LevelComplete = true;
}
else if (CurrentGuess == SecretNumber && CurrentGuessCount == 2)
{
Score += 6;
LevelComplete = true;
}
else if (CurrentGuess == SecretNumber && CurrentGuessCount == 3)
{
Score += 2;
LevelComplete = true;
}
else if (CurrentGuessCount >= 3)
{
GameOver = true;
}
CurrentGuessCount++;
return(runningTotal);
}
private async Task AddGuessesStatisticsAsync(long selectedViewCount, long notSelectedViewCount, bool save = true)
{
Guesses guesses = await _context.Guesses.FindAsync(DateTime.Now.Date); // DateTime.Now.Date removes hours/minutes/seconds
bool guessesModified = true;
if (guesses == null)
{
guessesModified = false;
guesses = new Guesses();
}
if (selectedViewCount >= notSelectedViewCount)
{
guesses.CorrectGuesses++;
}
else
{
guesses.WrongGuesses++;
}
if (guessesModified)
{
_context.Entry(guesses).State = EntityState.Modified;
}
else
{
_context.Guesses.Add(guesses);
}
if (save)
{
await SaveChangesDbAsync();
}
}
public int CalculateScore(int CurrentGuess)
{
int runningTotal = 0;
Guesses.Add($"{CurrentGuess} @ {DifficultyLevel}");
int score = 0;
CurrentGuessCount += 1;
if (CurrentGuess == SecretNumber && CurrentGuessCount == 1)
{
score += 10;
}
else if (CurrentGuess == SecretNumber && CurrentGuessCount == 2)
{
score += 6;
}
else if (CurrentGuess == SecretNumber && CurrentGuessCount == 3)
{
score += 2;
}
else
{
GameOver = true;
}
if (CurrentGuess == SecretNumber)
{
LevelComplete = true;
}
Score = score;
return(runningTotal);
}
/// <summary>
/// Computes a guess for a user.
/// </summary>
/// <param name="guess">User's guess in format 12345678, where each number represents a color</param>
/// <param name="name">User's nickname</param>
/// <returns></returns>
internal bool MakeGuess(string guess, string name)
{
CurrentUsersGuessed.Add(name);
Guesses.Add(name, guess);
if (Guesses.Count == Users.Count)
{
return(true);
}
else
{
string remainingUsers = "";
lock (Users)
{
foreach (var user in Users)
{
if (!CurrentUsersGuessed.Contains(user))
{
remainingUsers += user + ", ";
}
}
if (remainingUsers.Length > 0)
{
RemainingUsers = remainingUsers.Remove(remainingUsers.LastIndexOf(','));
}
}
return(false);
}
}
bool HaveWeWonYet()
{
var wordAsList = WordToGuess.ToList();
wordAsList.RemoveAll(c => Guesses.Contains(c));
return(wordAsList.Count == 0);
}
public IList <Card> GetKnownCards()
{
return
(Guesses
.Where(guess => guess.KnowAboutNominalAndColor())
.Select(guess => _memory.GetCardByGuess(guess).Card)
.ToList());
}
// Выбросить нужно ту карту, которая не нужна => P(карта сыграна U уже не может быть сыграна) -> max
// Нужно как-то учесть критичность карты, чтобы ненароком не выбросить нужное.
// P(карта сыграна U уже не может быть сыграна) -> max И
// P(карта не критичная) -> min
private CardInHand GetCardToDiscard()
{
var uniqueCards = _pilesAnalyzer.GetUniqueCards(FireworkPile, DiscardPile);
var thrownCards = _pilesAnalyzer.GetThrownCards(FireworkPile, DiscardPile);
var otherPlayerCards = GetOtherPlayersCards().Select(cih => cih.Card).ToList();
var excludedCards = thrownCards.Concat(otherPlayerCards);
//var boardContext = BoardContext.Create(_game.Board, _pilesAnalyzer, otherPlayerCards);
//var playerContext = new PlayerContext(this, );
//var discardStrategy = new DiscardStrategy();
//discardStrategy.EstimateDiscardProbability(boardContext, playerContext);
var cardsWhateverToPlay =
_pilesAnalyzer.GetCardsWhateverToPlay(FireworkPile, DiscardPile);
// разделим карты на две категории:
// (*) о которых что-то известно (номинал или цвет),
// (*) о которых ничего конкретного неизвестно.
// если из тех карт, о которых что-то известно, есть те, которые можно выкинуть,
// то выкидываем.
var guessesAboutKnownCards =
_memory
.GetGuesses()
.Where(guess => guess.KnowAboutRankOrColor());
bool ShouldDiscard(Guess guess) =>
guess.GetProbability(cardsWhateverToPlay, excludedCards) < DiscardProbabilityThreshold;
Guess guessToDiscard =
guessesAboutKnownCards.FirstOrDefault(ShouldDiscard);
if (guessToDiscard != null)
{
return(_memory.GetCardByGuess(guessToDiscard));
}
// что ж, тогда копаемся со второй группой.
// для каждой карты оценим вероятность того, что она - карта - критичная
// выбросим карту с наименьшей вероятностью
guessToDiscard =
Guesses
.Except(guessesAboutKnownCards)
.OrderBy(guess => guess.GetProbability(uniqueCards, excludedCards))
.FirstOrDefault();
if (guessToDiscard == null)
{
guessToDiscard = guessesAboutKnownCards
.OrderBy(guess => guess.GetProbability(uniqueCards, excludedCards))
.First();
}
return(_memory.GetCardByGuess(guessToDiscard));
}
public void UpdateGuesses(List <Guess> list)
{
foreach (Guess g in list)
{
if (!CheckAlreadyInside(g))
{
Guesses.Add(g);
}
}
}
public override int Guess()
{
var guess = NextGuess();
while (Guesses.Contains(guess))
{
guess = NextGuess();
}
base.Guess(guess);
return(guess);
}
private void DivideAllProdsBy(int n)
{
Guesses.Add(n);
for (int i = 0; i < Products.Count; i++)
{
if (Products[i] % n == 0)
{
Products[i] /= n;
}
}
}
public void Reset()
{
ResetTimer();
WordToDraw = null;
Rounds = 0;
CurrentRound = 0;
RemainingTime = 0;
Players.Clear();
Guesses.Clear();
MatchUid = String.Empty;
}
private void ForceAnswers(List <GameAnswer> ga, int igameAns)
{
foreach (GameAnswer item in ga)
{
if (!Guesses.Contains(item.AnswerString))
{
if (Guesses.Count <= igameAns)
{
Guesses.Add(item.AnswerString);
}
}
}
}
void GenerateTiles()
{
foreach (var character in WordToGuess)
{
if (Guesses.Contains(character))
{
Console.Write(character + " ");
}
else
{
Console.Write("_ ");
}
}
}
public void play()
{
while (!isWin)
{
Console.WriteLine("Entrer une lettre : ");
char letter = char.ToUpper(Console.ReadKey(true).KeyChar);
int letterIndex = WordToGuess.GetIndexOf(letter);
Console.WriteLine();
if (letterIndex != -1)
{
Console.WriteLine($"Bravo, vous avez trouver la lettre : {letter}");
Guesses.Add(letter);
}
else
{
Console.WriteLine($"la lettre {letter} ne se trouve pas dans le mot à deviner !");
Misses.Add(letter);
}
if (Misses.Count > 0)
{
Console.WriteLine($"Erreurs ({Misses.Count}) : {string.Join(", ", Misses)}");
}
currentWordGuessed = PrintWordToGuess();
if (currentWordGuessed.IndexOf('_') == -1)
{
isWin = true;
Console.WriteLine("Félicitation vous avez gagnez la partie ! ");
Console.ReadKey();
}
if (Misses.Count >= maxErrors)
{
Console.WriteLine("Dommage, c'est perdu ! ");
Console.ReadKey();
break;
}
}
}
public static void Main()
{
Guesses guess = new Guesses();
Console.WriteLine("Would you like to play the higher/lower game? (Y/N)");
string input = Console.ReadLine();
if (input == "Y" || input == "y")
{
Console.WriteLine("Which game mode would you like to play:");
Console.WriteLine("1 = Computer Guess");
Console.WriteLine("2 = User Guess");
input = Console.ReadLine();
if (input == "1")
{
while (!guess.IsGameOver())
{
int midGuess = (guess.GetLowerRange() + guess.GetHigherRange()) / 2;
guess.AIGuess(midGuess);
}
Console.WriteLine("Great! I guessed your number. Would you like to play again? (Y/N)");
input = Console.ReadLine();
if (input == "Y" || input == "y")
{
Main();
}
}
else
{
Random rnd = new Random();
int randomNumber = rnd.Next(1, 101);
guess.SetNumber(randomNumber);
while (!guess.IsGameOver())
{
guess.UserGuess();
}
Console.WriteLine("Great! You guessed my number. Would you like to play again? (Y/N)");
input = Console.ReadLine();
if (input == "Y" || input == "y")
{
Main();
}
}
}
}
public bool FoundWord()
{
bool hasFoundWord = false;
foreach (char c in SecretWord)
{
if (Guesses.Contains(c))
{
hasFoundWord = true;
}
else
{
hasFoundWord = false;
break;
}
}
return(hasFoundWord);
}
/// <summary>
/// Permet de jouer au jeu du pendu.
/// </summary>
public void Play()
{
while (!isWin)
{
Console.WriteLine("Entrez une lettre :");
char letter = char.ToUpper(Console.ReadKey(true).KeyChar);
int letterIndex = WordToGuess.GetIndexOf(letter);
Console.WriteLine();
if (letterIndex != -1)
{
Console.WriteLine("Vous avez trouvé la lettre : {0}", letter);
Guesses.Add(letter);
}
else
{
Console.WriteLine("La lettre {0} ne se trouve pas dans le mot", letter);
Misses.Add(letter);
}
Console.WriteLine($"Erreurs ({Misses.Count}) : {string.Join(", ", Misses)}");
currentWordGuessed = PrintWordToGuess();
if (currentWordGuessed.IndexOf('_') == -1)
{
isWin = true;
Console.WriteLine("Gagné");
Console.ReadKey();
}
if (Misses.Count >= maxErrors)
{
Console.WriteLine("Perdu !");
Console.WriteLine("le mot a trouver était : " + WordToGuess.Text);
Console.ReadKey();
break;
}
}
}
/// <summary>
/// Permet de jouer au jeu du pendu.
/// Cette méthode lit la touche sur laquelle l'utilisateur a appuyé
/// jusqu'à ce que la partie soit gagné ou perdue (10 erreurs).
/// </summary>
public void Play()
{
while (!isWin)
{
Console.WriteLine("Donnez moi une lettre :");
char letter = char.ToUpper(Console.ReadKey(true).KeyChar);
int letterIndex = WordToGuess.GetIndexOf(letter);
Console.WriteLine();
if (letterIndex != -1)
{
Console.WriteLine("Bravo, vous avez trouvé la lettre : {0}", letter);
Guesses.Add(letter);
}
else
{
Console.WriteLine("La lettre {0} ne se trouve pas dans le mot à deviner !", letter);
Misses.Add(letter);
}
Console.WriteLine($"Erreurs ({Misses.Count}) : {string.Join(", ", Misses)}");
currentWordGuessed = PrintWordToGuess();
if (currentWordGuessed.IndexOf('_') == -1)
{
isWin = true;
Console.WriteLine("Félicitations, c'est gagné !");
Console.ReadKey();
}
if (Misses.Count >= maxErrors)
{
Console.WriteLine("C'est perdu !");
Console.ReadKey();
break;
}
}
}
private string PrintWordToGuess()
{
string currentWordGuessed = "";
for (int i = 0; i < WordToGuess.Lenght; i++)
{
if (Guesses.Contains(WordToGuess.Text[i]))
{
currentWordGuessed += WordToGuess.Text[i];
}
else
{
currentWordGuessed += "_";
}
}
Console.WriteLine(currentWordGuessed);
Console.WriteLine();
return(currentWordGuessed);
}
void RunGameLoop()
{
HangmanConsoleWriter.PrintGuesses(Guesses);
GenerateTiles();
var guess = HangmanConsoleWriter.RequestInput();
if (HangmanInputValidation.ValidateInput(guess))
{
var guessCharacter = guess[0];
Guesses.Add(guessCharacter);
if (!WordToGuess.Contains(guessCharacter))
{
NumberOfWrongGuesses++;
}
else
{
if (HaveWeWonYet())
{
GameIsOngoing = false;
HangmanConsoleWriter.WinnerOutput(WordToGuess);
return;
}
}
}
else
{
HangmanConsoleWriter.InvalidGuess();
}
DrawHangman();
CheckNumberOfWrongGuesses();
}
private bool CorrectCharGuess()
{
return(Guesses.Count(g => g is CharGuess && ((CharGuess)g).IsGoodGuess) == Word.Distinct().Count());
}
private bool CorrectWordGuess()
{
return(Guesses.Any(g => g is WordGuess && ((WordGuess)g).IsGoodGuess));
}
public void CompleteRound(int index)
{
Guesses.Add(PossibleLetters[index]);
AppendSecretWord(index);
}
private async Task PotentialGuess(SocketMessage msg)
{
try
{
if (!(msg is SocketUserMessage))
{
return;
}
if (msg.Channel != GameChannel)
{
return; // message's channel has to be the same as game's
}
if (msg.Content.Length == 1) // message must be 1 char long
{
if (++MessagesSinceLastPost > 10)
{
MessagesSinceLastPost = 0;
try
{
await GameChannel.SendConfirmAsync("Hangman Game",
ScrambledWord + "\n" + GetHangman(),
footer : string.Join(" ", Guesses)).ConfigureAwait(false);
}
catch { }
}
if (!(char.IsLetter(msg.Content[0]) || char.IsDigit(msg.Content[0])))// and a letter or a digit
{
return;
}
var guess = char.ToUpperInvariant(msg.Content[0]);
if (Guesses.Contains(guess))
{
MessagesSinceLastPost = 0;
++Errors;
if (Errors < MaxErrors)
{
await GameChannel.SendErrorAsync("Hangman Game", $"{msg.Author.Mention} Letter `{guess}` has already been used.\n" + ScrambledWord + "\n" + GetHangman(),
footer : string.Join(" ", Guesses)).ConfigureAwait(false);
}
else
{
await End().ConfigureAwait(false);
}
return;
}
Guesses.Add(guess);
/*int HangmanCurrencyRewardAll = 5;
* int HangmanCurrencyRewardLetter = 1;*/
if (Term.Word.ToUpperInvariant().Contains(guess))
{
if (GuessedAll)
{
try { await GameChannel.SendConfirmAsync("Hangman Game", $"{msg.Author.Mention} guessed a letter `{guess}`!").ConfigureAwait(false); } catch { }
// giving reward
if (NadekoBot.BotConfig.HangmanCurrencyRewardAll > 0)
{
await CurrencyHandler.AddCurrencyAsync(msg.Author, $"Received {NadekoBot.BotConfig.CurrencyPluralName}", NadekoBot.BotConfig.HangmanCurrencyRewardAll, false).ConfigureAwait(false);
await GameChannel.SendConfirmAsync($"**{msg.Author}** received {NadekoBot.BotConfig.HangmanCurrencyRewardAll} {NadekoBot.BotConfig.CurrencySign}!").ConfigureAwait(false);
}
await End().ConfigureAwait(false);
return;
}
MessagesSinceLastPost = 0;
try
{
await GameChannel.SendConfirmAsync("Hangman Game", $"{msg.Author.Mention} guessed a letter `{guess}`!\n" + ScrambledWord + "\n" + GetHangman(),
footer : string.Join(" ", Guesses)).ConfigureAwait(false);
if (NadekoBot.BotConfig.HangmanCurrencyRewardLetter > 0)
{
await CurrencyHandler.AddCurrencyAsync(msg.Author, $"Received {NadekoBot.BotConfig.CurrencyPluralName}", NadekoBot.BotConfig.HangmanCurrencyRewardLetter, false).ConfigureAwait(false);
await GameChannel.SendConfirmAsync($"**{msg.Author}** received {NadekoBot.BotConfig.HangmanCurrencyRewardLetter} {NadekoBot.BotConfig.CurrencySign}!").ConfigureAwait(false);
}
}
catch { }
}
else
{
MessagesSinceLastPost = 0;
++Errors;
if (Errors < MaxErrors)
{
await GameChannel.SendErrorAsync("Hangman Game", $"{msg.Author.Mention} Letter `{guess}` does not exist.\n" + ScrambledWord + "\n" + GetHangman(),
footer : string.Join(" ", Guesses)).ConfigureAwait(false);
}
else
{
await End().ConfigureAwait(false);
}
}
}
}
catch (Exception ex) { _log.Warn(ex); }
}
private Task PotentialGuess(IMessage msg)
{
if (msg.Channel != GameChannel)
{
return(Task.CompletedTask); // message's channel has to be the same as game's
}
if (msg.Content.Length != 1) // message must be 1 char long
{
if (++MessagesSinceLastPost > 10)
{
MessagesSinceLastPost = 0;
Task.Run(async() =>
{
try { await GameChannel.SendConfirmAsync("Hangman Game", ScrambledWord + "\n" + GetHangman()).ConfigureAwait(false); } catch { }
});
}
return(Task.CompletedTask);
}
if (!(char.IsLetter(msg.Content[0]) || char.IsDigit(msg.Content[0])))// and a letter or a digit
{
return(Task.CompletedTask);
}
var guess = char.ToUpperInvariant(msg.Content[0]);
// todo hmmmm
// how do i want to limit the users on guessing?
// one guess every 5 seconds if wrong?
Task.Run(async() =>
{
try
{
if (Guesses.Contains(guess))
{
++Errors;
if (Errors < MaxErrors)
{
await GameChannel.SendErrorAsync("Hangman Game", $"{msg.Author.Mention} Letter `{guess}` has already been used.\n" + ScrambledWord + "\n" + GetHangman()).ConfigureAwait(false);
}
else
{
await End().ConfigureAwait(false);
}
return;
}
Guesses.Add(guess);
if (Term.Word.ToUpperInvariant().Contains(guess))
{
if (GuessedAll)
{
try { await GameChannel.SendConfirmAsync("Hangman Game", $"{msg.Author.Mention} guessed a letter `{guess}`!").ConfigureAwait(false); } catch { }
await End().ConfigureAwait(false);
return;
}
try { await GameChannel.SendConfirmAsync("Hangman Game", $"{msg.Author.Mention} guessed a letter `{guess}`!\n" + ScrambledWord + "\n" + GetHangman()).ConfigureAwait(false); } catch { }
}
else
{
++Errors;
if (Errors < MaxErrors)
{
await GameChannel.SendErrorAsync("Hangman Game", $"{msg.Author.Mention} Letter `{guess}` does not exist.\n" + ScrambledWord + "\n" + GetHangman()).ConfigureAwait(false);
}
else
{
await End().ConfigureAwait(false);
}
}
}
catch { }
});
return(Task.CompletedTask);
}
/// <summary>
/// Verifies if there are no more remaining users to make their guess in the current round.
/// If no, the next round can begin.
/// </summary>
/// <returns>True if the next round can begin. False if there are still players that needs to play.</returns>
internal bool HasHoRemainingUsers()
{
return(Guesses.Count() == Users.Count());
}
private async Task PotentialGuess(SocketMessage msg)
{
try
{
if (!(msg is SocketUserMessage))
{
return;
}
if (msg.Channel != GameChannel)
{
return; // message's channel has to be the same as game's
}
if (msg.Content.Length == 1) // message must be 1 char long
{
if (++MessagesSinceLastPost > 10)
{
MessagesSinceLastPost = 0;
try
{
await GameChannel.SendConfirmAsync("Hangman Game",
ScrambledWord + "\n" + GetHangman(),
footer : string.Join(" ", Guesses)).ConfigureAwait(false);
}
catch { }
}
if (!(char.IsLetter(msg.Content[0]) || char.IsDigit(msg.Content[0])))// and a letter or a digit
{
return;
}
var guess = char.ToUpperInvariant(msg.Content[0]);
if (Guesses.Contains(guess))
{
MessagesSinceLastPost = 0;
++Errors;
if (Errors < MaxErrors)
{
await GameChannel.SendErrorAsync("Hangman Game", $"{msg.Author.Mention} Letter `{guess}` has already been used.\n" + ScrambledWord + "\n" + GetHangman(),
footer : string.Join(" ", Guesses)).ConfigureAwait(false);
}
else
{
await End().ConfigureAwait(false);
}
return;
}
Guesses.Add(guess);
if (Term.Word.ToUpperInvariant().Contains(guess))
{
if (GuessedAll)
{
try { await GameChannel.SendConfirmAsync("Hangman Game", $"{msg.Author.Mention} guessed a letter `{guess}`!").ConfigureAwait(false); } catch { }
await End().ConfigureAwait(false);
return;
}
MessagesSinceLastPost = 0;
try
{
await GameChannel.SendConfirmAsync("Hangman Game", $"{msg.Author.Mention} guessed a letter `{guess}`!\n" + ScrambledWord + "\n" + GetHangman(),
footer : string.Join(" ", Guesses)).ConfigureAwait(false);
}
catch { }
}
else
{
MessagesSinceLastPost = 0;
++Errors;
if (Errors < MaxErrors)
{
await GameChannel.SendErrorAsync("Hangman Game", $"{msg.Author.Mention} Letter `{guess}` does not exist.\n" + ScrambledWord + "\n" + GetHangman(),
footer : string.Join(" ", Guesses)).ConfigureAwait(false);
}
else
{
await End().ConfigureAwait(false);
}
}
}
}
catch (Exception ex) { _log.Warn(ex); }
}
/// <summary>
/// Remove a user from the game
/// </summary>
/// <param name="name">User's nickname</param>
internal void Removeuser(string name)
{
Users.Remove(name);
Guesses.Remove(name);
}
