C/Visual C - Triki

#include <iostream> // Biblioteca estándar para entrada/salida (cout, cin)
#include <cstdlib> // Biblioteca estándar para funciones generales (rand, srand)
#include <ctime> // Biblioteca estándar para manipulación de tiempo (time
using namespace std;

char tablero[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};


// Función para reiniciar el tablero
void reiniciarTablero() {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
tablero[i][j] = ' ';
}
}
}

bool deseaJugarNuevamente() {
int opcion;
do {
cout << "¿Deseas jugar nuevamente? (0 = Sí / 1 = No): ";
cin >> opcion;

if (opcion != 0 && opcion != 1) {
cout << "Opción inválida. Ingresa 0 para Sí o 1 para No." << endl;
}

} while (opcion != 0 && opcion != 1);

return (opcion == 0);
}

// Función para imprimir el tablero
void imprimirTablero() {
cout << " 1 2 3" << endl;
for (int i = 0; i < 3; i++) {
cout << i + 1 << " ";
for (int j = 0; j < 3; j++) {
cout << tablero[i][j];
if (j < 2) {
cout << "|";
}
}
cout << endl;
if (i < 2) {
cout << " -----" << endl;
}
}
cout << endl;
}

// Función para verificar si alguien ha ganado
bool verificarGanador(char jugador) {
// Verificar filas y columnas
for (int i = 0; i < 3; i++) {
if ((tablero[i][0] == jugador && tablero[i][1] == jugador && tablero[i][2] == jugador) ||
(tablero[0][i] == jugador && tablero[1][i] == jugador && tablero[2][i] == jugador)) {
return true;
}
}

// Verificar diagonales
if ((tablero[0][0] == jugador && tablero[1][1] == jugador && tablero[2][2] == jugador) ||
(tablero[0][2] == jugador && tablero[1][1] == jugador && tablero[2][0] == jugador)) {
return true;
}

return false;
}

// Función para realizar un movimiento humano
bool realizarMovimientoHumano(int posicion, char jugador) {
int fila = (posicion - 1) / 3;
int columna = (posicion - 1) % 3;

if (fila >= 0 && fila < 3 && columna >= 0 && columna < 3 && tablero[fila][columna] == ' ') {
tablero[fila][columna] = jugador;
return true; // Movimiento válido
} else {
cout << "Movimiento inválido. Intenta de nuevo." << endl;
return false; // Movimiento inválido
}
}

// Función para realizar un movimiento de la computadora
void realizarMovimientoComputadora(char jugadorComputadora, char jugadorHumano) {
// Primero, intentar ganar
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (tablero[i][j] == ' ') {
tablero[i][j] = jugadorComputadora;
if (verificarGanador(jugadorComputadora)) {
return; // La computadora ha ganado
}
tablero[i][j] = ' '; // Deshacer el movimiento
}
}
}

// Luego, bloquear al jugador humano
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (tablero[i][j] == ' ') {
tablero[i][j] = jugadorHumano;
if (verificarGanador(jugadorHumano)) {
tablero[i][j] = jugadorComputadora; // Bloquear al jugador humano
return;
}
tablero[i][j] = ' '; // Deshacer el movimiento
}
}
}

// Si no se puede ganar ni bloquear, buscar una jugada estratégica
if (tablero[1][1] == ' ') {
tablero[1][1] = jugadorComputadora; // Jugar en el centro si está disponible
} else {
// Intentar ocupar una esquina si está disponible
for (int i = 0; i < 3; i += 2) {
for (int j = 0; j < 3; j += 2) {
if (tablero[i][j] == ' ') {
tablero[i][j] = jugadorComputadora;
return;
}
}
}

// Si no hay esquinas disponibles, jugar en cualquier borde
for (int i = 0; i < 3; i += 2) {
for (int j = 1; j < 3; j += 2) {
if (tablero[i][j] == ' ') {
tablero[i][j] = jugadorComputadora;
return;
}
}
}
}
}

// Función para determinar quién inicia
char determinarQuienInicia() {
srand(static_cast<unsigned int>(time(0)));

int jugadorHumano = rand() % 6 + 1; // Número entre 1 y 6
int jugadorComputadora = rand() % 6 + 1; // Número entre 1 y 6

cout << "Humano tiró un " << jugadorHumano << endl;
cout << "Computadora tiró un " << jugadorComputadora << endl;

if (jugadorHumano > jugadorComputadora) {
cout << "¡El humano inicia!" << endl;
return 'X';
} else {
cout << "¡La computadora inicia!" << endl;
return 'O';
}
}

int main() {


do{
reiniciarTablero();

cout << "¡Bienvenido al juego de triqui contra la computadora!" << endl;

char jugadorInicia = determinarQuienInicia();

while (true) {
imprimirTablero();

// Turno del jugador humano o computadora según quién inicie
if (jugadorInicia == 'X') {
// Turno del jugador humano
int posicion;
bool movimientoValido = false;
while (!movimientoValido) {
cout << "Tu turno. Ingresa la posición (1-9): ";
cin >> posicion;
movimientoValido = realizarMovimientoHumano(posicion, jugadorInicia);
}
} else {
// Turno de la computadora
realizarMovimientoComputadora('O', 'X');
}

// Verificar si el jugador humano o la computadora ha ganado
if (verificarGanador(jugadorInicia)) {
imprimirTablero();
if (jugadorInicia == 'X') {
cout << "¡Felicidades! Has ganado contra la computadora." << endl;
} else {
cout << "¡La computadora ha ganado! Intenta de nuevo." << endl;
}
break;
}

// Verificar empate
bool empate = true;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (tablero[i][j] == ' ') {
empate = false;
break;
}
}
if (!empate) {
break;
}
}

if (empate) {
imprimirTablero();
cout << "¡Es un empate!" << endl;
break;
}

// Actualizar jugadorInicia para el próximo turno
jugadorInicia = (jugadorInicia == 'X') ? 'O' : 'X';
}

}while (deseaJugarNuevamente());

cout << "¡Gracias por jugar! Hasta luego." << endl;

return 0;
}