API tools faq
paste
Advertisement
TheLegend12

Untitled

TheLegend12
Oct 11th, 2023
70
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.12 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <fstream>
  3. #include <string>
  4. #include <vector>
  5. using namespace std;
  6.  
  7. const int ROWS = 6;
  8. const int COLS = 6;
  9.  
  10. // int countNumberOfDots(char boardArray[][COLS], char moveDirection, int row, int column) {
  11. //     int countDots = 0;
  12.  
  13. //     if (moveDirection == 'L') {
  14. //         for (int i = column - 1; i >= 0; --i) {
  15. //             if (boardArray[row][i] == '.') {
  16. //                 countDots++;
  17. //             } else {
  18. //                 break;
  19. //             }
  20. //         }
  21. //     } else if (moveDirection == 'R') {
  22. //         for (int i = column + 1; i < COLS; ++i) {
  23. //             if (boardArray[row][i] == '.') {
  24. //                 countDots++;
  25. //             } else {
  26. //                 break;
  27. //             }
  28. //         }
  29. //     } else if (moveDirection == 'U') {
  30. //         for (int i = row - 1; i >= 0; --i) {
  31. //             if (boardArray[i][column] == '.') {
  32. //                 countDots++;
  33. //             } else {
  34. //                 break;
  35. //             }
  36. //         }
  37. //     } else if (moveDirection == 'D') {
  38. //         for (int i = 0; i < ROWS; ++i) {
  39. //             if (boardArray[i][column] == '.') {
  40. //                 countDots++;
  41. //             } else {
  42. //                 break;
  43. //             }
  44. //         }
  45. //     }
  46.  
  47. //     return countDots;
  48. // }
  49.  
  50. // int findMin(int a, int b) {
  51. //     return (a < b) ? a : b;
  52. // }
  53.  
  54. void displayBoard(char boardArray[][COLS]) {
  55.     cout << endl;
  56.     cout << "--------" << endl;
  57.     for (int i = 0; i < ROWS; ++i) {
  58.         cout << "|";
  59.         for (int j = 0; j < COLS; ++j) {
  60.             if (boardArray[i][j] == '-') {
  61.                 boardArray[i][j] = '.';
  62.             }
  63.             cout << boardArray[i][j];
  64.         }
  65.  
  66.         if (i == 2) {
  67.             cout << "=" << endl;
  68.         } else {
  69.             cout << "|" << endl;
  70.         }
  71.     }
  72.     cout << "--------" << endl;
  73. }
  74.  
  75. // void shiftCar(char boardArray[][COLS], int row, int col, char direction) {
  76. //     if (direction == 'L') {
  77. //         while (col - 1 >= 0 && boardArray[row][col - 1] == '.') {
  78. //             boardArray[row][col] = '.';
  79. //             boardArray[row][col - 1] = 'X';  // Symbolize a temporarily shifted car
  80. //             --col;
  81. //         }
  82. //     } else if (direction == 'R') {
  83. //         while (col + 1 < COLS && boardArray[row][col + 1] == '.') {
  84. //             boardArray[row][col] = '.';
  85. //             boardArray[row][col + 1] = 'X';  // Symbolize a temporarily shifted car
  86. //             ++col;
  87. //         }
  88. //     } else if (direction == 'U') {
  89. //         while (row - 1 >= 0 && boardArray[row - 1][col] == '.') {
  90. //             boardArray[row][col] = '.';
  91. //             boardArray[row - 1][col] = 'X';  // Symbolize a temporarily shifted car
  92. //             --row;
  93. //         }
  94. //     } else if (direction == 'D') {
  95. //         while (row + 1 < ROWS && boardArray[row + 1][col] == '.') {
  96. //             boardArray[row][col] = '.';
  97. //             boardArray[row + 1][col] = 'X';  // Symbolize a temporarily shifted car
  98. //             ++row;
  99. //         }
  100. //     }
  101. // }
  102.  
  103. // void moveLeft(char boardArray[][COLS], char carToMove, int numSpaces, char moveDirection) {
  104. //     for (int i = 0; i < ROWS; ++i) {
  105. //         int startCol = -1;  // Store the starting column of the car
  106.  
  107. //         // Find the starting column of the car
  108. //         for (int j = 0; j < COLS; ++j) {
  109. //             if (boardArray[i][j] == carToMove) {
  110. //                 startCol = j;
  111. //                 break;
  112. //             }
  113. //         }
  114.  
  115. //         if (startCol == -1)
  116. //             continue;  // Car not found in this row
  117.  
  118. //         // Check if there are spaces and no cars in the way
  119. //         bool canMove = true;
  120. //         for (int k = 1; k <= numSpaces; ++k) {
  121. //             if (startCol - k < 0 || boardArray[i][startCol - k] != '.') {
  122. //                 canMove = false;
  123. //                 break;
  124. //             }
  125. //         }
  126.  
  127. //         if (canMove) {
  128. //             // Move the entire car together
  129. //             for (int k = 0; k < numSpaces; ++k) {
  130. //                 if (boardArray[i][startCol - k] == carToMove) {
  131. //                     boardArray[i][startCol - k] = '.';
  132. //                     boardArray[i][startCol - k - 1] = carToMove;
  133. //                 }
  134. //             }
  135. //         } else {
  136. //             cout << "Invalid move. Car would go out of bounds or is blocked." << endl;
  137. //         }
  138. //     }
  139. // }
  140.  
  141.  
  142. // void moveRight(char boardArray[][COLS], char carToMove, int numSpaces, char moveDirection) {
  143. //     for (int i = 0; i < ROWS; ++i) {
  144. //         int startCol = -1;  // Store the starting column of the car
  145.  
  146. //         // Find the starting column of the car
  147. //         for (int j = COLS - 1; j >= 0; --j) {
  148. //             if (boardArray[i][j] == carToMove) {
  149. //                 startCol = j;
  150. //                 break;
  151. //             }
  152. //         }
  153.  
  154. //         if (startCol == -1)
  155. //             continue;  // Car not found in this row
  156.  
  157. //         // Check if there are spaces and no cars in the way
  158. //         bool canMove = true;
  159. //         for (int k = 1; k <= numSpaces; ++k) {
  160. //             if (startCol + k >= COLS || boardArray[i][startCol + k] != '.') {
  161. //                 canMove = false;
  162. //                 break;
  163. //             }
  164. //         }
  165.  
  166. //         if (canMove) {
  167. //             // Move the entire car together
  168. //             for (int k = 0; k < numSpaces; ++k) {
  169. //                 if (boardArray[i][startCol + k] == carToMove) {
  170. //                     boardArray[i][startCol + k] = '.';
  171. //                     boardArray[i][startCol + k + 1] = carToMove;
  172. //                 }
  173. //             }
  174. //         } else {
  175. //             cout << "Cannot move " << carToMove << " in the specified direction." << endl;
  176. //         }
  177. //     }
  178. // }
  179.  
  180.  
  181. // void moveUp(char boardArray[][COLS], char carToMove, int numSpaces, char moveDirection) {
  182. //     for (int j = 0; j < COLS; ++j) {
  183. //         int startRow = -1;  // Store the starting row of the car
  184.  
  185. //         // Find the starting row of the car
  186. //         for (int i = 0; i < ROWS; ++i) {
  187. //             if (boardArray[i][j] == carToMove) {
  188. //                 startRow = i;
  189. //                 break;
  190. //             }
  191. //         }
  192.  
  193. //         if (startRow == -1)
  194. //             continue;  // Car not found in this column
  195.  
  196. //         // Check if there are spaces and no cars in the way
  197. //         bool canMove = true;
  198. //         for (int k = 1; k <= numSpaces; ++k) {
  199. //             if (startRow - k < 0 || boardArray[startRow - k][j] != '.') {
  200. //                 canMove = false;
  201. //                 break;
  202. //             }
  203. //         }
  204.  
  205. //         if (canMove) {
  206. //             // Move the entire car together
  207. //             for (int k = 0; k < numSpaces; ++k) {
  208. //                 if (boardArray[startRow - k][j] == carToMove) {
  209. //                     boardArray[startRow - k][j] = '.';
  210. //                     boardArray[startRow - k - 1][j] = carToMove;
  211. //                 }
  212. //             }
  213. //         } else {
  214. //             cout << "Cannot move " << carToMove << " in the specified direction." << endl;
  215. //         }
  216. //     }
  217. // }
  218.  
  219.  
  220. // void moveDown(char boardArray[][COLS], char carToMove, int numSpaces, char moveDirection) {
  221. //     for (int j = 0; j < COLS; ++j) {
  222. //         int startRow = -1;  // Store the starting row of the car
  223.  
  224. //         // Find the starting row of the car
  225. //         for (int i = ROWS - 1; i >= 0; --i) {
  226. //             if (boardArray[i][j] == carToMove) {
  227. //                 startRow = i;
  228. //                 break;
  229. //             }
  230. //         }
  231.  
  232. //         if (startRow == -1)
  233. //             continue;  // Car not found in this column
  234.  
  235. //         // Check if there are spaces and no cars in the way
  236. //         bool canMove = true;
  237. //         for (int k = 1; k <= numSpaces; ++k) {
  238. //             if (startRow + k >= ROWS || boardArray[startRow + k][j] != '.') {
  239. //                 canMove = false;
  240. //                 break;
  241. //             }
  242. //         }
  243.  
  244. //         if (canMove) {
  245. //             // Move the entire car together
  246. //             for (int k = 0; k < numSpaces; ++k) {
  247. //                 if (boardArray[startRow + k][j] == carToMove) {
  248. //                     boardArray[startRow + k][j] = '.';
  249. //                     boardArray[startRow + k + 1][j] = carToMove;
  250. //                 }
  251. //             }
  252. //         } else {
  253. //             cout << "Cannot move " << carToMove << " in the specified direction." << endl;
  254. //         }
  255. //     }
  256. // }
  257. // bool canMove(char boardArray[][COLS], char carToMove, char moveDirection) {
  258. //     for (int i = 0; i < ROWS; ++i) {
  259. //         for (int j = 0; j < COLS; ++j) {
  260. //             if (boardArray[i][j] == carToMove) {
  261. //                 int dots = countNumberOfDots(boardArray, moveDirection, i, j);
  262. //                 int newRow, newCol;
  263.  
  264. //                 // Check if there are spaces around the car in the specified direction
  265. //                 if (moveDirection == 'L') {
  266. //                     newRow = i;
  267. //                     newCol = j - dots;
  268. //                 } else if (moveDirection == 'R') {
  269. //                     newRow = i;
  270. //                     newCol = j + dots;
  271. //                 } else if (moveDirection == 'U') {
  272. //                     newRow = i - dots;
  273. //                     newCol = j;
  274. //                 } else if (moveDirection == 'D') {
  275. //                     newRow = i + dots;
  276. //                     newCol = j;
  277. //                 }
  278.  
  279. //                 // Check if there are 0 surrounding cars in the specified direction
  280. //                 int surroundingCars = 0;
  281. //                 if (moveDirection == 'L' && newCol >= 0) {
  282. //                     if (newCol - 1 >= 0 && boardArray[i][newCol - 1] != '.')
  283. //                         surroundingCars++;
  284. //                 } else if (moveDirection == 'R' && newCol < COLS) {
  285. //                     if (newCol + 1 < COLS && boardArray[i][newCol + 1] != '.')
  286. //                         surroundingCars++;
  287. //                 } else if (moveDirection == 'U' && newRow >= 0) {
  288. //                     if (newRow - 1 >= 0 && boardArray[newRow - 1][j] != '.')
  289. //                         surroundingCars++;
  290. //                 } else if (moveDirection == 'D' && newRow < ROWS) {
  291. //                     if (newRow + 1 < ROWS && boardArray[newRow + 1][j] != '.')
  292. //                         surroundingCars++;
  293. //                 }
  294.  
  295. //                 if (surroundingCars == 0)
  296. //                     continue;
  297.  
  298. //                 return false;
  299. //             }
  300. //         }
  301. //     }
  302. //     return true;
  303. // }
  304.  
  305.  
  306. // void movingCarsOnBoard(char boardArray[][COLS]) {
  307. //     char carToMove;
  308. //     int numSpaces;
  309. //     char moveDirection;
  310.  
  311. //     displayBoard(boardArray);
  312.  
  313. //     cout << "Enter the car you want to move (A, B, C, etc.): ";
  314. //     cin >> carToMove;
  315.  
  316. //     cout << "Enter the number of spaces to move: ";
  317. //     cin >> numSpaces;
  318.  
  319. //     cout << "Enter the direction to move (L for left, R for right, U for up, D for down): ";
  320. //     cin >> moveDirection;
  321.  
  322. //     // Convert input to uppercase
  323. //     carToMove = toupper(carToMove);
  324. //     moveDirection = toupper(moveDirection);
  325.  
  326. //     // Call the moveCar function to move the car
  327. //     moveCar(boardArray, carToMove, numSpaces, moveDirection);
  328. // }
  329.  
  330.  
  331.  
  332. void readBoard(const string& fileName, char boardArray[][COLS]) {
  333.     ifstream file(fileName);
  334.     if (!file.is_open()) {
  335.         cout << "Error opening file." << endl;
  336.         return;
  337.     }
  338.  
  339.     string line;
  340.     int row = 0;
  341.  
  342.     // Read the board layout from the file
  343.     while (getline(file, line) && row < ROWS) {
  344.         // Ensure the line length is at most COLS characters
  345.         line.resize(COLS, ' ');
  346.  
  347.         for (int j = 0; j < COLS; ++j) {
  348.             boardArray[row][j] = line[j];
  349.         }
  350.  
  351.         row++;
  352.     }
  353.  
  354.     // Fill any remaining cells with spaces
  355.     for (; row < ROWS; ++row) {
  356.         for (int j = 0; j < COLS; ++j) {
  357.             boardArray[row][j] = ' ';
  358.         }
  359.     }
  360.  
  361.     file.close();
  362. }
  363.  
  364. void moveCar(char boardArray[][COLS], char usersCar, char moveCarDirection, int j, int i, int ROWS, int COLS, int numSpaces){
  365. for(int k = 0; k < numSpaces; ++k){
  366.  if(moveCarDirection == 'L'){
  367.         for(int i = 0; i < ROWS; ++i){
  368.             for(j = j-1; j >= 0; --j){
  369.                 if(boardArray[i][j] == '.'){
  370.                     boardArray[i][j] = usersCar;
  371.                     boardArray[i][j+1] = '.';
  372.                 }    
  373.             }
  374.         }
  375.     }
  376. else if(moveCarDirection == 'R'){
  377.     for(int i = 0; i < ROWS; ++i){
  378.         for(j = j + 1; j < COLS; ++j){
  379.             if(boardArray[i][j] == '.'){
  380.                     boardArray[i][j] = usersCar;
  381.                     boardArray [i][j - 1] = '.';
  382.                 }  
  383.  
  384.         }
  385.  
  386.  
  387.     }
  388.  
  389. }
  390.  
  391. else if(moveCarDirection == 'U'){
  392.     for(i = i - 1; i >= 0; --i){
  393.         if(boardArray[i][j] == '.'){
  394.            boardArray[i-1][j] = usersCar;
  395.            boardArray [i + 1][j] = '.';
  396.         }
  397.  
  398.     }
  399.  
  400. }
  401.  
  402. else if(moveCarDirection == 'D'){
  403.     for(i = i + 1; i < ROWS; ++i){
  404.         if(boardArray[i][j] == '.'){
  405.             boardArray[i+1][j] = usersCar;
  406.             boardArray [i - 1][j] = '.';
  407.         }
  408.  
  409.     }
  410.  
  411. }
  412. }
  413. }
  414.  
  415. bool checkForSpacesInDirection(char boardArray[][COLS], char usersCar, char moveCarDirection, int totalCars, int ROWS, int COLS, int j, int i){
  416. while(i != totalCars){
  417.  if(moveCarDirection == 'L'){
  418.         for(int i = 0; i < ROWS; ++i){
  419.             for(j = j-1; j >= 0; --j){
  420.                 if(boardArray[i][j] == '.'){
  421.                     i += 1;
  422.                 }    
  423.             }
  424.         }
  425.     }
  426. else if(moveCarDirection == 'R'){
  427.     for(int i = 0; i < ROWS; ++i){
  428.         for(j = j + 1; j < COLS; ++j){
  429.             if(boardArray[i][j] == '.'){
  430.                     i += 1;
  431.                 }  
  432.  
  433.         }
  434.  
  435.  
  436.     }
  437.  
  438. }
  439.  
  440. else if(moveCarDirection == 'U'){
  441.     for(i = i - 1; i >= 0; --i){
  442.         if(boardArray[i][j] == '.'){
  443.             i += 1;
  444.         }
  445.  
  446.     }
  447.  
  448. }
  449.  
  450. else if(moveCarDirection == 'D'){
  451.     for(i = i + 1; i < ROWS; ++i){
  452.         if(boardArray[i][j] == '.'){
  453.             i += 1;
  454.         }
  455.  
  456.     }
  457.  
  458. }
  459. }
  460. return true;  
  461.  
  462. }
  463.  
  464. // int countCarsOnBoard(char boardArray[][COLS], char usersCar, int ROWS, int COLS){
  465. //     int totalCars = 0
  466. //     for(int i = 0; i < ROWS; ++i){
  467. //         for(int j = 0; j < COLS; ++j){
  468. //             if (boardArray[i][j] == usersCar){
  469. //                 checkForSpacesInDirection(board, usersCar, moveCarDirection, totalCars, ROWS)
  470. //                 totalCars += 1;
  471. //         }
  472. //     }
  473. // }
  474. // return totalCars;
  475. // }
  476.  
  477. bool doesCarExist(char boardArray[][COLS], char usersCar, const int ROWS, const int COLS){
  478.     for(int i = 0; i < ROWS; ++i){
  479.         for(int j = 0; j < COLS; ++j){
  480.             if(boardArray[i][j] == usersCar){
  481.                 return true;
  482.         }
  483.  
  484.     }
  485.     cout << "This car is not on the board." << endl;
  486.     return false;
  487. }
  488. }
  489.  
  490.  
  491. int main() {
  492.     string fileName;
  493.     char usersCar;
  494.     int numSpaces;
  495.     char moveCarDirection;
  496.     int i;
  497.     int j;
  498.  
  499.     cout << "Enter the file name: ";
  500.     getline(cin, fileName);
  501.    
  502.     char boardArray[ROWS][COLS];
  503.  
  504.     readBoard(fileName, boardArray);
  505.     displayBoard(boardArray);
  506.    
  507.     int totalCars = 0;
  508.     while(usersCar != 'Q'){
  509.  
  510.         cout << "Enter next move (or Q to quit): ";
  511.         cin >> usersCar;
  512.         usersCar = toupper(usersCar);
  513.         cin >> numSpaces;
  514.         cin >> moveCarDirection;
  515.          moveCarDirection = toupper(moveCarDirection);
  516.          if (doesCarExist(boardArray, usersCar, ROWS, COLS) == true){
  517.              
  518.             for( i = 0; i < ROWS; ++i){
  519.                 for(j = 0; j < COLS; ++j){
  520.                     if (boardArray[i][j] == usersCar){
  521.                         totalCars += 1;
  522.         }
  523.  
  524.     }
  525. }
  526.     bool areSpacesThere = checkForSpacesInDirection(boardArray, usersCar, moveCarDirection, totalCars, ROWS, COLS
  527.     , j, i);
  528.     if(areSpacesThere == true){
  529.         moveCar( boardArray, usersCar, moveCarDirection,  j, i, ROWS, COLS, numSpaces);
  530.     }
  531.     }
  532. displayBoard(boardArray);
  533. }
  534.  
  535.     return 0;
  536. }
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!