C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;


public enum Piece { empty, white, black }


public static class menu
{
 public static void SelectGameType()
 {
  Console.WriteLine("What game would you like to play?");
  Console.WriteLine("Othello/Gomoku");

  bool gameSelectStatus = false;

  string gameTypeSelect;

  while (!gameSelectStatus)
  {

   gameTypeSelect = Console.ReadLine();

   if (gameTypeSelect == "Othello")
   {
	Program.currentGame = new Othello();
    break;
   }

   else if (gameTypeSelect == "Gomoku")
   {
    Console.WriteLine("Sorry, we have been developping this game. Othello please!");
   }
   else
   {
    Console.WriteLine("Invalid code. Please type again");
   }
  }
 }

 public static bool GamePlayerSelect()
 {
  bool gameModeStatus = false;
  string playerSelect;

  Console.WriteLine("Which game mode would you like to play?");
  Console.WriteLine("Human VS Human (type: h)/ Human VS Computer (type: c)");

  while (!gameModeStatus)
  {
   playerSelect = Console.ReadLine();

   if (playerSelect == "h") return true;
   else if (playerSelect == "c") return false;
   else Console.WriteLine("Invalid code. Please type again");
  }
  return false; //if gameModeStatus starts as true instead of false, while loop will never run. bool method always needs return.
 }
}



public class Board
{
 public Piece[,] pieces;
 public bool blacksTurn;

 public Board CopyBoard()
 { // creates a new instance of Board that's a copy of this one
  Board newBoard = new Board();
  newBoard.pieces = (Piece[,])pieces.Clone(); // make a new copy of pieces
  newBoard.blacksTurn = blacksTurn;
  return newBoard;
 }
}

public class GameHistory
{
 public Board[] boards;
}


public class Program
{
	public static bool gameFinished;
	public static bool gamePlayerSelect;
	public static int currentTurn; // starts at 0
	public static Game currentGame;

 public static void Main()
 {
  menu.SelectGameType(); // call SelectGameType class

  gamePlayerSelect = menu.GamePlayerSelect(); //store player mode.

  // initialize game history
  GameHistory history = new GameHistory();
  history.boards = new Board[64]; // game ends after 64 moves

  // initilize board
  Board board = new Board(); // create a new instance of a board class
  board.pieces = new Piece[8, 8]; // initialize pieces array

  // set random stones
  board.pieces[4, 4] = Piece.white;
  board.pieces[4, 3] = Piece.black;
  board.pieces[3, 3] = Piece.white;
  board.pieces[3, 4] = Piece.black;

  // add initial board to history
  history.boards[currentTurn] = board.CopyBoard();

  DisplayBoard(board);


  int computerX = 0, computerY = 0;

  while (!gameFinished)
  { //gameFinished == false

   if (!gamePlayerSelect && board.blacksTurn)// let computer move
   {
    

    while (!GameRules.IsMoveLegal(board, computerX, computerY))
    {
     Random computerMovementPositionX = new System.Random();
     computerX = computerMovementPositionX.Next(0, 7);

     Random computerMovementPositionY = new System.Random();
     computerY = computerMovementPositionY.Next(0, 7);
    }
    // make move
    GameRules.MakeMove(board, computerX, computerY);
    currentTurn += 1;

    // add board to history
    history.boards[currentTurn] = board.CopyBoard();

    // show new board
    DisplayBoard(board);
   }

   else //get player input
   {
    // get command
    Console.Write("undo/redo?");
    string command = Console.ReadLine();
    if (command == "undo")
    {
     currentTurn -= 1;
     board = history.boards[currentTurn].CopyBoard();
     DisplayBoard(board);
    }
    else if (command == "redo")
    {
     currentTurn += 1;
     board = history.boards[currentTurn].CopyBoard();
     DisplayBoard(board);
    }

    else
    {

     // get input
     Console.Write("x:");
     int inputX = int.Parse(Console.ReadLine());
     Console.Write("Y:");
     int inputY = int.Parse(Console.ReadLine());

     // check if move is legal
     if (GameRules.IsMoveLegal(board, inputX, inputY))
     {

      // make move
      GameRules.MakeMove(board, inputX, inputY);
      currentTurn += 1;

      // add board to history
      history.boards[currentTurn] = board.CopyBoard();

      // show new board
      DisplayBoard(board);
     }
     else
     {
      Console.Write("Illegal move!\n");
     }
    }
   }
  }
 } 


