Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

Proyecto: "Juego de Damass"

No description
by

Kristhel Palacios

on 21 February 2014

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Proyecto: "Juego de Damass"

Proyecto: "Juego de Damas"
Integrantes
Canaza Choque José Manuel
Mollepaza Amaut Karla Sofía
Palacios Pilares Kristhel
Tapia Paz Flor Gianella
Introducción
El presente proyecto tiene como finalidad la aplicación de Windows Forms para producir el popular juego de Damas (Checkers). Este juego será codificado según los principios o reglas del juego. Para construirlo se requiere de dos componentes primordiales: el tablero y las fichas.

Es importante la construcción de los componentes, puesto que su diseño es esencial al momento de asemejarlo a la realidad, por ello es importante considerar el modelo del tablero y las formas de las fichas. Una vez diseñados e implementados los componentes se tiene que programar los movimientos de cada una de las fichas.

Previamente estableceremos como requisito el uso de Microsoft Visual Studio 2012 (la versión puede variar a 2010 según los programadores establezcan), al entrar al programa se establecerá como plantilla la Aplicación de Windows Forms, donde se desarrollará el proyecto.


DISEÑO
Formulario 1:
En este formulario se muestran las instrucciones del juego mediante el control label. Así mismo, existe un botón denominado “Jugar”, el cual esconde el formulario y procede a mostrar el formulario siguiente donde se elegirá el número de jugadores.
FORMULARIO INTRUCCIONES:
Formulario 2:
Este formulario está compuesto por dos radio button, los cuales permiten elegir la cantidad de jugadores (1 o 2) que participarán en la partida. Para pasar al siguiente formulario se procede a realizar click en el botón “Aceptar”, el cual para validar dicho proceso evalúa la propiedad “Checked” de los radio button y selecciona el formulario siguiente a mostrar según sea la cantidad de jugadores.
FORMULARIO NÚMERO DE JUGADORES:
Formulario 3:
Este formulario depende de la opción elegida en el formulario anterior, puesto que si se eligió la primera opción solo posee un textbox para ingresar el nombre del único jugador que jugará la partida e inmediatamente pasa al siguiente formulario. Si este no es el caso y se eligió la segunda opción, aparecerá un formulario el cual mostrará dos textbox para ingresar los datos de los jugadores e inmediatamente pasará al formulario siguiente. Para poder pasar al siguiente formulario se colocó el botón aceptar el cual se acciona mediante el evento “click” y trabaja con el método “Hide”.
FORMULARIO NOMBRE DE LOS JUGADORES:
Caso 1:
Caso 2:
TABLERO
El desarrollo del tablero ya se explicó en la primera fase del proyecto, aunque en esta fase presenta unas cuantas variaciones, las cuales se mencionarán a continuación:
Se selecciona el botón de la posición “x” para moverla a una posición “y”, en este caso se mueven las imágenes de la ubicación correspondiente a la posición indicada validando el turno de cada jugador. Si la variable “turnoBlancas” = 1 y la variable “turnoNegras” = 0 implica que los movimientos corresponden a las fichas blancas, caso contrario el movimiento pertenece a las fichas negras. Cabe resaltar que las posiciones de cada ficha para realizar esta operación son arbitrarias, con la finalidad de restringir los movimientos.
Considerando el punto inicial de la ficha y el punto a donde ésta se moverá y los valores de marca “s”, ”n” y ”N”; se procede a verificar si el valor de la marca es “n” o “N”, donde se sabe que 'n' son fichas negras normales y 'N' Fichas negras reinas; una vez verificados estos valores se seleccionarán los botones para mover las imágenes dibujadas en cada uno a un punto específico del tablero. Para lograr el efecto de “comer” la ficha se asignará el valor de null a la imagen de la posición de la ficha contraria, la cual vendría a ser la ficha “comida”. Si la variable “turnoBlancas” = 1 y la variable “turnoNegras” = 0 implica que los movimientos corresponden a las fichas blancas, caso contrario el movimiento pertenece a las fichas negras.
• Asignación de movimientos:
• Habilitar la opción comer:
Para realizar ésta operación se hace uso de los “message box” evaluando si la variable “turnoBlancas” = 1 y la variable “turnoNegras” = 0 o viceversa. Esto implicará a quien corresponden los movimientos de cada jugada. Cabe resaltar que el valor 1 se da para emitir un valor lógico de verdadero a la variable asignada a dicho valor, mientras que el valor 0 emite un valor lógico de falso para poder operar la condición base del proceso. En caso de que no se asigne valor lógico a éstas variables se considera como movimiento inválido.
• Validar turnos de los jugadores:
En ésta operación se asigna un contador, el cual contará las fichas de cada jugador, por ello existirán dos contadores (uno para blancas y otro para negras). Estas fichas se contarán mediante estructuras repetitivas para arreglos bidimensionales y para generar el resultado del ganador la condición base se generará cuando alguno de los contadores de los jugadores llegue a 0, asignando las fichas blancas al jugador 1 y las negras al jugador 2.
• Verificar ganador:
En el menustrip generado se toma en cuenta las opciones “Juego” y “Opciones”. En juego se pude crear una nueva partida o salir del juego, mientras que en opciones se selecciona la cantidad de jugadores que realizarán la partida.
• Asignar menustrip:
Se utiliza un “timer” el cual correrá con el valor del tiempo actual según sea el turno del jugador (fichas blancas o negras). Estos tiempos se mostrarán en la parte superior del tablero junto a quien le corresponde el turno transformado los valores y mostrándolos en labels.
• Validar tiempo en los turnos:
El notifyIcon es un control que muestra un icono de notificación en la barra de tareas (área de noticicaciones) de Windows en tiempo de ejecución. Este control se usó básicamente para que el jugador sepa si el turno actual le corresponde a él o al jugador contrario. Para ello se ajusta la propiedad “BaloonTipIcon” en la opción “Info” para asociar la información a un globo de diálogo.
• Uso del control notifyIcon:
ANÁLISIS
“n” representa las fichas negras. Mientras que “b” representa las fichas blancas. Así mismo "s" son los espacios intermedios en blanco del tablero.
Al evaluar los movimientos de las fichas en el juego pudimos observar lo siguiente:
Cuando avanzan las fichas negras, avanzan con un valor de +9 hacia la derecha, mientras que para avanzar a la izquierda toma un valor de -7. Esto implica que corre 9 o 7 espacios desde su posición actual a la posición indicada.
Para el avance de las blancas, avanzan con un valor de +7 hacia la derecha, mientras que para avanzar a la izquierda toma un valor de -9. Basándonos en la lógica anterior diremos que corre 7 o 9 espacios.
En el caso de comer los valores de ambos se duplican.
CONSIDERACIONES
• La creación de una variable que permita generar un arreglo bidimensional de botones (Tablero_de__Juego), cuyo tamaño será de 8x8, en consecuencia se tendrán 64 botones los cuales serán los espacios del tablero.
• Generar el evento de carga del formulario, en este módulo se establecerán los espacios de la matriz de botones, es decir las posiciones donde se encontrarán cada uno de los botones, así mismo mediante la estructura repetitiva “For” se manejará en la matriz los dibujos correspondientes para cada botón creado mediante la propiedad “Location” y “System.Drawing.Point”, este último sirve para dibujar las fichas en las posiciones establecidas.
• Para mejorar el acabado se ajusta el tamaño de las fichas o puntos correspondientes a la matriz mediante la propiedad “Size” y “System.Drawing.Size”, este último sirve para ajustar el tamaño de las fichas o puntos.


