Mostrando entradas con la etiqueta Código Java. Mostrar todas las entradas
Mostrando entradas con la etiqueta Código Java. Mostrar todas las entradas

7/4/11

Adivina adivinanza


¿A que no sabéis a quién le han encargado, como proyecto final de una asignatura, diseñar un cliente para BLOGGER? ¿A que no sabéis quién tiene que implementar un programa en java que interactúe DE VERDAD con los servicios de blogger? ¿A qué no sabéis quién tiene que hacer que dicho programa sea capaz de gestionar la publicación de entradas, comentarios y el sistema de listados? ¿A que no sabéis a quién le han dado un mes de plazo?

A mí.

3/4/11

[Teach me!] Trucar un dado... virtual

Alguien me dijo una vez que quería aprender a programar. Bueno, realmente alguien no, bastantes alguien. Está bien. He pensado en algo.

Veréis, yo mejor que nadie puedo comprender a aquellos que sienten curiosidad y muchísimas ganas de iniciarse en el noble arte de la programación. Eso de toquetear el ordenador y ver cómo, de repente, puedes pasar de interactuar con cosas que otros han pensado a diseñarlas tú mismo y crear hasta los más descabellados productos de tu imaginación... lo que se siente no tiene precio, pero bueno, sois libres de quedaros con un excitante "¡qué guay!" también. A raíz de esto último, me veo en la obligación de comentaros que comprendo y, por supuesto, respeto que vuestro interés tenga límites. Después de todo, puede que juguetear con la programación os guste pero que entre vuestros planes no entre, ni remotamente, eso de que unos cochinos bits os vayan a dar de comer. Me hago cargo, my dears. Por ello, lo que os voy a contar no va a ser, ni mucho menos, lo que me cuentan a mí en clase. Voy a sacar mi tamiz mágico y os voy a servir los conocimientos que, pienso, son más interesantes.

Pero bueno, dejémonos de zarandajas y vayamos directos al grano. Para escribir en lenguaje Java, vamos a necesitar un programa llamado Eclipse que podéis bajar aquí (haciendo click en cualquiera de los enlaces, como por ejemplo el de Spain RedIRIS). Cuando os lo descarguéis (pesa 171MB, lo que un capítulo de anime aprox.) no hace falta que instaléis nada para poder usarlo. Simplemente, dado que os bajáis un archivo comprimido, habrá que descomprimirlo y buscar, dentro de la carpeta que se creará, el icono que inicia eclipse (una bolita redonda, morada y con tres rayitas blancas en el centro. Tenéis la chuleta en la imagen).


Bien, lo que viene a continuación lo relataré despacio:
Eclipse es un programa que nos permite escribir código y reproducirlo para ver qué ocurre. Sin embargo, para poder trabajar (antes de iniciarse nada) os va a pedir que seleccionéis un Workspace. ¿Que qué es un workspace? Fácil: tal como su nombre indica es un espacio de trabajo, un lugar en el que le pedís que os guarde todo lo que vais a ir haciendo. Crear un workspace es tan fácil como crear una nueva carpeta (donde queráis) y designarla con el nombre "Workspace Dado" o "Workspace Mastermind" o cualquier otro que describa brevemente de qué va a ir lo vayáis a crear. Después sólo tenéis que indicarle a Eclipse que queréis que ése sea el Workspace (Tenéis la chuleta en la imagen).

Para esta primera toma de contacto con Eclipse os he preparado yo misma el Workspace, con un código muy suculento que os enseñará a... trucar un dado. ¿Os gustan las trampas, queréis ganar una apuesta sin esfuerzo o, simplemente, gastarle una inocente broma a alguien? Bueno, pues con esto podréis, mis queridos y queridas pequeñuelas. Dado que el código que está escrito es bastante complejo para alguien que está empezando de cero, no os voy a hacer una gran descripción de las instrucciones que he escrito (me lo reservo para más adelante, cuando seáis unos pequeños expertos), pero sí que os voy a contar qué tenéis que tocar para que funcione y seáis capacez de trucar el dado. Podéis bajarlo de aquí (obtendréis una carpeta llamada Workspace Dado al descomprimir).

