Archive for the ‘Java’ Category

Diario de desarollo XVolley: Día 1

Día 1 (Viernes):

  • Generar el proyecto, y definir que diablos voy hacer.
    • Menú
      • Jugar
      • Opciones
      • Salir
    • Jugar
      • 1 Jugador
      • 2 Jugadores
    • Jugando
  • Los dos monos saltando evitando que se caiga la pelota
  • El que haya dado el ultimo toque cuando la pelota se haya caído, pierde un punto.
  • Sirve el otro.
  • Gana hasta que lleguen a 15 puntos y que lleven dos puntos de diferencia
  • Entidades
    • Jugador
      • InputPlayer
      • IAPlayer
      • Body
    • Pelota
      • Body
    • Piso
      • Body(Estático)
      • PisoBehavior
    • Maya
      • Body(Estático)

Generando un juego

Ya era hora de escribir y ademas medir mi nivel de avance en este proyecto.
Bueno es difícil crear un proyecto que considere todas las posibilidades que se puedan dar en el desarrollo de otro. Sin embargo esto no es algo imposible, siempre y cuando uno se de defina unos margenes aunque sean bien estrechos, es posible.

Bueno en las entradas anteriores había comentado que había hecho un juego en un poco más de una semana, aunque le falta mucho me sirvió mucho para aprender ciertas cosas que desconocía y fortalecer ciertas detalles que tenia débiles.

Quiero medir una cierta especie de avance en este proyecto, comparando lo que se puede generar y el juego que hice hace poco. Así que mostraré el código para el generador y algunas diferencias de los archivos generador con el juego actual.

Primero el código que define el prototipo.

DEFINE GAME XVolley
[
 DEFINE ENTITY Player(x:Integer,y:Integer,keyMap:KeyMap)
 [
 ADD BEHAVIOR InputPlayerBehavior(keyMap),
 ADD BEHAVIOR PlayerBodyBehavior(world,x,y)
 ],
 DEFINE ENTITY IAPlayer(x:Integer, y:Integer)
 [
 ADD BEHAVIOR IAPlayerBehavior(Player2),
 ADD BEHAVIOR PlayerBodyBehavior(world,x,y)
 ],
 DEFINE ENTITY Ground
 [
 ADD BEHAVIOR GroundBehavior,
 ADD BEHAVIOR GroundBodyBehavior(world,0,0,Width,Height)
 ],
 DEFINE ENTITY Ball
 [
 ADD BEHAVIOR BallBehavior
 ],
 DEFINE STATE Gameloop
 [
 ADD ENTITY Ground,
 ADD ENTITY Ball,
 ]
]

Le añadí unas cuantas cosas extras, que es el pasaje de argumentos, lo cual es más útil que utilizar otra clase para pasar datos. Aunque eso es lo que creo yo. Esto aún es muy básico, pero me será útil en proyectos futuros.

Bueno ,a primera clase que genero es el punto inicio del juego y ya está bastante madura su generación(por ahora), solo tiene algunas diferencias. izquierda modificado/derecha generado
http://www.diffchecker.com/cfbrhgz0

Ahora algunos constructores de entidad. No hay mucha diferencia entre estos archivos sin embargo puede ser un poco latoso andar corrigiendo los imports y los tipos nativos de Java. A pesar que el pasaje de argumentos es muy basico y no hace ninguna comprobación de tipos, es muy útil.

http://www.diffchecker.com/1orn22iw
http://www.diffchecker.com/opqjls5h
Y finalmente la clase con toda la magia y la más distinta. Es evidente que el generador aún le queda trabajo para poder alcanzar este nivel de implementación. La definición de esta clase en el generador estaba vacía, pero aún así no alcanzará a estar ni cerca de lo que yo programé para que funcionase el juego.
http://www.diffchecker.com/v2wk8xms

Cuando programé esta clase, trate de seguir un orden para que sea utilizado en el generador, y pude notar que existen reglas que pueden ser creadas en el mismo generador, aunque eso es trabajo de otra ocasión.

