API tools faq
paste
Advertisement
TheLegend12

Untitled

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