 public static void DisplayBoard(Board board)
 {
  // display
  string display = " 01234567\n"; // initialize empty string

 

  for (int y = 0; y < 8; y++)
  {
   display += y.ToString();　// display 0~7 on the left hand side
   for (int x = 0; x < 8; x++)
   {
    display += PieceToChar(board.pieces[x, y]);
   }
   display += "\n"; // add line break every 8 characters
  }

  Console.Write(display);
 }

 public static char PieceToChar(Piece piece)
 {

  if (piece == Piece.white) return '○';
  if (piece == Piece.black) return '●';
  return '.'; // empty piece
 }
}

public class Move
{
 int x;
 int y;
 bool blacksTurn;
}

public class Game 
{
	public virtual bool IsMoveLegal (Board board, int x, int y)
	{
		return false;
	}
	
	public virtual void MakeMove (Board board, int x, int y)
	{
		
	}
}


public class Othello : Game
{

 public override bool IsMoveLegal(Board board, int x, int y)
 {
  // check if not already occupied
  if (board.pieces[x, y] != Piece.empty)
   return false;

  // check every direction until we find a valid one (up, down, left, right, and diagonal
  if (CheckDirection(board, x, y, 1, 0)) return true;
  if (CheckDirection(board, x, y, 0, 1)) return true;
  if (CheckDirection(board, x, y, -1, 0)) return true;
  if (CheckDirection(board, x, y, 0, -1)) return true;

  if (CheckDirection(board, x, y, 1, 1)) return true;
  if (CheckDirection(board, x, y, 1, -1)) return true;
  if (CheckDirection(board, x, y, -1, 1)) return true;
  if (CheckDirection(board, x, y, -1, -1)) return true;

  return false;

 }

 private bool CheckDirection(Board board, int moveX, int moveY, int dirX, int dirY) // check if we can capture any pieces in the given direction 
 {
  // can't capture in this direction if it's on the edge of the board
  if (IsWithinBoard(moveX + dirX, moveY + dirY) == false) return false;

  // get pieces
  Piece ourStone = Piece.white;
  Piece oppositeStone = Piece.black;
  if (board.blacksTurn) ourStone = Piece.black;
  if (board.blacksTurn) oppositeStone = Piece.white;

  // check if the stone next to us is opposite color
  bool nextToOpposite = false;
  if (board.pieces[moveX + dirX, moveY + dirY] == oppositeStone)
  {
   nextToOpposite = true;
  }

  // check if there is our color stone in the given direction
  bool sameColorStoneFound = false;
  int x = moveX + dirX;
  int y = moveY + dirY;
  while (IsWithinBoard(x, y)) // each loop checks the next coordinate, until we find our stone or reach an empty square or the edge of the board
  {
   if (board.pieces[x, y] == ourStone)
   {
    sameColorStoneFound = true;
    break; // exit the loop when we find the first stone
   }

   if (board.pieces[x, y] == Piece.empty)
   {
    break;  // exit the loop if we reach an empty space
   }

   // move to next coordinate in the given direction
   x += dirX;
   y += dirY;
  }

  // direction is valid (can capture) if both conditions are true
  if (nextToOpposite && sameColorStoneFound)
   return true;
  else
   return false;

 }


 private bool IsWithinBoard(int x, int y)
 {
  if (x > 7 || x < 0 || y > 7 || y < 0)
  {
   return false;
  }
  else return true;
 }


