SUDOKU EN C#(VISUAL STUDIO)

¿QUE ES?

El Sudoku es un rompecabezas matemático de colocación que se popularizó en Japón en 1986 y se dio a conocer en el ámbito internacional en 2005.

El objetivo es rellenar una cuadrícula de 9×9 celdas dividida en subcuadrículas de 3×3 con las cifras del 1 al 9 partiendo de algunos números ya dispuestos en algunas de las celdas.

No se debe repetir ninguna cifra en una misma fila, columna o subcuadrícula

¿COMO JUGARLO?

     Las reglas del SuDoKu son muy simples. En este rompecabezas no se trata de sumar nada con los números, ni que éstos tengan un orden lógico, sino que jugamos con los números como si fueran piezas de un puzzle, sin repetir ninguna ni en horizontal (filas), ni vertical (columnas), ni en las cajas de 3x3. 

     Cada una de las filas en SuDoKu está compuesta por 9 celdas en las que debes poner la serie de números del 1 al 9 en el orden que creas oportuno, pero sin repetirlo y, obviamente, sin dejar ninguno por poner. 

     A su vez, las columnas también tienen la misma estructura, sólo que en vertical, que las filas y también sus condiciones de juego, es decir, al colocar un número en una fila tienes que tener en cuenta que no se repita en la columna en la que está incluido. 

     No conformes con esto, el juego se complica un poco más con las cajas de 3x3. Todas ellas deben contener en su interior la serie completa del 1 al 9. 

EMPECEMOS......

Primeramente es necesario crear un nuevo proyecto en visual studio. cuando este creado es necesario tocar el tema de los datagrid el cual es una clase Control de lista enlazada a datos que muestra los elementos del origen de datos en una tabla. El control DataGrid permite seleccionar, ordenar y editar estos elementos.

Este datagrid tiene como jerarquia de herencia System.Object 

  System.Web.UI.Control

    System.Web.UI.WebControls.WebControl

      System.Web.UI.WebControls.BaseDataList

        System.Web.UI.WebControls.DataGrid

Con esta clase vamos a generar la cuadricula de juego con el siguiente codigo

/// <summary> ///COMO SE REALIZA LA CUADRICULA CON UN DATAGRIGSPINER . ///Esta clase esta columna personalizada proporcionando un spinner de ///funcionalidad y se deriva de DataGridTextBoxColumn ///se debe hacer los puntos de respuesta de sólo lectura esta columna de estiloy no es de uso general ///como para hacer que el punto de partida de lectura del código.Es necesario ser tratado en el método Edit . ///Así que se ha expuesto un Juego propiedad donde podemos establecer instancia juego cuyas servicios son ///utililes para la graficacion de la cuadricula. /// </summary> public class DataGridSpinnerColumn : DataGridTextBoxColumn { private int filanormal=-1; private CurrencyManager cm=null; private VScrollBar vsBar; private Sudoku juego; private bool respuestaposicion=false; private const int columnatamano=30; /// <summary> /// Constructor /// </summary> public DataGridSpinnerColumn() { vsBar = new VScrollBar(); // Add Scroll and Leave event handler vsBar.Scroll += new ScrollEventHandler(Vertical); vsBar.Leave += new EventHandler(Vertical_Scroll_Leave); this.TextBox.Leave += new EventHandler(Textdejar); } public int SpinnerWidth { get {return vsBar.Width;} set { vsBar.Width=value;} } public int ScrollMaximo { set{ vsBar.Maximum = value;} get{ return vsBar.Maximum;} } public int ScrollMinimo { get { return vsBar.Minimum;} set { vsBar.Minimum=value;} } public int Scrollcambiotamano { get{return vsBar.SmallChange;} set{ vsBar.SmallChange =value; vsBar.LargeChange=value;} } public Sudoku jugar { set {juego=value;} } /// <summary> /// en este metodo se ajusta el valor para el desplazamiento del numero /// en la cuadricula donde se ascendera o se descendera deacuerdo al numero deseado /// /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Vertical(object sender, ScrollEventArgs e) { try { int dataValue = e.NewValue; this.TextBox.Text =dataValue.ToString(); }catch(Exception ex) { Console.WriteLine("Error {0}",ex.Message); } } /// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Textdejar(object sender,EventArgs e) { // Set the value back if (this.TextBox.Text.ToString().TrimEnd()!="") { string s = this.TextBox.Text; base.SetColumnValueAtRow(this.cm,this.filanormal,s); } else { this.TextBox.ReadOnly=false; } if(!respuestaposicion) { this.vsBar.Hide(); this.DataGridTableStyle.DataGrid.Scroll -= new EventHandler(DataGrid_Scroll); Invalidate(); } } /// <summary> /// en este metodo se controla la cantidad de eventos necesarios si el /// desplazamiento que se hace con el scroll en las casillas vacias no se desarrolla con exactituc /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Vertical_Scroll_Leave(object sender,EventArgs e) { // valor de retorno if (this.TextBox.Text.ToString().TrimEnd()!="") { string s = this.TextBox.Text; base.SetColumnValueAtRow(this.cm,this.filanormal,s); } if(!respuestaposicion) { this.vsBar.Hide(); this.DataGridTableStyle.DataGrid.Scroll -= new EventHandler(DataGrid_Scroll); Invalidate(); } } // en la clase editar hacemos los controles necesarios para el desplazamiento de las variables //en este caso de los numeros del uno al nueve protected override void Edit(System.Windows.Forms.CurrencyManager source, int rowNum, System.Drawing.Rectangle bounds, bool readOnly, string instantText, bool cellIsVisible) { base.Edit(source, rowNum, bounds, readOnly, instantText, cellIsVisible); if(this.TextBox.Text.TrimEnd()!="") { int dataValue = Int32.Parse(this.TextBox.Text); int pos = this.MappingName.LastIndexOf("col"); if(pos > -1) { string colIndex = this.MappingName.Substring(pos+3); int colPos = Int32.Parse(colIndex); respuestaposicion=juego.verificaposicion(rowNum,colPos,dataValue); } } else { respuestaposicion =false; } if (!readOnly && cellIsVisible) { // Save current row in the DataGrid and currency manager // associated with the data source for the DataGrid this.filanormal = rowNum; this.cm = source; if(!respuestaposicion) { this.DataGridTableStyle.DataGrid.Scroll += new EventHandler(DataGrid_Scroll); // se realiza la especificacion del combobos para cada celda en este caso la //actual this.vsBar.Parent = this.TextBox.Parent; Rectangle rect = this.DataGridTableStyle.DataGrid.GetCurrentCellBounds(); this.vsBar.Location = new Point(rect.Right-this.SpinnerWidth,rect.Top); this.vsBar.Size = new Size(this.SpinnerWidth,this.TextBox.Height); this.vsBar.Show(); this.vsBar.BringToFront(); this.vsBar.Show(); this.TextBox.ReadOnly=true; this.TextBox.BackColor = Color.Blue; this.TextBox.ForeColor=Color.White; } else { this.TextBox.ReadOnly=true; this.TextBox.BackColor=Color.White; this.TextBox.ForeColor =Color.Black; } } } public void DataGrid_Scroll(object sender,EventArgs e) { this.vsBar.Hide(); } // Dada una fila , consigue el valor correspondiente para la congruencia de las series //del sudoku al momento de encontarse se realiza la respectiva distribucion protected override object GetColumnValueAtRow(System.Windows.Forms.CurrencyManager source, int rowNum) { //teniendo ya el numero hace la respectiva visualizacion object obj = base.GetColumnValueAtRow(source, rowNum); if(obj.ToString().TrimEnd() !="") { this.vsBar.Value = Int32.Parse(obj.ToString()); } else { this.vsBar.Value =1; } return obj; } }

