Introducción a la estructura de datos Pila (Stack) en C
En este artículo, explicaré paso a paso cómo programé el juego Battleship en C. Este proyecto sigue una estructura clara, dividiendo el código en funciones bien definidas para manejar la lógica del juego.
1. Inicialización del Tablero
Para representar el tablero, usamos una matriz bidimensional de caracteres. Inicialmente, llenamos el tablero con agua ('~').
void InicializarTablero(char tablero[TAMANO][TAMANO]) {
for (int i = 0; i < TAMANO; i++) {
for (int j = 0; j < TAMANO; j++) {
tablero[i][j] = '~'; // Agua
}
}
}2. Colocación de los Barcos
Los barcos se colocan aleatoriamente en el tablero, asegurándonos de que no se superpongan.
void ColocarBarco(char tablero[TAMANO][TAMANO], int tamano_barco) {
int x, y, direccion;
bool colocado = false;
while (!colocado) {
x = rand() % TAMANO;
y = rand() % TAMANO;
direccion = rand() % 2; // 0 = horizontal, 1 = vertical
if (EsPosicionValida(tablero, x, y, tamano_barco, direccion)) {
for (int i = 0; i < tamano_barco; i++) {
if (direccion == 0) tablero[x][y + i] = 'B';
else tablero[x + i][y] = 'B';
}
colocado = true;
}
}
}3. Disparos y Evaluación de Impacto
Cuando el jugador elige una coordenada, verificamos si hay un barco ('B') o agua ('~').
void Disparar(char tablero[TAMANO][TAMANO], int x, int y) {
if (tablero[x][y] == 'B') {
tablero[x][y] = 'X'; // Impacto
printf("¡Impacto!\n");
} else {
tablero[x][y] = 'O'; // Agua
printf("Agua...\n");
}
}4. Verificación de Hundimiento de Barcos
Después de cada disparo, verificamos si todos los segmentos de un barco han sido alcanzados.
bool SiSeHundio(char tablero[TAMANO][TAMANO]) {
for (int i = 0; i < TAMANO; i++) {
for (int j = 0; j < TAMANO; j++) {
if (tablero[i][j] == 'B') return false; // Aún queda un barco
}
}
return true; // Todos los barcos han sido destruidos
}5. Estructura Principal del Juego
El flujo principal del juego usa un bucle que permite a los jugadores disparar hasta que todos los barcos sean destruidos.
Codigo: Battleship.h
#ifndef battleship_game
#include
#include
#include
#include
#include
#define ROWS 10
#define COLS 10
#define HORIZONTAL 0
#define VERTICAL 1
#define NUM_SHIPS 4
#define BGN '~'
#define HIT '*'
#define MISS '/'
typedef enum Bool {
FALSE,
TRUE
} Bool;
typedef enum IAMode {
noShipWasHit,
ShipHitButNotSunked,
shipSunked
} IAMode;
typedef struct Coordinates {
int x;
int y;
} Coordinates;
typedef struct Battleship{
char symbol;
int length;
char* name;
} Battleship;
typedef struct PlayerRecord {
int numOfHits;
int misses;
int score;
} PlayerRecord;
typedef struct Matrix {
char symbol;
Coordinates position;
} Matrix;
Bool gameOver = FALSE;
int randNumber(int low, int high) {
srand(time(NULL));
int n = 0;
if (low == 0)
n = rand() % ++high;
if (low > 0)
n = rand() % ++high + ++low;
return n;
}
void initBoard(Matrix board[][COLS]){
for (int i = 0; i < ROWS; i++) {
for (int j = 0; j < COLS; j++) {
board[i][j].position.x = i;
board[i][j].position.y = j;
board[i][j].symbol = BGN;
}
}
}
void printBoard(Matrix gameBoard[][COLS], Bool isHidden)
{
int i = 0, j = 0;
printf(" 0 1 2 3 4 5 6 7 8 9\n");
for (i = 0; i < ROWS; i++){
printf("%d ", i);
for(j = 0; j < COLS; j++) {
if (isHidden == TRUE) {
printf("%c ", gameBoard[i][j].symbol);
}
else {
switch (gameBoard[i][j].symbol)
{
case HIT:
printf("%c ", HIT);
break;
case MISS:
printf("%c ", MISS);
break;
case BGN:
default:
printf("%c ", BGN);
break;
}
}
}
putchar('\n');
}
}
void shipInBoard(Matrix gameBoard[][COLS], Coordinates coord, Battleship ship, int direction)
{
int i = ship.length - 1;
for (i = 0; i < ship.length; i++) {
if (direction == HORIZONTAL) {
gameBoard[coord.x][coord.y + i].symbol = ship.symbol;
}
else {
gameBoard[coord.x + i][coord.y].symbol = ship.symbol;
}
}
}
Bool stringToCoordinate(Coordinates position[], char *stringPosition, int length) {
Bool flag = TRUE;
int i = 0, j = 0, k = 1;
/* checks if length of input is good */
if (strlen (stringPosition)/2 == length) {
/* loops through the length of the ship */
for (i = 0; i < length && flag; i++) {
/* checks if each cell is a digit */
if (isdigit (stringPosition[j]) && isdigit (stringPosition[k])) {
position[i].x = stringPosition[j] - '0';
position[i].y = stringPosition[k] - '0';
j += 2;
k += 2;
} else {
flag = FALSE;
}
}
} else {
flag = FALSE;
}
return flag;
}
void allocShipManually(Matrix gameBoard[][COLS], Battleship ship[]) {
char stringPosition[11] = "";
int i = 0, j = 0;
Coordinates position[4];
Bool isValid = FALSE;
fflush (stdin);
for (i = 0; i < NUM_SHIPS; i++) {
while (TRUE) {
system ("cls");
printBoard (gameBoard, TRUE);
printf ("> Por favor poner %d casillas (xy) para acomodar %s en el plano (SIN ESPACIOS):\n", ship[i].length, ship[i].name);
printf ("> ");
scanf ("%s", stringPosition);
/* convertStringtoPosition returns false if unsuccessful */
if (stringToCoordinate(position, stringPosition, ship[i].length)) {
isValid = TRUE;
for (j = 0; j < ship[i].length; j++) {
if (gameBoard[position[j].x][position[j].y].symbol == BGN) {
gameBoard[position[j].x][position[j].y].symbol = ship[i].symbol;
} else {
isValid = FALSE;
printf ("> No son validas sus entradas!\n");
if (j != 0)
while (j >= 0) {
gameBoard[position[j].x][position[j].y].symbol = BGN;
j--;
}
break;
}
}
} else {
isValid = FALSE;
printf ("> NO son validas sus entradas!\n");
}
if (isValid == TRUE) break;
}
}
}
Coordinates createShipPosition(int direction, int length) {
Coordinates pos;
if (direction == HORIZONTAL) {
pos.x = randNumber(0, ROWS);
pos.y = randNumber(0, COLS - length);
} else {
pos.x = randNumber(0, ROWS - length);
pos.y = randNumber(0, COLS);
}
return pos;
}
Bool checkPosition(Matrix gameBoard[][COLS], Coordinates coord, int direction, int length)
{
Bool flag = TRUE;
for (int i = 0; (flag && i < length); i++) {
if(direction == HORIZONTAL) {
if(gameBoard[coord.x][coord.y + i].symbol != BGN && ((coord.y + i) < COLS)) {
flag = FALSE;
}
}
else if (direction == VERTICAL) {
if(gameBoard[coord.x + i][coord.y].symbol != BGN && ((coord.x + i) < ROWS)) {
flag = FALSE;
}
}
else {
printf("No Direction given");
flag = FALSE;
}
}
return flag;
}
void allocShipRandom(Matrix gameBoard[][COLS], Battleship ship[]) {
int direction = -1;
Coordinates temp;
int i = 0;
for (i = 0; i < NUM_SHIPS; i++) {
while(TRUE) {
direction = randNumber(0, 1);
temp = createShipPosition(direction, ship[i].length);
if (checkPosition(gameBoard, temp, direction, ship[i].length)) break;
}
shipInBoard(gameBoard, temp, ship[i], direction);
}
}
Coordinates getTarget()
{
Coordinates coord;
fflush(stdin);
printf("Favor de ingresar coordenadas de su ataque, ej. (3 4) :\n");
int x = 0, y = 0;
printf("> ");
scanf("%d %d", &x, &y);
coord.x = x;
coord.y = y;
return coord;
}
Coordinates targetAIRand()
{
Coordinates coord;
int x = randNumber(0, ROWS);
int y = randNumber(0, COLS);
coord.x = x;
coord.y = y;
return coord;
}
Coordinates* targetAreaAI(Coordinates* presentHit, Bool borders[], int* flag)
{
//int flag = 0;
Coordinates* temp = presentHit;
//NORTH OF THE TARGET
if (borders[0] == TRUE) {
borders[0] = FALSE;
borders[1] = TRUE;
} // EAST OF TARGET
else if (borders[1] == TRUE) {
*flag = 1;
borders[1] = FALSE;
borders[2] = TRUE;
} // SOUTH
else if (borders[2] == TRUE) {
*flag = 2;
borders[2] = FALSE;
borders[3] = TRUE;
} // WEST
else if (borders[3] == TRUE) {
*flag = 3;
borders[3] = FALSE;
borders[0] = TRUE;
}
switch (*flag)
{
case 0:
temp->y--;
break;
case 1:
temp->x++;
break;
case 2:
temp->y++;
break;
case 3:
temp->x--;
break;
default:
break;
}
return temp;
}
int checkIfHit(Matrix boardGame[][COLS], Coordinates target)
{
int hit = -2;
switch (boardGame[target.x][target.y].symbol)
{
case BGN:
hit = 0;
break;
case 'a':
case 'd':
case 'b':
case 'c':
hit = 1;
break;
case '*':
case MISS:
default:
hit = -1;
break;
}
return hit;
}
void updateMatrix(Matrix boardGame[][COLS], Coordinates target)
{
switch (boardGame[target.x][target.y].symbol)
{
case BGN:
boardGame[target.x][target.y].symbol = MISS;
break;
case 'd':
case 'c':
case 'a':
case 'b':
boardGame[target.x][target.y].symbol = HIT;
break;
default:
break;
}
}
Bool IfShipHasSunk(int ships[][NUM_SHIPS], int player, char shipType) {
Bool isSink = FALSE;
switch (shipType)
{
case 'a':
ships[player][0] -= 1;
if (ships[player][0] == 0)
{
printf(" Se hundio el barco acorazado del jugador %d\n", player + 1);
isSink = TRUE;
}
break;
case 'd':
ships[player][1] -= 1;
if (ships[player][1] == 0)
{
printf(" Se hundio el barco destructor del jugador %d\n", player + 1);
isSink = TRUE;
}
break;
case 'b':
ships[player][2] -= 1;
if (ships[player][2] == 0)
{
printf(" Se hundio el barco bunker del jugador %d\n", player + 1);
isSink = TRUE;
}
break;
case 'c':
ships[player][3] -= 1;
if (ships[player][3] == 0)
{
printf(" Se hundioel barco crusero del jugador %d\n", player + 1);
isSink = TRUE;
}
break;
default:
printf("Seems the conditions to check is ship was sunked fallthrough");
break;
}
return isSink;
}
Bool gameOverCond(PlayerRecord players[], int player)
{
Bool flag;
if (players[player].numOfHits == 11)
return flag = TRUE;
else
return flag = FALSE;
}
#endif
Codigo: Battleship.c
#include "battleship_game.h"
#define PLAYER1 0
#define PLAYER2 1
// Función auxiliar: Genera un tiro aleatorio usando un patrón checkered (solo celdas donde (x+y) sea par)
Coordinates targetAIHunt(Matrix board[][COLS])
{
Coordinates candidate;
do {
candidate.x = randNumber(0, ROWS - 1);
candidate.y = randNumber(0, COLS - 1);
/* Se escogen solo celdas del patrón checkered y que no hayan sido ya atacadas.
Se consideran atacadas aquellas que tienen HIT o MISS. */
} while (((candidate.x + candidate.y) % 2) != 0 ||
(board[candidate.x][candidate.y].symbol == HIT ||
board[candidate.x][candidate.y].symbol == MISS));
return candidate;
}
void gameLoop()
{
/* INICIALIZACIÓN DE TABLEROS */
Matrix playerOne[ROWS][COLS];
Matrix playerTwo[ROWS][COLS];
/* INICIALIZACIÓN DE BARCOS */
Battleship mainShips[NUM_SHIPS] = {
{'a', 4, "acorazado"},
{'d', 3, "destructor"},
{'b', 2, "bunker"},
{'c', 2, "crusero"}
};
/* INICIALIZACIÓN DE JUGADORES */
int player;
int playerOneShips[NUM_SHIPS] = {4, 3, 2, 2};
int playerTwoShips[NUM_SHIPS] = {4, 3, 2, 2};
PlayerRecord playersRecords[2] = {{0, 0, 0}, {0, 0, 0}};
/* VARIABLES DIVERSAS */
int menuOption;
int shot;
char charShipType;
/* VARIABLES PARA EL MODO TARGETING DE LA IA */
Bool aiTargetMode = FALSE; // Indica si la IA tiene un tiro exitoso previo y está en modo targeting
Coordinates lastHit; // Almacena la última coordenada de impacto
int neighborIndex = 0; // Índice para recorrer las celdas vecinas
Coordinates neighbors[4]; // Vecinos en orden: arriba, derecha, abajo, izquierda
/* COORDENADA PARA EL TIRO */
Coordinates target;
/* INICIALIZACIÓN DE LOS TABLEROS */
initBoard(playerOne);
initBoard(playerTwo);
printf ("- Seleccione la manera de colocar sus barcos en el tablero:\n");
printf (" Para colocarlos manualmente presione: 1\n");
printf (" Para colocarlos aleatoriamente presione: 2\n");
printf ("- Ingrese la opción: ");
scanf ("%d", &menuOption);
player = randNumber(0, 1);
printf ("> Jugador %d tiene el primer turno.\n", player + 1);
Denuevo:
switch (menuOption) {
case 1:
allocShipManually(playerOne, mainShips);
break;
case 2:
allocShipRandom(playerOne, mainShips);
break;
default:
printf("Opción no válida, repita de nuevo por favor.\n");
goto Denuevo;
break;
}
allocShipRandom(playerTwo, mainShips);
printf ("- ATENCIÓN: Se han generado los barcos de la computadora.\n");
printf ("- Prepárese para perder.\n");
while (gameOver != TRUE) {
switch (player)
{
case PLAYER1:
printf("Tablero enemigo:\n");
printBoard(playerTwo, FALSE);
printf("# Tu tablero:\n");
printBoard(playerOne, TRUE);
do {
target = getTarget();
shot = checkIfHit(playerTwo, target);
if (shot == -1) {
printf("- Fallaste el tiro o esa casilla ya fue atacada.\n");
}
} while (shot == -1);
charShipType = playerTwo[target.x][target.y].symbol;
break;
case PLAYER2:
/* TURNO DE LA COMPUTADORA (IA) */
printf("# Tablero del jugador 1:\n");
printBoard(playerOne, TRUE);
printf("# Turno de la poderosa IA.\n");
if (aiTargetMode) {
/* Modo targeting: se prueban las celdas vecinas del último impacto */
Bool foundNeighbor = FALSE;
for (; neighborIndex < 4; neighborIndex++) {
Coordinates candidate = neighbors[neighborIndex];
if (candidate.x < 0 || candidate.x >= ROWS || candidate.y < 0 || candidate.y >= COLS)
continue; // Fuera de límites
/* Se evita atacar celdas ya disparadas (con HIT o MISS) */
if (playerOne[candidate.x][candidate.y].symbol == HIT ||
playerOne[candidate.x][candidate.y].symbol == MISS)
continue;
target = candidate;
foundNeighbor = TRUE;
neighborIndex++; // Avanza para la siguiente prueba en futuros turnos
break;
}
if (!foundNeighbor) {
/* Si no hay vecinos válidos, se sale del modo targeting */
aiTargetMode = FALSE;
neighborIndex = 0;
target = targetAIHunt(playerOne);
}
} else {
/* Modo hunting: se selecciona un tiro aleatorio siguiendo el patrón */
target = targetAIHunt(playerOne);
}
shot = checkIfHit(playerOne, target);
while (shot == -1) {
/* Si se escogió una casilla ya atacada, se vuelve a escoger */
if (aiTargetMode) {
Bool foundNeighbor = FALSE;
for (; neighborIndex < 4; neighborIndex++) {
Coordinates candidate = neighbors[neighborIndex];
if (candidate.x < 0 || candidate.x >= ROWS || candidate.y < 0 || candidate.y >= COLS)
continue;
if (playerOne[candidate.x][candidate.y].symbol == HIT ||
playerOne[candidate.x][candidate.y].symbol == MISS)
continue;
target = candidate;
foundNeighbor = TRUE;
neighborIndex++;
break;
}
if (!foundNeighbor) {
aiTargetMode = FALSE;
neighborIndex = 0;
target = targetAIHunt(playerOne);
}
} else {
target = targetAIHunt(playerOne);
}
shot = checkIfHit(playerOne, target);
}
charShipType = playerOne[target.x][target.y].symbol;
/* Si la IA acierta un barco, se activa el modo targeting */
if (shot == 1) {
lastHit = target;
neighbors[0].x = lastHit.x - 1; neighbors[0].y = lastHit.y; // Arriba
neighbors[1].x = lastHit.x; neighbors[1].y = lastHit.y + 1; // Derecha
neighbors[2].x = lastHit.x + 1; neighbors[2].y = lastHit.y; // Abajo
neighbors[3].x = lastHit.x; neighbors[3].y = lastHit.y - 1; // Izquierda
aiTargetMode = TRUE;
neighborIndex = 0;
}
break;
} // Fin del switch según el jugador
/* Procesar el resultado del tiro */
if (shot == 1) { // Tiro exitoso
printf("- Las coordenadas (%d, %d) impactaron un barco!\n", target.x, target.y);
playersRecords[player].numOfHits++;
if (player == PLAYER2)
(void)IfShipHasSunk(playerOneShips, !player, charShipType);
else
(void)IfShipHasSunk(playerTwoShips, !player, charShipType);
}
else {
printf("- Las coordenadas (%d, %d) fallaron.\n", target.x, target.y);
playersRecords[player].misses++;
}
/* Actualizar el tablero del oponente según el tiro */
if (player == PLAYER1)
updateMatrix(playerTwo, target);
else
updateMatrix(playerOne, target);
/* Cambio de turno */
player = !player;
gameOver = gameOverCond(playersRecords, player);
if (gameOver) {
printf("El jugador %d es el ganador!!\n", player);
}
system("cls");
}
}
int main()
{
/* Inicializar la semilla para números aleatorios una sola vez */
srand(time(NULL));
gameLoop();
return 0;
}