Algorithms_in_C 1.0.0
Set of algorithms implemented in C.
Loading...
Searching...
No Matches
Functions
naval_battle.c File Reference

naval_battle implementation in C using only the stdio.h for Standard Input and Output. More...

#include <stdio.h>
Include dependency graph for naval_battle.c:

Functions

int validEntryLineColumn (int line, char column)
 for Standard Input Output More...
 
int validatePosition (int mat[10][10], int boat, int line, int column, char guide)
 Function validatePosition Responsible for checking if the position can receive the boat. More...
 
int canShoot (int mat[10][10], int line, int column)
 Function canShoot Responsible to verify that it is a valid position to shoot. More...
 
void positionBoat (int mat[10][10], int boat)
 Function positionBoat Responsible for placing the boats on the board, according to the size. More...
 
void printMessage (char *msg)
 Function printMessage Responsible for printing the auxiliary message. More...
 
void printMessageScore (int pts1, int pts2)
 Function printMessageScore Responsible for printing the score messages. More...
 
char printTable (int logic, int stage)
 Function printTable Responsible for printing the board. More...
 
void printsTray (int mat[10][10], int stage)
 Function printsTray Responsible for printing the visual board for the user. More...
 
void shoot (int mat[10][10], int line, int column)
 Function shoot Responsible for saying if he hit a boat. More...
 
int calculateScore (int mat[10][10], int line, int column)
 Function calculateScore Responsible for calculating the score obtained during the game. More...
 
void printPositioning (int Player, int boat, int nm)
 Function printPositioning Responsible for printing messages for positioning boats on the board; of player 1 and 2. More...
 
int main ()
 Main function. More...
 

Detailed Description

naval_battle implementation in C using only the stdio.h for Standard Input and Output.

Author
Carlos Rafael
Herick Lima

Naval battle is a game, to be played by two people. It consists of knocking down the enemy ship, through shots , when hit the ship is revealed with the respective number of its size. Example: size 3 = 3 3 3 on the board. To play - boats over size 1, need direction; V -> vertical and H -> horizontal. Example Input 1 A H -> line 1, column A, direction H (Horizontal).

Function Documentation

◆ calculateScore()

int calculateScore ( int  mat[10][10],
int  line,
int  column 
)

Function calculateScore Responsible for calculating the score obtained during the game.