 public override void MakeMove(Board board, int x, int y)
 {

  // apply player input
  if (board.blacksTurn) board.pieces[x, y] = Piece.black;
  else board.pieces[x, y] = Piece.white;

  // flip opponent's stones
  FlipStonesInDirection(board, x, y, 1, 0);
  FlipStonesInDirection(board, x, y, 0, 1);
  FlipStonesInDirection(board, x, y, -1, 0);
  FlipStonesInDirection(board, x, y, 0, -1);

  FlipStonesInDirection(board, x, y, 1, 1);
  FlipStonesInDirection(board, x, y, 1, -1);
  FlipStonesInDirection(board, x, y, -1, 1);
  FlipStonesInDirection(board, x, y, -1, -1);

  // switch turns
  board.blacksTurn = !board.blacksTurn;

 }

 private void FlipStonesInDirection(Board board, int moveX, int moveY, int dirX, int dirY)
 {
  // don't do anything if this direction is not valid (can't capture/flip any pieces)
  if ((CheckDirection(board, moveX, moveY, dirX, dirY)) == false)
  {
   return;
  }

  // get pieces
  Piece ourStone = Piece.white;
  Piece oppositeStone = Piece.black;
  if (board.blacksTurn) ourStone = Piece.black;
  if (board.blacksTurn) oppositeStone = Piece.white;

  // keep going in direction flipping everything on the way until we reach our stone
  int x = moveX + dirX;
  int y = moveY + dirY;
  while (IsWithinBoard(x, y)) // each loop checks the next coordinate, until we find our stone or reach an empty square (should never happen here) or the edge of the board
  {
   if (board.pieces[x, y] == oppositeStone)
   {
    board.pieces[x, y] = ourStone; // flip and keep the loop going
   }

   else if (board.pieces[x, y] == ourStone)
   {
    break;
   }

   else if (board.pieces[x, y] == Piece.empty)
   {
    Console.Write("ERROR (this should never happen.");
    break;
   }

   // move to next coordinate in the given direction
   x += dirX;
   y += dirY;
  }


 }



}

​x
 
