Autor Tema: Pregunta Juego 2d (Leído 3428 veces)

luzop · « **en:** Sábado 22 de Enero de 2005, 22:37 »

Hola.

Pienso hacer un pequeño juego 2D (nunca he hecho
nada antes)

Pero antes que nada, quiero hacer una prueba con el asunto de las colisiones, y ahi
es donde me gustaría algunos consejos/opiniones/links/etc.

Pienso utilizar un rectangulo para representar mi personaje, y para ver si intersecta el piso, pienso hacer un test "caja móvil / linea " , es decir, hayar el
primer tiempo de colision entre la caja y todas las lineas que representan el piso.

Para mover el personaje pienso usar el clásico:

fuerza - roce = masa * acel;
velocidad += acel * delta_tiempo
posicion += velocidad * delta_tiempo

(en donde fuerza se actualiza segun las teclas de movimiento)

..bueno, de eso se trata el primer test que quiero hacer.

algún consejo ?? (lo voy a hacer en java)

gracias.

xplod

Luzop:

Antes que nada permíteme felicitarte por tomar la decisión de adentrarte en esta "onda" de lo videojuegos.

Con respecto a lo de tu pregunta temo no poder ayudarte mucho con el código, pues no conozco el lenguage de Java muy bien (estoy más orientado a hacer este tipo de cosas en Flash); pero te puedo dar alguno que otro consejo:

Bueno con lo del asunto de las colisiones, en muchos lenguajes de programación existe una instrucción donde un "objeto interactúa cuando choque con otro" (hitTest en Flash); esta instrucción debe de ir dentro de alguna condicionante (if) que se este actualizando constantemente.

Por ejemplo:

if (_root.circulo.hitTest(_root.cuadro)==true)
{
_root.circulo._x -= 1;
}

En cuanto lo del personaje y los juegos en 2D se refiere déjame decirte que no debes aplicar el código al personaje: el personaje realmente nunca se mueve (o lo hace muy poco); es el "escenario" en sí el que lo hace. Así que para crear la sensación de movimiento debes aplicar tus fórmulas para que el escenario "avance" y crear el código para controlar la animación de tu personaje "que camina" y así crear la ilusión de desplazamiento por "tu mundo virtual".

(A lo mejor esto va de más, porque realmente no sé a que grado de realismo y complejidad deseas hacer tu juego). Creo que antes que nada es preciso darle vida a tu personaje poniendole un "objetivo" y "dificultades" (historia tal vez), esto con el fin de que si en algún momento quieres compartirlo, cree un cierto grado de interés y ¿por que no? hasta adicción.

Espero no haberte hecho "bolas" con este rollo y que te sirva de algo...

Xplod

luzop

Gracias.

Bueno, con respecto a lo de "mover el escenario" , me estoy basando en algunas explicaciones de un libro que me conseguí. Ya sabía que algo tendría que hacer al
respecto ( "four-way scrolling" le llama el autor). Pero lo estaba dejando para
mas adelante, despues de que tenga claro el asunto de las intersecciones.

El ejemplo del libro usa "tiles", pero yo no quiero usar esa metodología. Quiero
hacer algo estilo mario bros ( ojala! )

.

Quiero que el personaje se deslize por pendientes automaticamte, y que haga
una pequeña aceleración/desaceleración al momento de "soltar/presionar" las
teclas de movimiento.

Estoy haciendo un pequeño test. Como mensioné antes, hago intersección
caja/lineas y el cuento de la física.

en realida quería saber si hay alguna "tecnica" común para mover personajes de este tipo , y que es mas facil, usar test geométricos o chequear si los pixels de el personaje y el "escenario" se intersectan y luego reacomodar el personaje de algún modo (como tu código). Aunque que con esto último no se me ocurre una
manera fácil de hacer lo que dije antes (aceleracion ...etc).

Estoy haciendo esto

:

Código: Text

 
  float prev_x = box.getX();
    float prev_y = box.getY();
    
    box.update(dt);
    
    float box_x=box.getX();
    float box_y=box.getY();
    
    float dir_x = box_x-prev_x;
    float dir_y = box_y-prev_y;
    
    float min_x= box_x;
    float min_y= box_y - box.getHeight();
    
    float max_x = box_x+box.getWidth();
    float max_y = box_y;
    
    float tInter = Tools.POSITIVE_INFINITY; 
    float normal_x=0;
    float normal_y=1;
    float[] normal_temp=new float[2];
    
    // AABB con  cada vertice del piso.
    // Tiro un rayo en la dirección contraria al movimiento de la caja
    // con origen en los vertices de cada linea y lo intersecto con la caja
    for(int i=0; i&#60;lineas.length&#59; i+=2){
      float t = Tools.int_AABB_Rayo(min_x , min_y,
                       max_x , max_y,
                       lineas[i],lineas[i+1],
                      -dir_x , -dir_y , 
                      normal_temp );
      if( t!=Tools.POSITIVE_INFINITY && t &#60; tInter ){
        tInter = t;
        normal_x = normal_temp[0];
        normal_y = normal_temp[1];
      }
    
    }
 
    // Cada vertice del AABB con las líneas del piso.
    // Tiro un rayo en la direccion de movimiento de la caja
    // con origen en cada vertice de la caja y lo intersecto con
    // las lineas del piso
    for(int i=0,c=0; i&#60;lineas.length&#59; i+=4,c++){
      
      float t;
      
      // Vertice top,left
      t = Tools.int_Rayo_Linea_Eberly(lineas[i],lineas[i+1],
                    lineas[i+2],lineas[i+3],
                    dir_x,dir_y,
                    box_x,box_y);
      
      if( t!=Tools.POSITIVE_INFINITY && t &#60; tInter){
        tInter = t;
        normal_x = normales[c][0];
        normal_y = normales[c][1];
      }                    
      
      // vertice top,right                 
      t = Tools.int_Rayo_Linea_Eberly(lineas[i],lineas[i+1],
                 lineas[i+2],lineas[i+3],
                 dir_x,dir_y,
                 box_x+box.getWidth(),box_y);
      
      if( t!=Tools.POSITIVE_INFINITY && t &#60; tInter){
        tInter = t;
        normal_x = normales[c][0];
        normal_y = normales[c][1];
      }                 
      
      // vertice bottom,right                 
      t = Tools.int_Rayo_Linea_Eberly(lineas[i],lineas[i+1],
                 lineas[i+2],lineas[i+3],
                 dir_x,dir_y,
                 box_x+box.getWidth(),box_y-box.getHeight());
      
      if( t!=Tools.POSITIVE_INFINITY && t &#60; tInter){
        tInter = t;
        normal_x = normales[c][0];
        normal_y = normales[c][1];
      }
      
      // vertice bottom,left                 
      t = Tools.int_Rayo_Linea_Eberly(lineas[i],lineas[i+1],
                 lineas[i+2],lineas[i+3],
                 dir_x,dir_y,
                 box_x,box_y-box.getHeight());                 
      
      if( t!=Tools.POSITIVE_INFINITY && t &#60; tInter){
        tInter = t;
        normal_x = normales[c][0];
        normal_y = normales[c][1];
      }
    }
    
    // este es el &#34;sliding&#34;. Aquí estoy teniedo problemas :P
    if( tInter != Tools.POSITIVE_INFINITY ){
      float Q_x = prev_x + dir_x*tInter;
      float Q_y = prev_y + dir_y*tInter;
      float dot = ((box_x-Q_x)*normal_x) + ((box_y-Q_y)*normal_y);
      int final_x = (int)(box_x - normal_x*dot);
      int final_y = (int)(box_y - normal_y*dot);
      
      box.setX(final_x);
      box.setY(final_y);
                           //quizas aqui correr de nuevo el algoritmo
      return;
    }
 
 

Para moverlo uso esto

Código: Text

 
public class EulerBody{
  
  protected float MAG_GRAVEDAD = 75f;
    protected float MAG_ROCE = 5;
    protected float MAG_FUERZA = 45;//26;
    protected final float EPSILON = 1E-005F;
    
    protected float pos_x,pos_y;
    protected float vel_x,vel_y;
    protected float acel_x,acel_y;
    protected float fuerza_x,fuerza_y;
  
  
  public void update(float dt)
    {
      fuerza_y -= MAG_GRAVEDAD;
      
      // f_roce = dir_velocidad*mag_roce
      float f_roce_x,f_roce_y;
      f_roce_x = vel_x * MAG_ROCE;
      f_roce_y = vel_y * MAG_ROCE;
      
        // acel = (fuerza - f_roce)/masa &#59; masa = 1
        acel_x = fuerza_x - f_roce_x;
        acel_y = fuerza_y - f_roce_y;
        
    //vel += acel * dt
    vel_x += acel_x * dt;
    vel_y += acel_y * dt;
        
        // fuerza=0
        fuerza_x=0;
        fuerza_y=0;
        
        if( Math.sqrt(vel_x*vel_x + vel_y*vel_y)  &#60; EPSILON){
          vel_x = 0;
          vel_y = 0;
        }
        else{
          pos_x += vel_x * dt;
          pos_y += vel_y * dt;
        }
    }
    
    public void apply_XForce(float fx){
      fuerza_x += fx;
    }
    public void apply_YForce(float fy){
      fuerza_y += fy;
    }
 
}
 
 

Bueno, cualquier cosa gracias.

JuanK

Citar

El ejemplo del libro usa "tiles", pero yo no quiero usar esa metodología. Quiero
hacer algo estilo mario bros ( ojala! ) cool.gif

MARIO BROS USA TILES,
DKC USA TILES
PRACTICAMENTE TODOS LOOS JUEGOS DE SCROLL USAN TILES.

luzop

Citar

MARIO BROS USA TILES,

ba! disculpas.
( En todo caso me refería al "Super mario world" ...igual usa tiles ?? ...ni idea ).

Saludos.

JuanK

hitman47

hola luzop una opcion q tienes para hacer el juego puede ser el usar games engines para java o librerias y paquetes personalizados q hay por la red como el java3D y la clase CANVAS etc. tambien
en la pagina de java sun hay un par de tuto sobre juegos a pantalla completa.

salu2.

luzop

ok, gracias.

SoloCodigo

Autor Tema: Pregunta Juego 2d (Leído 3428 veces)

luzop

Pregunta Juego 2d

xplod

Re: Pregunta Juego 2d

luzop

Re: Pregunta Juego 2d

JuanK

Re: Pregunta Juego 2d

luzop

Re: Pregunta Juego 2d

JuanK

Re: Pregunta Juego 2d

hitman47

Re: Pregunta Juego 2d

luzop

Re: Pregunta Juego 2d