Parameters
matboard
linematrix row
columnmatrix column
Returns
resulting score
443{
444 int c = 0, b = 0, e = 0, d = 0;
445
446 if (mat[line][column] == 10)
447 {
448 mat[line][column] = 50;
449 return 2;
450 }
451
452 else if (mat[line][column] == 20)
453 {
454 if (mat[line + 1][column] == 20)
455 {
456 b = 1;
457 }
458
459 if (mat[line - 1][column] == 20)
460 {
461 c = 1;
462 }
463
464 if (mat[line][column + 1] == 20)
465 {
466 d = 1;
467 }
468
469 if (mat[line][column - 1] == 20)
470 {
471 e = 1;
472 }
473
474 if (b == 1)
475 {
476 if (mat[line + 1][column] == 20)
477 {
478 mat[line][column] = 50;
479 mat[line + 1][column] = 50;
480 return 4;
481 }
482 else
483 {
484 return 0;
485 }
486 }
487
488 if (c == 1)
489 {
490 if (mat[line - 1][column] == 20)
491 {
492 mat[line][column] = 50;
493 mat[line - 1][column] = 50;
494 return 4;
495 }
496 else
497 {
498 return 0;
499 }
500 }
501
502 if (d == 1)
503 {
504 if (mat[line][column + 1] == 20)
505 {
506 mat[line][column] = 50;
507 mat[line][column + 1] = 50;
508 return 4;
509 }
510 else
511 {
512 return 0;
513 }
514 }
515
516 if (e == 1)
517 {
518 if (mat[line][column - 1] == 20)
519 {
520 mat[line][column] = 50;
521 mat[line][column - 1] = 50;
522 return 4;
523 }
524 else
525 {
526 return 0;
527 }
528 }
529 }
530
531 else if (mat[line][column] == 30)
532 {
533 if (mat[line + 1][column] == 30)
534 {
535 b = 1;
536 }
537
538 if (mat[line - 1][column] == 30)
539 {
540 c = 1;
541 }
542 if (mat[line][column + 1] == 30)
543 {
544 d = 1;
545 }
546
547 if (mat[line][column - 1] == 30)
548 {
549 e = 1;
550 }
551
552 if (b == 1 && c == 1)
553 {
554 if (mat[line + 1][column] == 30 && mat[line - 1][column] == 30)
555 {
556 mat[line][column] = 50;
557 mat[line + 1][column] = 50;
558 mat[line - 1][column] = 50;
559 return 7;
560 }
561 else
562 {
563 return 0;
564 }
565 }
566
567 else if (d == 1 && e == 1)
568 {
569 if (mat[line][column + 1] == 30 && mat[line][column - 1] == 30)
570 {
571 mat[line][column] = 50;
572 mat[line][column - 1] = 50;
573 mat[line][column + 1] = 50;
574 return 7;
575 }
576 else
577 {
578 return 0;
579 }
580 }
581
582 else if (d == 1)
583 {
584 if (mat[line][column + 1] == 30 && mat[line][column + 2] == 30)
585 {
586 mat[line][column] = 50;
587 mat[line][column + 1] = 50;
588 mat[line][column + 2] = 50;
589 return 7;
590 }
591 else
592 {
593 return 0;
594 }
595 }
596
597 else if (e == 1)
598 {
599 if (mat[line][column - 1] == 30 && mat[line][column - 2] == 30)
600 {
601 mat[line][column] = 50;
602 mat[line][column - 1] = 50;
603 mat[line][column - 2] = 50;
604 return 7;
605 }
606 else
607 {
608 return 0;
609 }
610 }
611
612 else if (c == 1)
613 {
614 if (mat[line - 1][column] == 30 && mat[line - 2][column] == 30)
615 {
616 mat[line][column] = 50;
617 mat[line - 1][column] = 50;
618 mat[line - 2][column] = 50;
619 return 7;
620 }
621 else
622 {
623 return 0;
624 }
625 }
626
627 else if (b == 1)
628 {
629 if (mat[line + 1][column] == 30 && mat[line + 2][column] == 30)
630 {
631 mat[line][column] = 50;
632 mat[line + 1][column] = 50;
633 mat[line + 2][column] = 50;
634 return 7;
635 }
636 else
637 {
638 return 0;
639 }
640 }
641 }
642 return 0;
643}

◆ canShoot()

int canShoot ( int  mat[10][10],
int  line,
int  column 
)

Function canShoot Responsible to verify that it is a valid position to shoot.

Parameters
matboard
linematrix row
columnmatrix column
Returns
if the position is valid for shooting
108{
109 if (mat[line][column] == -2 || mat[line][column] == 10 ||
110 mat[line][column] == 20 || mat[line][column] == 30 ||
111 mat[line][column] == 50)
112 {
113 return 0;
114 }
115
116 return 1;
117}

◆ main()

int main ( void  )

Main function.

Returns
0 on exit

the one with the most points wins, or the one who knocks down all boats first.

