PROYECTO DE AULA

CRISTIAN EDUARDO SÁNCHEZ SIMANCA

LAURA DANIELA BUENO GARAVITO

PROGRAMACIÓN DE COMPUTADORES
POLITECNICO GRANCOLOMBIANO
BOGOTÁ
2020

INTRODUCCIÓN:
Se realizará el programa correspondiente para el desarrollo del juego
llamado Quoridor, se demostrará paso a paso mediante el programa
eclipse el procedimiento para el tablero, piezas y movimientos.

El juego constará de un tablero virtual de nueve por nueve casillas

para un total de 81 casillas, también deberá incluir cuatro peones de
colores diferentes y 20 bloques. Se incluirá en el documento el
programa individual de cada parte del juego y su correspondiente
indicación.

OBJETIVOS:
Objetivo general:
Desarrollar el programa del juego Quoridor mediante eclipse, el cual
pueda ser jugable y sea acorde a las normas del juego.

Objetivo específico:
 Realizar el programa del tablero aplicado al juego.

 Hacer el programa correspondiente para los peones y su

movilidad dentro del tablero.

 Aplicar el programa adecuado para los bloques que puedan

detener el avance de los peones.

 Realizar el programa del lanzamiento de los dados el cual

permita que el número obtenido sea el mismo del avance del
peón.
QUORIDOR:
El Quoridor es un juego abstracto de estrategia en el que pueden
participar dos o cuatro personas. Utilizando un tablero similar al
de Ajedrez o las Damas, cada jugador debe llevar su peón al otro
extremo del tablero. Su oponente, sin embargo, puede utilizar bloques
de madera para bloquear el paso de dos casilleros, obligando al otro a
desviarse y demorar así su llegada. Está prohibido encerrar al peón
rival. Resulta ganador quien llega primero al otro extremo.
Los bloques pueden ubicarse tanto horizontal como verticalmente,
debiendo siempre bloquear dos casilleros. Las distintas combinaciones
posibles lleva a que muchas veces se generen laberintos y existan
verdaderas tácticas de estrategia durante el juego. Fue creado
en Francia en el año 1997 como resultado de la evolución de un juego
creado por Mirko Marchesi en 1975. Entre otros, recibió el
premio Mensa Mind Game de 1997.

Entrega 1:

La primera entrega del proyecto consiste de dos entregables:

 Programa que dibuja el tablero de juego en la consola. Las

piezas deben aparecer en su posición inicial. Use como guía
otros juegos en consola (busque en google ascii board games).

 Manual de usuario del juego: Manual con instrucciones precisas

y completas de cómo usar la aplicación. Dado que el juego no ha
sido implementado, previamente a la escritura del manual debe
realizarse un diseño completo de la interfaz del juego. Dado que
la interacción con el usuario se dará únicamente mediante la
consola, la comunicación debe ser mediada únicamente por el
teclado. El uso de imágenes no es posible.
Tablero:

El tablero del juego consta con 81 casillas (9x9), el programa mostrado

a continuación muestra el tablero correspondiente al juego hecho en el
programa eclipse.

public class quoridor{

//autores: cristian sanchez y Daniela bueno//

//proyecto de aula//

//programacion de computadores//

//fecha: 11/03/2020//

public static void main(String[] args) {

System.out.println(" _ _ _ _ _ _ _ _ _");

System.out.println("|_|_|_|_|•|_|_|_|_|");

System.out.println("|_|_|_|_|_|_|_|_|_|");

System.out.println("|_|_|_|_|_|_|_|_|_|");

System.out.println("|_|_|_|_|_|_|_|_|_|");

System.out.println("|•|_|_|_|_|_|_|_|•|");

System.out.println("|_|_|_|_|_|_|_|_|_|");

System.out.println("|_|_|_|_|_|_|_|_|_|");

System.out.println("|_|_|_|_|_|_|_|_|_|");

System.out.println("|_|_|_|_|•|_|_|_|_|");

}
Reglas del juego
 Quoridor es un juego para 2 jugadores cuyas reglas son muy
simples:

 Se desarrolla en un tablero tiene 9 filas y 9 columnas. Cada

jugador tiene un peón y diez muros.