Una vez hayáis bajado el Workspace y le hayáis dicho a Eclipse que ahí es donde tiene que trabajar, el programa se iniciará y os encontraréis con algo como esto:



A la izquierda se encuentra el Package Explorer, que nos sirve para navegar por entre las cosas que tenemos creadas. De hecho, si le dais a la flechita que hay en "Dado" os enseñará un nuevo icono llamado "src" y éste os mostrará "implementacionDado" y, finalmente, éste os mostrará "Dado.java". Esto último se llama Clase. Las Clases en Java son, para que nos entendamos, algo así como moldes. En esta ocasión, yo he creado una clase, un molde, para un dado.
En el centro se encuentra el editor de código y, como podréis ver, tiene cosas escritas. Son las instrucciones para que funcione el programa. Podéis leerlas si gustáis, puesto que están comentadas. Todo aquello que empiece con una doble barra "//blablabla" se escribe en verde y significa que es un comentario. Lo mismo para las cosas que empiezan con "/**blablabla... */" y están resaltadas en azul. Los comentarios se refieren a la línea o líneas que van inmediatamente después y traducen a los humanos lo que éstas mandan que se haga.
Arriba del todo se encuentran dos barras: la de herramientas y bajo ella una barra que contiene una serie de iconos. De momento el único que utilizaremos será el que parece un play, esto es, el icono del círculo verde con un triángulo en su interior. Servirá para que el código se ejecute.
Por último, abajo del todo, justo donde acaba el editor central, se encuentra la consola. La consola es la ventanita que nos mostrará lo que ocurre cuando ejecuta el código. Si está bien implementado, mostrará lo que le hemos pedido. Si no... bueno, sino pasaría otra cosa, pero el código funciona, así que ya comentaremos otro día que sucedería.


Bien, y ahora os voy a enseñar cómo hacer que funcione este cacharro. Veréis, lo único que tenéis que hacerle es darle al botoncito de play y contestar a dos preguntitas. Para contestar a las preguntas tenéis que pinchar en la consola y escribir. Lo que el programa necesita que le suministréis son números (números así: 3, NO así: tres). La primera pregunta os requerirá el número de caras que tiene que tener vuestro dado. La segunda se refiere al número de dados que queréis tirar. Por ejemplo, en la oca, (si mal no recuerdo) creo que se tiran dos dados. Aquí teneís un ejemplo visual de lo que habría salido si yo hubiese tirado un dado de diez caras siete veces:



Y ahora... vamos a trucarlo :D

Sin embargo, my dears, os advierto de que tenéis que ser coherentes. Si queréis trucar un dado, tenéis que tener en cuenta de cuántas caras va a ser y cuál es el resultado que queréis que salga. Si lo que buscáis es, ajem, putear a alguien... pues, obviamente, querréis que siempre le salga el número más bajo. Y el número más bajo de un dado es el 1, no el cero, que os conozco. Si lo que queréis es favoreceros con una tirada perfecta, pues lo mismo pero al revés. El máximo número que podrá salir será el máximo de caras que tenga. Pero bueno, que me estoy enrrollando, ¿qué tenéis que tocar? ÚNICAMENTE ESTO, LO QUE OS HE PUESTO AQUÍ EN ROJO:

private static int generaNumeroAleatorio(int unNumero ) {
/*Generamos un número aleatorio cuyo máximo valor se corresponda con el parámetro recibido y le pedimos que se quede sólo con la parte entera.*/
       double f=Math.random()*(unNumero+1);
        int a=(int)f;
        //Evaluamos si el número generado es cero. De ser así lo cambia.
        while(a==0){
            f=Math.random()*(unNumero+1);
            a=(int)f;
        }
        return a;
    }



Bien, lo que está en rojo es una condición a evaluar. Ahora mismo significa que, cuando el programa genere un número aleatorio y éste resulte ser un cero, que lo descarte y saque otro número aleatorio (los dados no tienen cero). Pero podéis decirle que, mientras que el número que se haya generado no sea el que vosotros queréis, vuelva a generar otro número. ¿Cómo se escribe esto en Java? Así:

a!=6 Esto significa que mientras el número que se saque sea diferente de seis, vuelva a generar otro número.
a!=10 Esto significa lo mismo pero poniéndole en vez de un seis un diez.
a!=1 Y, esto último, exactamente lo mismo pero con un uno.