814{
815 int Player1[10][10];
816 int Player2[10][10];
817 int plays = 1;
818 int pts1 = 0, pts2 = 0, a1 = 0, a2 = 0;
819 int line, col = 0, lin = 0;
820 char column;
821
822 // filling matrix with 0
823 for (int i = 0; i < 10; i++)
824 {
825 for (int j = 0; j < 10; j++)
826 {
827 Player1[i][j] = 0;
828 Player2[i][j] = 0;
829 }
830 }
831
832 // positioning boats
833 for (int i = 1; i <= 2; i++)
834 {
835 for (int j = 1; j <= 6; j++)
836 {
837 if (i == 1)
838 {
839 printPositioning(i, 1, j);
840 printsTray(Player1, 0);
841 positionBoat(Player1, 1);
842 }
843 else if (i == 2)
844 {
845 printPositioning(i, 1, j);
846 printsTray(Player2, 0);
847 positionBoat(Player2, 1);
848 }
849 }
850 for (int j = 1; j <= 4; j++)
851 {
852 if (i == 1)
853 {
854 printPositioning(i, 2, j);
855 printsTray(Player1, 0);
856 positionBoat(Player1, 2);
857 }
858 else if (i == 2)
859 {
860 printPositioning(i, 2, j);
861 printsTray(Player2, 0);
862 positionBoat(Player2, 2);
863 }
864 }
865 for (int j = 1; j <= 2; j++)
866 {
867 if (i == 1)
868 {
869 printPositioning(i, 3, j);
870 printsTray(Player1, 0);
871 positionBoat(Player1, 3);
872 }
873 else if (i == 2)
874 {
875 printPositioning(i, 3, j);
876 printsTray(Player2, 0);
877 positionBoat(Player2, 3);
878 }
879 }
880 }
881
882 // starting the game
883 while (plays <= 40)
884 {
885 if (plays % 2 != 0)
886 {
887 printMessageScore(pts1, pts2);
888 printMessage("Player 1's turn");
889 printsTray(Player2, 1);
890 scanf("%d %c", &line, &column);
891
892 while (validEntryLineColumn(line, column) != 1 ||
893 canShoot(Player2, line - 1, column - 65) != 1)
894 {
895 line = 0;
896 column = 'a';
897 printf("Position unavailable!\n");
898 scanf("%d %c", &line, &column);
899 }
900 lin = line - 1;
901 col = column - 65;
902 shoot(Player2, lin, col);
903 a1 = pts1;
904 pts1 += calculateScore(Player2, lin, col);
905
906 if (a1 != pts1)
907 {
908 printMessage("Player 1 DROPPED A BOAT!");
909 }
910 }
911 else
912 {
913 printMessageScore(pts1, pts2);
914 printMessage("Player 2's turn");
915 printsTray(Player1, 1);
916 scanf("%d %c", &line, &column);
917
918 while (validEntryLineColumn(line, column) != 1 ||
919 canShoot(Player1, line - 1, column - 65) != 1)
920 {
921 printf("Position unavailable!\n");
922 scanf("%d %c", &line, &column);
923 }
924 lin = line - 1;
925 col = column - 65;
926 shoot(Player1, lin, col);
927 a2 = pts2;
928 pts2 += calculateScore(Player1, lin, col);
929
930 if (a2 != pts2)
931 {
932 printMessage("Player 2 DROPPED A BOAT!");
933 }
934 }
935
936 plays++;
937 }
938 /**
939 * the one with the most points wins, or the one who knocks down all boats
940 * first.
941 */
942 printMessage("END GAME\n");
943 printMessageScore(pts1, pts2);
944
945 return 0;
946}
shoot
void shoot(int mat[10][10], int line, int column)
Function shoot Responsible for saying if he hit a boat.
Definition: naval_battle.c:411
printMessageScore
void printMessageScore(int pts1, int pts2)
Function printMessageScore Responsible for printing the score messages.
Definition: naval_battle.c:280
positionBoat
void positionBoat(int mat[10][10], int boat)
Function positionBoat Responsible for placing the boats on the board, according to the size.
Definition: naval_battle.c:124
printMessage
void printMessage(char *msg)
Function printMessage Responsible for printing the auxiliary message.
Definition: naval_battle.c:266
canShoot
int canShoot(int mat[10][10], int line, int column)
Function canShoot Responsible to verify that it is a valid position to shoot.
Definition: naval_battle.c:107
printPositioning
void printPositioning(int Player, int boat, int nm)
Function printPositioning Responsible for printing messages for positioning boats on the board; of pl...
Definition: naval_battle.c:652
validEntryLineColumn
int validEntryLineColumn(int line, char column)
for Standard Input Output
Definition: naval_battle.c:25
calculateScore
int calculateScore(int mat[10][10], int line, int column)
Function calculateScore Responsible for calculating the score obtained during the game.
Definition: naval_battle.c:442
printsTray
void printsTray(int mat[10][10], int stage)
Function printsTray Responsible for printing the visual board for the user.
Definition: naval_battle.c:355
Here is the call graph for this function:

◆ positionBoat()

void positionBoat ( int  mat[10][10],
int  boat 
)

Function positionBoat Responsible for placing the boats on the board, according to the size.

