Juego de Cuatro en Línea: Implementación en Python

¡Claro! El juego «Four-in-a-Row» (Cuatro en línea) es un pasatiempo clásico que implica colocar fichas en un tablero vertical con el objetivo de formar una línea de cuatro fichas del mismo color de forma vertical, horizontal o diagonal. Podemos crear una versión simple de este juego utilizando Python.

Para comenzar, necesitaremos representar el tablero y las fichas, así como implementar la lógica del juego para permitir que dos jugadores coloquen sus fichas y verificar si alguno de ellos ha ganado.

Aquí tienes un ejemplo básico de cómo podríamos implementar este juego en Python:

pythonCopy code
class CuatroEnLinea:
    def __init__(self, filas=6, columnas=7):
        self.filas = filas
        self.columnas = columnas
        self.tablero = [[' ' for _ in range(columnas)] for _ in range(filas)]

    def imprimir_tablero(self):
        for fila in self.tablero:
            print('|'.join(fila))
            print('-' * (self.columnas * 2 - 1))

    def validar_movimiento(self, columna):
        return 0 <= columna < self.columnas and self.tablero[0][columna] == ' '

    def realizar_movimiento(self, columna, ficha):
        for fila in range(self.filas - 1, -1, -1):
            if self.tablero[fila][columna] == ' ':
                self.tablero[fila][columna] = ficha
                return fila

    def verificar_victoria(self, fila, columna):
        ficha = self.tablero[fila][columna]

        # Verificar horizontalmente
        contador = 0
        for c in range(self.columnas):
            if self.tablero[fila][c] == ficha:
                contador += 1
                if contador == 4:
                    return True
            else:
                contador = 0

        # Verificar verticalmente
        contador = 0
        for f in range(self.filas):
            if self.tablero[f][columna] == ficha:
                contador += 1
                if contador == 4:
                    return True
            else:
                contador = 0

        # Verificar diagonalmente (/)
        contador = 0
        for d in range(-min(fila, columna), min(self.filas - fila - 1, self.columnas - columna - 1)):
            if self.tablero[fila + d][columna + d] == ficha:
                contador += 1
                if contador == 4:
                    return True
            else:
                contador = 0

        # Verificar diagonalmente (\)
        contador = 0
        for d in range(-min(fila, self.columnas - columna - 1), min(self.filas - fila - 1, columna)):
            if self.tablero[fila + d][columna - d] == ficha:
                contador += 1
                if contador == 4:
                    return True
            else:
                contador = 0

        return False

    def jugar(self):
        jugador_actual = 'X'

        while True:
            self.imprimir_tablero()
            columna = int(input(f'Jugador {jugador_actual}, elige una columna (0-{self.columnas - 1}): '))

            if self.validar_movimiento(columna):
                fila = self.realizar_movimiento(columna, jugador_actual)

                if self.verificar_victoria(fila, columna):
                    self.imprimir_tablero()
                    print(f'¡Jugador {jugador_actual} ha ganado!')
                    break
                elif all(self.tablero[0][i] != ' ' for i in range(self.columnas)):
                    self.imprimir_tablero()
                    print('¡Empate!')
                    break
                else:
                    jugador_actual = 'O' if jugador_actual == 'X' else 'X'
            else:
                print('Movimiento inválido. Intenta de nuevo.')


if __name__ == "__main__":
    juego = CuatroEnLinea()
    juego.jugar()

Este código define una clase CuatroEnLinea que representa el juego. Tiene métodos para imprimir el tablero, validar un movimiento, realizar un movimiento, verificar si hay una victoria y el bucle principal del juego. Los jugadores pueden elegir columnas donde colocar sus fichas, y el juego continuará hasta que uno de los jugadores gane o haya un empate.

Este es solo un ejemplo básico para darte una idea de cómo se podría implementar el juego «Four-in-a-Row» en Python. Puedes personalizar y mejorar este código según tus necesidades y preferencias. ¡Diviértete jugando!

Por supuesto, aquí tienes una explicación más detallada del código proporcionado:

1. Clase CuatroEnLinea:

   • Esta clase representa el juego «Four-in-a-Row». Al crear una instancia de esta clase, se inicializa un nuevo juego con un tablero vacío de tamaño predeterminado (6 filas y 7 columnas, similar al juego clásico).

2. Método init:

   • Este método inicializa el juego con el número de filas y columnas especificado, creando un tablero vacío utilizando una lista de listas.

3. Método imprimir_tablero:

   • Este método imprime el estado actual del tablero en la consola. Utiliza barras verticales ‘|’ para separar las columnas y guiones ‘-‘ para crear las líneas horizontales del tablero.

4. Método validar_movimiento:

   • Este método verifica si un movimiento en una columna específica es válido. Verifica si la columna está dentro del rango del tablero y si la fila superior de esa columna está vacía.

5. Método realizar_movimiento:

   • Este método coloca una ficha en la columna seleccionada por un jugador. Comienza desde la fila inferior y busca la primera fila vacía en esa columna, colocando la ficha allí.

6. Método verificar_victoria:

   • Este método verifica si hay una victoria después de que un jugador realiza un movimiento. Examina las fichas en la fila y columna del movimiento, así como las diagonales que pasan por ese punto, para determinar si hay una línea de cuatro fichas del mismo jugador.

7. Método jugar:

   • Este método inicia el bucle principal del juego. Permite a los jugadores realizar turnos alternativos hasta que uno de ellos gane o haya un empate. Muestra el tablero después de cada movimiento y solicita la entrada del jugador para seleccionar una columna donde colocar su ficha.

8. Función principal:

   • La función principal crea una instancia de la clase CuatroEnLinea y llama al método jugar para iniciar el juego.

Este código proporciona una implementación básica del juego «Four-in-a-Row» en Python. Es un buen punto de partida para expandir y mejorar el juego, agregando funcionalidades como un menú de inicio, una interfaz gráfica de usuario, inteligencia artificial para jugar contra la computadora, opciones de personalización del tablero, entre otras características.