• Enlazar los botones de la matriz al evento click que se agregue a los demás botones, bajo condicionales, las cuales establecerán los colores de cada espacio (blanco o azul) y para las fichas será otros colores que resalten en el tablero (amarillo y marrón).
• El evento click se enganchará cada botón a la matriz utilizando “Current” y “Sender”. Si no se selecciona el botón, por condición se seleccionará otra ficha y se intercambiará el botón antes seleccionar el botón objetivo, para esto se utilizarán los valores de ubicación con la finalidad de calcular el índice correspondiente en la matriz usando la propiedad “Location”.


• Para Cambiar las imágenes de los botones actuales y de destino se usa la propiedad “Image” la cual se seleccionará y se moverá a la posición que se indique.
Resumiendo lo anterior podemos decir que:
• Primero creamos una Clase Tablero_de_ Juego donde creamos
// Elementos
boton: Boton;
marca: caracter;
ubicacion: entero;
// Constructor
Tablero_de_ Juego (nuevoBoton, nuevaMarca, nuevaUbicacion)
boton = nuevoBoton;
marca = nuevaMarca;
ubicacion = nuevaUbicacion;
// Propiedad que representa cada cuadrado del tablero
publico Boton Boton
obtener{retornar boton;}
// Propiedad que representa la marca en el tablero
publico caracter Marca
obtener{retornar marca;}
colocar{marca = value;}
// Propiedad que representa la ubicación de la casilla del tablero
publico entero Ubicacion
obtener{retornar ubicacion;}