Parameters
matboard
boatboat
125{
126 int line, j;
127 char column, guide;
128
129 if (boat == 1)
130 {
131 scanf("%d %c", &line, &column);
132
133 while (validEntryLineColumn(line, column) != 1 ||
134 validatePosition(mat, boat, (line - 1), (column - 65), 'H') != 1)
135 {
136 printf("Position unavailable!\n");
137 scanf("%d %c", &line, &column);
138 }
139 }
140
141 else
142 {
143 scanf("%d %c %c", &line, &column, &guide);
144
145 while (validEntryLineColumn(line, column) == 0 ||
146 validatePosition(mat, boat, (line - 1), (column - 65), guide) ==
147 0)
148 {
149 printf("Position unavailable!\n");
150 scanf("%d %c %c", &line, &column, &guide);
151 }
152 }
153
154 int aux = column - 'A';
155 line -= 1;
156
157 if (boat == 1)
158 {
159 for (j = aux; j < (aux + boat); j++)
160 {
161 mat[line][j] = boat;
162 }
163
164 for (int a = line - 1; a < (line + boat + 1); a++)
165 {
166 for (int b = aux - 1; b < (aux + boat + 1); b++)
167 {
168 if (a >= 0 && a <= 9 && b >= 0 && b <= 9)
169 {
170 if (mat[a][b] != boat)
171 {
172 mat[a][b] = -1;
173 }
174 }
175 }
176 }
177 }
178
179 if (guide == 'H')
180 {
181 for (j = aux; j < (aux + boat); j++)
182 {
183 mat[line][j] = boat;
184 }
185 if (boat == 3)
186 {
187 for (int a = line - 1; a < (line + boat - 1); a++)
188 {
189 for (int b = aux - 1; b < (aux + boat + 1); b++)
190 {
191 if (a >= 0 && a <= 9 && b >= 0 && b <= 9)
192 {
193 if (mat[a][b] != boat)
194 {
195 mat[a][b] = -1;
196 }
197 }
198 }
199 }
200 }
201
202 else
203 {
204 for (int a = line - 1; a < (line + boat); a++)
205 {
206 for (int b = aux - 1; b < (aux + boat + 1); b++)
207 {
208 if (a >= 0 && a <= 9 && b >= 0 && b <= 9)
209 {
210 if (mat[a][b] != boat)
211 {
212 mat[a][b] = -1;
213 }
214 }
215 }
216 }
217 }
218 }
219
220 if (guide == 'V')
221 {
222 for (j = line; j < (line + boat); j++)
223 {
224 mat[j][aux] = boat;
225 }
226 if (boat == 3)
227 {
228 for (int a = line - 1; a < (line + boat + 1); a++)
229 {
230 for (int b = aux - 1; b < (aux + boat - 1); b++)
231 {
232 if (a >= 0 && a <= 9 && b >= 0 && b <= 9)
233 {
234 if (mat[a][b] != boat)
235 {
236 mat[a][b] = -1;
237 }
238 }
239 }
240 }
241 }
242
243 else
244 {
245 for (int a = line - 1; a < (line + boat + 1); a++)
246 {
247 for (int b = aux - 1; b < (aux + boat); b++)
248 {
249 if (a >= 0 && a <= 9 && b >= 0 && b <= 9)
250 {
251 if (mat[a][b] != boat)
252 {
253 mat[a][b] = -1;
254 }
255 }
256 }
257 }
258 }
259 }
260}
validatePosition
int validatePosition(int mat[10][10], int boat, int line, int column, char guide)
Function validatePosition Responsible for checking if the position can receive the boat.
Definition: naval_battle.c:43
Here is the call graph for this function:

◆ printMessage()

void printMessage ( char *  msg)

Function printMessage Responsible for printing the auxiliary message.

Parameters
msgmsg with board
267{
268 printf("************************\n");
269 printf("*\n");
270 printf("* %s\n", msg);
271 printf("*\n");
272 printf("************************\n");
273}

◆ printMessageScore()

void printMessageScore ( int  pts1,
int  pts2 
)

Function printMessageScore Responsible for printing the score messages.

Parameters
pts1player 1 score
pts2player 2 score
281{
282 printf("************************\n");
283 printf("*\n");
284 printf("* Player'S SCORE 1: %02d\n", pts1);
285 printf("* Player'S SCORE 2: %02d\n", pts2);
286 printf("*\n");
287 printf("************************\n");
288}

◆ printPositioning()

void printPositioning ( int  Player,
int  boat,
int  nm 
)

Function printPositioning Responsible for printing messages for positioning boats on the board; of player 1 and 2.