 Cada jugador comienza en una fila opuesta del tablero, en el

espacio del centro. El objetivo es llegar al otro lado del tablero.

 En un turno un jugador puede tomar una acción: mover su peón

o colocar un muro.

 Los peones se pueden mover en cuatro direcciones: arriba,

abajo, izquierda o derecha.
  Cuando dos peones quedan enfrentados en casilleros
adyacentes que no se encuentran separados

 por un muro, el jugador que se está moviendo puede saltar a su

oponente y colocarse en el siguiente casillero, avanzando un
casillero adicional.

 Si hay un muro detrás del peón del oponente a saltar o se

encuentra en el borde del tablero, el

 jugador puede colocar su peón a la derecha o izquierda del otro

peón.

 Las paredes se colocan para bloquear o interrumpir al oponente,

o para mover al peón propio cerca de la meta. Los peones deben
moverse alrededor de los muros.

 Una vez que los muros se han colocado no se pueden mover.

Los muros deben estar completamente colocados en el tablero.

 No se puede encerrar a un oponente. Siempre debe existir un

camino hacia la meta para cada jugador.

Tablero
Para referirnos a las posiciones del tablero utilizaremos una notación
como la del ajedrez, donde se nombran las columnas con letras de la
A a la I y las filas con números entre el 1 y el 9.Como se observa en la
figura, el peón negro se encuentra en E1 mientras que el peón blanco
se encuentra en E9 (sus posiciones iniciales).

Movimientos con los mandos del teclado

Las fichas estarán programadas para moverse en cuatro diferentes
direcciones según la tecla seleccionada, las direcciones posibles son:
adelante, atrás, izquierda y derecha. Los mandos en el teclado se
realizarán con las teclas de flechas( ⬆️,⬇️,⬅️,➡️ ). Solo tendrá un
movimiento por turno, por lo tanto el jugador solo podrá seleccionar
una tecla en la dirección que desee tomar y esperar que pase el turno
de los demás jugadores para poder avanzar nuevamente una casilla.

Entrega 2
La segunda entrega del proyecto consiste de dos entregables:

 Manual de usuario del juego corregido de acuerdo a la

retroalimentación recibida de la primera entrega.