using System;
​
​
public enum Piece { empty, white, black }
​
​
public static class menu
{
 public static void SelectGameType()
 {
  Console.WriteLine("What game would you like to play?");
  Console.WriteLine("Othello/Gomoku");
​
  bool gameSelectStatus = false;
​
  string gameTypeSelect;
​
  while (!gameSelectStatus)
  {
​
   gameTypeSelect = Console.ReadLine();
​
   if (gameTypeSelect == "Othello")
   {
    Program.currentGame = new Othello();
    break;
   }
​
   else if (gameTypeSelect == "Gomoku")
   {
    Console.WriteLine("Sorry, we have been developping this game. Othello please!");
   }
   else
   {
    Console.WriteLine("Invalid code. Please type again");
   }
  }
 }
​
 public static bool GamePlayerSelect()
 {
  bool gameModeStatus = false;
  string playerSelect;
​
  Console.WriteLine("Which game mode would you like to play?");
  Console.WriteLine("Human VS Human (type: h)/ Human VS Computer (type: c)");
​
  while (!gameModeStatus)
  {
   playerSelect = Console.ReadLine();
​
   if (playerSelect == "h") return true;
   else if (playerSelect == "c") return false;
   else Console.WriteLine("Invalid code. Please type again");
  }
  return false; //if gameModeStatus starts as true instead of false, while loop will never run. bool method always needs return.
 }
}
​
​
​
public class Board
{
 public Piece[,] pieces;
 public bool blacksTurn;
​
 public Board CopyBoard()
 { // creates a new instance of Board that's a copy of this one
  Board newBoard = new Board();
  newBoard.pieces = (Piece[,])pieces.Clone(); // make a new copy of pieces
  newBoard.blacksTurn = blacksTurn;
  return newBoard;
 }
}
​
public class GameHistory
{
 public Board[] boards;
}
​
​
public class Program
{
    public static bool gameFinished;
    public static bool gamePlayerSelect;
    public static int currentTurn; // starts at 0
    public static Game currentGame;
​
 public static void Main()
 {
  menu.SelectGameType(); // call SelectGameType class
​
  gamePlayerSelect = menu.GamePlayerSelect(); //store player mode.
​
  // initialize game history
  GameHistory history = new GameHistory();
  history.boards = new Board[64]; // game ends after 64 moves
​
  // initilize board
  Board board = new Board(); // create a new instance of a board class
  board.pieces = new Piece[8, 8]; // initialize pieces array
​
  // set random stones
  board.pieces[4, 4] = Piece.white;
  board.pieces[4, 3] = Piece.black;
  board.pieces[3, 3] = Piece.white;
  board.pieces[3, 4] = Piece.black;
​
  // add initial board to history
  history.boards[currentTurn] = board.CopyBoard();
​
  DisplayBoard(board);
​
​
  int computerX = 0, computerY = 0;
​
  while (!gameFinished)
  { //gameFinished == false
​
   if (!gamePlayerSelect && board.blacksTurn)// let computer move
   {
    
​
    while (!GameRules.IsMoveLegal(board, computerX, computerY))
    {
     Random computerMovementPositionX = new System.Random();
     computerX = computerMovementPositionX.Next(0, 7);
​
     Random computerMovementPositionY = new System.Random();
     computerY = computerMovementPositionY.Next(0, 7);
    }
    // make move
    GameRules.MakeMove(board, computerX, computerY);
    currentTurn += 1;
​
    // add board to history
    history.boards[currentTurn] = board.CopyBoard();
​
    // show new board
    DisplayBoard(board);
   }
​
   else //get player input
   {
    // get command
    Console.Write("undo/redo?");
    string command = Console.ReadLine();
    if (command == "undo")
    {
     currentTurn -= 1;
     board = history.boards[currentTurn].CopyBoard();
     DisplayBoard(board);
    }
    else if (command == "redo")
    {
     currentTurn += 1;
     board = history.boards[currentTurn].CopyBoard();
     DisplayBoard(board);
    }
​
    else
    {
​
     // get input
     Console.Write("x:");
     int inputX = int.Parse(Console.ReadLine());
     Console.Write("Y:");
     int inputY = int.Parse(Console.ReadLine());
​
     // check if move is legal
     if (GameRules.IsMoveLegal(board, inputX, inputY))
     {
​
      // make move
      GameRules.MakeMove(board, inputX, inputY);
      currentTurn += 1;
​
      // add board to history
      history.boards[currentTurn] = board.CopyBoard();
​
      // show new board
      DisplayBoard(board);
     }
     else
     {
      Console.Write("Illegal move!\n");
     }
    }
   }
  }
 } 
​
​
 public static void DisplayBoard(Board board)
 {
  // display
  string display = " 01234567\n"; // initialize empty string
​
 
​
  for (int y = 0; y < 8; y++)
  {
   display += y.ToString();　// display 0~7 on the left hand side
   for (int x = 0; x < 8; x++)
   {
    display += PieceToChar(board.pieces[x, y]);
   }
   display += "\n"; // add line break every 8 characters
  }
​
  Console.Write(display);
 }
​
 public static char PieceToChar(Piece piece)
 {
​
  if (piece == Piece.white) return '○';
  if (piece == Piece.black) return '●';
  return '.'; // empty piece
 }
}
​
public class Move
{
 int x;
 int y;
 bool blacksTurn;
}
​
public class Game 
{
    public virtual bool IsMoveLegal (Board board, int x, int y)
    {
        return false;
    }
    