Parameters
Playernumber representing the Player
boatnumber that represents the boat
nmwhich message to print
653{
654 if (Player == 1)
655 {
656 char msg1[60] = "Player 1 - Position the size boat 1 (1/6)";
657 char msg2[60] = "Player 1 - Position the size boat 1 (2/6)";
658 char msg3[60] = "Player 1 - Position the size boat 1 (3/6)";
659 char msg4[60] = "Player 1 - Position the size boat 1 (4/6)";
660 char msg5[60] = "Player 1 - Position the size boat 1 (5/6)";
661 char msg6[60] = "Player 1 - Position the size boat 1 (6/6)";
662
663 char msg7[60] = "Player 1 - Position the size boat 2 (1/4)";
664 char msg8[60] = "Player 1 - Position the size boat 2 (2/4)";
665 char msg9[60] = "Player 1 - Position the size boat 2 (3/4)";
666 char msg10[60] = "Player 1 - Position the size boat 2 (4/4)";
667
668 char msg11[60] = "Player 1 - Position the size boat 3 (1/2)";
669 char msg12[60] = "Player 1 - Position the size boat 3 (2/2)";
670
671 if (boat == 1)
672 {
673 if (nm == 1)
674 {
675 printMessage(msg1);
676 }
677 else if (nm == 2)
678 {
679 printMessage(msg2);
680 }
681 else if (nm == 3)
682 {
683 printMessage(msg3);
684 }
685
686 else if (nm == 4)
687 {
688 printMessage(msg4);
689 }
690
691 else if (nm == 5)
692 {
693 printMessage(msg5);
694 }
695
696 else if (nm == 6)
697 {
698 printMessage(msg6);
699 }
700 }
701 else if (boat == 2)
702 {
703 if (nm == 1)
704 {
705 printMessage(msg7);
706 }
707 else if (nm == 2)
708 {
709 printMessage(msg8);
710 }
711 else if (nm == 3)
712 {
713 printMessage(msg9);
714 }
715 else if (nm == 4)
716 {
717 printMessage(msg10);
718 }
719 }
720 else if (boat == 3)
721 {
722 if (nm == 1)
723 {
724 printMessage(msg11);
725 }
726 if (nm == 2)
727 {
728 printMessage(msg12);
729 }
730 }
731 }
732
733 if (Player == 2)
734 {
735 char msg1[60] = "Player 2 - Position the size boat 1 (1/6)";
736 char msg2[60] = "Player 2 - Position the size boat 1 (2/6)";
737 char msg3[60] = "Player 2 - Position the size boat 1 (3/6)";
738 char msg4[60] = "Player 2 - Position the size boat 1 (4/6)";
739 char msg5[60] = "Player 2 - Position the size boat 1 (5/6)";
740 char msg6[60] = "Player 2 - Position the size boat 1 (6/6)";
741
742 char msg7[60] = "Player 2 - Position the size boat 2 (1/4)";
743 char msg8[60] = "Player 2 - Position the size boat 2 (2/4)";
744 char msg9[60] = "Player 2 - Position the size boat 2 (3/4)";
745 char msg10[60] = "Player 2 - Position the size boat 2 (4/4)";
746
747 char msg11[60] = "Player 2 - Position the size boat 3 (1/2)";
748 char msg12[60] = "Player 2 - Position the size boat 3 (2/2)";
749
750 if (boat == 1)
751 {
752 if (nm == 1)
753 {
754 printMessage(msg1);
755 }
756 else if (nm == 2)
757 {
758 printMessage(msg2);
759 }
760 else if (nm == 3)
761 {
762 printMessage(msg3);
763 }
764 else if (nm == 4)
765 {
766 printMessage(msg4);
767 }
768 else if (nm == 5)
769 {
770 printMessage(msg5);
771 }
772 else if (nm == 6)
773 {
774 printMessage(msg6);
775 }
776 }
777 else if (boat == 2)
778 {
779 if (nm == 1)
780 {
781 printMessage(msg7);
782 }
783 else if (nm == 2)
784 {
785 printMessage(msg8);
786 }
787 else if (nm == 3)
788 {
789 printMessage(msg9);
790 }
791 else if (nm == 4)
792 {
793 printMessage(msg10);
794 }
795 }
796 else if (boat == 3)
797 {
798 if (nm == 1)
799 {
800 printMessage(msg11);
801 }
802 else if (nm == 2)
803 {
804 printMessage(msg12);
805 }
806 }
807 }
808}
Here is the call graph for this function:

◆ printsTray()

void printsTray ( int  mat[10][10],
int  stage 
)

Function printsTray Responsible for printing the visual board for the user.

