API tools faq
paste
Advertisement
Guest User

idwh

a guest
May 29th, 2015
22
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 21.76 KB | None | 0 0
raw download clone embed print report
  1. // Skeleton program code for the AQA COMP1 Summer 2015 examination
  2. // this code should be used in conjunction with the Preliminary Material
  3. // written by the AQA COMP1 Programmer Team
  4. // developed in the Visual C# 2008 Express programming environment
  5.  
  6. using System;
  7. using System.Collections.Generic;
  8. using System.Linq;
  9. using System.Text;
  10.  
  11. namespace CaptureTheSarrum
  12. {
  13.     class Program
  14.     {
  15.         //public const int BoardDimension = 8;
  16.  
  17.         public const int BoardRanks = 9;
  18.         public const int BoardFiles = 9;
  19.  
  20.         public static int WhiteScore = 0;
  21.         public static int BlackScore = 0;
  22.  
  23.         static void Main(string[] args)
  24.         {
  25.             string[,] Board = new string[BoardRanks + 1, BoardFiles + 1];
  26.             Boolean GameOver;
  27.             int StartSquare = 0;
  28.             int FinishSquare = 0;
  29.             int StartRank = 0;
  30.             int StartFile = 0;
  31.             int FinishRank = 0;
  32.             int FinishFile = 0;
  33.             Boolean MoveIsLegal;
  34.             char PlayAgain;
  35.             char SampleGame;
  36.             char WhoseTurn;
  37.             PlayAgain = 'Y';
  38.             do
  39.             {
  40.                 WhoseTurn = 'W';
  41.                 GameOver = false;
  42.                 //Console.Write("Do you want to play the sample game (enter Y for Yes)? ");
  43.                 //SampleGame = char.Parse(Console.ReadLine());
  44.                 SampleGame = GetTypeOfGame();
  45.                 if ((int)SampleGame >= 97 && (int)SampleGame <= 122)
  46.                     SampleGame = (char)((int)SampleGame - 32);
  47.                 InitialiseBoard(ref Board, SampleGame);
  48.                 do
  49.                 {
  50.                     DisplayBoard(Board);
  51.                     DisplayWhoseTurnItIs(WhoseTurn);
  52.                     MoveIsLegal = false;
  53.                     do
  54.                     {
  55.                         GetMove(ref StartSquare, ref FinishSquare);
  56.                         StartRank = StartSquare % 10;
  57.                         StartFile = StartSquare / 10;
  58.                         FinishRank = FinishSquare % 10;
  59.                         FinishFile = FinishSquare / 10;
  60.                         MoveIsLegal = CheckMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile, WhoseTurn);
  61.                         if (!MoveIsLegal)
  62.                             Console.WriteLine("That is not a legal move - please try again");
  63.                     } while (!MoveIsLegal);
  64.                     GameOver = CheckIfGameWillBeWon(Board, FinishRank, FinishFile);
  65.                     MakeMove(ref Board, StartRank, StartFile, FinishRank, FinishFile, WhoseTurn);
  66.                     if (GameOver)
  67.                         DisplayWinner(WhoseTurn);
  68.                     if (WhoseTurn == 'W')
  69.                         WhoseTurn = 'B';
  70.                     else
  71.                         WhoseTurn = 'W';
  72.                 } while (!GameOver);
  73.                 Console.Write("Do you want to play again (enter Y for Yes)? ");
  74.                 PlayAgain = char.Parse(Console.ReadLine());
  75.                 if ((int)PlayAgain > 97 && (int)PlayAgain <= 122)
  76.                     PlayAgain = (char)((int)PlayAgain - 32);
  77.             } while (PlayAgain == 'Y');
  78.         }
  79.  
  80.         public static void DisplayWhoseTurnItIs(char WhoseTurn)
  81.         {
  82.             if (WhoseTurn == 'W')
  83.                 Console.WriteLine("It is White's turn. White's score is currently " + WhiteScore);
  84.             else
  85.                 Console.WriteLine("It is Black's turn. Black's score is currently " + BlackScore);
  86.         }
  87.  
  88.         public static char GetTypeOfGame()
  89.         {
  90.             char TypeOfGame;
  91.             Console.Write("Do you want to play the sample game (enter Y for Yes or N for No)? ");
  92.             TypeOfGame = char.Parse(Console.ReadLine());
  93.             return TypeOfGame;
  94.         }
  95.  
  96.         public static void DisplayWinner(char WhoseTurn)
  97.         {
  98.             if (WhoseTurn == 'W')
  99.                 Console.WriteLine("Black's Sarrum has been captured.  White wins!");
  100.             else
  101.                 Console.WriteLine("White's Sarrum has been captured.  Black wins!");
  102.             Console.WriteLine();
  103.         }
  104.  
  105.         public static Boolean CheckIfGameWillBeWon(string[,] Board, int FinishRank, int FinishFile)
  106.         {
  107.             Boolean GameWon;
  108.             if (Board[FinishRank, FinishFile][1] == 'S')
  109.                 GameWon = true;
  110.             else
  111.                 GameWon = false;
  112.             return GameWon;
  113.         }
  114.  
  115.         public static void DisplayBoard(string[,] Board)
  116.         {
  117.             int RankNo;
  118.             int FileNo;
  119.             Console.WriteLine();
  120.             for (RankNo = 1; RankNo <= BoardRanks; RankNo++)
  121.             {
  122.                 Console.WriteLine("    ____________________________");
  123.                 Console.Write(RankNo + "   ");
  124.                 for (FileNo = 1; FileNo <= BoardFiles; FileNo++)
  125.                     Console.Write("|" + Board[RankNo, FileNo]);
  126.                 Console.WriteLine("|");
  127.             }
  128.             Console.WriteLine("    ____________________________");
  129.             Console.WriteLine("     1  2  3  4  5  6  7  8  9");
  130.             Console.WriteLine();
  131.             Console.WriteLine();
  132.         }
  133.  
  134.         public static Boolean CheckRedumMoveIsLegal(string[,] Board, int StartRank, int StartFile, int FinishRank, int FinishFile, char ColourOfPiece)
  135.         {
  136.             Boolean RedumMoveIsLegal = false;
  137.             if (ColourOfPiece == 'W')
  138.             {
  139.                 if (FinishRank == StartRank - 1)
  140.                     if ((FinishFile == StartFile) && (Board[FinishRank, FinishFile] == "  "))
  141.                         RedumMoveIsLegal = true;
  142.                     else
  143.                         if ((Math.Abs(FinishFile - StartFile) == 1) && (Board[FinishRank, FinishFile][0] == 'B'))
  144.                             RedumMoveIsLegal = true;
  145.                 if (StartRank == 8)
  146.                 {
  147.                     if (FinishRank == StartRank - 2)
  148.                     if ((FinishFile == StartFile) && (Board[FinishRank, FinishFile] == "  "))
  149.                         RedumMoveIsLegal = true;
  150.                     else
  151.                         if ((Math.Abs(FinishFile - StartFile) == 1) && (Board[FinishRank, FinishFile][0] == 'B'))
  152.                             RedumMoveIsLegal = true;
  153.                 }
  154.             }
  155.             else
  156.             {
  157.                 if (FinishRank == StartRank + 1)
  158.                     if ((FinishFile == StartFile) && (Board[FinishRank, FinishFile] == "  "))
  159.                         RedumMoveIsLegal = true;
  160.                     else
  161.                         if ((Math.Abs(FinishFile - StartFile) == 1) && (Board[FinishRank, FinishFile][0] == 'W'))
  162.                             RedumMoveIsLegal = true;
  163.                 if (StartRank == 2)
  164.                 {
  165.                     if (FinishRank == StartRank + 2)
  166.                         if ((FinishFile == StartFile) && (Board[FinishRank, FinishFile] == "  "))
  167.                             RedumMoveIsLegal = true;
  168.                         else
  169.                             if ((Math.Abs(FinishFile - StartFile) == 1) && (Board[FinishRank, FinishFile][0] == 'W'))
  170.                                 RedumMoveIsLegal = true;
  171.                 }
  172.             }
  173.             return RedumMoveIsLegal;
  174.         }
  175.  
  176.         public static Boolean CheckSarrumMoveIsLegal(string[,] Board, int StartRank, int StartFile, int FinishRank, int FinishFile)
  177.         {
  178.             Boolean SarrumMoveIsLegal = false;
  179.             if ((Math.Abs(FinishFile - StartFile) <= 1) && (Math.Abs(FinishRank - StartRank) <= 1))
  180.                 SarrumMoveIsLegal = true;
  181.             return SarrumMoveIsLegal;
  182.         }
  183.  
  184.         public static Boolean CheckGisgigirMoveIsLegal(string[,] Board, int StartRank, int StartFile, int FinishRank, int FinishFile)
  185.         {
  186.             Boolean GisgigirMoveIsLegal;
  187.             int Count;
  188.             int RankDifference;
  189.             int FileDifference;
  190.             GisgigirMoveIsLegal = false;
  191.             RankDifference = FinishRank - StartRank;
  192.             FileDifference = FinishFile - StartFile;
  193.             if (RankDifference == 0)
  194.             {
  195.                 if (FileDifference >= 1)
  196.                 {
  197.                     GisgigirMoveIsLegal = true;
  198.                     for (Count = 1; Count <= FileDifference - 1; Count++)
  199.                         if (Board[StartRank, StartFile + Count] != "  ")
  200.                             GisgigirMoveIsLegal = false;
  201.                 }
  202.                 else
  203.                     if (FileDifference <= -1)
  204.                     {
  205.                         GisgigirMoveIsLegal = true;
  206.                         for (Count = -1; Count >= FileDifference + 1; Count--)
  207.                             if (Board[StartRank, StartFile + Count] != "  ")
  208.                                 GisgigirMoveIsLegal = false;
  209.                     }
  210.             }
  211.             else if (FileDifference == 0)
  212.                 if (RankDifference >= 1)
  213.                 {
  214.                     GisgigirMoveIsLegal = true;
  215.                     for (Count = 1; Count <= RankDifference - 1; Count++)
  216.                     {
  217.                         if (Board[StartRank + Count, StartFile] != "  ")
  218.                             GisgigirMoveIsLegal = false;
  219.                     }
  220.                 }
  221.                 else
  222.                     if (RankDifference <= -1)
  223.                     {
  224.                         GisgigirMoveIsLegal = true;
  225.                         for (Count = -1; Count >= RankDifference + 1; Count--)
  226.                             if (Board[StartRank + Count, StartFile] != "  ")
  227.                                 GisgigirMoveIsLegal = false;
  228.                     }
  229.             return GisgigirMoveIsLegal;
  230.         }
  231.  
  232.         public static Boolean CheckNabuMoveIsLegal(string[,] Board, int StartRank, int StartFile, int FinishRank, int FinishFile)
  233.         {
  234.             Boolean NabuMoveIsLegal = false;
  235.             if ((Math.Abs(FinishFile - StartFile) == 1) && (Math.Abs(FinishRank - StartRank)) == 1)
  236.                 NabuMoveIsLegal = true;
  237.             return NabuMoveIsLegal;
  238.         }
  239.  
  240.         public static Boolean CheckMarzazPaniMoveIsLegal(string[,] Board, int StartRank, int StartFile, int FinishRank, int FinishFile)
  241.         {
  242.             Boolean MarzazPaniMoveIsLegal = false;
  243.             if (((Math.Abs(FinishFile - StartFile) == 1) && (Math.Abs(FinishRank - StartRank) == 0) ||
  244.             ((Math.Abs(FinishFile - StartFile) == 0) && (Math.Abs(FinishRank - StartRank) == 1))))
  245.                 MarzazPaniMoveIsLegal = true;
  246.             return MarzazPaniMoveIsLegal;
  247.         }
  248.  
  249.         public static Boolean CheckEtluMoveIsLegal(string[,] Board, int StartRank, int StartFile, int FinishRank, int FinishFile)
  250.         {
  251.             Boolean EtluMoveIsLegal = false;
  252.             if ((Math.Abs(FinishFile - StartFile) == 2) && (Math.Abs(FinishRank - StartRank) == 0)
  253.             || (Math.Abs(FinishFile - StartFile) == 0) && (Math.Abs(FinishRank - StartRank) == 2))
  254.                 EtluMoveIsLegal = true;
  255.             return EtluMoveIsLegal;
  256.         }
  257.  
  258.         public static Boolean CheckKashaptuMoveIsLegal(string[,] Board, int StartRank, int StartFile, int FinishRank, int FinishFile)
  259.         {
  260.             Boolean KashaptuMoveIsLegal = false;
  261.             if ((Math.Abs(FinishFile - StartFile) <= 4) && (Math.Abs(FinishRank - StartRank) == 0)
  262.             || (Math.Abs(FinishFile - StartFile) == 0) && (Math.Abs(FinishRank - StartRank) <= 4))
  263.                 KashaptuMoveIsLegal = true;
  264.             return KashaptuMoveIsLegal;
  265.         }
  266.  
  267.         public static Boolean CheckMoveIsLegal(string[,] Board, int StartRank, int StartFile, int FinishRank, int FinishFile, char WhoseTurn)
  268.         {
  269.             char PieceType;
  270.             char PieceColour;
  271.             Boolean MoveIsLegal = true;
  272.             if ((FinishFile == StartFile) && (FinishRank == StartRank))
  273.                 MoveIsLegal = false;
  274.             PieceType = Board[StartRank, StartFile][1];
  275.             PieceColour = Board[StartRank, StartFile][0];
  276.             if (WhoseTurn == 'W')
  277.             {
  278.                 if (PieceColour != 'W')
  279.                     MoveIsLegal = false;
  280.                 if (Board[FinishRank, FinishFile][0] == 'W')
  281.                     MoveIsLegal = false;
  282.             }
  283.             else
  284.             {
  285.                 if (PieceColour != 'B')
  286.                     MoveIsLegal = false;
  287.                 if (Board[FinishRank, FinishFile][0] == 'B')
  288.                     MoveIsLegal = false;
  289.             }
  290.             if (MoveIsLegal)
  291.                 switch (PieceType)
  292.                 {
  293.                     case 'R':
  294.                         MoveIsLegal = CheckRedumMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile, PieceColour);
  295.                         break;
  296.                     case 'S':
  297.                         MoveIsLegal = CheckSarrumMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile);
  298.                         break;
  299.                     case 'M':
  300.                         MoveIsLegal = CheckMarzazPaniMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile);
  301.                         break;
  302.                     case 'G':
  303.                         MoveIsLegal = CheckGisgigirMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile);
  304.                         break;
  305.                     case 'N':
  306.                         MoveIsLegal = CheckNabuMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile);
  307.                         break;
  308.                     case 'E':
  309.                         MoveIsLegal = CheckEtluMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile);
  310.                         break;
  311.                     case 'K':
  312.                         MoveIsLegal = CheckKashaptuMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile);
  313.                         break;
  314.                     default:
  315.                         MoveIsLegal = false;
  316.                         break;
  317.                 }
  318.             return MoveIsLegal;
  319.         }
  320.  
  321.         public static void InitialiseBoard(ref string[,] Board, char SampleGame)
  322.         {
  323.             int RankNo;
  324.             int FileNo;
  325.             if (SampleGame == 'Y')
  326.             {
  327.                 for (RankNo = 1; RankNo <= BoardRanks; RankNo++)
  328.                     for (FileNo = 1; FileNo <= BoardFiles; FileNo++)
  329.                         Board[RankNo, FileNo] = "  ";
  330.                 Board[1, 2] = "BG";
  331.                 Board[1, 4] = "BS";
  332.                 Board[1, 8] = "WG";
  333.                 Board[2, 1] = "WR";
  334.                 Board[3, 1] = "WS";
  335.                 Board[3, 2] = "BE";
  336.                 Board[3, 8] = "BE";
  337.                 Board[6, 8] = "BR";
  338.             }
  339.             else if (SampleGame != 'Y' && SampleGame != 'y')
  340.             {
  341.                 for (RankNo = 1; RankNo <= BoardRanks; RankNo++)
  342.                     for (FileNo = 1; FileNo <= BoardFiles; FileNo++)
  343.                         if (RankNo == 2)
  344.                             Board[RankNo, FileNo] = "BR";
  345.                         else
  346.                             if (RankNo == 8)
  347.                                 Board[RankNo, FileNo] = "WR";
  348.                             else
  349.                                 if ((RankNo == 1) || (RankNo == 9))
  350.                                 {
  351.                                     if (RankNo == 1)
  352.                                         Board[RankNo, FileNo] = "B";
  353.                                     if (RankNo == 9)
  354.                                         Board[RankNo, FileNo] = "W";
  355.                                     switch (FileNo)
  356.                                     {
  357.                                         case 1:
  358.                                         case 9:
  359.                                             Board[RankNo, FileNo] = Board[RankNo, FileNo] + "G";
  360.                                             break;
  361.                                         case 2:
  362.                                         case 8:
  363.                                             Board[RankNo, FileNo] = Board[RankNo, FileNo] + "E";
  364.                                             break;
  365.                                         case 3:
  366.                                         case 7:
  367.                                             Board[RankNo, FileNo] = Board[RankNo, FileNo] + "N";
  368.                                             break;
  369.                                         case 4:
  370.                                             Board[RankNo, FileNo] = Board[RankNo, FileNo] + "M";
  371.                                             break;
  372.                                         case 5:
  373.                                             Board[RankNo, FileNo] = Board[RankNo, FileNo] + "S";
  374.                                             break;
  375.                                         case 6:
  376.                                             Board[RankNo, FileNo] = Board[RankNo, FileNo] + "K";
  377.                                             break;
  378.                                     }
  379.                                 }
  380.                                 else
  381.                                     Board[RankNo, FileNo] = "  ";
  382.             }
  383.                
  384.         }
  385.  
  386.         public static void GetMove(ref int StartSquare, ref int FinishSquare)
  387.         {
  388.             bool InputCheck = false;
  389.  
  390.             do
  391.             {
  392.                 Console.Write("Enter cooordinates of square containing piece to move (file first): ");
  393.                 try
  394.                 {
  395.                     StartSquare = int.Parse(Console.ReadLine());
  396.                     InputCheck = true;
  397.                 }
  398.                 catch (Exception)
  399.                 {
  400.                    
  401.                     Console.WriteLine("Error. That input is not acceptable, please try again.");
  402.                     InputCheck = false;
  403.                 }
  404.  
  405.                 if (StartSquare < 11)
  406.                 {
  407.                     Console.WriteLine("Error. Input is too large, please try again.");
  408.                     InputCheck = false;
  409.                 }
  410.  
  411.             } while (InputCheck == false);
  412.  
  413.             InputCheck = false;
  414.  
  415.             do
  416.             {
  417.                 Console.Write("Enter cooordinates of square to move piece to (file first): ");
  418.                 try
  419.                 {
  420.                     FinishSquare = int.Parse(Console.ReadLine());
  421.                     InputCheck = true;
  422.                 }
  423.                 catch (Exception)
  424.                 {
  425.  
  426.                     Console.WriteLine("Error. That input is not acceptable, please try again.");
  427.                     InputCheck = false;
  428.                 }
  429.  
  430.                 if (FinishSquare > 99)
  431.                 {
  432.                     Console.WriteLine("Error. Input is too large, please try again.");
  433.                     InputCheck = false;
  434.                 }
  435.  
  436.             } while (InputCheck == false);
  437.  
  438.             //Console.Write("Enter cooordinates of square containing piece to move (file first): ");
  439.             //StartSquare = int.Parse(Console.ReadLine());
  440.             //Console.Write("Enter cooordinates of square to move piece to (file first): ");
  441.             //FinishSquare = int.Parse(Console.ReadLine());
  442.         }
  443.  
  444.         public static void MakeMove(ref string[,] Board, int StartRank, int StartFile, int FinishRank, int FinishFile, char WhoseTurn)
  445.         {
  446.             if ((WhoseTurn == 'W') && (FinishRank == 1) && (Board[StartRank, StartFile][1] == 'R'))
  447.             {
  448.                 Board[FinishRank, FinishFile] = "WM";
  449.                 Board[StartRank, StartFile] = "  ";
  450.             }
  451.             else
  452.                 if ((WhoseTurn == 'B') && (FinishRank == 8) && (Board[StartRank, StartFile][1] == 'R'))
  453.                 {
  454.                     Board[FinishRank, FinishFile] = "BM";
  455.                     Board[StartRank, StartFile] = "  ";
  456.                 }
  457.                 else
  458.                 {
  459.                     Board[FinishRank, FinishFile] = Board[StartRank, StartFile];
  460.                     Board[StartRank, StartFile] = "  ";
  461.                 }
  462.  
  463.             if (WhoseTurn == 'W')
  464.             {
  465.                 switch ((Board[FinishRank, FinishFile][1]))
  466.                 {
  467.                     case 'R':
  468.                         WhiteScore++;
  469.                         break;
  470.                     case 'G':
  471.                         WhiteScore = +3;
  472.                         break;
  473.                     case 'E':
  474.                         WhiteScore = +5;
  475.                         break;
  476.                     case 'N':
  477.                         WhiteScore = +7;
  478.                         break;
  479.                     case 'M':
  480.                         WhiteScore = +9;
  481.                         break;
  482.                     case 'S':
  483.                         WhiteScore = +10;
  484.                         break;
  485.                     case 'K':
  486.                         WhiteScore = +10;
  487.                         break;
  488.                     default:
  489.                         break;
  490.                 }
  491.             }
  492.             if (WhoseTurn == 'B')
  493.             {
  494.                 switch ((Board[FinishRank, FinishFile][1]))
  495.                 {
  496.                     case 'R':
  497.                         BlackScore++;
  498.                         break;
  499.                     case 'G':
  500.                         BlackScore = +3;
  501.                         break;
  502.                     case 'E':
  503.                         BlackScore = +5;
  504.                         break;
  505.                     case 'N':
  506.                         BlackScore = +7;
  507.                         break;
  508.                     case 'M':
  509.                         BlackScore = +9;
  510.                         break;
  511.                     case 'S':
  512.                         BlackScore = +10;
  513.                         break;
  514.                     case 'K':
  515.                         BlackScore = +9;
  516.                         break;
  517.                     default:
  518.                         break;
  519.                 }
  520.             }
  521.         }
  522.     }
  523. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!