PICAS Y FIJAS

Hola, a todos espero que estén bien, bueno en esta oportunidad voy a publicar el juego de picas y fijas, voy a explicar el juego: Es un juego con números que data de un siglo o más, el juego también se puede jugar con varios dígitos, en este caso esta echo para 4 es muy sencillo modificar la cantidad de valores, cada uno de los jugadores escribe un número secreto de n dígitos. Las cifras deben ser todas diferentes. Luego, a su vez, los jugadores tratan de adivinar el número de su oponente, que da el número de aciertos. Si las cifras son coincidentes en sus posiciones correctas, son "fijas"(o bulls), si en diferentes posiciones, son "picas"(o cows). Ejemplo:

El número secreto: 4271

Intento del oponente: 1234

Respuesta: una fija y dos picas. (La fija es "2", las picas son "4" y "1".)

Como siempre se debe crear un nuevo proyecto en visual studio 2013 que se llame Picas y Fijas, luego de ello pensamos en las funciones y cualidades que va a tener la aplicación de picas y fijas:

Yo personalmente quise hacer una interfaz donde el jugador realiza el juego solitario, pero también es adaptable al juego por parejas o mas, para el desarrollo de esta aplicación creamos los parametros iniciales y el método constructor:

/// <summary> /// Los parametros iniciales que son dos arreglos para guardar los numero a adivinar y los numeros ingresados /// por el usuario y picas, fijas e intentos realizados. /// </summary> int[] arregloAdivinador = new int[5]; int[] arregloEscondido = new int[5]; int picas,fijas,intentos = 0; public Form1() { InitializeComponent(); arregloEscondido = llenarVector(); }

El método que sigue realiza la operación de llenar el arregloEscondido o primer vector con los números aleatorios que el usuario debe adivinar:

public int [] llenarVector() { int[] arregloEscondido = new int[5]; Random r = new Random(); int num; for (int i = 0; i < arregloEscondido.Length; i++) { do { num = r.Next(0,9); } while (repetido(arregloEscondido, num)); arregloEscondido[i] = num; } int numero = Convert.ToInt32(comboBox1.SelectedItem); for (int i = 1; i <= numero; i++) { (panelbox.Controls.Find("PNumeroAdivinar" + i.ToString(), false)[0]).Text = arregloEscondido[i].ToString(); } return arregloEscondido; }

Existe un método que realiza la operación de crear los arreglos mediante el comboBox que creamos para insertar la cantidad de dígitos que el usuario quiere adivinar:

/// <summary> /// Este metodo realiza la creacion de los dos arreglos para el numero aleatorio y el ingresado por el usuario, /// se ubican en cada panel respectivo y se asignan propiedades. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void comboBox1_SelectedIndexChanged(object sender, EventArgs e) { int numero = Convert.ToInt32(comboBox1.SelectedItem); int a = 80; for (int i = 1; i <= numero; i++) { TextBox PNumeroAdivinar = new TextBox(); //instanciamos nuestros nuevos TextBox del arreglo escondido TextBox PNumeroAdivinar2 = new TextBox(); //instanciamos nuestros nuevos TextBox del arreglo a insertar PNumeroAdivinar.Location = new Point(50, 12); PNumeroAdivinar.Left = a; PNumeroAdivinar.Height = 80; PNumeroAdivinar.Width = 80; PNumeroAdivinar.Name = "PNumeroAdivinar" + i.ToString(); this.Controls.Add(PNumeroAdivinar); panelbox.Controls.Add(PNumeroAdivinar); PNumeroAdivinar2.Location = new Point(50, 12); PNumeroAdivinar2.Left = a; PNumeroAdivinar2.Height = 100; PNumeroAdivinar2.Width = 80; PNumeroAdivinar2.Name = "PNumeroAdivinar2" + i.ToString(); this.Controls.Add(PNumeroAdivinar2); panelbox2.Controls.Add(PNumeroAdivinar2); a = a + 80; } comboBox1.Enabled = false; }

El siguiente método realiza la comparación con los dos vectores y escoge la cantidad de picas que tiene el arreglo ingresado por el usuario:

/// <summary> /// Metodo que cuenta las picas comparando en cada espacio de los dos arreglos si hay uno igual /// </summary> /// <param name="arregloAdivinador">arreglos en que se comparan uno al otro</param> /// <param name="ArregloEscondido"></param> /// <returns>picas-fijas</returns> public int Mirarpicas(int[] arregloAdivinador, int[] ArregloEscondido) { int picas = 0; int fijas = MirarFijas(arregloAdivinador, arregloEscondido); for (int i = 1; i < arregloAdivinador.Length; i++) { for (int j = 1; j < arregloAdivinador.Length; j++) { if (arregloAdivinador[j] == ArregloEscondido[i] ) { picas++; } } } return picas-fijas; }

En el siguiente caso ocurre lo mismo pero en cambio ahora compara el numero de fijas obtenidas por el usuario:

