public void PlayAFullGameOfHumanPlayers() { MockConsoleInput( Scissors, Paper, Paper, Paper, Scissors, Paper); var game = AGame.Build(); game.Play(); Assert.Equal( @"Player 1 input (P,R,S):Scissors Player 2 input (P,R,S):Paper Player1Wins Player 1 input (P,R,S):Paper Player 2 input (P,R,S):Paper Draw Player 1 input (P,R,S):Scissors Player 2 input (P,R,S):Paper Player1Wins Final score after 3 turns: Player1Wins!! - 2 times Player1Wins - 0 times Player2Wins - 1 times Draw ", _output.ToString()); }
public override Solution <TMove> Solve(AGame <TMove> game, ANode <TMove> finalState) { Solution <TMove> r = null; int count = this.GetStepCount(game); for (int k = 0; k < count; k++) { var partFinalState = this.BuildSolutionStep(game, finalState, k + 1); base.FilterNode = this.BuildFilterNode(game, finalState, k + 1, partFinalState); Solution <TMove> partial = base.Solve(game, partFinalState); System.Diagnostics.Debug.WriteLine($"Finished step {k + 1} of {count}"); if (partial.Last != null) { game.State = partial.Last; } else { System.Diagnostics.Debug.WriteLine("Could not reach exact solution, is puzzle feasible?"); return(r); } r += partial; } return(r); }
public void PlayAFullGameOfTwoTacticalPlayers() { var randomMoves = new [] { Scissors, Paper }; var game = AGame .WithNumberOfTurns(2) .WithPlayer1("tactical") .WithPlayer2("tactical") .WithRandomMoves(randomMoves) .Build(); game.Play(); Assert.Equal( @"Player 1 (Tactical CPU):S Scissors Player 2 (Tactical CPU):P Paper Player1Wins Player 1 (Tactical CPU):R Rock Player 2 (Tactical CPU):S Scissors Player1Wins Final score after 2 turns: Player1Wins!! - 2 times Player1Wins - 0 times Player2Wins - 0 times Draw ", _output.ToString()); }
public Task PostAsync(IMessageChannel chan, string text, AGame sender) { var quizzAudio = (IAudioGame)sender; quizzAudio.GetNewProcess(); var process = Process.Start(new ProcessStartInfo { FileName = "ffmpeg", Arguments = $"-hide_banner -loglevel fatal -i - -af volume=0.2 -f s16le -ac 2 -ar 48000 pipe:1", UseShellExecute = false, RedirectStandardOutput = true, RedirectStandardInput = true }); quizzAudio.SetCurrentProcess(process); _ = Task.Run(async() => { var stream = await StaticObjects.HttpClient.GetStreamAsync(text); await stream.CopyToAsync(process.StandardInput.BaseStream); process.StandardInput.Close(); }); _ = Task.Run(async() => { using Stream output = process.StandardOutput.BaseStream; try { await output.CopyToAsync(quizzAudio.GetAudioOutStream()); } catch (OperationCanceledException) { return; } }); return(Task.CompletedTask); }
public async Task PostAsync(IMessageChannel chan, string text, AGame _) { try { var result = await StaticObjects.HttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Head, text)); var length = int.Parse(result.Content.Headers.GetValues("content-length").ElementAt(0)); if (length < 8000000) { await chan.SendFileAsync((await StaticObjects.HttpClient.GetAsync(text)).Content.ReadAsStream(), "image" + Path.GetExtension(text)); } else // Too big to be sent on Discord { await chan.SendMessageAsync(text); } } catch (Discord.Net.HttpException dne) { if (dne.DiscordCode == DiscordErrorCode.MissingPermissions) { throw new GameLost("Missing permissions to send files"); } else { throw; } } }
public void GameIsFinishedWithoutWinner_WhenAllPositionsAreTakenAndNoPlayerHasTakenWinLinePositions() { var game = AGame.WithoutWinner(); var result = game.Outcome(); result.Should().Be("egal"); }
public void AskForNextMove_WhenGameIsNotFinished() { var game = AGame.WhichIsNotFinished(); var result = game.Outcome(); result.Should().Be("next"); }
public void ExceptionShouldBeThrown_WhenPlayerMakeMoveToFilledPosition(string activePlayer) { var game = AGame.WithFilledPosition(2, "X"); Action action = () => game.Move(activePlayer, 2); action.ShouldThrow <InvalidOperationException>(); }
public void ExceptionShouldBeThrown_WhenSamePlayerTakeMoreThanOneConsecutiveMoves() { var game = AGame.WithFilledPosition(1, "X"); Action action = () => game.Move("X", 2); action.ShouldThrow <ArgumentException>(); }
private async Task CheckGame(AGame game) { Type type = game.GetType(); MethodInfo info = type.GetMethod("GetPostAsync", BindingFlags.Instance | BindingFlags.NonPublic); foreach (string s in await(Task <string[]>) info.Invoke(game, null)) { Assert.True(await IsLinkValid(s), "Invalid URL " + s); } }
public void PlayerShouldWin_WhenMakeMovesOnOneOfDiagonalLinePositions(string winnerPlayer, string expectedWinner, params int[] diagonalWinPositions) { var game = AGame.WithWinnerPlayer(winnerPlayer, diagonalWinPositions); var winner = game.Outcome(); winner.Should().Be(expectedWinner); }
public async Task PostAsync(IMessageChannel chan, string text, AGame _) { var result = await StaticObjects.HttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Head, text)); var length = int.Parse(result.Content.Headers.GetValues("content-length").ElementAt(0)); if (length < 8000000) { await chan.SendFileAsync(await StaticObjects.HttpClient.GetStreamAsync(text), "image" + Path.GetExtension(text)); } else // Too big to be sent on Discord { await chan.SendMessageAsync(text); } }
public void CalculateScore(string player1Move, string player2Move, Score expectedScore) { MockConsoleInput( player1Move, player2Move); var game = AGame .WithNumberOfTurns(1) .Build(); game.Play(); Assert.Contains( $@"Final score after 1 turns: {expectedScore}!!", _output.ToString()); }
public void PlayAFullGameWithTwoRandomCpuPlayers() { var randomMoves = new [] { Scissors, Paper, Paper, Paper, Rock, Scissors }; var game = AGame .WithPlayer1("random") .WithPlayer2("random") .WithRandomMoves(randomMoves) .Build(); game.Play(); Assert.Equal( @"Player 1 (Random CPU):S Scissors Player 2 (Random CPU):P Paper Player1Wins Player 1 (Random CPU):P Paper Player 2 (Random CPU):P Paper Draw Player 1 (Random CPU):R Rock Player 2 (Random CPU):S Scissors Player1Wins Final score after 3 turns: Player1Wins!! - 2 times Player1Wins - 0 times Player2Wins - 1 times Draw ", _output.ToString()); }
public void IgnoreInvalidUserInputAndRequestItAgain() { MockConsoleInput( "Invalid", Scissors, Paper); var game = AGame .WithNumberOfTurns(1) .Build(); game.Play(); Assert.Contains( @"Player 1 input (P,R,S):Player 1 input (P,R,S):Scissors Player 2 input (P,R,S):Paper Player1Wins", _output.ToString()); }
void UpdateMenuInfo() { AGame game = ROM.Instance.Game; codeLabel.Text = game.Code; gameLabel.Text = game.Name; creatorLabel.Text = game.Creator; tableNumerical.Maximum = game.SongTables.Length - 1; tableNumerical.Value = 0; tableNumerical.Visible = game.SongTables.Length > 1; SetSongMaximum(); PopulatePlaylists(game.Playlists); openMIDIToolStripMenuItem.Enabled = openASMToolStripMenuItem.Enabled = teToolStripMenuItem.Enabled = vteToolStripMenuItem.Enabled = eSf2ToolStripMenuItem.Enabled = eASMToolStripMenuItem.Enabled = eMIDIToolStripMenuItem.Enabled = songsComboBox.Enabled = songNumerical.Enabled = playButton.Enabled = true; }
public void PlayAFullGameWithMixOfHumanAndRandomCpuPlayers() { MockConsoleInput( Scissors, Paper, Rock ); var randomMoves = new [] { Paper, Paper, Scissors }; var game = AGame .WithPlayer1("human") .WithPlayer2("random") .WithRandomMoves(randomMoves) .Build(); game.Play(); Assert.Equal( @"Player 1 input (P,R,S):Scissors Player 2 (Random CPU):P Paper Player1Wins Player 1 input (P,R,S):Paper Player 2 (Random CPU):P Paper Draw Player 1 input (P,R,S):Rock Player 2 (Random CPU):S Scissors Player1Wins Final score after 3 turns: Player1Wins!! - 2 times Player1Wins - 0 times Player2Wins - 1 times Draw ", _output.ToString()); }
public virtual Solution <TMove> Solve(AGame <TMove> game, ANode <TMove> finalState) { this.graph = new Graph <TMove>(game.State); this.game = game; // Le noeud passé en paramètre est supposé être le noeud initial var N = game.State; this.graph.Opened.Add(N); // tant que le noeud n'est pas terminal et que ouverts n'est pas vide while (this.graph.Opened.Count != 0 && !finalState.Equals(N)) { // Le meilleur noeud des ouverts est supposé placé en tête de liste // On le place dans les fermés this.graph.Opened.Remove(N); this.graph.Closed.Add(N); // Il faut trouver les noeuds successeurs de N this.UpdateSuccessors(N, finalState); // Inutile de retrier car les insertions ont été faites en respectant l'ordre // On prend le meilleur, donc celui en position 0, pour continuer à explorer les états // A condition qu'il existe bien sûr if (this.graph.Opened.Count > 0) { N = this.graph.Opened[0]; } else { N = null; } } this.graph.Finish(N); return(Solution <TMove> .BuildPathFrom(this.graph)); }
protected override ANode <TaquinGame.Move> BuildSolutionStep(AGame <TaquinGame.Move> gameRef, ANode <TaquinGame.Move> targetState, int n) { this.filter = this.saved ?? this.Build(gameRef as TaquinGame, targetState as TaquinNode, 0); this.saved = this.Build(gameRef as TaquinGame, targetState as TaquinNode, n); return(this.saved); }
protected override ANode <TaquinGame.Move> BuildFilterNode(AGame <TaquinGame.Move> gameRef, ANode <TaquinGame.Move> targetState, int n, ANode <TaquinGame.Move> currentSolutionStep) { return(this.filter); }
protected override int GetStepCount(AGame <TaquinGame.Move> game) { int gameSize = (game as TaquinGame).Size; return(2 * gameSize - 3); }
protected virtual ANode <TMove> BuildFilterNode(AGame <TMove> gameRef, ANode <TMove> targetState, int n, ANode <TMove> currentSolutionStep) { return(null); }
/// <summary> /// Génère la grille de l'étape <paramref name="n"/>. /// </summary> /// <param name="targetState">Etat final ciblé.</param> /// <param name="n">Numéro de l'étape.</param> /// <returns></returns> protected abstract ANode <TMove> BuildSolutionStep(AGame <TMove> gameRef, ANode <TMove> targetState, int n);
public async Task PostAsync(IMessageChannel chan, string text, AGame _) { await chan.SendMessageAsync(text); }
/// <summary> /// Nombre d'étapes soit le plus grand nombre qu'acceptera la fonction <see cref="BuildSolutionStep(ANode{TMove}, int)"/> /// </summary> /// <param name="game"></param> /// <returns></returns> protected abstract int GetStepCount(AGame <TMove> game);