Es decir, que tenéis que poner a!= seguido del número que queráis sacar. ¿Fácil, verdad? Por cierto, por si no encontráis dónde está situada esa parte del código, os diré que está en la línea 42, más o menos en la mitad.

Bueno y para terminar, comentaros que hay infinidad de maneras de trucar un dado. Nosotros lo hemos hecho para que nos salga un sólo número todo el rato... pero claro, si tirasemos muchos dados sería fácil que nos descubrieran, ¿no? Por ello también podemos pedirle al programa que descarte siempre los unos, o que sólo saque los números de un determinado intervalo, o etc, etc... todo lo que esas retorcidas cabecitas vuestras puedan pensar. Y eso es todo, ahora os toca a vosotros. ¡Manipulad el dado y sentíos los dueños del universo!

12/11/10

Next target: Mastermind


-¡Beep! ¡Error! ¡NO compila!
-¡Beep! ¡Error! ¡NO compila! 
(Desperación, golpe)
-¡Beep! ¡Compila! ¡El resultado es el esperado!
Si, hay días que podrían describirse perfectamente así...

El pasado lunes empezamos la tercera y última práctica de mi asignatura cuatrimestral favorita (ejemprogramaciónejem). Muchas, muchísimas veces me he preguntado cuál sería el primer videojuego que programaría... y, aunque no es exactamente un videojuego, ahora ya tengo una respuesta: Mastermind.
La verdad es que casi me caigo de la silla cuando nuestro otro profesor de prácticas (tenemos dos, éste es el especial que solo nos da cuatro clases clave en el curso) nos comentó por encima cómo teníamos que enfocar este proyecto, porque, uhm... cómo decirlo... bueno, el caso es que nunca antes había jugado al Mastermind. Para los que, como yo por aquel entonces, no tengan ni puñetera idea de qué va el juego, podéis informaros aquí y jugarlo aquí.
Después del susto inicial y de unos cuantos ejercicios con matrices y números aleatorios con los que soltarnos, he de decir que estoy emocionada. He leído el guión de la práctica y he empezado a programarlo hasta donde mis conocimientos me han permitido, pero tengo muchas ganas de terminarlo y verlo funcionar de verdad. Y, como me apetece seguir hablando del Mastermind, voy a colgar el primer método del programa porque es muy sencillo y creo que voy a saber explicarlo bien. Este método (en general todos los métodos) hace una determinada función que nosotros hemos programado de antemano. Así, para no tener que estar escribiendo siete veces, por ejemplo, "quiero que eleves al cuadrado el valor de la variable no se cual..." en sintaxis de Java, lo que hacemos es llamar al método "eleva al cuadrado" y decirle sobre qué queremos que lo aplique (normalmente los métodos suelen contener funciones más complicadas). Tachan, lo que antes nos ocupaba veinte líneas ahora sólo nos ocupa una. Ahorramos espacio y el código es mucho más claro y legible.

Método: generaNumeroAleatorio

Los comentarios en Java se escriben mediante doble barra // ó bien barra asterisco-asterisco barra /*-comentario-*/. El código está muy, muy, muy comentado para que sepáis qué significa exactamente cada línea. Cada comentario se refiere a la línea inmediatamente posterior a él (comentario arriba, línea comentada abajo). Los colores los pongo tal y como se asignan en java.

    /*Este método genera un número aleatorio comprendido en el intervalo [1,valoresPosibles]*/
    public static int generaNumeroAleatorio(int valoresPosibles){
                    /*Almacena en una variable llamada "f", un número aleatorio decimal generado entre [0,valoresPosibles]*/
        double f=Math.random()*(valoresPosibles+1);
                    /*Le pedimos que sólo se quede con la parte entera (número sin comas) del número generado.*/
        int a=(int)f;
        /*En las tres líneas siguientes evalúa si el número generado es cero. De ser así lo cambia.*/
        while(a==0){
            f=Math.random()*(valoresPosibles+1);
            a=(int)f;
        }
        /*Una vez nuestros requisitos se cumplan, se devuelve el valor del número generado*/
        return a;
    }