Gracias a Freemarker ando mucho más rápido generando las plantillas para generar código. Y al parecer JavaCC se me está quedando corto o yo no lo sé usar. De todas formas, veré si puedo usar ANTLR debido a que se mantiene actualizado y la gramática es más fácil de mantener.

Gracias: Diffchecker

Un generador de juegos

Esta idea es algo que cae en la categoría de ideas locas, debido a la cantidad(muchos) de programas que permiten crear juegos y el costo de desarrollar un programa como estos es alto. Sin embargo yo no voy apostar por crear algo bonito como Unity, UDK, etc… si no por un generador de código a partir de un lenguaje(o intento) desarrollado para este objetivo.

De primera pensaba que este lenguaje debería poder desarrollar un juego completo, sin embargo era demasiado para mí y aunque tuviese ayuda solo seria un castillo más en el aire.  Entonces si no podía hacerlo completo puedo hacerlo incompleto o prototiparlos, pero lo más rápido posible para que valga la pena usarlo.

Para poder crear este lenguaje que por ahora llamo Fast Prototyping for Games (FP4G) y utilizare tecnologías como JavaCC y JCodeModel los cuales me permiten hacer un parser para el lenguaje y generar código en java. El resultado será codigo compilable en java con el esqueleto del juego y usando la biblioteca libGDX.
El lenguaje sera simple, de hecho me base en el objeto json de javascript aunque, con ligeras modificaciones.

[
valor = 1,
valorA = "hola",

etc...
]

No es algo muy complejo, solo hay que definir cosas y mágicamente el generador crea todas las clases por ti listas para que tu agregues los comportamientos necesarios para definir ciertos objetos, pero todo lo demás estará listo. La idea es que uno define que va tener y va definiendo sus propiedades. Nada más.

Y lo que tengo ya hecho.

DEFINE GAME
[
name = "Prueba",
DEFINE STATE GameLoop
[
  ADD SYSTEM SceneSystem,
  ADD SYSTEM PhysicsSystem,
  ADD SYSTEM EntitySystem,
  DEFINE ENTITY Coin
  [
     position = [ x = 10, y = 10]
  ],
  ADD ENTITY Coin,
  ADD ENTITY Coin
  ],
  START GameLoop
]

Y genera esto
(Main) http://pastebin.com/L3EaMLec
(GameLoop) http://pastebin.com/BJvDWKrR
(CoinEntity) http://pastebin.com/e193m8hu
Que con las bibliotecas correctas va compilar y mostrar una moneda en pantalla.

Como dibujar un Sprite en Java II

Hola
En el articulo anterior se vio como dibujar una imagen simple en Java  ahora les mostraré algo más complejo.  Vamos a tener una imagen que estará compuesta de varias imágenes, pero nosotros solo dibujaremos un solo sector de la imagen.

Ejemplo:

Imagen de ejemplo del Api de Java MicroEdition

En esta imagen se ve que tenemos una imagen compuesta de varias imagenes pequeñas (nota todos de igual tamaño) y nosotros a voluntad podemos elegir que area de la imagen a dibujar. Cada área (o frame) se puede identificar usando un indice empezando desde el 0 (ver imagen anterior).

Para poder dibujar un frame, debemos saber cual será el área de recorte ya que Java no conoce estos indices solo en posiciones x,y y en pixeles, para eso podemos calcular el área de recorte se usa una formula sencilla.

Ejemplo:

int indice = 3;
int sx = (indice % (anchoImagen/anchoFrame))*anchoFrame;
int sy = (indice / (anchoImagen/anchoFrame))*altoFrame;
//anchoFrame y altoFrame son constantes y definen el ancho y alto del Frame
//altoImagen y altoImagen son constantes y definen el ancho y alto de la imagen

Nota: Todas las divisiones son enteras.

Y finalmente pintamos nuestra imagen usando esta función

Graphics g; //alguna instancia de Graphics
BufferedImage image; //alguna imagen previamente cargada
int x = 10, y = 20;
g.drawImage(image,
x, y, x + anchoFrame, y + altoFrame,
sx, sy, sx + anchoFrame, sy + altoFrame,
null);
//sx y sy son las variables que calculamos previamente