• Luego declaro una Matriz de Botones
Tablero_de__Juego[,] buttons = new Tablero_de__Juego[8, 8];
• Creamos los Botones
// Creación de Botones
privado Button button1 = new Button();
privado Button button64 = new Button();
• Después establecer espacios de la Matriz para los botones.
buttons[x, y] = nuevo Tablero_de__Juego(boton1, 'marca', ubicacion);
buttons[nx, ny] = nuevo Tablero_de__Juego(botón_n,'marca_n', ubicación_n);
• Finalmente para esta primera etapa asignamos la dimensión de los dibujos y tamaño de cada uno de los botones. Establecer imagen de las fichas en los botones y fondo de color de acuerdo a la marca en la Matriz del Tablero. Controlar los movimientos con un evento click en cada botón.

Movimiento de las fichas
Antes de realizar los movimientos se debe inicializar las piezas, para ello se recuperará la posición según la lógica que manejamos de los valores 7 y 9 para blancas, negras y el total. Esto se basa en la aplicación de un "switch" que retornará las variables "i" y "j" que no vienen a ser otra cosa mas que la posición.
Ejemplo:
static void Recuperarij9N(ref int posicion, out int i, out int j)
{
i = 0; j = 0;
switch (posicion)
{
case 19: { i = 1; j = 1; } break;
case 28: { i = 2; j = 2; } break;
case 37: { i = 3; j = 3; } break;
//Esto se repetirá hasta 32 sumando +9 a cada posición debido a que trabaja con los datos hasta la mitad del tablero (sólo lado derecho)
}
}
La misma lógica se aplica a los otros casos basándose en su posición inicial y la operación que le corresponde (+7, -7,-9).
Para mover las fichas acudimos al evento "click" donde podemos observar lo siguiente:
Se crea un botón auxagrupailiar de la siguiente forma:
Button AuxBtn = (Button)sender;
Se sabe que "sender" a todos los eventos "click" de todos los botones teniendo la siguiente funcionalidad:

//Si no se selecciona el botón, seleccionar otra ficha intercambiar el botón antes seleccionada con el botón objetivo
Luego:
// Utilice los valores de ubicación para calcular el índice correspondiente en la matriz basándose en los estados "X" e "Y"
Después:
// Cambie las imágenes de los botones de los actuales y de destino
Finalmente:
//Valide si el movimiento es para blancas o para negras
// Considere que la marca seleccionada sea igual a "n" o "b" para saber que ficha moverá, también que el botón donde se moverá dicha marca sea un espacio en blanco "s" y finalmente el turno del jugador según el valor de verdad de la variable bool que permite asignar turno.

A continuación para fichas negras:
//Para mover las fichas negras la ubicación del botón seleccionado añadirá 9 posiciones o reducirá 7 desde donde se encuentra.