Y eso es todo. Queríamos un número del intervalo cerrado [1, valoresPosibles], así que sólo teníamos que generar números aleatorios y decirle que si generaba un cero lo descartase y volviese a generar otro número aleatorio.


Oh, btw... sólo hay dos lenguas que me resultan tremendamente apasionantes. Puede que la primera ocupe ese lugar privilegiado porque la mayoría de los lenguajes de programación se escriban así, porque sus construcciones idiomáticas resulten apasionantes o porque resulte Descaradamente Genial en labios de Brian Kinney... pero, sea como sea, el inglés es definitivamente la lengua más cool y sexy del mundo. Seguida de cerca, claro está, por el fluido japonés que emana de los labios de Orihara Izaya y compañía...



1/11/10

¿Tú no sabes hacer magia?


Pues yo sí. Yo sé hacer magia sirviéndome de mis dedos.
No sé cuándo, cómo o por qué exactamente empecé a interesarme por la programación. Pero sí sé que cuando termino de programar algo que sé que sirve para hacer otro algo, experimento una sensación increíble. El simple hecho de pedirle a una cosa inanimada que cobre vida por un instante y realice la tarea que le estoy pidiendo me resulta asombroso. Y más asombro aún me resulta ver que no hay huecos, fallos y que contempla todas las posibilidades de acción de una mente humana. Es decir, que funciona para todos y cada uno de los supuestos que un ser humano podría exigir. Es magia, joder. 
Metafóricamente hablando, claro.

El otro día, terminando mi segunda práctica para la asignatura de programación me di cuenta de lo difícil que me resultaba pensar en los algoritmos y el código de según qué ejercicios. Así que, aunque no fue uno de los que más me costó, voy a colgar el código de mi primer juego de ajedrez en Java. Creo que fue el más laborioso, aunque no es ni de lejos un programa que sirva para jugar una partida completa de ajedrez. Pero, joder, me siento orgullosa de este código. 

Si queréis probarlo tenéis que tener la herramienta Eclipse (sección Download, ahora mismo la versión que está es Eclipse Classic 3.6.1). Muy rápida y fácil de bajar y ejecutar.

Enunciado ejercicio 5. Ajedrez
Crear una clase que recibirá como parámetros del método main 2 valores, que se almacenarán en 2 variables de tipo entero, una llamada numeroPeon y otra llamada movimiento. Crear un único array para representar un tablero de ajedrez con la posición inicial de todas las piezas. Imprimir por pantalla el tablero. Implementar el movimiento del peón blanco indicado por numeroPeon (el situado más a la izquierda será el 1, etc.), que avanzará 1 ó 2 casillas según indique la variable movimiento, e imprimir por pantalla la situación final de tablero. Si elnumeroPeon no es un número entre 1 y 8, o movimiento no es igual a 1 ó 2, imprimir por pantalla "Movimiento no válido". Representar: 


-Casillas vacías: símbolos @ y símbolos #, para casillas blancas y negras
respectivamente.
-Casillas ocupadas: inicial del nombre de la pieza que la ocupa, en
mayúscula para las blancas y en minúscula para las negras (ej. T para una
torre blanca, d para una dama negra, etc.).
 

package práctica3ªParte;

