Desarrollo de Lógica y Algoritmos para Juegos en Programación

Implementación de Algoritmos y Lógica de Juegos en Pseudocódigo

Este documento presenta una serie de implementaciones en pseudocódigo, que simulan la lógica de diversos juegos y algoritmos fundamentales. Se abordan desde la mecánica de un juego clásico como el Tres en Raya, hasta las reglas de movimiento de piezas de ajedrez, la lógica de un juego de adivinanzas como Mastermind, la conversión de números a binario y una validación básica para Sudoku.

Juego de Tres en Raya (Tic-Tac-Toe)

A continuación, se detalla la lógica para un juego de Tres en Raya, incluyendo la inicialización del tablero, la gestión de turnos, la validación de movimientos y la determinación del ganador o un empate.

tablero = [0,0,0; 0,0,0; 0,0,0]; % Inicialización de un tablero 3x3 con ceros
ganador = 0;
lleno = 0;
jugador = 1;

while (lleno < 9 && ganador == 0)
    disp(['Jugador ' num2str(jugador)]);
    x = input('Ingrese coordenada x (1-3): ');
    y = input('Ingrese coordenada y (1-3): ');

    if tablero(x,y) ~= 0
        disp('¡Casilla ocupada! Por favor, introduzca una ficha en otra casilla.');
    else if x < 1 || x > 3 || y < 1 || y > 3
        disp('¡Coordenadas fuera de rango! Por favor, introduzca una ficha en otra casilla.');
    else
        correcto = 1; % Indica que la jugada es válida
    end
    end
    % Nota: La siguiente línea se ejecuta independientemente de si la jugada fue "correcta"
    % en el bloque if/else if/else anterior. En una implementación real,
    % esta parte debería estar dentro del 'else' del bloque de validación.
    tablero(x,y) = jugador;

    % Comprobación de victoria en fila
    n = find(tablero(x, :) == jugador);
    % Comprobación de victoria en columna
    v = find(tablero(:,y) == jugador);
    % Comprobación de victoria en diagonal principal
    d1 = find(diag(tablero) == jugador);
    % Comprobación de victoria en diagonal secundaria
    aux = [tablero(1,3) tablero(2,2) tablero(3,1)];
    d2 = find(aux == jugador);

    if (length(n) == 3 || length(v) == 3 || length(d1) == 3 || length(d2) == 3)
        ganador = jugador;
    end

    lleno = lleno + 1; % Incrementa el contador de casillas llenas

    if jugador == 1
        jugador = 2;
    else
        jugador = 1;
    end
end % Fin del bucle principal del juego

if jugador == 1
    disp('¡Jugador 1 gana!');
else
    if ganador == 2
        disp('¡Jugador 2 gana!');
    else
        disp('¡Es un empate!');
    end
end

Lógica de Movimiento de Piezas de Ajedrez

Esta sección presenta funciones individuales para validar los movimientos básicos de las piezas de ajedrez en un tablero de 8x8. Cada función devuelve s=1 si el movimiento es válido y s=0 si no lo es, considerando solo la posición inicial y final, sin tener en cuenta obstáculos o capturas (excepto el peón).

Función para la Reina (Queen)

function s = reina(a, b, x, y)
    s = 1;
    if x < 1 || x > 8 || y < 1 || y > 8 % Fuera de los bordes del tablero
        s = 0;
    end
    ax = abs(a - x);
    by = abs(b - y);
    % Nota: La lógica original para la reina es incompleta.
    % Una reina se mueve horizontal, vertical o diagonalmente.
    % La condición correcta sería: if ~(ax == 0 || by == 0 || ax == by) s = 0; end;
    if a ~= x && b ~= y % Si no es movimiento horizontal ni vertical
        s = 0;
    end
end

Función para el Alfil (Bishop)

function s = alfil(a, b, x, y)
    s = 1;
    color = 1; % Variable 'color' no definida como entrada, posible placeholder.
    if x < 1 || x > 8 || y < 1 || y > 8
        s = 0;
    end
    % Nota: Falta la lógica para validar el movimiento diagonal (abs(a-x) == abs(b-y)).
end

Función para el Peón (Pawn)

function s = peon(tablero, color, a, b, x, y)
    s = 1;
    if x < 1 || x > 8 || y < 1 || y > 8
        s = 0;
    end
    if color == 1 % Asumiendo color 1 para peones que avanzan hacia arriba (disminuyen 'a')
        if (a - x) ~= 1 || (b - y) ~= 0 % Si no avanza una casilla hacia adelante
            s = 0;
        end
        % Lógica de captura: si las casillas adyacentes diagonales no están ocupadas por el oponente (2)
        % Nota: Esta lógica de captura es muy específica y podría ser incorrecta o incompleta.
        if tablero(a, b - 1) ~= 2 || tablero(a, b + 1) ~= 2
            s = 0;
        end
    end
    % Nota: Falta la lógica para el color 2 (peones que avanzan hacia abajo).
