User Tag List

Página 1 de 3 123 ÚltimoÚltimo
Resultados 1 al 15 de 45

Tema: Hilo de Programación en MegaDrive [SGDK]

  1. #1

    Fecha de ingreso
    Oct 2012
    Mensajes
    211
    Mencionado
    1 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    4
    Agradecer Thanks Received 
    115
    Thanked in
    Agradecido 39 veces en [ARG:2 UNDEFINED] posts

    Hilo de Programación en MegaDrive [SGDK]

    He creado este hilo para que pongamos aquí todo lo que vayamos intentando y consiguiendo con el kit de desarrollo SGDK para MegaDrive.

    Copio el código del rotozoom que estoy intentando, no da error pero no pinta nada en la pantalla.

    Código:
    #include "genesis.h"
    #include "BKG.h"
    
    int XX = 0;
    int x = 0;
    int y = 0;
    int u = 0;
    int v = 0;
    int W = 0;
    
    u16 color = 0x0000;
    
    int main(){
     
     BMP_init(1, 0, 1);
     VDP_drawBitmap(VDP_PLAN_A,&bkg,0,0);
     
     while (1){
     
        if (W == 1024) W = 0; //el ángulo en no se que unidades
    	
        //copiar y pegar pixeles de imagen, resolución de 160x128, El modo BMP de dibujo de imágenes, usa pixeles de 2x2
        for(y=0;y<=224;y+=2){
           for(x=0;x<=320;x+=2)
           {
            u = fix16Int(x*cosFix16(W)+y*(-sinFix16(W)));
            v = fix16Int(x*sinFix16(W)+y*cosFix16(W));
            color = BMP_GETPIXEL(x,y);                              //Copia pixel
            BMP_SETPIXEL(u,v,color);                                //pega pixel
            }
        }
    	
    	W++;
    
    
            BMP_clear(); //no hace nada.. 	
    	BMP_flip(1); //no hace nada...
    
            BMP_showFPS(1);
    
    	VDP_waitVSync();
    	
     }
       
    }
    Última edición por mills332; 29/04/2014 a las 20:22

  2. #2

    Fecha de ingreso
    Oct 2012
    Mensajes
    211
    Mencionado
    1 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    4
    Agradecer Thanks Received 
    115
    Thanked in
    Agradecido 39 veces en [ARG:2 UNDEFINED] posts
    Otro efecto bueno, este si funciona porque han creado una función específica para el, pero estába un poco rara, o yo no la entendía muy bien... Bueno, para novatos.

    Se trata de mover un plano con una función seno o coseno, para que haga ondas.

    Código:
    #include <genesis.h>
    
    int i = 0;
    
    int LINES = 0; //screen lines
    
    u16 hscroll[1024] = {0}; //scroll values
    
    int SPEED = 0; // wave speed
    
    int main(){
    
        VDP_setScreenWidth320();
    
    	VDP_setScrollingMode(HSCROLL_LINE, VSCROLL_PLANE);
    	
    	LINES = VDP_getScreenHeight(); 
    
        while(1){
    	
            for(i = 0; i < (LINES+1); i++) hscroll[i] = sinFix16( ((SPEED + (i << 2)) & 1023));	
    
    		
    		VDP_drawText("Test", 17, 11);
    		
    		VDP_drawText("Line scroll", 14, 13);
    		
    		VDP_drawText("-----------", 14, 15);
    
    		VDP_setHorizontalScrollLine(VDP_PLAN_A, 0, hscroll,LINES,1);
    		
            SPEED += 3;  
    
         
    		VDP_waitVSync();
    	}
    }

  3. #3

    Fecha de ingreso
    Sep 2006
    Ubicación
    Malaga
    Mensajes
    6,303
    Mencionado
    37 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    1,097
    Agradecer Thanks Received 
    1,158
    Thanked in
    Agradecido 805 veces en [ARG:2 UNDEFINED] posts
    Puede que falle en el BMP_SETPIXEL(u, v) ¿que rango de valores tiene u,v?
    Prueba a hacer un BMP_SETPIXEL(x,y,x), para ver si pinta algo o te falta volcar el bmp.

    Si cosFix16 y sinFix16 tiene un rango de salida de -512 a 511, lo multiplicas por la X y se te va al carajo, aunque después hagas el fix16Int (no he visto en la doc el intervalo de valores de entrada ni de salida).

    De todas formas para hacer el rotozoom, se hace así:
    Coges un angulo de entrada
    Coges una escala X y escala Y
    Para ese angulo, sacas un vector para recorrer lineas "horizontales" y otro para pasar de linea en linea.
    Escalas los dos vectores por la escala X y la escala Y.
    Recorres un bitmap usando esos vectores y vuelcas en la pantalla de forma secuencial (igual que la estas recorriendo ahora)

    Si lo haces así el centro de rotación estara en la esquina de la pantalla, ahora es cuestión de cambiarlo antes de dibujar.
    No es lo mismo tener diez años de experiencia, que tener un año de experiencia diez veces.

  4. #4

    Fecha de ingreso
    Jun 2004
    Mensajes
    12,354
    Mencionado
    41 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    667
    Agradecer Thanks Received 
    665
    Thanked in
    Agradecido 437 veces en [ARG:2 UNDEFINED] posts
    Entradas de blog
    17

  5. #5

    Fecha de ingreso
    Oct 2012
    Mensajes
    211
    Mencionado
    1 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    4
    Agradecer Thanks Received 
    115
    Thanked in
    Agradecido 39 veces en [ARG:2 UNDEFINED] posts
    Cita Iniciado por swapd0 Ver mensaje
    Puede que falle en el BMP_SETPIXEL(u, v) ¿que rango de valores tiene u,v?
    Prueba a hacer un BMP_SETPIXEL(x,y,x), para ver si pinta algo o te falta volcar el bmp.

    Si cosFix16 y sinFix16 tiene un rango de salida de -512 a 511, lo multiplicas por la X y se te va al carajo, aunque después hagas el fix16Int (no he visto en la doc el intervalo de valores de entrada ni de salida).

    De todas formas para hacer el rotozoom, se hace así:
    Coges un angulo de entrada
    Coges una escala X y escala Y
    Para ese angulo, sacas un vector para recorrer lineas "horizontales" y otro para pasar de linea en linea.
    Escalas los dos vectores por la escala X y la escala Y.
    Recorres un bitmap usando esos vectores y vuelcas en la pantalla de forma secuencial (igual que la estas recorriendo ahora)

    Si lo haces así el centro de rotación estara en la esquina de la pantalla, ahora es cuestión de cambiarlo antes de dibujar.
    De todas formas, para que funcione a 3 o 4 FPS hay que saltarse pixeles de 8 en 8, o sea que una resolucion a nivel de tiles, así que es más facil mover los tiles, creo yo. O si no pues se hace un fake metiendo una secuencia de imágenes rotadas en diferentes ángulos, puede que se vea mejor... jeje.

  6. #6

    Fecha de ingreso
    Sep 2006
    Ubicación
    Malaga
    Mensajes
    6,303
    Mencionado
    37 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    1,097
    Agradecer Thanks Received 
    1,158
    Thanked in
    Agradecido 805 veces en [ARG:2 UNDEFINED] posts
    Seguro que se puede hacer en tiempo real y que funcione a mas fps, mira las demos de Atari ST y veras que no van tan mal. Eso si, tendrías que pasar de C y hacerlo en ensamblador.
    No es lo mismo tener diez años de experiencia, que tener un año de experiencia diez veces.

  7. #7

    Fecha de ingreso
    Dec 2003
    Ubicación
    Tarragona
    Mensajes
    1,510
    Mencionado
    44 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    0
    Agradecer Thanks Received 
    33
    Thanked in
    Agradecido 12 veces en [ARG:2 UNDEFINED] posts
    He cogido el codigo que ha puesto K-teto y he estado trasteando un poco con el y he sacado el dibujado de los tiles fuera del while que mueve el scroll... creo que ahora he entendido lo de los planos...

    Corregidme si me equivoco, los planos son de 512x512 pixeles y solo son para poner fondos con scroll? porque un mapa es mucho mas grande que esos 512x512...

    aqui pongo el codigo por si quereis probarlo.

    Código:
    #include <genesis.h>
    
    s32 coordY = 5;
    s32 coordX = 5;
    u16 numtile = 1;
    s16 ScrollX = 0;
    
    const u32 tile[8]=
    {
    	0x00111100, // Línea 1: pixels 1 a 8
        0x01144110, // Línea 2
        0x11244211, // Línea 3
        0x11244211, // Línea 4
        0x11222211, // Línea 5
        0x11222211, // Línea 6
        0x01122110, // Línea 7
        0x00111100  // Línea 8: píxels 57 a 64
    };
    const u32 tile2[8]=
    {
    	0x00111100,  // Línea 8: píxels 57 a 64
        0x01122110, // Línea 7
        0x11222211, // Línea 6
        0x11222211, // Línea 5
        0x11244211, // Línea 4
        0x11244211, // Línea 3
        0x01144110, // Línea 2
        0x00111100 // Línea 1: pixels 1 a 8
    };
    
    
    int main( )
    {
        VDP_setScrollingMode (HSCROLL_PLANE, VSCROLL_PLANE); // le decimos que tipo de scroll queremos, tile a tile, linea a linea...
        VDP_loadTileData( (const u32 *)tile, 1, 1, 0);
        VDP_loadTileData( (const u32 *)tile2, 2, 1, 0);
        VDP_setBackgroundColor(0);
     
    	coordX = 0;
    	coordY = 2;
    	while (coordY<28)
        {
        	while (coordX<64)
            {
            	numtile = 1 - numtile;
                VDP_setTileMapXY(VDP_PLAN_A, 1 + numtile, coordX, coordY);
                coordX++;
            }
            coordY++;
            coordX = 0;
        }
        
    	VDP_drawText("0000000001111111111222222222233333333334444444444555555555566666", 0, 0);
    	VDP_drawText("1234567890123456789012345678901234567890123456789012345678901234", 0, 1);
    	
    	
    	VDP_drawText("El texto tambien forma parte del PLANO A", 2, 10);
           
        while(1)
        {
    	    VDP_setHorizontalScroll( VDP_PLAN_A, ScrollX ); //movemos el mapa x puntos a la izquierda, voy a usar la variable ciclo mismamente
    		
            if ( ScrollX == -256 ) ScrollX = 256;
    		ScrollX--;
            
            VDP_waitVSync();
    	}
        return (0);
    }

    Un saludo!
    Que no se vea no significa que no exista!

  8. #8

    Fecha de ingreso
    Jun 2004
    Mensajes
    12,354
    Mencionado
    41 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    667
    Agradecer Thanks Received 
    665
    Thanked in
    Agradecido 437 veces en [ARG:2 UNDEFINED] posts
    Entradas de blog
    17
    Mierda, yo decia que por hoy ya no mas, que llevaba toda la tarde.
    Y aqui estoy, arrancando windows para volver a ponerme, te odio! XDD

  9. #9

    Fecha de ingreso
    Jun 2004
    Mensajes
    12,354
    Mencionado
    41 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    667
    Agradecer Thanks Received 
    665
    Thanked in
    Agradecido 437 veces en [ARG:2 UNDEFINED] posts
    Entradas de blog
    17
    Pues partiendo de tu codigo, le he dado unas vueltas para hacerte un ejemplo de scroll por lineas.
    Código:
    #include <genesis.h>
    
    u16 numtile = 1;
    s16 lineaY = 0;
    s32 i,wait,numwait = 0;
    char texto [3];
    const u32 tile[8]=
    {
    	0x00111100, // Línea 1: pixels 1 a 8
        0x01144110, // Línea 2
        0x11244211, // Línea 3
        0x11244211, // Línea 4
        0x11222211, // Línea 5
        0x11222211, // Línea 6
        0x01122110, // Línea 7
        0x00111100  // Línea 8: píxels 57 a 64
    };
    const u32 tile2[8]=
    {
    	0x00111100,  // Línea 8: píxels 57 a 64
        0x01122110, // Línea 7
        0x11222211, // Línea 6
        0x11222211, // Línea 5
        0x11244211, // Línea 4
        0x11244211, // Línea 3
        0x01144110, // Línea 2
        0x00111100 // Línea 1: pixels 1 a 8
    };
    
    u16 desplazamiento[32]={0,1,2,2,3,3,4,4,4,5,5,5,5,6,6,6,6,6,5,5,5,5,4,4,4,3,3,2,2,1,1,0}; // una forma de onda suave
    
    void myJoyHandler( u16 joy, u16 changed, u16 state)
    {
        //Si el botón pulsado corresponde al pad en el puerto 1
       if (joy == JOY_1)
       {
           //La sintaxis del código para comprobar el estado
           //del botón será la que sigue variando el valor
           //con el que se compararán sendos atributos:
           //state y change, state correspondiéndose con la
           //pulsación del botón y change con la liberación
           //del mismo
          if (state & BUTTON_START) //Si se pulsa START
          {
              //Que específicamente elijamos estas determinadas
              //coordenadas (x=5, y=13) se debe a que en la
              //función main vamos a mostrar el rótulo
              //correspondiente al estado del botón START en
              //dichas coordenadas. Lo que lo que estaremos
              //haciendo será sobreescribir el rótulo cada vez
              //que se pulse o suelte el botón, ya sea mostrando
              //"START button 1" o "START button 0" según el caso
             //VDP_drawText("START button 1", 5, 13);
             //El área para disponer texto en pantalla en
             //megadrive se corresponde exactamente con el área
             //de tiles visibles en pantalla (no hay razón para
                //no considerar cara caracter un tile, que es lo
                //que también son). Por lo tanto, en el modo PAL
                //"normal" en que disponemos de una resolución de
                //320x224 tendremos un área de 40x28 caracteres;
                //La primera fila y la primera columna toma valor
                //cero, por lo que para comenzar un texto en la
                //esquina superior izquierda lo haríamos tal que
                //así: //VDP_drawText("texto", 0, 0);
          }
          else if (changed & BUTTON_START) //Si se suelta
          {
             //VDP_drawText("START button 0", 5, 13);
          }
    
          if (state & BUTTON_A) //Si se pulsa A
          {
             //VDP_drawText("A button 1", 5, 14);
    
          }
          else if (changed & BUTTON_A) //Si se suelta A
          {
             //VDP_drawText("A button 0", 5, 14);
          }
    
          if (state & BUTTON_B)
          {
             //VDP_drawText("B button 1", 5, 15);
          }
          else if (changed & BUTTON_B)
          {
             //VDP_drawText("B button 0", 5, 15);
          }
    
          if (state & BUTTON_C)
          {
             //VDP_drawText("C button 1", 5, 16);
          }
          else if (changed & BUTTON_C)
          {
             //VDP_drawText("C button 0", 5, 16);
          }
    
          if (state & BUTTON_X)
          {
             //VDP_drawText("X button 1", 17, 14);
          }
          else if (changed & BUTTON_X)
          {
             //VDP_drawText("X button 0", 17, 14);
          }
    
          if (state & BUTTON_Y)
          {
             //VDP_drawText("Y button 1", 17, 15);
          }
          else if (changed & BUTTON_Y)
          {
             //VDP_drawText("Y button 0", 17, 15);
          }
    
          if (state & BUTTON_Z)
          {
             //VDP_drawText("Z button 1", 17, 16);
          }
          else if (changed & BUTTON_Z)
          {
             //VDP_drawText("Z button 0", 17, 16);
          }
    
          if (state & BUTTON_UP)
          {
             //VDP_drawText("UP button 1", 5, 17);
          }
          else if (changed & BUTTON_UP)
          {
             //VDP_drawText("UP button 0", 5, 17);
          }
    
          if (state & BUTTON_DOWN)
          {
             //VDP_drawText("DOWN button 1", 5, 18);
          }
          else if (changed & BUTTON_DOWN)
          {
             //VDP_drawText("DOWN button 0", 5, 18);
          }
    
          if (state & BUTTON_LEFT)
          {
             //VDP_drawText("LEFT button 1", 5, 19);
          }
          else if (changed & BUTTON_LEFT)
          {
              if (numwait>0)
                numwait--;
             //VDP_drawText("LEFT button 0", 5, 19);
          }
    
          if (state & BUTTON_RIGHT)
          {
              numwait++;
             //VDP_drawText("RIGHT button 1", 5, 20);
          }
          else if (changed & BUTTON_RIGHT)
          {
             //VDP_drawText("RIGHT button 0", 5, 20);
          }
       }
    
    
       // otras funciones interesante
       // JOY_update() refresca el estado del pad, se llama en cada refresco de la pantalla
        // JOY_readJoypad( joy ) ¨devuelve el estado del pad1
        // JOY_waitPressBtn() espera a que se pulse un boton (no direcciones)
        // JOY_waitPress(joy, BUTTON_A | BUTTON_UP) espera a pulsar un boton indicado en un pad especifico
    
    }//end myJoyHandler()
    
    void initTileMap() // crea el mapa de tiles
    {
    s32 coordY = 0;
    s32 coordX = 0;
    
        while (coordY<28)
        {
        	while (coordX<64)
            {
            	numtile = 1 - numtile;
                VDP_setTileMapXY(VDP_PLAN_B, 1 + numtile, coordX, coordY); // dibujamos en el plano B para que no interfiera con el texto
                coordX++;
            }
            coordY++;
            coordX = 0;
        }
    }
    int main()
    {
     // empezamos a inicializar cosas y a preparar el programa
        JOY_init(); //joystick
        JOY_setSupport(PORT_1, JOY_SUPPORT_6BTN); // puerto y tipo de pad
        JOY_setEventHandler( &myJoyHandler ); // indicamos que funcion es la que controla el pad
        VDP_setScrollingMode (HSCROLL_LINE, VSCROLL_PLANE); //necesitamos que el scroll horizontal sea por lineas
        VDP_loadTileData( (const u32 *)tile, 1, 1, 0); // cargamnos el tile 1
        VDP_loadTileData( (const u32 *)tile2, 2, 1, 0); // cargamos el tile 2, el mismo que el 1 pero invertido
        VDP_setBackgroundColor(63); //ponemos un color de fondo, el 63 es un azul brillante en la paleta por defecto
        initTileMap(); // esta es la funcion que dibuja el mapa de tiles
        numwait=1; // le ponemos por lo menos un retrazado, que si no no se ve una leche
    // ya hemos terminado de inicializar todo lo necesario, vamos con el bucle principal
    
        while(1)
        {
            for (lineaY=0;lineaY<=223;lineaY++) // vamos a recorrer toda la resolucion vertical, de 0 a 223 (224 pixels de alto)
            {
                if (i<=32) i=0; //nuestro array de desplazamientos tiene 32 valores distintos, si alcanzamos el ultimo, volvemos al primero
                VDP_setHorizontalScrollLine (VDP_PLAN_B, lineaY,&desplazamiento[i],32,1); //movemos el plano B, en el A esta el texto
                i++;
                for (wait=1;wait<=numwait;wait++) VDP_waitVSync(); //cuantas veces esperamos el vsync? (para hacerlo mas lento y ver algo)
                VDP_drawText("Numero de retrazos:", 1, 4);
                intToStr (numwait,texto,3);
                VDP_drawText(texto, 20, 4);
            }
    	}
        return (0);
    }
    Con las direcciones derecha e izquierda del pad, controlas la velocidad de la "animacion", añadiendo o quitando esperas al retrazado vertical.

    EDIT: Enlace a la rom por si alguien lo quiere probar.
    https://mega.co.nz/#!TEtTEAJQ!-lC_AL...cIUqy0CNWMRsas

    -----Actualizado-----

    Me acabo de dar cuenta de un pequeño error releyendo el codigo, los tiles siempre se iban a ver desplazados un pixel a la derecha porque el "i++;" deberia ir despues de dibujarlos y no antes, si no, el valor minimo de i a la hora de dibujar va a ser 1 y no 0.
    Solucionado, he puesto el incremento de i justo despues de dibujar el efecto.

    -----Actualizado-----

    Sobe el tema de los mapas, si los planos son de 512x512, como habria que hacerlo para meter un mapa mas grande que eso digamos en horizontal? desplazando el mapa una linea vertical de tiles y añadiendo la siguiente linea vertical de tiles al final?
    Última edición por K-teto; 30/04/2014 a las 06:09

  10. #10

    Fecha de ingreso
    Oct 2012
    Mensajes
    211
    Mencionado
    1 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    4
    Agradecer Thanks Received 
    115
    Thanked in
    Agradecido 39 veces en [ARG:2 UNDEFINED] posts
    Cita Iniciado por K-teto Ver mensaje

    Sobe el tema de los mapas, si los planos son de 512x512, como habria que hacerlo para meter un mapa mas grande que eso digamos en horizontal? desplazando el mapa una linea vertical de tiles y añadiendo la siguiente linea vertical de tiles al final?
    No tengo ni idea, segun stef, para hacer mapas estilo sonic, hay que usar trozos grandes de pantalla y los vas metiendo uno detras del otro. Una vez vi los niveles del sonic que alguien había ripeado, y cada parte era grande, por ejemplo el looping era un "tile", un trozo de suelo con 3 palmeras era otro mega-tile. y luego los ordena en una matriz.

  11. #11

    Fecha de ingreso
    Jun 2004
    Mensajes
    12,354
    Mencionado
    41 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    667
    Agradecer Thanks Received 
    665
    Thanked in
    Agradecido 437 veces en [ARG:2 UNDEFINED] posts
    Entradas de blog
    17
    Habra que mirar documentacion y el trabajo de otros para saber como va el tema.
    Porque no se si el sgdk ya viene preparado para manejar mapas de tiles grandes.

    Alguien conoce el super hydlide? un rpg temprano de megadrive, te movias de pantalla en pantalla, cuando llegabas al borde de una pantalla, hacia un scroll a la siguiente y asi.
    Me recuerda a este problema XDD

    Por cierto, uno de mis juegos favoritos, y su banda sonora me encanta.
    Última edición por K-teto; 30/04/2014 a las 16:55

  12. #12

    Fecha de ingreso
    Dec 2003
    Ubicación
    Tarragona
    Mensajes
    1,510
    Mencionado
    44 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    0
    Agradecer Thanks Received 
    33
    Thanked in
    Agradecido 12 veces en [ARG:2 UNDEFINED] posts
    Cita Iniciado por K-teto Ver mensaje
    Sobe el tema de los mapas, si los planos son de 512x512, como habria que hacerlo para meter un mapa mas grande que eso digamos en horizontal? desplazando el mapa una linea vertical de tiles y añadiendo la siguiente linea vertical de tiles al final?
    Creo que los 2 planos son para hacer el efecto paralax o rellenar el fondo y que lo que son los tiles de escenario realmente es en la capa de sprite y se dibujarían haciendo como el "frustum culling" de los motores 3D pero con los tiles... seria dividir el escenario en porciones grandes y depende de donde se encuentre el personaje dibujarías solo las porciones que quedan dentro de la pantalla ahorrando tener que rastrear todo el escenario completo y así ahorrar tiempo de proceso.

    Juraria que había un emulador en el que podías desactivar los planos pero ahora no me acuerdo del nombre, si cargamos el sonic podríamos ver en que plano se carga el escenario... juraría que es en el de sprites.


    Un saludo!

    Lo retiro, acabo de mirarlo con el emulador y el escenario esta en el plano A y el fondo en el plano B, ademas cada plano se divide en 2: low e high, el low dibuja los tiles por debajo de los sprites y el high por encima de los sprites...

    Pues viendo esto debe ser algo como lo que dice K-teto...
    Última edición por ArChEr; 30/04/2014 a las 18:40
    Que no se vea no significa que no exista!

  13. #13

    Fecha de ingreso
    Oct 2012
    Mensajes
    211
    Mencionado
    1 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    4
    Agradecer Thanks Received 
    115
    Thanked in
    Agradecido 39 veces en [ARG:2 UNDEFINED] posts
    Cita Iniciado por ArChEr Ver mensaje
    Lo retiro, acabo de mirarlo con el emulador y el escenario esta en el plano A y el fondo en el plano B, ademas cada plano se divide en 2: low e high, el low dibuja los tiles por debajo de los sprites y el high por encima de los sprites...

    Pues viendo esto debe ser algo como lo que dice K-teto...
    El plano A es el más cercano, está por defecto sobre el plano B. Pero puedes cambiar la prioridad de tiles o de trozos completos del plano B para que estén encima del A.

    Los dos planos tienen transparencia, el color transparente es el mas "oscuro" de la paleta, Pero si no hay nada debajo y la zona tiene prioridad cero, se supone que se ve el color. no lo he probado...
    Si dos zonas tienen la misma prioridad, se respeta el orden por defecto, esprites sobre pano B y plano B sobre plano A

    En el juego del minigolf he hecho el plano A con prioridad 1, el B 0 y los esprites 0. De esta forma los esprites se ven encima del plano B y debajo de las partes no transparentes del plano A.


    La prioridad es e valor que va detras de PAL
    Código:
        //PLANOS
        ind = TILE_USERINDEX;
        VDP_drawImageEx(BPLAN, &FONDO, TILE_ATTR_FULL(PAL0,0,0,0,ind),0,0,0,1);
        ind += bkg.tileset->numTile;	
        VDP_drawImageEx(APLAN, &SOBRE_FONDO, TILE_ATTR_FULL(PAL1,1,0,0,ind),0,0,0,1);
        ind += Title.tileset->numTile;
       
        OBJETOS
        SPR_initSprite(&objects[0], &sprite0, fix16ToInt(posx), fix16ToInt(posy), TILE_ATTR(PAL2,1,0,0)); un puntero sobre todos los demas
        SPR_initSprite(&objects[1], &sprite1, fix16ToInt(posx), fix16ToInt(posy), TILE_ATTR(PAL2,0,0,0)); un objeto, sobre el plano B y bajo el plano A
    Última edición por mills332; 01/05/2014 a las 16:31

  14. #14

    Fecha de ingreso
    Oct 2012
    Mensajes
    211
    Mencionado
    1 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    4
    Agradecer Thanks Received 
    115
    Thanked in
    Agradecido 39 veces en [ARG:2 UNDEFINED] posts

    Colisiones.

    Trabajando en el juego de minigolf he conseguido detectar bordes para las colisiones.

    Definimos una pared inclinada mediante las coordenadas de una recta con 97 puntos:

    Código:
    u16 B1x[97] = 
    {
    0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,
    21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
    41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96
    }; 
    u16 B1y[97] =
    {
    38,38,37,37,37,36,36,35,35,35,34,34,33,33,33,32,32,31,31,31,
    30,30,29,29,29,28,28,27,27,27,26,26,25,25,25,24,24,23,23,23,
    22,22,21,21,21,20,20,19,19,19,18,18,17,17,17,16,16,15,15,15,
    14,14,13,13,13,12,12,11,11,11,10,10,9,9,9,8,8,7,7,7,6,6,5,5,
    5,4,4,3,3,3,2,2,1,1,1,0,0
    };
    Definimos un punto dentro de la recta, un valor de 0 a 97 de los de arriba:

    Código:
    u16 Col_Point;
    Ahora dentro del while, metemos un for, que va chequeando en cada frame, si la posicion de la bola coincide con alguno de los 97 pares x,y.

    Código:
    		  
    while(1){
    
      for (Col_Point = 0; Col_Point < 98; Col_Point++ )
      {
        if ((posx == B1x[Col_Point])  && (posy == B1y[Col_Point]))
             {
             //aqui activamos alguna variable que indique colision y la usamos para otras cosas fuera del for.
             }
      }
    
    }
    Para que detecte mejor la colisión, hay que chequear si las coordenadas de la bola entran dentro de un intervalo de los valores de la recta +4 y -4 pixeles. Por que si la bola va muy rápido, se puede saltar la coordenada sin rebotar.

    Luego está el tema de calcular vectores que no tengo ni idea, esta formula se supone que lo hace, pero no entiendo como sacar la x y la y del vector resultante.


    V = Vector entrante
    V = (vx, vy)
    N = Vector Normal de la pared (vector unitario)
    N = (nx, ny).

    VectorRebote = -2*(V * N)*N + V

    V * N = v.x*n.x+v.y*n.y.
    N + V = nx + vx , ny + vy}

    calcular vector unitario N partir de M: N = M/ Raiz de (M * M)

    A ver si alguien lo pilla mejor que yo. Seguiré intentándolo.
    Última edición por mills332; 19/05/2014 a las 17:43

  15. #15

    Fecha de ingreso
    Sep 2006
    Ubicación
    Malaga
    Mensajes
    6,303
    Mencionado
    37 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    1,097
    Agradecer Thanks Received 
    1,158
    Thanked in
    Agradecido 805 veces en [ARG:2 UNDEFINED] posts
    Es mejor que hagas las colisiones por geometría y no mirando un mapa de bits/bytes para ver si hay colisión. Ademas así de un tirón resuelves las colisiones con paredes en cualquier dirección.
    No es lo mismo tener diez años de experiencia, que tener un año de experiencia diez veces.

Página 1 de 3 123 ÚltimoÚltimo

Permisos de publicación

  • No puedes crear nuevos temas
  • No puedes responder temas
  • No puedes subir archivos adjuntos
  • No puedes editar tus mensajes
  •