 Primera versión de la aplicación:

La aplicación debe mostrar el tablero de juego en la consola y debe

permitir a los jugadores realizar movimientos (y ver los efectos de
estos). No es necesario para esta entrega que el juego verifique la
validez de los movimientos.

Manual de usuario
Pueden jugar de 2 a 4 jugadores, hasta pueden jugar 3, simplemente
hay que estar atento a que siempre tenga el camino más fácil que los
otros dos, se puede sin problemas.

Reglas
Cada jugador maneja un peón el cual será identificado con un punto (•)
y podrá escoger entre los siguientes colores (•, •, •, •). Y una serie de
barreras que serán identificadas (####, ####, ####, ####). Si juegan
cuatro jugadores, se repartirán 5 barreras a cada uno, si juegan dos,
10 barreras a cada uno y si juegan tres 6 barreras.
En tu turno tiene dos opciones, Mover el peón una casilla en horizontal
o vertical, nunca en diagonal y se hará con los siguientes mandos de
las flechas en el teclado según la dirección que desee desplazarse (
⬆️,⬇️,⬅️,➡️) o colocar una barrera con las mismas indicaciones solo que
antes deberás presionar la tecla (ESPACIO) para seleccionar la opción
de usar barreras.
Las barreras siempre ocupan dos espacios dentro del tablero y se
pueden tocar unas con otras formando muros. Una vez puesta una
barrera, esta no podrá ser movida, así que hay que tener cuidado a
administrarlas correctamente ya que no se recuperan. Tampoco se
podrá encerrar completamente a los adversarios así que siempre se
debe dejar un camino o salida posible para que pueda alcanzar su
lado deseado.

Objetivo
El objetivo de cada jugador es llegar con su peón al lado opuesto
antes de que lo hagan sus contrincantes.

Estrategias

Reed apertura: esta apertura es colocar en las dos primeras rondas

del juego, dos barreras en la tercera fila frente al oponente. Una
estrategia contra esta abertura es colocar dos paredes horizontales de
la tercera fila, al final de cada fila, lo que reduce la trayectoria de cada
jugador de un desplazamiento.

Shiller de apertura: Ambos jugadores mueven sus peones en tres

ocasiones. Entonces, el primer jugador coloca una pared verticalmente
en la fila que está más cerca de él, con dos rutas de acceso a otro
jugador mientras que sólo proporcionando a.
Ala de apertura: Ambos jugadores mueven sus peones en tres
ocasiones. Entonces, el primer jugador coloca una barrera horizontal
detrás de su base. En la siguiente ronda, el primer jugador coloca su
segunda barrera al lado de la primera barrera, creando una pared
detrás de él. En las siguientes rondas, luego pone sus barreras
ortogonales a sus primeras dos barreras. Por lo tanto, el primer
jugador da su oponente la elección entre dos caminos, manteniendo
un camino abierto para él.

Final
Gana el primer jugador llegue con su peón al lado opuesto del tablero.
Programa final:
En el programa Eclipse realizamos el siguiente código:
import java.util.*;
public class juego {
/* Cristián Eduardo Sánchez Simanca, Laura Daniela Bueno
* Cod :1820650380, 1910650181
* Obje tivo: Crear el tablero de quoridor , pocisionar los jugadores y generar el
movimiento de cada uno de los jugadores
 */

public static void main(String[] args) {

// En las siguientes lineas de código creamos los jugadores y les asignamos a cada
uno un caracter
char jug1= '*' ;
char jug2= '+';
char jug3= '#' ;
char jug4= '$';
// En las siguientes lineas de código creamos el tablero y le asignamos un caracter a
las pocisiones.
char[][] tablero = new char [9][9] ;
for (int i = 0; i < tablero.length; i++) {
for (int j = 0; j < tablero.length; j++) {
tablero[i][j]= '.' ;
}
}
// En las Siguientes lineas de código hacemos la validacion de que solo pueden jugar
2 0 4 jugadores.
Scanner sn=new Scanner(System.in);
System.out.println(" Seleccione si 2 o 4 jugadores");
byte cantjugadores= sn.nextByte();
while((cantjugadores != 2)&& (cantjugadores!=4)){
System.out.println(" Cantidad no valida");
cantjugadores= sn.nextByte();
}
System.out.println();
// En las siguientes lineas de código ponemos los dos jugadores en sus respectivas
pocisiones.
 if(cantjugadores ==2) {

for (int i = 0; i < tablero.length; i++) {

for (int j = 0; j < tablero.length; j++) {
tablero[0][4]= jug1 ;
tablero[8][4]= jug2 ;
System.out.print(" "+tablero[i][j]+" ");
}
System.out.println();
}
// Las siguientes lineas guardamos la pocisión incial del jugadores.
int posXjug1=0;
int posYjug1=4;
int posXjug2=8;
int posYjug2=4;
// El jugador 1 ingresa la dirección en la que desean desplazarce.
while(true) {
System.out.println("Ingrese 8 si quiere colocar una pared , 9 si quiere realizar
un movimiento ");
int accion=sn.nextInt();

if (accion==9) {

System.out.println("juega el player 1 ingrese la direccion en la que movera, 1

para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");
int mov = sn.nextInt();
System.out.println(mov);

if (posXjug1==tablero.length || posXjug1==0 || posYjug1==tablero.length ||

posYjug1==0) {
System.out.println("Movimiento no valido");
 mov=sn.nextInt();
System.out.println("juega el player 1 ingrese la direccion en la que movera,
1 para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");

if(mov== 1) {
tablero[posXjug1][posYjug1]='.';
tablero[posXjug1+1][posYjug1]=jug1;
posXjug1=posXjug1+1;
}
if(mov== 2) {
tablero[posXjug1][posYjug1]='.';
tablero[posXjug1-1][posYjug1]=jug1;
posXjug1=posXjug1-1;
}
if(mov== 3) {
tablero[posXjug1][posYjug1]='.';
tablero[posXjug1][posYjug1-1]=jug1;
posYjug1--;
}
if(mov== 4) {
tablero[posXjug1][posYjug1]='.';
tablero[posXjug1][posYjug1+1]=jug1;
posYjug1++;
}
}
else if(accion ==8) {
System.out.println("ingresa las coordenadas X e Y para colocar el muro");
int coordmuroX=sn.nextInt();
 }

// En estas lineas de código imprimimos el tablero actualizado

for (int i = 0; i < tablero.length; i++) {
for (int j = 0; j < tablero.length; j++) {

System.out.print(" "+tablero[i][j]+" ");

}

System.out.println();
}

// El jugador 2 ingresa la dirección en la que desean desplazarce.

System.out.println("juega el player 2 ingrese la direccion en la que movera, 1

para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");
int mov2 = sn.nextInt();
System.out.println(mov2);
if (posXjug2==tablero.length || posXjug2==0 || posYjug2==tablero.length ||
posYjug2==0) {
System.out.println("Movimiento no valido");
mov2=sn.nextInt();
System.out.println("juega el player 1 ingrese la direccion en la que movera,
1 para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");
}
if(mov2== 1) {
tablero[posXjug2][posYjug2]='.';
tablero[posXjug2-1][posYjug2]=jug2;
posXjug2--; }
if(mov2== 2) {
 tablero[posXjug2][posYjug2]='.';
tablero[posXjug2+1][posYjug2]=jug2;
posXjug2++;
}
if(mov2== 3) {
tablero[posXjug2][posYjug2]='.';
tablero[posXjug2][posYjug2-1]=jug2;
posYjug2--;
}
if(mov2== 4) {
tablero[posXjug2][posYjug2]='.';
tablero[posXjug2][posYjug2+1]=jug2;
posYjug2++;
}
}

// En esta lineas de código imprimimos el tablero actualizado

for (int i = 0; i < tablero.length; i++) {
for (int j = 0; j < tablero.length; j++) {

System.out.print(" "+tablero[i][j]+" ");

}

System.out.println();
}}

// En estas lineas se hace la implementacion para 4 jugadores

 else{
int posXjug1=0;
int posYjug1=4;
int posXjug2=4;
int posYjug2=0;
int posXjug3=4;
int posYjug3=8;
int posXjug4=8;
int posYjug4=4;

// En esta parte guardamos las pocisiones iniciales de cada jugador

for (int i = 0; i < tablero.length; i++) {
for (int j = 0; j < tablero.length; j++) {
tablero[0][4]= jug1 ;
tablero[4][0]= jug2 ;
tablero[4][8]= jug3 ;
tablero[8][4]= jug4 ;
System.out.print(" "+tablero[i][j]+" ");
}
System.out.println();
}

// En estas lineas de código el primer jugador decide que direccion movera la ficha.
while (true) {
System.out.println("juega el player 1 ingrese la direccion en la que movera, 1
para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");
int mov = sn.nextInt();
System.out.println(mov);
if (posXjug1==tablero.length || posXjug1==0 || posYjug1==tablero.length ||
posYjug1==0) {
System.out.println("Movimiento no valido");
 mov=sn.nextInt();
System.out.println("juega el player 1 ingrese la direccion en la que movera, 1
para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");
}

if(mov== 1) {
tablero[posXjug1][posYjug1]='.';
tablero[posXjug1+1][posYjug1]=jug1;
posXjug1=posXjug1+1;

}
if(mov== 2) {
tablero[posXjug1][posYjug1]='.';
tablero[posXjug1-1][posYjug1]=jug1;
posXjug1=posXjug1-1;
}
if(mov== 3) {
tablero[posXjug1][posYjug1]='.';
tablero[posXjug1][posYjug1-1]=jug1;
posYjug1--;
}
if(mov== 4) {
tablero[posXjug1][posYjug1]='.';
tablero[posXjug1][posYjug1+1]=jug1;
posYjug1++;
}
for (int i = 0; i < tablero.length; i++) {
for (int j = 0; j < tablero.length; j++) {
 System.out.print(" "+tablero[i][j]+" ");
}

System.out.println();
}

// En estas lineas de código el segundo jugador decide que direccion movera la

ficha.

System.out.println("juega el player 2 ingrese la direccion en la que movera, 1

para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");
int mov2 = sn.nextInt();
System.out.println(mov2);
if (posXjug2==tablero.length || posXjug2==0 || posYjug2==tablero.length ||
posYjug2==0) {
System.out.println("Movimiento no valido");
mov2=sn.nextInt();
System.out.println("juega el player 1 ingrese la direccion en la que movera, 1
para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");
}

if(mov2== 1) {
tablero[posXjug2][posYjug2]='.';
tablero[posXjug2-1][posYjug2]=jug2;
posXjug2--; }
if(mov2== 2) {
tablero[posXjug2][posYjug2]='.';
tablero[posXjug2+1][posYjug2]=jug2;
posXjug2++;
}
 if(mov2== 3) {
tablero[posXjug2][posYjug2]='.';
tablero[posXjug2][posYjug2-1]=jug2;
posYjug2--;
}
if(mov2== 4) {
tablero[posXjug2][posYjug2]='.';
tablero[posXjug2][posYjug2+1]=jug2;
posYjug2++;
}
for (int i = 0; i < tablero.length; i++) {
for (int j = 0; j < tablero.length; j++) {

System.out.print(" "+tablero[i][j]+" ");

}

System.out.println();
}
// En estas lineas de código el tercer jugador decide que direccion movera la
ficha.
System.out.println("juega el player 3 ingrese la direccion en la que movera, 1
para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");
int mov3 = sn.nextInt();
System.out.println(mov3);
if (posXjug3==tablero.length || posXjug3==0 || posYjug3==tablero.length ||
posYjug3==0) {
System.out.println("Movimiento no valido");
mov3=sn.nextInt();
System.out.println("juega el player 3 ingrese la direccion en la que movera, 1
para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");
}
if(mov3== 1) {
tablero[posXjug3][posYjug3]='.';
tablero[posXjug3-1][posYjug3]=jug3;
posXjug3--; }
if(mov3== 2) {
tablero[posXjug3][posYjug3]='.';
tablero[posXjug3+1][posYjug3]=jug3;
posXjug3++;
}
if(mov3== 3) {
tablero[posXjug3][posYjug3]='.';
tablero[posXjug3][posYjug3-1]=jug3;
posYjug3--;
}
if(mov3== 4) {
tablero[posXjug3][posYjug3]='.';
tablero[posXjug3][posYjug3+1]=jug3;
posYjug3++;
}
for (int i = 0; i < tablero.length; i++) {
for (int j = 0; j < tablero.length; j++) {

System.out.print(" "+tablero[i][j]+" ");

}

System.out.println();
}
 // En estas lineas de código el cuarto jugador decide que direccion movera la
ficha.

System.out.println("juega el player 4 ingrese la direccion en la que movera, 1

para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");
int mov4 = sn.nextInt();
// System.out.println(mov4);
if (posXjug4==tablero.length || posXjug4==0 || posYjug4==tablero.length ||
posYjug4==0) {
System.out.println("Movimiento no valido");
mov4=sn.nextInt();
System.out.println("juega el player 4 ingrese la direccion en la que movera, 1
para arriba, 2 para abajo, 3 para la izquierda y 4 par ala derecha");
}

if(mov4== 1) {
tablero[posXjug4][posYjug4]='.';
tablero[posXjug4-1][posYjug4]=jug4;
posXjug4--; }
if(mov4== 2) {
tablero[posXjug4][posYjug4]='.';
tablero[posXjug4+1][posYjug4]=jug4;
posXjug4++;
}
if(mov4== 3) {
tablero[posXjug4][posYjug4]='.';
tablero[posXjug4][posYjug4-1]=jug4;
posYjug4--;
}
if(mov4== 4) {
tablero[posXjug4][posYjug4]='.';
 tablero[posXjug4][posYjug4+1]=jug4;
posYjug4++;
}
for (int i = 0; i < tablero.length; i++) {
for (int j = 0; j < tablero.length; j++) {

System.out.print(" "+tablero[i][j]+" ");

}

System.out.println();
}

}
}

}
}