public class Ejercicio5 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
       
        /*Lo primero que hace es comprobar que se introducen dos  parámetros. Si no es así, el programa lo notificará y se finalizará.*/
        if (args.length>2 || args.length<2){
            System.out.println("Han de introducirse dos parámetros.");
            System.exit(0);
           
        /*Si el número de parámetros introducido es correcto, entonces transformará los parámetros de tipo String a tipo int y los almacenará cada uno en una variable. También crea un array bidimensional de tipo String de 8x8*/
           
        }else{
           
        int numeroPeon= Integer.parseInt(args[0]);
        int movimiento= Integer.parseInt(args[1]);
        String [][] tablero= new String[8][8];
       
        /*Atendiendo a las reglas del ajedrez, sabemos que la primera casilla situada más a la izquierda de cada jugador ha de ser negra y que el rey ha de estar en su color. Planteando que nosotros utilizaramos las piezas negras, la diposición del tablero sería la siguiente.*/
       
        //Piezas blancas frente a nosotros.
        tablero [0][0]= "T";
        tablero [0][1]= "C";
        tablero [0][2]= "A";
        tablero [0][3]= "D";
        tablero [0][4]= "R";
        tablero [0][5]= "A";
        tablero [0][6]= "C";
        tablero [0][7]= "T";
       
        //Peones blancos colocados en sus respectivas posiciones con ayuda de un bucle for.
        for(int j=0; j<8; j++){
            tablero[1][j]= "P";
        }
       
        /*Entre las piezas blancas y las negras hay cuatro filas de casillas vacías. Con ayuda de bucles for inicializamos cada casilla de cada fila con su correspondiente valor.*/
        for (int j=0; j<8; j++){
            tablero[2][j]="@";
            tablero[2][1]="#";
            tablero[2][3]= "#";
            tablero[2][5]="#";
            tablero[2][7]="#";
        }
        for (int j=0; j<8; j++){
            tablero[3][j]="#";
            tablero[3][1]="@";
            tablero[3][3]= "@";
            tablero[3][5]="@";
            tablero[3][7]="@";
        }
       
        for (int j=0; j<8; j++){
            tablero[4][j]="@";
            tablero[4][1]="#";
            tablero[4][3]= "#";
            tablero[4][5]="#";
            tablero[4][7]="#";
        }
        for (int j=0; j<8; j++){
            tablero[5][j]="#";
            tablero[5][1]="@";
            tablero[5][3]= "@";
            tablero[5][5]="@";
            tablero[5][7]="@";
        }
        //Los peones negros son colocados en sus respectivas posiciones con un bucle for.   
        for(int j=0; j<8; j++){
        tablero[6][j]= "p";
        }
        //Piezas negras.
        tablero[7][0]= "t";
        tablero[7][1]="c";
        tablero[7][2]="a";
        tablero[7][3]="d";
        tablero[7][4]="r";
        tablero[7][5]="a";
        tablero[7][6]="c";
        tablero[7][7]="t";
       
        /*El programa se sirve de dos bucles "for" para recorrer todas las posiciones del array. Empieza asignándoles a las dos variables el valor [0][0] y termina cuando asigna la última posición de las filas y las columnas. Imprime por pantalla el tablero de ajedrez con sus posiciones iniciales.*/
        for (int i=0; i
            for (int j=0; j
                System.out.print(tablero[i][j] + "\t");
            }
            System.out.println("");   
        }
        /*Imprime por pantalla un mensaje que separa el tablero inicial del tablero con la jugada*/
        System.out.println("El movimiento de la jugada:");
       
        /*Antes de ejecutar el movimiento, comprueba que los parámetros introducidos son válidos. Si no lo son, lo notifica y se finaliza.*/
        if (numeroPeon>8 || numeroPeon<1){
            System.out.println("Movimiento no válido");
            System.exit(0);
        }
        if (movimiento>2 || movimiento<1){
            System.out.print("Movimiento no válido");
            System.exit(0);
        }
       
        /*Si los parámetros son válidos comprueba qué peón ha de mover y de qué color es la casilla que va a abandonar. Esta comprobación la realiza mirando si el parámetro (al que le restamos una unidad ya que la primera posición de los arrays es "0") es par. Si es par implementamos el movimiento del peón blanco asignando a la casilla que deja vacía el color negro y a la casilla donde se traslada el símbolo del peón*/
        if((numeroPeon-1)%2==0){
            tablero[1][(numeroPeon-1)]="#";
            tablero[1+movimiento][(numeroPeon-1)]="P";
        /*Si el peón no es par implementamos su movimiento asignando a la casilla que deja vacía el color blanco y a la casilla donde se traslada el símbolo del peón.*/
        }else{
            tablero[1][(numeroPeon-1)]="@";
            tablero[1+movimiento][(numeroPeon-1)]="P";
        }
        //Por último, se imprime el tablero por pantalla con el movimiento implementado.
        for (int i=0; i
            for (int j=0; j
                System.out.print(tablero[i][j] + "\t");
            }
            System.out.println("");   
        }
        }
    }
}





Ejecución con parámetros 5 y 2.
 
Nos vemos.