NEGRAS
Esto se basa en validar si la ubicación del botón a mover es múltiplo de 8 de un número par hasta 64. Esto implica que dicha posición viene a ser la línea final donde las fichas pueden coronar (valores a tomar: 64 || 48 || 32 || 16). Una vez validada esta condición ocurre lo siguiente:
La imagen auxiliar cambia a la de una ficha coronada y la marca cambia a una "N" que implica que esta ficha es una reina, despues de ello inicializa el turno de la blancas. En caso de que la condición especificada anteriormente no sea verdadera la imagen seguirá siendo una ficha normal validando su marca inicial.
//Coronando Fichas Negras:
//Previamente se validará si la ubicación del botón que recibirá la ficha es igual al botón seleccionado sumado con el doble de la lógica operativa de movimiento (9).
//Comiendo Piezas Blancas
Si es así la ubicación actual será la ubicación del botón que recibió el movimiento y recuperará la posición de 9 en negras. Luego evaluará si la marca en la posición de los botones es "b" o "B" con la finalidad de poder comer fichas blancas coronando fichas negras.
Para ello nuevamente validará que las posiciones sean las de la linea final (previamente ya se explicó como funciona dicho método) y se procede a cambiar la ficha por la de una reina cambiando su marca a "N" y borrando la ficha blanca que comió, de ahí vendría a ser el turno de las blancas. Caso contrario la ficha sigue en su estado original aunque puede comer la ficha blanca y procede a ceder el turno a las blancas.
Luego la ubicación obtendrá el valor de la ubicación donde se movió la ficha añadiéndole el doble del valor del la lógica de operación asignado (9) y recuperará los puntos totales en las ubicaciones donde se movió la ficha (para ubicación 2 el valor será 9, para la tercera ubicación el valor será del doble de 7 y para la ubicación 4 su valor será -7).
Una vez que se haya capturado estas 4 ubicaciones será el turno de las negras sabiendo que las marcas en las condiciones cumplen alguna de estas condiciones:
(buttons[k, l].Marca == 'b' && buttons[i, j].Marca == 's' ||
buttons[k, l].Marca == 'B' && buttons[i, j].Marca == 's' ||
buttons[n, m].Marca == 'b' && buttons[a, b].Marca == 's' ||buttons[n, m].Marca == 'B' && buttons[a, b].Marca == 's')
//Ahora, si la ubicación del botón que recibirá la ficha es igual al botón seleccionado sumado con el doble de la lógica operativa de movimiento (7). Se procede a realizar la misma operación que se realizó para el caso de que sea 9, solo que recuperará las posiciones con el método de 7N, se validan los mismos requerimientos en la linea final al momento de coronar tomando en cuenta las mismas consideraciones. La variación también radicará en capturar las cuatro ubicaciones siguientes cambiando las operaciones que realizaran para ubicarse.
ubicacion = moverBoton.Ubicacion - (2 * 7), ubicacion2 = moverBoton.Ubicacion - 7, ubicacion3 = moverBoton.Ubicacion + (2 * 9) y
ubicacion4 = moverBoton.Ubicacion + 9. Finalmente se toman en cuenta las validaciones anteriores para permitir el turn de las fichas negras nuevamente.
// MOVIMIENTOS FICHAS NEGRAS REYNAS
Para poder realizar ésta operación se debe considerar que la marca de la ficha sea "N", que el espacio a donde se mueva tenga como marca "s" y que el valor booleano de turno negras sea verdadero.
Luego se debe verificar lo siguiente:
seleccionarBoton.Ubicacion + 9 == moverBoton.Ubicacion || seleccionarBoton.Ubicacion + (2*9) == moverBoton.Ubicacion|| seleccionarBoton.Ubicacion + (3 * 9) == moverBoton.Ubicacion || seleccionarBoton.Ubicacion + (4*9) == moverBoton.Ubicacion|| seleccionarBoton.Ubicacion + (5 * 9) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion + (6 * 9) == moverBoton.Ubicacion|| seleccionarBoton.Ubicacion + (7 * 9) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion - 7 == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion - (2*7) == moverBoton.Ubicacion|| seleccionarBoton.Ubicacion - (3 * 7) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion - (4 * 7) == moverBoton.Ubicacion|| seleccionarBoton.Ubicacion - (5 * 7) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion - (6 * 7) == moverBoton.Ubicacion)
Como resultado la imagen de la reina se moverá al lugar especificado siendo su movimiento libre.
En caso de:
(moverBoton.Ubicacion == seleccionarBoton.Ubicacion - 9
|| seleccionarBoton.Ubicacion - (2 * 9) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion - (3 * 9) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion - (4 * 9) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion - (5 * 9) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion - (6 * 9) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion - (7 * 9) == moverBoton.Ubicacion
|| moverBoton.Ubicacion == seleccionarBoton.Ubicacion + 7
|| seleccionarBoton.Ubicacion + (2 * 7) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion + (3 * 7) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion + (4 * 7) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion + (5 * 7) == moverBoton.Ubicacion
|| seleccionarBoton.Ubicacion + (6 * 7) == moverBoton.Ubicacion)
La imagen también se moverá en el patrón especificado
//Comiendo Piezas Blancas
moverBoton.Ubicacion == seleccionarBoton.Ubicacion + (2 * 9) || moverBoton.Ubicacion == seleccionarBoton.Ubicacion + (3 * 9)||
moverBoton.Ubicacion == seleccionarBoton.Ubicacion + (4 * 9) || moverBoton.Ubicacion == seleccionarBoton.Ubicacion + (5 * 9)||
moverBoton.Ubicacion == seleccionarBoton.Ubicacion + (6 * 9) || moverBoton.Ubicacion == seleccionarBoton.Ubicacion + (7 * 9))
Para que la ficha de la reina se mueva libremente
Recupera las posiciones con el método de Recuperar 9N
Validar la siguiente condición:
(buttons[i, j].Marca == 'b' || buttons[i, j].Marca == 'B')
La acción anterior permite eliminar las fichas blancas tomando las siguientes ubicaciones
ubicacion = moverBoton.Ubicacion + (2 * 9);
ubicacion2 = moverBoton.Ubicacion + 9;
ubicacion3 = moverBoton.Ubicacion - (2 * 7);
ubicacion4 = moverBoton.Ubicacion - 7;
ubicacion5 = moverBoton.Ubicacion + (2 * 7);
ubicacion6 = moverBoton.Ubicacion + 7;
Observación: Notese que las ubicaciones que toma son más que cuando come una pieza normal
(buttons[k, l].Marca == 'b' && buttons[i, j].Marca == 's' ||
buttons[k, l].Marca == 'B' && buttons[i, j].Marca == 's' ||
buttons[n, m].Marca == 'b' && buttons[a, b].Marca =="s"||
buttons[n, m].Marca == 'B' && buttons[a, b].Marca == 's'||
buttons[o, p].Marca == 'b' && buttons[r, q].Marca == 's' ||
buttons[o, p].Marca == 'B' && buttons[r, q].Marca == 's')
Esto permitirá que el turno de las blancas termine y el de las negras inicie
Luego se toma como modelo el uso del método 9N para trabajar el 7N donde las ubicaciones cambiarán como se muestra a continuación
ubicacion = moverBoton.Ubicacion - (2 * 7);
ubicacion2 = moverBoton.Ubicacion - 7;
ubicacion3 = moverBoton.Ubicacion + (2 * 9);
ubicacion4 = moverBoton.Ubicacion + 9;
ubicacion5 = moverBoton.Ubicacion - (2 * 9);
ubicacion6 = moverBoton.Ubicacion - 9;