/// <summary> /// Metodo que cuenta las fijas comparando en cada espacio de los dos arreglos si hay uno igual /// </summary> /// <param name="arregloAdivinador">arreglos en que se comparan uno al otro</param> /// <param name="ArregloEscondido"></param> /// <returns>fijas</returns> public int MirarFijas(int[] arregloAdivinador, int[] ArregloEscondido) { fijas = 0; for (int i = 1; i < arregloAdivinador.Length; i++) { if (arregloAdivinador[i] == ArregloEscondido[i]) { fijas++; } } return fijas; }

El método ganar compara sencillamente si la cantidad de fijas es igual al valor que el usuario escogió como dígitos, existe otro método que ingresa los datos de cada caja de texto y los guarda en el arreglo:

/// <summary> /// Este metodo genera la insercion de los datos digitados en las cajas de texto del panel 2 al arreglo adivinador /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Insertar_Click(object sender, EventArgs e) { //if ( (NumeroAdivinar1.Text == "" || NumeroAdivinar2.Text == "" || NumeroAdivinar3.Text == "" || NumeroAdivinar4.Text == "")) //{ // MessageBox.Show("Por favor ingrese un valor numerico"); //}else { arregloAdivinador = insertarVector(); picas = Mirarpicas(arregloAdivinador, arregloEscondido); fijas = MirarFijas(arregloAdivinador, arregloEscondido); log.Text += " \n Numero Introducido: " + arregloAdivinador[0].ToString() + " " + " existen " + picas + " picas y existen " + fijas + " fijas " ; Ganar(fijas); intentos++; TriesText.Text = intentos.ToString(); } }

Y por ultimo generamos un método que genera un nuevo juego, y lo que hace es que desbloquea el combobox, y borra las cajas de texto de los paneles que el usuario generado anteriormente:

private void nuevoJuego_Click(object sender, EventArgs e) { panelbox.Controls.Clear(); panelbox2.Controls.Clear(); comboBox1.Enabled = true; log.Text = " "; int[] arregloEscondido = new int[5]; Random r = new Random(); int num; for (int i = 0; i < arregloEscondido.Length; i++) { do { num = r.Next(0, 9); } while (repetido(arregloEscondido, num)); arregloEscondido[i] = num; } intentos=0; TriesText.Text = intentos.ToString(); }

Yo realice una ventana nueva que cuando el usuario gana el juego se abre automáticamente y muestra un archivo .gif, también se cierra 2 segundos después de haberse abierto.

Bueno eso es todo por hoy, les agradezco por su tiempo y espero que les haya gustado, enseguida dejo el enlace para descargar el proyecto .zip.

Gracias.

Descargar archivo

PUZZLE NUMERICO

EL PUZZLE NUMERICO es un juego tipo solitario, en una cuadrícula de 4x4 se colocan los números del 1 al 15, dejando una casilla vacía, que puede ser ocupada por las piezas adyacentes, se trata de desordenar las 15 piezas con número y volver a recomponer el orden, puede resultar entretenido el proceso mediante el que se consigue resolverlo, pero el problema que te planteo es decidir si cualquier permutación de los 15 números puede ser reordenada, es decir, si el juego tiene solución para cualquier distribución inicial de los 15 números.

Inicialmente creamos un nuevo proyecto en visual studio 2013 que tenga el nombre del juego, luego creamos los parámetros de la clase y el método constructor:

/// <summary> /// Estos son los atributos generales que vamos a manejar en toda la clase. /// </summary> int[] numerosAleatorios = new int[15]; int intentos, segundos, minutos, horas; /// <summary> /// Método constructor de la clase Form1 que inicializa los componentes y atributos del juego. /// </summary> public Form1() { InitializeComponent(); inicializarVectorAleatoriamente(); fijarValorEnBotones(); }

Se debe detectar primero la dinámica del juego y las posibles acciones que este va a generar, en puzzle numérico existen unas reglas básicas que no se deben obviar como lo son: las casillas solo deben tener 4 movimientos, hacia arriba, abajo, izquierda y derecha si se encuentra el espacio posible, el juego finaliza cuando todas las casillas se encuentren en el orden correcto de izquierda a derecha y arriba hacia abajo, en el juego es posible reiniciar la partida y también generar los movimientos realizados:

Luego debemos crear 12 métodos básicos para la dinámica del juego y 16 métodos estándar para realizar los movimientos que tiene cada ficha en el juego, el primer método sera el que genere los números aleatorios de todo el juego y los coloque aleatoriamente en cada casilla:

/// <summary> /// Método que genera números aleatorios /// </summary> public void inicializarVectorAleatoriamente() { Random aleatorio = new Random(); int numeroAleatorio; for (int i = 0; i < numerosAleatorios.Length; i++) { do{ numeroAleatorio = aleatorio.Next(1, 16); }while(estaAsignado(numeroAleatorio, i)); numerosAleatorios[i] = numeroAleatorio; } }

El método que inserta cada valor en cada casilla es el siguiente:

/// <summary> /// Método que guarda en un arreglo los botones del 1 al 15 y asigna a cada uno de ellos /// los valores generado randomicamente en numerosAleatorios[]. /// </summary> public void fijarValorEnBotones() { Button[] botones = new Button[] { b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15 }; b16.BackColor = Color.Black; intentos = 0; movimientos.Text = "Movimientos: " + intentos; segundos = 0; minutos = 0; horas = 0; tiempo.Text = horas.ToString("D2") + ":" + minutos.ToString("D2") + ":" + segundos.ToString("D2"); timer1.Enabled = true; for (int i = 0; i < botones.Length; i++) { botones[i].Text = numerosAleatorios[i].ToString(); botones[i].BackColor = Color.Transparent; } }

Un método importante es el de finalizar el juego:

public void completarJuego() { if (b1.Text == 1.ToString() && b2.Text == 2.ToString() && b3.Text == 3.ToString() && b4.Text == 4.ToString() && b5.Text == 5.ToString() && b6.Text == 6.ToString() && b7.Text == 7.ToString() && b8.Text == 8.ToString() && b9.Text == 9.ToString() && b10.Text == 10.ToString() && b11.Text == 11.ToString() && b12.Text == 12.ToString() && b13.Text == 13.ToString() && b14.Text == 14.ToString() && b15.Text == 15.ToString()) { timer1.Stop(); MessageBox.Show(" ¡¡ Juego completado en " + intentos + " movimientos !!\n Tiempo: " + horas.ToString("D2") + ":" + minutos.ToString("D2") + ":" + segundos.ToString("D2"), "Felicidades"); } }

Cada casilla instancia un método general que realiza el movimiento de las figuras y cada que se oprime el botón "reset" se realizara una distribución aleatoria de números:

/// <summary> /// <summary> /// Método que evalua si es posible generar un movimiento en los botones centrales del /// juego (invocando al método cambiarPropiedades()). /// </summary> /// <param name="botonCentral"></param> /// <param name="botonContiguo1"></param> /// <param name="botonContiguo2"></param> /// <param name="botonContiguo3"></param> /// <param name="botonContiguo4"></param> public void realizarMovimiento(Button botonCentral, Button botonContiguo1, Button botonContiguo2, Button botonContiguo3, Button botonContiguo4) { if (botonContiguo1.BackColor == Color.Black) cambiarPropiedades(botonCentral, botonContiguo1); else if (botonContiguo2.BackColor == Color.Black) cambiarPropiedades(botonCentral, botonContiguo2); else if (botonContiguo3.BackColor == Color.Black) cambiarPropiedades(botonCentral, botonContiguo3); else if (botonContiguo4.BackColor == Color.Black) cambiarPropiedades(botonCentral, botonContiguo4); } /// Este metodo reordena los valores del juego e inicializa el contador. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void button1_Click_1(object sender, EventArgs e) { inicializarVectorAleatoriamente(); fijarValorEnBotones(); }

Eso es todo, el juego es muy interesante y ayuda a controlar y organizar la mente, si tienen dudas con gusto me escriben o le escriben al blog de mi compañero Jeison: http://jeisonayudaspuntonet.blogspot.com/2015/03/puzzle-numerico.html quien tambien participo en el desarrollo de esta maravillosa aplicacion.

Muchas gracias.

Descargar codigo.

Clases Abstractas

CLASES ABSTRACTAS

Hola, en esta ocasión quiero hablar sobre las clases abstractas y su implementación en el diagrama de clases poligonos regulares, como bien se sabe una clase abstracta no necesariamente debe tener métodos abstractos, en algunos casos la clase abstracta simplemente sirve para efectuar operaciones comunes a subclases sin necesidad de métodos abstractos. en otros casos si se usaran los métodos abstractos para referenciar operaciones en la clase abstracta del contenido de la sobreescritura en las subclases.

Las clases TRIANGULO, CUADRADO y PENTÁGONO pueden ser no abstractas ya que es una de las razones de ser de las clases abstractas, una clase abstracta no puede ser instanciada, pero pueden crearse subclases concretas sobre la base de una clase abstracta, y crear instancias de esas subclases, para esto hay que heredar de la clase abstracta y anular los métodos abstractos implementandolos.

En el diagrama podemos observar cómo hemos definido una clase abstracta denominada PoligonoRegular, se identifica señalando <<abstract>> en la parte superior del icono de la clase. Sin embargo, hereda de la clase Punto que no es abstracta, lo cual significa que puede haber instancias de Punto pero no de PoligonoRegular.

Triangulo, cuadrado y pentágono son subclases de la clase abstracta PoligonoRegular, que a su vez obtiene el metodo Punto en la clase Punto que es no abstracta y con ella varios metodos mas como lo son Punto con dos parámetros Double y Eje que a su vez es una clase <<enumeration>> que es una clase “especial” que limitan la creación de objetos  a los especificados explícitamente en la implementación de la clase. La única limitación que tienen los enumerados respecto a una clase normal es que si tiene constructor, este debe de ser privado para que no se puedan crear nuevos objetos.

Muchas gracias, nos veremos en otra ocasión.