    public virtual void MakeMove (Board board, int x, int y)
    {
        
    }
}
​
​
public class Othello : Game
{
​
 public override bool IsMoveLegal(Board board, int x, int y)
 {
  // check if not already occupied
  if (board.pieces[x, y] != Piece.empty)
   return false;
​
  // check every direction until we find a valid one (up, down, left, right, and diagonal
  if (CheckDirection(board, x, y, 1, 0)) return true;
  if (CheckDirection(board, x, y, 0, 1)) return true;
  if (CheckDirection(board, x, y, -1, 0)) return true;
  if (CheckDirection(board, x, y, 0, -1)) return true;
​
  if (CheckDirection(board, x, y, 1, 1)) return true;
  if (CheckDirection(board, x, y, 1, -1)) return true;
  if (CheckDirection(board, x, y, -1, 1)) return true;
  if (CheckDirection(board, x, y, -1, -1)) return true;
​
  return false;
​
 }
​
 private bool CheckDirection(Board board, int moveX, int moveY, int dirX, int dirY) // check if we can capture any pieces in the given direction 
 {
  // can't capture in this direction if it's on the edge of the board
  if (IsWithinBoard(moveX + dirX, moveY + dirY) == false) return false;
​
  // get pieces
  Piece ourStone = Piece.white;
  Piece oppositeStone = Piece.black;
  if (board.blacksTurn) ourStone = Piece.black;
  if (board.blacksTurn) oppositeStone = Piece.white;
​
  // check if the stone next to us is opposite color
  bool nextToOpposite = false;
  if (board.pieces[moveX + dirX, moveY + dirY] == oppositeStone)
  {
   nextToOpposite = true;
  }
​
  // check if there is our color stone in the given direction
  bool sameColorStoneFound = false;
  int x = moveX + dirX;
  int y = moveY + dirY;
  while (IsWithinBoard(x, y)) // each loop checks the next coordinate, until we find our stone or reach an empty square or the edge of the board
  {
   if (board.pieces[x, y] == ourStone)
   {
    sameColorStoneFound = true;
    break; // exit the loop when we find the first stone
   }
​
   if (board.pieces[x, y] == Piece.empty)
   {
    break;  // exit the loop if we reach an empty space
   }
​
   // move to next coordinate in the given direction
   x += dirX;
   y += dirY;
  }
​
  // direction is valid (can capture) if both conditions are true
  if (nextToOpposite && sameColorStoneFound)
   return true;
  else
   return false;
​
 }
​
​
 private bool IsWithinBoard(int x, int y)
 {
  if (x > 7 || x < 0 || y > 7 || y < 0)
  {
   return false;
  }
  else return true;
 }
​
​
 public override void MakeMove(Board board, int x, int y)
 {
​
  // apply player input
  if (board.blacksTurn) board.pieces[x, y] = Piece.black;
  else board.pieces[x, y] = Piece.white;
​
  // flip opponent's stones
  FlipStonesInDirection(board, x, y, 1, 0);
  FlipStonesInDirection(board, x, y, 0, 1);
  FlipStonesInDirection(board, x, y, -1, 0);
  FlipStonesInDirection(board, x, y, 0, -1);
​
  FlipStonesInDirection(board, x, y, 1, 1);
  FlipStonesInDirection(board, x, y, 1, -1);
  FlipStonesInDirection(board, x, y, -1, 1);
  FlipStonesInDirection(board, x, y, -1, -1);
​
  // switch turns
  board.blacksTurn = !board.blacksTurn;
​
 }
​
 private void FlipStonesInDirection(Board board, int moveX, int moveY, int dirX, int dirY)
 {
  // don't do anything if this direction is not valid (can't capture/flip any pieces)
  if ((CheckDirection(board, moveX, moveY, dirX, dirY)) == false)
  {
   return;
  }
​
  // get pieces
  Piece ourStone = Piece.white;
  Piece oppositeStone = Piece.black;
  if (board.blacksTurn) ourStone = Piece.black;
  if (board.blacksTurn) oppositeStone = Piece.white;
​
  // keep going in direction flipping everything on the way until we reach our stone
  int x = moveX + dirX;
  int y = moveY + dirY;
  while (IsWithinBoard(x, y)) // each loop checks the next coordinate, until we find our stone or reach an empty square (should never happen here) or the edge of the board
  {
   if (board.pieces[x, y] == oppositeStone)
   {
    board.pieces[x, y] = ourStone; // flip and keep the loop going
   }
​
   else if (board.pieces[x, y] == ourStone)
   {
    break;
   }
​
   else if (board.pieces[x, y] == Piece.empty)
   {
    Console.Write("ERROR (this should never happen.");
    break;
   }
​
   // move to next coordinate in the given direction
   x += dirX;
   y += dirY;
  }
​
​
 }
​
​
​
}

1 2 3
4 5 6
7 8 9
where do you want to play:

Cached Result
Last Run:	10:02:46 am
Compile:	0.106s
Execute:	0.002s
Memory:	32kb
CPU:	0.016s

View IL Code