Con esas modificaciones al ejecutar el proyecto tendremos una cuadricula de 9x9 casillas lo cual es la base de nuestro sudoku.

Después de generar esta estructura es necesario llamarla en nuestro windows form para que se visualice  para nuestro caso el juego va a tener 3 niveles de dificultad para ello se utilizo

public void Generar(nivel level) { // Inicia el metodo // Se crean las respuestas de forma aletoria Iniconjunto(); int minPos,maxPos,nin; // con este switch mostramos las posiciones para poder inicar el juego switch(level) { case nivel.simple: minPos=4; maxPos=6; nin=8; oculto(minPos,maxPos,nin); break; case nivel.medio: minPos=3; maxPos=5; nin= 7; oculto(minPos,maxPos,nin); break; case nivel.completo: minPos=3; maxPos=5; nin = 6; oculto(minPos,maxPos,nin); break; default: oculto(3,6,7); break; } // con este vector almacenamos en memoria el juego generado for(int i=0;i<maximafilas;i++) { for(int j=0;j<maximacolumnas;j++) { copiar[i,j] =problema[i,j]; } } }

Generando el nivel el código ramdom utilizado en ayudas anteriores generar una serie de números los cuales se ubicaran aleatoria mente en la cuadricula del datagrid al ingresar los numeros el sistema verificara si el numero ingresado es corresto para ello se utilizo.

public bool verificaduplicado(int posfila,int poscolumna,int valorn) { // revisa las filas del tablero for(int i=0;i<maximafilas;i++) { if(problema[i,poscolumna]== valorn) { if(i!=posfila) { return true; }else{ continue;} } if(problema[posfila,i] == valorn) { if(i!= poscolumna){ return true;}else{ continue;} } } int x = posfila /3; int y = poscolumna/3; for(int j=0;j<minicimjuntofilas;j++) { for(int k=0;k<ninicunjuntocolumnas;k++) { int p = x*3+j; int q = y*3+k; if ((p==posfila)&&(q==poscolumna)) { continue; }else if(problema[p,q]== valorn) { return true; } } } return false; }

cuando se haga la validación anterior si el usuario desea puede empezar un nuevo juego en el nivel deseado esto hace una interacción mas conjunta con el usuario para ello se hace uso de :


private void Iniconjunto() { int aux1 = DateTime.Now.Millisecond %3; for(int i=0;i<maximafilas;i++) { for(int j=0;j<maximacolumnas;j++) { conjuntonumero[i,j] =original[i,j]; problema[i,j]=0; copiar[i,j]=0; } } Random aleatorio = new Random(aux1); int filaxcolumna = aleatorio.Next(1,3); aux1 = DateTime.Now.Millisecond %3; aleatorio = new Random(aux1); int setNumber = aleatorio.Next(1,3); if(intercambiofilas) { cambiodedatos(setNumber,filaxcolumna,combinacion.filas); intercambiofilas =false; } else { cambiodedatos(setNumber,filaxcolumna,combinacion.columnas); intercambiofilas=true; } aux1 = DateTime.Now.Millisecond %3; aleatorio = new Random(aux1); setNumber = aleatorio.Next(1,3); cambiodedatos(setNumber,filaxcolumna,combinacion.filascolumnas); }

En el siguiente link dejo el proyecto con código abierto para que si desean lo modifiquen y lo puedan mejorar estoy atento a correcciones o dudas que estén bien.


!!!!!!!!!!!DESCARGA EL PROYECTO!!!!!!!!!!!!!

PICAS Y FIJAS EN C# (VISUAL STUDIO)

Hola amigos el día de hoy espesaremos un juego interesante llamado picas y pijas que consiste en descubrir un numero secreto .

¿COMO SE JUEGA?

Un juego muy conocido es picas y fijas, el cual consiste en tratar de adivinar un número en la menor cantidad de intentos. En cada intento, el jugador dice N dígitos  y el oponente(en este caso la maquina) le da pistas de cuántos aciertos tuvo, sin indicarle cuales fueron, de la siguiente forma: Si algún dígito que dice el jugador se encuentra dentro del número a adivinar, pero no está en la posición correcta, se llama PICA. Si el dígito se encuentra en la posición adecuada, se llama FIJA. Así, las pistas serán la cantidad de PICAS y la cantidad de FIJAS que se tienen. El juego termina cuando algún jugador tiene N FIJAS (N dígitos en el orden adecuado).

EMPEZAMOS .............

primeramente se genera un nuevo proyecto con windows form en c#. lo que utilizaremos es una serie de textbox donde el usuario va poder escribir los números deseados ya sea de la cantidad que halla elegido en este caso están para desarrollar de 2 a 9 dígitos al generar la interfaz obtendremos algo parecido a esto

Los números del 2 al nueve son la cantidad de niveles de nuestro juego para empezar debes elegir uno de ellos y entonces debes generar los textbox correspondientes para los diferentes tipos

para poder generar la interacción en canto a la selección de los niveles es necesario tener los siguientes métodos 

public void inicializarNivelSeleccionado(int cifras) { timer1.Start(); acumuladorIntentos = ""; intentos.Text = ""; contadorIntentos = 0; contIntentos.Text = "Intentos: " + contadorIntentos; segundos = 0; minutos = 0; horas = 0; tiempo.Text = horas.ToString("D2") + ":" + minutos.ToString("D2") + ":" + segundos.ToString("D2"); for (i = 0; i < cifras; i++) { digitosIngresados[i].Visible = true; digitosIngresados[i].Enabled = true; digitosIngresados[i].Text = ""; digitosEscondidos[i].Visible = true; digitosGenerados[i].Visible = true; } for (i = cifras; i < digitosIngresados.Length; i++) { digitosIngresados[i].Visible = false; digitosIngresados[i].Enabled = false; } for (i = cifras; i < digitosEscondidos.Length; i++) digitosEscondidos[i].Visible = false; for (i = cifras; i < digitosGenerados.Length; i++) digitosGenerados[i].Visible = false; for (i = 0; i < nivelSeleccionado.Length; i++) nivelSeleccionado[i].Visible = false; nivelSeleccionado[cifras - 2].Visible = true; digitosIngresados[0].Focus(); button1.Visible = true; button1.Enabled = true; contIntentos.Visible = true; intentos.Visible = true; reiniciarNivel.Visible = true; reiniciarJuego.Visible = true; decifrar.Visible = true; }

Cuando se halla seleccionado el nivel deseado es necesario crear un nemero que se adapte a la cantidad para ello se debe crear un numero aleatorio lo que se inicia con lo siguiente

public int[] generarNumeroAleatorio(int cifras) { int numeroAleatorio; cifrasGeneradasEvaluadas = new int[cifras]; int[] numeroGenerado = new int[cifras]; Random aleatorio = new Random(); for (i = 0; i < numeroGenerado.Length; i++) { numeroAleatorio = aleatorio.Next(0, 10); numeroGenerado[i] = numeroAleatorio; cifrasGeneradasEvaluadas[i] = numeroAleatorio; digitosGenerados[i].Text = numeroAleatorio.ToString(); } return numeroGenerado; }

Cuando se genere un numero aleatorio es necesario que el usuario ingrese los números que el cree correcto respecto al nivel que eligió pero se debe validar que todos los campos se encuentren correctamente llenos.

public bool encontrarCamposVacios(int numeroCampos) { bool estaVacio = false; for (i = 0; i < numeroCampos; i++) { if (digitosIngresados[i].Text == "") estaVacio = true; } return estaVacio; }

Si el método anterior valida que todos están completamente con un dato números es necesario capturarlos para así compararlo con el numero generado aleatoria mente

public int[] capturarNumeroIngresado(int cifras) { int[] numeroIngresado = new int[cifras]; cifrasIngresadasEvaluadas = new int[cifras]; for (i = 0; i < numeroIngresado.Length; i++) { numeroIngresado[i] = Convert.ToInt32(digitosIngresados[i].Text); cifrasIngresadasEvaluadas[i] = Convert.ToInt32(digitosIngresados[i].Text); } return numeroIngresado; }

Al capturar todos estos datos se comprar con numero generado verificando si existe una pica o una fija y si es totalmente correcto el juego termina satisfactoriamente.

public int encontrarFijas(int[] numeroIngresado, int[] numeroGenerado) { int fijas = 0; for (i = 0; i < numeroIngresado.Length; i++) { if (numeroIngresado[i] == numeroGenerado[i]) { fijas++; numeroGenerado[i] = -1; numeroIngresado[i] = -1; } } return fijas; } /// <summary> /// Método que compara los arreglos numeroIngresado y numeroGenerado en posiciones diferentes para /// determinar el número de picas existentes entre ambos a través de una variable contadora /// (cambiando por "-1" los campos de los arreglos numeroGenerado y numeroIngresado donde se /// encontró una pica). /// </summary> /// <param name="numeroIngresado"></param> /// <param name="numeroGenerado"></param> /// <returns></returns> public int encontrarPicas(int[] numeroIngresado, int[] numeroGenerado) { int picas = 0; for (i = 0; i < numeroIngresado.Length; i++) { for (j = 0; j < numeroGenerado.Length; j++) { if (i != j && numeroIngresado[i] == numeroGenerado[j] && numeroIngresado[i] >= 0 && numeroGenerado[j] >= 0) { picas++; numeroGenerado[j] = -1; numeroIngresado[i] = -1; } } } return picas; }

y si estos métodos se ejecutan correctamente es necesario imprimir la cantidad de intentos que se realizaron para ello se hace uso de:

public void imprimirIntento(int[] cifrasIntento, int picasIntento, int fijasIntento, int intento) { String numeroIntento = ""; for (i = 0; i < cifrasIntento.Length; i++) numeroIntento = numeroIntento + cifrasIntento[i].ToString(); acumuladorIntentos = acumuladorIntentos + numeroIntento + " P= " + picasIntento + " F= " + fijasIntento + "\r\n"; intentos.Text = acumuladorIntentos; contIntentos.Text = "Intentos: " + intento; }.

ya como paso siguiente es necesario dar todas las funcionalidades  a los botones creados como reiniciar juego, descifrar el numero, para ello únicamente es necesario llamar los métodos creados anteriormente en cada uno de los botones.

private void label1_Click(object sender, EventArgs e) { } /// <summary> /// Guarda el número de cifras seleccionado y acondiciona el juego y el número generado a dicho nivel. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void pb2_Click(object sender, EventArgs e) { nivelElegido = 2; inicializarNivelSeleccionado(nivelElegido); cifrasGeneradas = generarNumeroAleatorio(nivelElegido); } /// <summary> /// Guarda el número de cifras seleccionado y acondiciona el juego y el número generado a dicho nivel. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void pb3_Click(object sender, EventArgs e) { nivelElegido = 3; inicializarNivelSeleccionado(nivelElegido); cifrasGeneradas = generarNumeroAleatorio(nivelElegido); } /// <summary> /// Guarda el número de cifras seleccionado y acondiciona el juego y el número generado a dicho nivel. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void pb4_Click(object sender, EventArgs e) { nivelElegido = 4; inicializarNivelSeleccionado(nivelElegido); cifrasGeneradas = generarNumeroAleatorio(nivelElegido); } /// <summary> /// Guarda el número de cifras seleccionado y acondiciona el juego y el número generado a dicho nivel. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void pb5_Click(object sender, EventArgs e) { nivelElegido = 5; inicializarNivelSeleccionado(nivelElegido); cifrasGeneradas = generarNumeroAleatorio(nivelElegido); } /// <summary> /// Guarda el número de cifras seleccionado y acondiciona el juego y el número generado a dicho nivel. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void pb6_Click(object sender, EventArgs e) { nivelElegido = 6; inicializarNivelSeleccionado(nivelElegido); cifrasGeneradas = generarNumeroAleatorio(nivelElegido); } /// <summary> /// Guarda el número de cifras seleccionado y acondiciona el juego y el número generado a dicho nivel. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void pb7_Click(object sender, EventArgs e) { nivelElegido = 7; inicializarNivelSeleccionado(nivelElegido); cifrasGeneradas = generarNumeroAleatorio(nivelElegido); } /// <summary> /// Guarda el número de cifras seleccionado y acondiciona el juego y el número generado a dicho nivel. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void pb8_Click(object sender, EventArgs e) { nivelElegido = 8; inicializarNivelSeleccionado(nivelElegido); cifrasGeneradas = generarNumeroAleatorio(nivelElegido); } /// <summary> /// Guarda el número de cifras seleccionado y acondiciona el juego y el número generado a dicho nivel. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void pb9_Click(object sender, EventArgs e) { nivelElegido = 9; inicializarNivelSeleccionado(nivelElegido); cifrasGeneradas = generarNumeroAleatorio(nivelElegido); } /// <summary> /// Guarda el número de cifras seleccionado y acondiciona el juego y el número generado a dicho nivel. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void pb10_Click(object sender, EventArgs e) { nivelElegido = 10; inicializarNivelSeleccionado(nivelElegido); cifrasGeneradas = generarNumeroAleatorio(nivelElegido); } /// <summary> /// Limita la caja de texto a un valor numerico y mueve el cursor a la siguiente caja de texto. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void cifra1_KeyPress(object sender, KeyPressEventArgs e) { validarIngresoDeCifras(e, cifra2); } /// <summary> /// Limita la caja de texto a un valor numerico y mueve el cursor a la siguiente caja de texto. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void cifra2_KeyPress(object sender, KeyPressEventArgs e) { validarIngresoDeCifras(e, cifra3); } /// <summary> /// Limita la caja de texto a un valor numerico y mueve el cursor a la siguiente caja de texto. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void cifra3_KeyPress(object sender, KeyPressEventArgs e) { validarIngresoDeCifras(e, cifra4); } /// <summary> /// Limita la caja de texto a un valor numerico y mueve el cursor a la siguiente caja de texto. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void cifra4_KeyPress(object sender, KeyPressEventArgs e) { validarIngresoDeCifras(e, cifra5); } /// <summary> /// Limita la caja de texto a un valor numerico y mueve el cursor a la siguiente caja de texto. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void cifra5_KeyPress(object sender, KeyPressEventArgs e) { validarIngresoDeCifras(e, cifra6); } /// <summary> /// Limita la caja de texto a un valor numerico y mueve el cursor a la siguiente caja de texto. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void cifra6_KeyPress(object sender, KeyPressEventArgs e) { validarIngresoDeCifras(e, cifra7); } /// <summary> /// Limita la caja de texto a un valor numerico y mueve el cursor a la siguiente caja de texto. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void cifra7_KeyPress(object sender, KeyPressEventArgs e) { validarIngresoDeCifras(e, cifra8); } /// <summary> /// Limita la caja de texto a un valor numerico y mueve el cursor a la siguiente caja de texto. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void cifra8_KeyPress(object sender, KeyPressEventArgs e) { validarIngresoDeCifras(e, cifra9); } /// <summary> /// Limita la caja de texto a un valor numerico y mueve el cursor a la siguiente caja de texto. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void cifra9_KeyPress(object sender, KeyPressEventArgs e) { validarIngresoDeCifras(e, cifra10); } /// <summary> /// Limita la caja de texto a un valor numerico y mueve el cursor a la siguiente caja de texto. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void cifra10_KeyPress(object sender, KeyPressEventArgs e) { validarIngresoDeCifras(e, cifra10); } /// <summary> /// Botón que valida si hay campos vacios, de ser así envía una alerta al usuario; de lo /// contrario aumenta el contador de intentos en 1, captura el número ingresado, encuentra las /// picas y fijas e imprime en un TextBox el resultado para finalmente borrar los campos de /// ingreso y restablecer los arreglos con los cuales se encontraron las picas y fijas, y /// luego poder evaluar si el usuario ha decifrado el número oculto completamente para /// detener el tiempo de juego y enviar una alerta de victoria. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void button1_Click(object sender, EventArgs e) { if (encontrarCamposVacios(nivelElegido)) { MessageBox.Show("Por favor ingrese los dígitos completos.", "Alerta"); } else { reproducirSonido(); contadorIntentos++; cifrasIngresadas = capturarNumeroIngresado(nivelElegido); fijasEncontradas = encontrarFijas(cifrasIngresadasEvaluadas, cifrasGeneradasEvaluadas); picasEncontradas = encontrarPicas(cifrasIngresadasEvaluadas, cifrasGeneradasEvaluadas); imprimirIntento(cifrasIngresadas, picasEncontradas, fijasEncontradas, contadorIntentos); for (i = 0; i < cifrasGeneradas.Length; i++) cifrasGeneradasEvaluadas[i] = cifrasGeneradas[i]; for (i = 0; i < digitosIngresados.Length; i++) digitosIngresados[i].Text = ""; digitosIngresados[0].Focus(); if (completarJuego(nivelElegido, fijasEncontradas)) { timer1.Stop(); button1.Enabled = false; for (i = 0; i < nivelElegido; i++) digitosEscondidos[i].Visible = false; MessageBox.Show(" ¡¡ Juego completado en " + contadorIntentos + " intentos !!\n Tiempo: " + horas.ToString("D2") + ":" + minutos.ToString("D2") + ":" + segundos.ToString("D2"), "Felicidades"); } } } /// <summary> /// Enlaza el pictureBox a la página de la Universidad Libre. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void banner_Click_1(object sender, EventArgs e) { System.Diagnostics.Process.Start("http://www.unilibre.edu.co/index.php"); } /// <summary> /// Lleva e imprime el tiempo de juego del usuario en horas, minutos y segundos a través de /// un timer. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void timer1_Tick(object sender, EventArgs e) { segundos++; if (segundos == 60) { minutos++; segundos = 0; } if (minutos == 60) { horas++; minutos = 0; } tiempo.Text = horas.ToString("D2") + ":" + minutos.ToString("D2") + ":" + segundos.ToString("D2"); } /// <summary> /// Método que reinicia el nivel actual. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void reiniciarNivel_Click(object sender, EventArgs e) { inicializarNivelSeleccionado(nivelElegido); cifrasGeneradas = generarNumeroAleatorio(nivelElegido); } /// <summary> /// Método que reinicia completamente el juego. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void reiniciarJuego_Click(object sender, EventArgs e) { InicializarJuego(); } /// <summary> /// Botón que hace visible el número generado, detiene el tiempo de juego y deshabilita el /// botón de intentos. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void decifrar_Click(object sender, EventArgs e) { timer1.Stop(); button1.Enabled = false; for (i = 0; i < nivelElegido; i++) digitosEscondidos[i].Visible = false; } /// <summary> /// Método que reproduce un sonido con cada intento. /// </summary> public void reproducirSonido() { SoundPlayer movimiento = new SoundPlayer(Properties.Resources.SonidoIntento); movimiento.Play(); } }

Y con esto ya se ha terminado la parte funcional de nuestro juego ya si es desicion suya pueden adicionar mas imágenes o sonidos para que tengo un complemento visual mas robusto espero que les sea de mucha ayuda. si tiene alguna corrección estoy atento a ellas hasta pronto.

Les dejo el proyecto para que si desean lo puedan mejorar...

!!!!!!!!!!!!DESCARGA EL PROYECTO!!!!!!!!!!!!!

PUZZLE NUMERICO

hola amigos. el dia de hoy aprenderemos como crear nuestro propio juego de numero como lo podemos ver en la imagen superior. Como ya lo sabrán vamos a utilizar visual studio

¿QUE ES UN PUZZLE NUMÉRICO?

juego de mesa con el objetivo de organizar una secuencia en este caso de números

EMPECEMOS..........

Primeramente debes crear un proyecto en visual studio de windows form en c#

Cuando la creemos en el windows form que nos aparece vamos a colocar 16 botones para que forme una cuadricula  como se muestra en la imagen. cuando ya tengas todas los botones les vas a poner un nombre a cada botón, les recomiendo que ese nombre sea en secuencia por ejemplo c1,c2,c2,c4..etc para que no  te confundas fácilmente.

Cuando se crean los 16 botones correspondientes el botón numero 16 debe quedar en negro el cual hará el papel del espacio.

Al generar esta interfaces del juego es necesario que cada botón tenga un numero del 1-15 de forma aleatorio sin que se repita para ello se realiza lo siguiente.

Con este fragmento se generan los números aleatoria mente.

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; } } /// <summary> /// Método que valida si un número esta repetido o no en el arreglo numerosAleatorios[] a través /// de un valor booleano, partiendo de un valor y un límite en el arreglo como parámetros. /// </summary> /// <param name="valor"></param> /// <param name="limite"></param> /// <returns></returns> private bool estaAsignado(int valor, int limite) { bool ok = false; for (int j=0; j < limite; j++) { if (valor == numerosAleatorios[j]) { ok = true; } } return ok; }