Y les dejo un regalo

//Sprite.java
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;

/**
*
* @author egyware
*/
public class Sprite{

private Posicion posicion = new Posicion();
private BufferedImage image;
private int frame;
private int width;
private int height;
private int tw;
//private int th;

public void SetFrame(int index){
frame = index;
}

public void Pintar(Posicion relative, Graphics2D g){
int x = posicion.x;
int y = posicion.y;
if(relative != null){
x+=relative.x;
y+=relative.y;
}
int i = frame % tw;
int j = frame / tw;
g.drawImage(image,
x, y, x + width, y + height,
i*width, j*height, (i+1)*width, (j+1)*height, null);
}

public void Build(String spriteName,int spriteWidth,int spriteHeight){
try {
image = ImageIO.read(ClassLoader.getSystemResourceAsStream(spriteName));
width = spriteWidth;
height = spriteHeight;
tw = image.getWidth()/width;
//th = image.getHeight()/height;
} catch (IOException ex) {
Logger.getLogger(Sprite.class.getName()).log(Level.SEVERE, null, ex);
}
}

public void SetPosicion(Posicion p) {
posicion.Set(p);
}

public void SetPosicion(int x, int y) {
posicion.Set(x,y);
}

public int GetWidth() {
return width;
}

public int GetHeight() {
return height;
}

}
//Posicion.java
/**
*
* @author egyware
*/
public final class Posicion {
public int x;
public int y;

/**
* Constructor por defecto
*/
public Posicion(){
}

/**
* Constructor
* @param x posicion x
* @param y posicion y
*/
public Posicion(int x,int y){
Set(x,y);
}

/**
* Constructor copia
* @param other Posicion otro vector que le copia sus valores
*/
public Posicion(Posicion p){
Set(p);
}

public void Set(int _x,int _y){
x = _x;
y = _y;
}
public void Set(Posicion p){
if(p != null){
x = p.x;
y = p.y;
}else{
x = 0;
y = 0;
}
}

@Override
public String toString(){
return getClass().getSimpleName()+" ("+x+","+y+")";
}

}

El codigo completo que estoy usando para mi tarea 🙂

Quejas y pateleos en los comentarios 🙂
Saludos!

Como dibujar un Sprite en Java

De hace tiempo que no escribo en mi blog, pero el Vistor me insistio amablemente para que publicará este tutorial. Bueno también es mi culpa porque yo le dije que iba subir tutorial, bueno aquí vamos 😛

Para este tutorial debes haber usado antes la clase Graphics en algún proyecto.

Usaremos las clases ImageIO y BufferedImage las que nos permitirá poder dibujar las imagenes en nuestra ventana.

Primer paso incluir las clases que necesitamos para nuestro proyecto.

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;

Segundo paso cargar nuestra imagen a la memoria osea en una vil variable

 //constructor
 private BufferedImage vil_variable;
 public  Panel(){
 vil_variable = ImageIO.read(new File("foto.png"));
 }

En este caso cargamos una imagen de nuestro computador a nuestra vil variable, pero podemos descargar esa imagen directamente desde internet o desde nuestro propio jar como por ejemplo.

 vil_variable = ImageIO.read(new URL("http://dominioX.com/foto.png"));
 
 vil_variable = ImageIO.read(ClassLoader.getSystemResourceAsStream("foto.png"));
 

Bueno ahora que tenemos la imagen cargada en una vil variable, podemos pintarla sin nigún problema

public paint(Graphics g){
int x = 10, y = 20;
g.drawImage(vil_variable,x,y,null);
}

Bueno, por fin hemos pintado la imagen en las posiciones x,y. Si deseas puedes cambiar esos valores y posicionarlo en cualquier lugar que quieras. Esto es bastante simple, pero cuando tenga más tiempo les mostraré como hacer sprites animados.

Nota: He ignorado todos las excepciones de Java para simplificar el codigo

Saludos!