Parameters
matMatrix
stagegame step
356{
357 int logic;
358 char imp;
359
360 printf(" ");
361 for (int i = 65; i < 75; i++)
362 {
363 printf("%c", i);
364 if (i < 74)
365 {
366 printf(" ");
367 }
368 }
369 printf("\n");
370
371 for (int i = 0; i < 12; i++)
372 {
373 if (i > 0 && i < 11)
374 {
375 printf("%02d ", i);
376 }
377
378 else
379 {
380 printf(" ");
381 }
382
383 for (int j = 0; j < 12; j++)
384 {
385 if ((i > 0 && i < 11) && (j > 0 && j < 11))
386 {
387 logic = mat[i - 1][j - 1];
388 imp = printTable(logic, stage);
389 printf("%c", imp);
390 }
391 else
392 {
393 printf("#");
394 }
395
396 if (j < 11)
397 {
398 printf(" ");
399 }
400 }
401 printf("\n");
402 }
403}
printTable
char printTable(int logic, int stage)
Function printTable Responsible for printing the board.
Definition: naval_battle.c:296
Here is the call graph for this function:

◆ printTable()

char printTable ( int  logic,
int  stage 
)

Function printTable Responsible for printing the board.

Parameters
logicreturn of the logical matrix
stagegame step
Returns
char for visual matrix
297{
298 if (stage == 0)
299 {
300 if (logic == 0)
301 {
302 return '.';
303 }
304
305 else if (logic == -1)
306 {
307 return '*';
308 }
309
310 else if (logic == 1)
311 {
312 return '1';
313 }
314
315 else if (logic == 2)
316 {
317 return '2';
318 }
319
320 else
321 {
322 return '3';
323 }
324 }
325
326 else
327 {
328 if (logic == 0 || logic == -1 || logic == 1 || logic == 2 || logic == 3)
329 {
330 return '.';
331 }
332
333 else if (logic == -2)
334 {
335 return 'x';
336 }
337
338 else if (logic == 10 || logic == 20 || logic == 30)
339 {
340 return 'N';
341 }
342
343 else
344 {
345 return 'A';
346 }
347 }
348}

◆ shoot()

void shoot ( int  mat[10][10],
int  line,
int  column 
)

Function shoot Responsible for saying if he hit a boat.

Parameters
matboard
linematrix row
columnmatrix column
412{
413 if (mat[line][column] == 0 || mat[line][column] == -1)
414 {
415 mat[line][column] = -2;
416 }
417
418 else if (mat[line][column] == 1)
419 {
420 mat[line][column] = 10;
421 }
422
423 else if (mat[line][column] == 2)
424 {
425 mat[line][column] = 20;
426 }
427
428 else if (mat[line][column] == 3)
429 {
430 mat[line][column] = 30;
431 }
432}

◆ validatePosition()

int validatePosition ( int  mat[10][10],
int  boat,
int  line,
int  column,
char  guide 
)

Function validatePosition Responsible for checking if the position can receive the boat.

Parameters
matboard
boatboat
linematrix row
columnmatrix column
Returns
if the position is valid
45{
46 int cont = 0;
47 int i, j;
48
49 if (line < 0 || line > 9 || column < 0 || column > 9 ||
50 (guide != 'H' && guide != 'V') || boat < 1 || boat > 3)
51 {
52 return 0;
53 }
54
55 if (guide == 'H')
56 {
57 if ((10 - column) < boat)
58 {
59 return 0;
60 }
61 else
62 {
63 for (j = column; j < (column + boat); j++)
64 {
65 if (mat[line][j] == 0)
66 {
67 cont++;
68 }
69 }
70 }
71 }
72
73 if (guide == 'V')
74 {
75 if ((10 - line) < boat)
76 {
77 return 0;
78 }
79
80 else
81 {
82 for (i = line; i < (line + boat); i++)
83 {
84 if (mat[i][column] == 0)
85 {
86 cont++;
87 }
88 }
89 }
90 }
91
92 if (cont == boat)
93 {
94 return 1;
95 }
96 return 0;
97}

◆ validEntryLineColumn()

int validEntryLineColumn ( int  line,
char  column 
)

for Standard Input Output

Function validEntryLineColumn Responsible for validating entries, for positioning boats

Parameters
linematrix row
columnmatrix column
Returns
if the row and column are valid
26{
27 if ((line >= 1 && line <= 10) && (column >= 65 && column <= 74))
28 {
29 return 1;
30 }
31
32 return 0;
33}