Al generar los números aleatorios es necesario fijarlo a cada uno de los botones respectivamente para ello se empleo.

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; } }

Cuanto estos procesos se encuentren implantados se realiza el movimiento de cada botón dando una instrucción por separado a cada botón.

private void b15_Click(object sender, EventArgs e) { realizarMovimiento(b15, b11, b14, b16); completarJuego(); }

a realizar este movimiento el botón debe tomar las propiedades del botón vació con el que se hará el movimiento para que genere una persepcion de cambio.

/// <summary> /// Método que intercambia las propiedades de los botones que recibe como parámetro y /// reproduce un sonido en cada movimiento invocando al método reproducirSonido(). /// </summary> /// <param name="bCentral"></param> /// <param name="bContiguo"></param> public void cambiarPropiedades(Button bCentral, Button bContiguo) { bContiguo.BackColor = Color.Transparent; bCentral.BackColor = Color.Black; bContiguo.Text = bCentral.Text; bCentral.Text = ""; intentos++; movimientos.Text = "Movimientos: " + intentos; } /// <summary> /// Método que evalua si es posible generar un movimiento en los botones de las esquinas del /// juego (invocando al método cambiarPropiedades()). /// </summary> /// <param name="botonCentral"></param> /// <param name="botonContiguo1"></param> /// <param name="botonContiguo2"></param> public void realizarMovimiento(Button botonCentral, Button botonContiguo1, Button botonContiguo2) { if (botonContiguo1.BackColor == Color.Black) cambiarPropiedades(botonCentral, botonContiguo1); else if (botonContiguo2.BackColor == Color.Black) cambiarPropiedades(botonCentral, botonContiguo2); } /// <summary> /// Método que evalua si es posible generar un movimiento en los botones laterales del /// juego (invocando al método cambiarPropiedades()). /// </summary> /// <param name="botonCentral"></param> /// <param name="botonContiguo1"></param> /// <param name="botonContiguo2"></param> /// <param name="botonContiguo3"></param> public void realizarMovimiento(Button botonCentral, Button botonContiguo1, Button botonContiguo2, Button botonContiguo3) { 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); } /// <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); }