end

Función para la Torre (Rook)

function s = torre(a, b, x, y)
    s = 1;
    color = 2; % Variable 'color' no definida como entrada, posible placeholder.
    if x < 1 || x > 8 || y < 1 || y > 8
        s = 0;
    end
    if color == 1 % Inconsistencia con 'color = 2' anterior.
        if a ~= x && b ~= y % Si no es movimiento horizontal ni vertical
            s = 0;
        end
    end
end

Función para el Caballo (Knight)

function s = caballo(tablero, color, a, b, x, y)
    if x < 1 || x > 8 || y < 1 || y > 8
        s = 0;
    end
    % Nota: La lógica para el movimiento del caballo es compleja y parece incorrecta.
    % Un caballo se mueve en forma de 'L': (abs(dx) == 1 && abs(dy) == 2) || (abs(dx) == 2 && abs(dy) == 1).
    if abs((a + 1) - x) ~= abs(b - y)
        s = 0;
    else
        if abs((a - 1) - x) ~= abs(b - y)
            s = 0;
        else
            if abs(a - x) ~= abs((b + 1) - y)
                s = 0;
            else
                if abs(a - x) ~= abs((b - 1) - y)
                    s = 0;
                else
                    s = 1;
                end
            end
        end
    end
end

Función para el Rey (King)

function s = rey(tablero, color, a, b, x, y)
    if x < 1 || x > 8 || y < 1 || y > 8
        s = 0;
    end
    if abs(x - a) > 1 || abs(y - b) > 1 % Si el movimiento es mayor a una casilla
        s = 0;
    end
    % Nota: 'tablero(x-y)' no es una indexación válida. Se asume 'tablero(x,y)'.
    % Esta condición verifica si la casilla de destino está ocupada por una pieza del mismo color.
    if tablero(x,y) == color
        s = 0;
    end
end

Implementación del Juego Mastermind

Este segmento de código simula una versión simplificada del juego Mastermind, donde se comparan secuencias de números para determinar coincidencias.

W = []; % Secuencia a adivinar
V = []; % Intento del jugador
col = 0; % Contador de coincidencias exactas (valor y posición)

for i = 1:4
    V(i) = input('Ingrese valor para la secuencia secreta (1-9): ');
end

while col < 4 % Bucle principal del juego, continúa hasta adivinar los 4 valores
    col = 0; % Reiniciar contador de coincidencias exactas para cada intento
    for i = 1:4
        W(i) = input('Ingrese valores para su intento (1-9): ');
    end

    % 'ncorrecta' cuenta las coincidencias exactas (valor y posición)
    ncorrecta = length(find(V == W));
    % 'col' también cuenta las coincidencias exactas.
    % Nota: En Mastermind real, se distinguen "fichas negras" (correctas en valor y posición)
    % y "fichas blancas" (correctas en valor pero no en posición).
    % Esta implementación solo cuenta las "fichas negras".
    for i = 1:4
        if V(i) == W(i)
            col = col + 1;
        end
    end
    disp([num2str(ncorrecta) ' correctas, ' num2str(col) ' colocadas']);
end

Conversión de Número Decimal a Binario

Este algoritmo convierte un número entero decimal a su representación binaria, mostrándolo como un número decimal (ej. 5 -> 101).

n = input('Introduce un número entero positivo: ');
sol = 0; % Almacena el resultado binario como un número decimal
i = 0;   % Contador para la posición del bit (potencia de 10)
co = n;  % Copia del número original para las operaciones

while co ~= 1
    if rem(co, 2) == 1 % Si el residuo es 1, el bit actual es 1
        sol = sol + 1 * (10^i); % Asumiendo 101^i era un error tipográfico por 10^i
    end
    i = i + 1; % Incrementa la posición del bit
    co = fix(co / 2); % Divide el número por 2 para el siguiente bit
end
sol = sol + 10^i; % Esta línea maneja el último bit (cuando co se convierte en 1)

Validación Básica de Sudoku

Este fragmento de código realiza una validación muy básica para un tablero de Sudoku, comprobando si la suma de cada fila y cada columna es 45 (suma de números del 1 al 9).

% Asumiendo 'A' es una matriz 9x9 que representa el tablero de Sudoku.
% Esta validación es incompleta para un Sudoku real, ya que no verifica
% la unicidad de números en filas, columnas o subcuadrículas 3x3.
if length(find(sum(A) == 45)) == 9 && length(find(sum(A') == 45)) == 9
    s = 1; % Indica que las sumas de filas y columnas son correctas
else
    s = 0; % Indica que las sumas de filas o columnas no son correctas
end

Este documento proporciona una visión general de la implementación de diversas lógicas de programación, desde la simulación de juegos hasta algoritmos matemáticos básicos. Aunque algunas secciones requieren una lógica más robusta para una funcionalidad completa, sirven como punto de partida para el desarrollo de sistemas más complejos.