Algo que es muy importante para cualquier programa o aplicación, es poder leer y escribir a archivos. De otra manera, nuestra información se pierde al apagar la computadora.
En Java se puede leer de y escribir a archivos de diferentes maneras. En el video que presento, usé streams (concretamente un FileInputStream) para leer los datos de un archivo MP3 y obtener la información sobre la canción, si es que se almacenó.
Aquí les presento el video y abajo hay una liga para descargar el código fuente.
La imagen de Duke (la mascota de Java) tocando la guitarra lo tomé del blog de La Playina del Norte y la idea de este proyecto surgió del siguiente libro:
Antes que nada, hay que tener la imagen que deseas poner en la ventana (o JFrame como dijimos antes). Lo puedes dibujar en Paint, Photoshop o bajar de internet. En mi caso bajé esta imagen de dos carros que luego giré en las 4 direcciones (arriba, abajo, izquierda y derecha) para tener el total de 8 imágenes:
Luego estas imágenes se tienen que copiar a la carpeta donde está tu proyecto, dentro de la carpeta /build/classes donde es el nombre que le asignaste al proyecto hecho en NetBeans.
Ahora para dibujar una de estas imágenes en la ventana, el código necesario antes de dibujar la imagen (en el constructor, por ejemplo) es algo como este:
Luego para dibujar la imagen, usa este código (que debe reemplazar el dibujo de los 2 rectángulos con los que estábamos representando a los carritos hasta ahora):
g.drawImage(img,x,y,this);
Obviamente, x y y son las coordenadas de la esquina superior derecha de la imagen (en nuestro caso, son las del Rectangle p1 y p2) y this hace referencia a la ventana actual (el JFrame donde está todo).
Para que todo esto funcione, se tiene que incluir al principio de la clase este import (para la clase URL):
import java.net.*;
¡Y listo! Con eso debería quedar. En el video mostraré el código que usé en este proyecto, mismo que puedes descargar aquí.
Audio en Java
Es muy sencillo poner audio en formato WAV (el método aquí descrito no funciona para MP3). Al igual que con las imágenes de mapa de bits, hay que copiar el o los archivos a la carpeta donde está el proyecto.
Después de esto, deberá ingresar un código como este:
Como se podrá suponer el lector archivo.wav es el nombre del archivo que se copió a la carpeta del proyecto. Las instrucción sonido.loop() hace que el sonido suene y cuando termine vuelva a sonar y así repetir indefinidamente hasta que se termina el programa. Si desea que solo suene una vez, en lugar de eso escriba sonido.play().
No olvides de importar la librería con import java.applet.AudioClip.
Explicación en video
Aquí les dejo el video donde comento los cambios realizados al proyecto. El código fuente del proyecto final se puede descargar aquí.
¿Y qué sigue?
Hay mil cosas que se podrían hacer para que este proyecto quedara mejor. Se puede crear una imagen que diga las instrucciones al entrar al juego, se pueden contar el número de vueltas que da cada jugador (revisando si el rectángulo del carro hace colisión con el rectángulo de la meta y que va en dirección UP) y que gane el primer jugador en completar 3 vueltas. Pero eso ya lo dejo para que sea implementado por el lector.
Agradecimientos
La pintura hecha en una oficina de Duke (la mascota de Java) con un rubí, lo tomé del blog de JRuby. Y como ha sucedido con los posts del proyecto de la carrera de carros, las ideas principales salieron de este libro:
Hemos estado trabajando con un proyecto en Java que dibuja una pista de carreras (no muy estético, pero funcional) y luego usamos threads para mover 2 carros. Hasta allí todo bien, pero no muy divertido que digamos. Por eso, en este post, vamos a hacer dos cosas: detectar colisiones (para que los "carros" no puedan pasar por los obstáculos ni por encima del otro carro) y escuchar eventos del teclado para poder controlar los carros. En pocas palabras, nuestro juego por fin va a ser funcional.
Pero como dijo Jack el destripador, vámonos por partes: primero vamos a ver que onda con la detección de colisiones y luego veremos que onda con el teclado. Así que sin más preámbulos, arrancamos...
Colisiones
Hacer la detección de colisiones (en otras palabras, ver si un objeto "choca" con otro) es bastante sencillo en Java cuando se usan objetos de la clase Rectangle (por eso los usamos desde el primer momento: era más sencillo dibujar sin ellos, pero nos sirven en este momento) porque tiene un método que revisa si hay colisión. Este método se llama intersects.
Digamos que quiero saber si el Rectangler1 se intersecta (o colisiona) con un Rectangle r2, puedo usar el siguiente código:
if (r1.intersects(r2)) {
// Código que se ejecuta si hay colisión
}
Y como podrán imaginar, para revisar múltiples colisiones, puedo usar el operador booleano AND (representado como &&) para ver si dos condiciones se cumplen o el operados OR (representado como ||) para ver si uno de los dos condiciones son verdaderos.
Por ejemplo, si quiero ver si el rectángulo r1 chocó con el rectángulo r2 o el r3, usaría este código:
if (r1.intersects(r2) || r1.intersects(r3)) {
// Código que se ejecuta si choca con r2 o con r3
}
Esta imagen muestra si hay colisiones entre rectángulos (en otras palabras, si se intersectan):
Escuchando el teclado (KeyListener)
Ya en un post anterior hablé sobre "escuchar" eventos en Java (incluyendo el teclado), pero aquí me concentraré solo en el teclado para completar este proyecto. Si desea profundizar, sugiero que vea el post Interfaces gráficas 4: Escuchando eventos.
El KeyListener permite recibir lo que ha escrito el usuario en el teclado. Para usarlo, es necesario agregar, al final de la línea de "public class ..." lo siguiente (esto también aplica para clases internas como las que hicimos en los threads del post anterior):
implements KeyListener
Después de esto, en el constructor (o el método run si estás en un thread), hay que agregar el siguiente código para "despertar" al KeyListener y ponerlo a trabajar:
addKeyListener(this);
Recuerda que el this asocia los eventos que "escucha" del teclado a esta clase.
Después de esto, hay que agregar 3 métodos a la clase
public void keyPressed(KeyEvent e) { }
public void keyReleased(KeyEvent e) { }
public void keyTyped(KeyEvent e) { }
Estas funciones, al igual que el paint del que hablamos en el primer post de esta serie, son ejecutadas de forma automática: el keyPressed se llama cuando se presiona una tecla, el keyReleased se ejecuta cuando el usuario quita el dedo de la tecla y ésta se levanta y el keyTyped ocurre cuando el usuario presiona y suelta la tecla. El mas usado de los tres es el keyTyped, que es precisamente el único que vamos a codificar en este ejemplo.
Finalmente, para saber qué tecla presionó el usuario, uso el código:
e.getKeyChar()
(Si te fijas, e es el parámetro que viene en los métodos y es objeto de la clase KeyEvent que tiene información sobre lo que se ha tecleado).
Integrando este rollo con el proyecto
Como explico con más detalle en el video, voy a crear variables para indicar la dirección del carrito: si vale 0 el carrito viaja hacia arriba, 1 a la izquierda, etc. Para hacerlo más fácil, los voy a hacer constantes porque no quiero que se modifiquen en el código (usando la palabra final al declararlos).
Después de esto, voy a usar el KeyListener para cambiar la dirección del carrito del jugador. También vamos a hacer que el rumbo del carrito cambie al alterar la coordenada x si se mueve hacia la izquierda o derecha y la coordenada y si va hacia arriba o abajo.
Finalmente hay que revisar si el usuario no chocó con un obstáculo o con el otro jugador. Si sucede, vamos a poner la velocidad del jugador en un valor negativo para que el carro retroceda hasta "agarrar vuelo".
Aquí les dejo el video donde lo explico y el código fuente completo (bueno, completo hasta este momento) lo pueden descargar aquí.
Agradecimientos
La imagen de Duke evitando colisiones en patineta lo tomé del blog de CPU y la de los rectángulos que se intersectan son de una página de Tufts University. Y como ha sucedido con los 2 posts anteriores, la idea vino de este libro:
En mi post anterior dibujamos una pista de carreras rudimentaria con rectángulos usando Java. Pero, ¿de qué sirve una pista sin carros? Eso mismo pensé, así que en esta ocasión vamos a añadirle código al proyecto anterior para que podamos tener dos carritos moviéndose de forma independiente una de otra.
La mejor manera de hacer que cada carro se mueva de forma independiente a la ejecución del resto del programa es usar algo llamaos hilos o threads como se conocen en inglés. Cada thread es un código (o "flujo de control" para que se oiga más interesante) que se ejecuta en paralelo con el resto del programa (o con otros threads). Es la forma de implementar multiprocesamiento en un programa de Java (¿nunca han escuchado de multithreading cuando hablan de sistemas operativos?).
Para crear un thread, lo vamos a implemtar como una clase que está dentro de la clase principal (en el caso de este ejemplo, va a ser una clase dentro de mi clase RaceGame). Lo único que hay que cuidar es que herede de la clase Thread. El código de declaración de la clase interna sería esta:
public class extends Thread {
}
Como has de imaginar, puede ser cualquier cosa menos el nombre de la clase en la que está declarado (recuérdate que lo estoy implementando como una clase dentro de la otra clase). En mi caso, declaré dos clases de este tipo (una para cada carrito) llamados moveCar1 y moveCar2.
El corazón de un thread es el método run(). Aquí es donde se define el código que se va a ejecutar. En mi caso concreto voy a mover un carro y lo voy a poner dentro de un ciclo infinito para que siempre esté moviéndose. Un ciclo while(true)me sirve para este fin.
Para hacer mi programa mas seguro, voy a poner mi código dentro de un bloque try...catch. El código que ponga después de la instrucción try se va a ejecutar, pero si hay algún problema va a hacer lo que le diga en la sección catch. De otra forma, mostraría error y truena mi programa. Lo que he dicho hasta ahorita se vería así:
while (true) {
try {
// código para mover el carrito
} catch (Exception e) {
break;
}
}
Como podrá observar el lector, si sucede un error simplemente lo ignoro (con el break). A lo mejor en otro tipo de programa podría poner código aquí para cerrar bases de datos, liberar memoria, o intentar otra cosa. Pero en este programa simplemente voy a hacer de cuenta que nada pasó. Y como el lector podrá deducir, en lugar de lo que va en el comentario // código para mover el carrito debe ir el código que haga que se mueva el carro.
Finalmente para que el Thread se ejecute, es necesario crear el objeto y llamar su método start(). Así que en el constructor de la clase principal, en mi caso RaceGame, voy a escribir lo siguiente:
moveCar1 mc1 = new moveCar1();
mc1.start();
En este video muestro lo que expliqué aquí (con los cambios que realicé en el código del proyecto anterior) y el código modificado lo puedes descargar aquí.
La imagen de Duke (la mascota de Java) con hilos (o Threads) lo tomé de una página de crunchify.com. Y, al igual que con el post anterior, la idea de este proyecto surgió de este libro:
Hablando de Java, ya había comentado como hacer interfaces gráficas, usar Layout Managers para ventanas, hacer interfaces complejas, escuchar eventos y hasta como usar un ScrollPane. En esta ocasión voy a hablar de la forma de usar la clase JFrame para dibujar rectángulos en una ventana. Obviamente estos principios pueden ayudarte a dibujar lo que quieras, pero voy a crear una pista de carreras rudimentaria para un juego donde los jugadores podrán controlar unos carritos (rectángulos) a través de esta pista.
Antes de mostrar el video, quiero resaltar algunos aspectos importantes del programa (el código fuente se puede descargar también más adelante).
Antes de hacer otra cosa, para dibujar en un JFrame (el JFrame es la pura ventana vacía), se tiene que incluir en la línea de declaración de la clase. En mi caso concreto, se hace de esta manera:
public class RaceGame extends JFrame
Después de esto, hay que cambiar la función main() para que contenga una línea de código donde se crea el objeto de la clase (lo cual hace que se llame el constructor de la clase). En mi caso concreto se puede hacer de la siguiente forma:
RaceGame g = new RaceGame();
Todo el código necesario para correr tu clase debe estar en el constructor: por esta razón no escribo más código en la función main(). Si tienes dudas con constructores, no dudes en ver este post de mi blog donde lo explico.
Después para dibujar objetos en mi JFrame, es necesario incluir el método paint() en la clase. Es aquí donde se establecen colores y dibujan figuras. Esta función la ejecuta el sistema operativo cada vez que necesita redibujar la ventana.
Aquí les dejo un video que explica el programa hasta esta etapa:
Y si quieren el código, lo pueden descargar de aquí.
La imagen de la pisa de carreras que se está dibujando la tomé de la página de Bit Rebels.
La idea de este proyecto fue tomado de este libro:
Esta es mi última entrega sobre la forma de insertar, eliminar y actualizar registros de forma fácil usando Access y Visual Basic (ambos versión 2010). En este video muestro la forma de validar errores usando el evento Validating y el control ErrorProvider, además de lo que vimos en videos anteriores.
Les dejo las ligas a los videos anteriores (aunque como son posts seguidos en mi blog, si le das hacia abajo, seguro los encuentras): leer datos desde una tabla de Access (usando DataReader y DataGridView), insertar registros, actualizar registros (aunque en esta ocasión presentamos la versión 2 de esta parte) y eliminar registros. Para entender la parte de base de datos de este video, es necesario haber visto estos videos anteriores.
El video que me mostró la forma de usar el evento Validating y el control ErrorProvider fue este (por si a alguien le interese solo una explicación de esta parte, olvidándose de lo de bases de datos).
También pueden descargar el código del proyecto hasta esta etapa (espero que sea la última) aquí.
Espero que les haya sido de utilidad. Ahora sí, aquí les dejo el video. ¡Hasta la próxima!
P.D. La imagen del error de Homero lo tomé de la página de Gorka Garmendia. ¡Gracias!
Aquí está la tercera parte (¿o es la cuarta? En fin…) de mi explicación sobre la programación de bases de datos de Access 2010 desde Visual Basic. En esta ocasión describo como eliminar registros. De antemano me disculpo por los errores (tuve que depurar el proyecto en el video), pero no lo eliminé porque también es parte del proceso: aprender a depurar programas.
Dicen que lo prometido es deuda, así que cumplo mi trato: ayer en mi post de blog (y video) dije que iba a continuar haciendo modificaciones al proyecto de Visual Basic que hemos estado trabajando. Aquí les presento un video donde realizo la función de Actualizar. Este sería el 2do de 4 videos que pienso hacer. Por cierto, muchas ideas fueron tomadas de este video de Código Facilito. Si no has visto mi post anterior, te recomiendo que lo veas porque es imprescindible para entender lo que explico en este video.
El código del proyecto lo pueden descargar aquí. ¡Hasta la próxima!
En mi post anterior puse material (y código de ejemplo descargable) que mostraba cómo leer datos de una tabla hecha en Access. Inspirándome en éste video de Código Facilito, hice este video que muestra como insertar datos a una tabla de Access.
Como prometí en el video, aquí está la liga al post de mi blog donde hice un ejercicio que usa INSERT y aquí pueden descargar el código fuente de lo que he hecho hasta ahora.
Aquí les dejo el video. Espero que les sea de utilidad. ¡Saludos!
Aunque lo he explicado en varias ocasiones, me topé con estos videos de Código Facilito que explican cómo conectarse a una base de datos, cómo usar el DataReader y cómo llenar datos en un DataGrid. Aquí les pongo los videos:
Además de esas ligas a los videos, les dejo el proyecto que queda al final de estos videos. Lo puedes descargar aquí.
También te dejo referencias en mi blog desde donde puedes leer más sobre cómo leer datos de una base de datos en Access:
Espero que les sea útil. Estoy preparando videos para insertar, actualizar, eliminar y verificar errores que espero estar subiendo la semana entrante. ¡Saludos!
Hace mucho tiempo hice un video acerca de Windows MovieMaker. Pero la interfaz ha cambiado mucho (y mi forma de hacer videos también), así que decidí hacer otro con la nueva versión. La idea es que este sería el primer video introductorio, pero luego hago otros que cubran otras características de este programa.
Espero que les haya sido de utilidad. ¡Hasta el próximo video!
El próximo martes 21 de mayo a las 9am y otra vez a las 12pm, daré una conferencia llamada "Videojuegos de la vida cotidiana" donde platicaré un poco sobre los beneficios psicológicos que traen los videojuegos. Va a estar muy interesante. ¡Los espero!
Continuando con la forma de programar interfaces en Java (te sugiero que antes de seguir, leas los posts 1, 2, 3 y 4), hoy hice un pequeño video que explica cómo usar la clase JScrollPane.
El código fuente lo puedes descargar aquí y el video lo puedes ver a continuación:
La imagen de Duke en una ventana que usa ScrollPane lo encontré en el sitio de Oracle (está el ejemplo de cómo crear una ventana con JScrollPane).