Y estos son los fragmentos base para el programa ya es necesario que le coloques fondo o sonido si quieren o alguna imagen como lo hice espero que les sirva y quedo atento a alguna corrección o aporte que deseen realizar. les dejo el código para quien lo quiera modificar o realizar alguna optimizacion

DESCARGA EL PROYECTO!!!!!!!!!!!!!

CALCULADORA EN .NET

Hola a todos.

Hoy les mostrare como crear una simple calculadora en c# mediante nuestro desarrollador VISUAL STUDIO ULTIMATE 2013, Para ello es necesario crear un nuevo proyecto de consola. primeramente se da click en el menú ARCHIVO>NUEVO>PROYECTO.

Al seleccionarlo damos click en aplicación de consola.

Al crearla vas a escribir el nombre del proyecto (calculadora). cuando la crees te va a aparecer el código de inicio. en eta primera clase crearemos los metodos de las operaciones para nuestra calculadora para ello es necesario crear dos clase para poder instanciar cada método y donde en una se realizaran las operaciones y otras las respectivas pruebas-

PRIMER CLASE= PruebasCalculadoraEnteros.

(si deseas puedes copiar el método o si te parece poco efectivo, puedes mejorarlo y envíanos tu solución  )

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Calculadora { /// <summary> /// En esta clase se crean toos los metodons en cuanto a las operaciones a realizar /// </summary> class PruebasCalculadoraEnteros { /// <summary> /// Se crea una instancia de la clase CalculadoraEnteros para utilizar los metodos /// </summary> CalculadoraEnteros calculadora = new CalculadoraEnteros(); /// <summary> /// El metodo pruebaSumeDosEnteros toma como elementos, 2 enteros para su posterior suma donde el resultado /// se imprime en consola /// </summary> public void pruebaSumeDosEnteros() { int result = calculadora.sumeDosEnteros(102, 70); Console.WriteLine("sumeDosEnteros: " + result); } /// <summary> /// El metodo pruebaRestaosEnteros toma como elementos, 2 enteros para su posterior resta donde el resultado /// se imprime en consola /// </summary> public void pruebaResteDosEnteros() { int result = calculadora.resteDosEnteros(210, 67); Console.WriteLine("resteDosEnteros: " + result); } /// <summary> ///El metodo pruebaSumeDosEnteros toma como elementos, 2 enteros para su posterior multiplicacion donde el resultado /// se imprime en consola /// </summary> public void pruebaMultipliqueDosEnteros() { int result = calculadora.multipliqueDosEnteros(17, 51); Console.WriteLine("multipliqueDosEnteros: " + result); } /// <summary> /// El método pruebaCalculeCociente llama al método calculeCociente a través de una instancia de la clase CalculadoraEnteros, /// se ingresan dos enteros como parámetro y se captura el valor retornado en una variable que se imprime por consola. /// </summary> public void pruebaCalculeCociente() { int cociente = calculadora.calculeCociente(167, 10); Console.WriteLine("calculeCociente: " + cociente); } /// <summary> /// El método pruebaCalculeResiduo llama al método calculeResiduo a través de una instancia de la clase CalculadoraEnteros, /// se ingresan dos enteros como parámetro y se captura el valor retornado en una variable que se imprime por consola. /// </summary> public void pruebaCalculeResiduo() { int residuo = calculadora.calculeResiduo(167, 10); Console.WriteLine("calculeResiduo: " + residuo); } /// <summary> /// El método pruebaSumeEnteros llama al método sumeEnteros a través de una instancia de la clase CalculadoraEnteros, /// se ingresa un arreglo de enteros como parámetro y se captura el valor que retorna de la suma en una variable que /// se imprime por consola. /// </summary> public void pruebaSumeEnteros() { int[] enteros = { 1, 2, 3, 4, 5, 6 }; int suma = calculadora.sumeEnteros(enteros); Console.WriteLine("sumeEnteros: " + suma); } /// <summary> /// El método pruebaMultipliqueEnteros llama al método multipliqueEnteros a través de una instancia de la clase /// CalculadoraEnteros, se ingresa un arreglo de enteros como parámetro y se captura el valor que retorna de la /// multiplicación en una variable que se imprime por consola. /// </summary> public void pruebaMultipliqueEnteros() { int[] enteros = { 1, 2, 3, 4, 5, 6 }; int producto = calculadora.multipliqueEnteros(enteros); Console.WriteLine("multipliqueEnteros: " + producto); } /// <summary> /// El método Main contiene una instancia de la clase PruebasCalculadoraEnteros y a través de ésta invoca a los métodos /// que ejecutan las pruebas correspondientes a cada operación; finalmente espera una tecla para finalizar la ejecución. /// </summary> /// <param name="args"></param> static void Main(string[] args) { PruebasCalculadoraEnteros pruebas = new PruebasCalculadoraEnteros(); pruebas.pruebaSumeDosEnteros(); pruebas.pruebaResteDosEnteros(); pruebas.pruebaMultipliqueDosEnteros(); pruebas.pruebaCalculeCociente(); pruebas.pruebaCalculeResiduo(); pruebas.pruebaSumeEnteros(); pruebas.pruebaMultipliqueEnteros(); Console.ReadKey(); } } }

SEGUNDA CLASE=CalculadoraEnteros

En esta clase van todos los metodos lógicos para poder hacer nuestras operaciones.



using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Calculadora { /// <summary> /// La clase CalculadoraEnteros contiene todos los métodos asociados únicamente a las operaciones. /// </summary> class CalculadoraEnteros { /// <summary> /// El método sumeDosEnteros toma como parámetro dos números enteros y retorna la suma de ellos. /// </summary> /// <param name="num1"></param> /// <param name="num2"></param> /// <returns></returns> public int sumeDosEnteros(int num1, int num2) { int result = num1 + num2; return result; } /// <summary> /// El método resteDosEnteros toma como parámetro dos números enteros y retorna la resta de ellos. /// </summary> /// <param name="num1"></param> /// <param name="num2"></param> /// <returns></returns> public int resteDosEnteros(int num1, int num2) { int result = num1 - num2; return result; } /// <summary> /// El método multipliqueDosEnteros toma como parámetro dos números enteros y retorna la multiplicación entre ellos. /// </summary> /// <param name="num1"></param> /// <param name="num2"></param> /// <returns></returns> public int multipliqueDosEnteros(int num1, int num2) { int result = num1 * num2; return result; } /// <summary> /// El método calculeCociente toma como parámetro dos números enteros y retorna el cociente de la división entre ellos. /// </summary> /// <param name="num1"></param> /// <param name="num2"></param> /// <returns></returns> public int calculeCociente(int num1, int num2) { int cociente = num1 / num2; return cociente; } /// <summary> /// El método calculeResiduo toma como parámetro dos números enteros y retorna el residuo de la división entre ellos. /// </summary> /// <param name="num1"></param> /// <param name="num2"></param> /// <returns></returns> public int calculeResiduo(int num1, int num2) { int residuo = num1 % num2; return residuo; } /// <summary> /// El método sumeEnteros recibe como parámetro un arreglo de enteros, los cuales va sumando mediante un ciclo for que recorre /// dicho arreglo, y en una variable acumuladora almacena el resultado que finalmente es retornado. /// </summary> /// <param name="numeros"></param> /// <returns></returns> public int sumeEnteros(int[] numeros) { int suma = 0; for (int i = 0; i < numeros.Length; i++) { suma = suma + numeros[i]; } return suma; } /// <summary> /// El método multipliqueEnteros recibe como parámetro un arreglo de enteros, los cuales va multiplicando mediante un ciclo /// for que recorre dicho arreglo, y en una variable acumuladora almacena el resultado que finalmente es retornado. /// </summary> /// <param name="numeros"></param> /// <returns></returns> public int multipliqueEnteros(int[] numeros) { int producto = 1; for (int i = 0; i < numeros.Length; i++) { producto = producto * numeros[i]; } return producto; } } }

Después de haber creado estas clases das iniciar para que pueda compilar y te deberá salir una pantalla de fondo negro con los resultados de las diferentes operaciones.

Espero les sea de mucha ayuda hasta un nuevo aporte.

Realizado en conjunto con FERNANDO CHITIVA HUERTAS.

NUESTRO PRIMER HOLA EN .NET

Hola nuevamente a todos..
El día de hoy aprenderemos como crear nuestra primer aplicación de consola en visual studio para ellos vamos a seguir una serie de pasos para lograr nuestro objetivo

¿QUE ES UNA APLICACIÓN DE CONSOLA?

Las aplicaciones de consola denominada así porque se ejecutan en aplicaciones de consola del sistema, son líneas de comandos de texto y no cuentan con interfaz gráfica.

Las aplicaciones de consola son de manera sencilla al crear y programar en ella.

CREANDO NUESTRA PRIMERA APLICACIÒN

primeramente abrimos o ejecutamos el programa visual studio, al momento de abrir nos aparecerá una pantalla de inicio.

El siguiente paso es colocar el puntero del muose en el menú archivos se desplegara una lista de opciones, seleccionamos nuevo, después seleccionamos proyecto(si se te facilita el manejo de tu pc puedes dar Ctrl+Mayus.+N).

Cuando seleccionemos nuevo proyecto nos aparecerá una pantalla con las opciones de desarrollo que nos habilita visual studio, pueden elegir la que ustedes deseen pero para este caso en particular vamos a elegir Aplicación de consola .

Al dar clic  nos mostrara una pantalla de desarrollo en este caso en especial sera c#.

la pantalla mostrara el ambiente donde vamos a poder ingresar las lineas de código para construir las aplicaciones que deseemos. Para nuestro primer hola mundo vas a ingresar las siguientes lineas de código:

NOTA: En visual studio se generan comentarios dentro del código para ello utilizamos /// al escribirlas puedes seguir comentando cada linea de código de una forma explicativa.

 System.Console.WriteLine("hola mundo");///con esta linea se llama a la consola para que agregue un mensaje, el deseado.

            System.Console.ReadLine();///la función de esta linea es pausar la pantalla para poder visualizar el mensaje.

Estas lineas de código se ubican de la siguiente forma.

al escribir vamos al menú y seleccionamos iniciar el cual ejecuto el programa final.

y nos aparecera

y ha quedado listo nuestro primer hola mundo si necesitas alguna ayuda puedes crear un comentario o un correo electrónico para poderte ayudar y también les dejo el programa para que lo puedan descargar 

Descargar hola mundo

CREANDO REPOSITORIOS EN VISUAL STUDIO ULTIMATE 2013

hola a todos.
el día de hoy aprenderemos como crear un proyecto en equipo, para que puedan trabajar en simultaneo con un compañero o un grupo. Primeramente vamos a abrir nuestro programa desarrollador.

ahora iniciaremos sesión directamente en nuestro ambiente, es necesario tener una cuenta microsoft, si aun no la tienes puedes crearla directamente en la parte superior derecha del ambiente de desarrollo.

Cuando creemos este usuario, vamos a crear nuestro primer proyecto nuevo en equipo
para ello, vamos al menu y buscamos EQUIPO damos click y damos conectar con TEAM FOUNDATION SERVER

Al dar click en esta opción, justo al lado derecho del ambiente de desarrollo nos aparecerá una serie de opciones, vamos a buscar la que nos dice seleccionar proyecto de equipo.

 si deseas mas información sobre el proceso anterior visita el siguiente enlace:

como crear nuestro espacio de servidor team foundation server

Cuando lo hallas realizado el proceso, solo debes dar al menú archivo>nuevo>proyecto en equipo, donde podrás trabajar con otras personas directamente. Para que puedas crear el proyecto paso a paso visita el siguiente enlace:

como crear nuestro proyecto en equipo

El siguiente vídeo nos mostrara porque es tan importante usar un proyecto en equipo.

Como realizar varias tareas en mi proyecto de equipo

INSTALANDO VISUAL STUDIO ULTIMATE 2013

Por : jeisson muñoz

Hola a todos.
En esta guía observaremos el paso a paso para la debida instalación del software VISUAL STUDIO ULTIMATE 2013

¿REQUISITOS DE INSTALACIÓN?

Requisitos de hardware

• Procesador a 1,6 GHz o superior
• 1 GB de RAM (1,5 GB si se ejecuta en una máquina virtual)
• 20 GB de espacio disponible en el disco duro
• Disco duro de 5400 RPM
• Tarjeta de vídeo compatible con DirectX 9 que funcione con una resolución de pantalla de 1024 x 768 o superior.

DESCARGA VISUAL STUDIO ULTIMATE 2013

¿COMO INSTALARLO?

Primeramente debe dar click en el link de descargar, donde automáticamente en el navegador aparecerá lo siguiente:

Al dar click en el archivo se genera la carga del instalador,  y te aparecerá una pantalla donde debes seleccionar la casilla  de licencia y condiciones de uso del programa

cuando hayas seleccionado la casilla, debes dar siguiente para continuar con el proceso de instalación, luego te aparecerá una ventana donde podrás elegir una serie de características opcionales del software, debes seleccionar las opciones que gustes o las puedes instalar todos (la instalación de las características opcionales se seleccionan de acuerdo al tipo de uso a realizar ).

Si ya has decidido que  características opcionales instalar das click en el botón siguiente para continuar con el proceso, te aparecerá una ventana con el progreso de descarga e instalación del software:

El progreso de descarga e instalación dependerán del ancho de banda de tu conexión a Internet y las características de tu PC, entre mas altas las características el programa finalizara la instalación mas rápidamente.

Al finalizar el proceso debes elegir un lenguaje de programación o lo puedes omitir das siguiente y te saldrá la pantalla de inicio dándote la bienvenida y ahora ya puedes disfrutar del VISUAL STUDIO ULTIMATE 2013.