Drei gewinnt

[TestClass] 
public class GameStateTests 
{ 
  [TestMethod] 
  [TestCategory("GameState")] 
  public void GameState_Running() 
  { 
    // Act 
    var expectedState = typeof(GameStateRunning); 
    var actualState = 
      new GameStateRunning().Execute(); 
 
    // Assert 
    Assert.IsInstanceOfType( 
      actualState, 
      expectedState); 
  } 
} 
 

namespace TicTacToe.Lib; 
public class GameStateRunning 
{ 
  public object Execute()
  { 
    throw new NotImplementedException(); 
  } 
} 
 

namespace TicTacToe.Lib; 
public interface IGameState 
{ 
  IGameState Execute(); 
} 
 

public class GameStateRunning : IGameState 
{ 
  public IGameState Execute() { 
    return this; 
  } 
} 
 

IGameState Execute(GameBoard board); 

IUserInput userInput; 
 

public GameBoard(IUserInput userInput) 
{ 
  this.userInput = userInput; 
} 
 

public int GetField() 
{ 
  return userInput.GetField(this.ActivePlayer); 
} 
 

[TestMethod] 
[TestCategory("GameState")] 
public void GameState_Running() 
{ 
  // Arrange 
  var userInput = new StubUserInput() 
  { 
    GetFieldPlayer = player => { return 1; } 
  }; 
 
  // Act 
  var expectedState = typeof(GameStateRunning); 
  var actualState = new GameStateRunning() 
    .Execute(new GameBoard(userInput)); 
 
  // Assert 
  Assert.IsInstanceOfType( 
    actualState, 
    expectedState); 
} 

IGameState SimulateGame(GameBoard board) 
{ 
  IGameState currentState = new GameStateRunning(); 
  IGameState lastState = null; 
 
  while (currentState != null) 
  { 
    lastState = currentState; 
    currentState = currentState.Execute(board); 
  } 
  return lastState; 
} 
 

private int[] movesPlayerOneWins = { 1, 2, 4, 5, 7 }; 
 
X O _ 
X O _ 
X _ _  => Spieler 1 gewinnt 
 

static int move = 0; 
 

[TestMethod] 
[TestCategory("GameState")] 
public void GameState_Won() 
{ 
  // Arrange 
  var userInput = new StubUserInput() 
  { 
    GetFieldPlayer = player => { 
      return movesPlayerOneWins[move++]; } 
  }; 
 
  // Act 
  var expectedState = typeof(GameStateWon); 
  var actualState = SimulateGame( 
    new GameBoard(userInput)); 
 
  // Assert 
  Assert.IsInstanceOfType( 
    actualState, 
    expectedState); 
} 
 

public class GameStateWon : IGameState 
{ 
  public IGameState Execute(GameBoard board) { 
    return null; 
  } 
} 
 

if (board.CheckWinner()) { 
  return new GameStateWon(); 
} 
 

int[] movesRemis = { 1, 2, 4, 7, 8, 5, 9, 6, 3 }; 
 

[TestMethod] 
[TestCategory("GameState")] 
public void GameState_Remis() 
{ 
  // Arrange 
  var userInput = new StubUserInput() 
  { 
    GetFieldPlayer = player => { 
      return movesRemis[move++]; } 
  }; 
  // Act 
  var expectedState = typeof(GameStateRemis); 
  var actualState = this.SimulateGame( 
    new GameBoard(userInput)); 
  // Assert 
  Assert.IsInstanceOfType(actualState, expectedState); 
} 
 

public class GameStateRemis : IGameState 
{ 
  public IGameState Execute(GameBoard board) { 
    return null; 
  } 
} 
 

... 
else if( moveCount == 9) 
{ 
  return new GameStateRemis(); 
} 
 

[TestInitialize] 
public void Initialize() { 
  move = 0; 
} 
 

X _ _ 
O X _ 
O O X 
 

[TestMethod] 
[TestCategory("GameBoard")] 
public void Display_Board() 
{ 
  // Gameboard representation 
  // 8 7 6 
  // 5 4 3 
  // 2 1 0 
 
  board.Set(8); 
  board.Set(5); 
  board.Set(4); 
  board.Set(2); 
  board.Set(0); 
  board.Set(1); 
 
  // X # # 
  // O X # 
  // O O X 
 
  var actual = board.ToString(); 
  var expected = "X__\r\nOX_\r\nOOX\r\n"; 
 
  actual.Should().Be(expected); 
} 
 

public override string ToString() 
{ 
  // Convert the board (represented as a number) 
  // to a bit string. The padding makes sure that 
  // it is 18 characters in size and gets leading 
  // zeros. 
  var bits = 
    Convert.ToString(board, 2).PadLeft(18, '0'); 
  
  var sb = new StringBuilder(); 
  string nextCharacter; 
 
  for (int i = 0; i < 9; i++) 
  { 
    nextCharacter = "_"; // An empty field 

    if (bits[i].Equals('1')) nextCharacter = "O"; 
    if (bits[i + 9].Equals('1')) nextCharacter = "X"; 
 
    sb.Append(nextCharacter); 
 
    // Linebreak 
    if ((i + 1) % 3 == 0) sb.AppendLine(); 
  } 
  return sb.ToString(); 
} 
 

using TicTacToe.Lib; 
namespace TicTacToe.Console; 
 
public class UserInput : IUserInput 
{ 
  public int GetField(Player player) 
  { 
    string? input; 
    int field; 
    do 
    { 
      System.Console.WriteLine("Player {0}, 
        please enter a number between 1 and 9.", 
        (int)player + 1); 
      input = System.Console.ReadLine(); 
    } while (!int.TryParse(input, out field) || 
        field < 1 || field > 9); 
 
    return field; 
  } 
} 

using TicTacToe.Lib; 
 
var board = new GameBoard(new UserInput()); 
IGameState currentState = new GameStateRunning(); 
 
while (currentState != null) { 
  Console.Clear(); 
  Console.WriteLine(board); 
 
  Try { 
    currentState = currentState.Execute(board); 
  } 
  catch (Exception ex) { 
    Console.WriteLine(ex.Message); 
    Console.WriteLine("Press any key to continue."); 
    Console.ReadLine(); 
  } 
}