Así mismo se usa el mismo modulo para permitir el turno a las fichas blancas y luego pasar a las fichas negras.
Luego se toma como modelo el uso del método 9N y 7N para trabajar el 9B donde las ubicaciones cambiarán como se muestra a continuación

ubicacion = moverBoton.Ubicacion - (2 * 9);
ubicacion2 = moverBoton.Ubicacion - 9;
ubicacion3 = moverBoton.Ubicacion + (2 * 7);
ubicacion4 = moverBoton.Ubicacion + 7;
ubicacion5 = moverBoton.Ubicacion - (2 * 7);
ubicacion6 = moverBoton.Ubicacion - 7;


Así mismo se usa el mismo modulo para permitir el turno a las fichas blancas y luego pasar a las fichas negras.
Luego se toma como modelo el uso del método 9N, 7N y 9B para trabajar el 7B donde las ubicaciones cambiarán como se muestra a continuación

ubicacion = moverBoton.Ubicacion - (2 * 9);
ubicacion2 = moverBoton.Ubicacion - 9;
ubicacion3 = moverBoton.Ubicacion + (2 * 7);
ubicacion4 = moverBoton.Ubicacion + 7;
ubicacion5 = moverBoton.Ubicacion - (2 * 7);
ubicacion6 = moverBoton.Ubicacion - 7;


Así mismo se usa el mismo modulo para permitir el turno a las fichas blancas y luego pasar a las fichas negras.
BLANCAS
La lógica de funcionamiento es la misma que la delas fichas negras con algunas variaciones las cuales serán:
Manejo de variables en ves de "n" y "N" se manejan las variables "b" y "B".
Activar valor bool de turno blancas como true y tunrno negras como false.
Full transcript