¿Qué tipo de números son éstos?

[Haohmaru]

Es sencillo, lo que pasa es que me he explicado como el culo xD Si saco algo de tiempo pondré algún ejemplo.

Pues muchísimas gracias Segata es todo un detalle

[swapd0]

Por ejemplo, cogiendo el byte 3 del primer tile que pones (el "02" de "0x02aa"), en binario es: 0000 0010, lo cual representa 4 píxeles con los colores 0, 0, 0 y 1 de la paleta.

Has metido la pata, es el color 2 de la paleta.

0x02aa = %00 00 00 10 10 10 10 10 -> color 0 0 0 2 2 2 2, estos colores se usan como un indice entro de la paleta asociada al tile (la que pones con SetColors)

[Segata Sanshiro]

Si lo que pone en el documento técnico es correcto (no es un documento oficial), el orden de los bits está invertido dentro de cada pareja de bits, así que 10 sería el color 1 y no el 2.

En cualquier caso esto solo influye a la hora de asignar los valores RGB definitivos, no a la forma del dibujo.

[Haohmaru]

La verdad es que esto se me está volviendo un poco pesado, me pierdo en ciertos aspectos.

Si no he entendido mal, se supone que esto sería algo así en pasos (por decirlo de alguna manera):

Tile >> Obtención de valores hexadecimales >> Transformación de valor Hexadecimal a Hexadecima lde 16 bits

Entiendo que, de alguna manera que ya intentaré averiguar como, se obtiene los bytes del Tile, y de ésto, se obtiene su valor hexadecimal, posteriormente, se transforman a dígitos hexadecimales de 16 bits ¿Estoy equivocado?

[swapd0]

Si tienes acceso a la memoria donde estan los tiles, si en vez de acceder a ellos por un puntero a byte(char en C) usas un puntero a short ya lo tienes hecho, despues haces un fprintf(out, "%04x", *ptr) y ya esta. Donde ptr es el puntero a la memoria de los tiles.

[Haohmaru]

Si tienes acceso a la memoria donde estan los tiles, si en vez de acceder a ellos por un puntero a byte(char en C) usas un puntero a short ya lo tienes hecho, despues haces un fprintf(out, "%04x", *ptr) y ya esta. Donde ptr es el puntero a la memoria de los tiles.

Me perdí por completo. Creo que lo que explicas es el proceso contrario de lo que quiero hacer. Mi fin es el siguiente:

El programa para crear Tiles es una auténtica caca, pero, es el único que hay. Lo que pretendo es saber que proceso o como haría el proceso para convertir los tiles que le paso a un fichero con extención .c, con el sistema numérico que puse en el primer post.

[Segata Sanshiro]

Lo que dice swapd0 te sirve para cuando tengas cargados los tiles ya en memoria, y seguramente sea la forma más rápida de hacerlo una vez los tengas ya cargados.

Para ir un poco por partes, una de las muchas formas de hacerlo sería:

- Dibujar el tile en GIMP, Photoshop, etc. y guardarlo en un formato que sea muy sencillo de leer, como por ejemplo PGM. Asegúrate de que el programa te deja elegir guardarlo en formato PGM "ASCII", para facilitar las cosas. Aquí tienes los detalles del formato PGM: http://paulbourke.net/dataformats/ppm/
- Crear una utilidad en C, Java, etc. que lea el fichero PGM y escriba un fichero .c (o al menos un fichero de texto con el array en el formato de C, para copiarlo y pegarlo en tu código).

Para ir probando, puedes hacer un dibujo de 16x16 en escala de grises, guardarlo en PGM, y abrirlo con un editor de texto, para ver cómo es. Aquí tienes detallado el formato. Básicamente te encontrarás:

- Una línea con la cabecera "P2"
- Opcionalmente, una línea con un comentario introducido por el editor gráfico que hayas usado
- Una línea con dos números separados por un espacio, que son las dimensiones del gráfico
- Una línea que dice el valor máximo que puede tomar cada píxel. Seguramente sea 255 o 15 o algo así, donde 255 es blanco y 0 es negro. Realmente solo necesitamos 4 tonos de gris, si consigues configurar tu editor gráfico para que trabaje directamente a 4 tonos de gris mejor (en ese caso en esta línea pondrá un "3"). Más tarde asignarás en tu programa la paleta con los valores RGB que quieras.
- Un montón de líneas, ya con los valores de cada píxel. Asegúrate de que lo has pintado de forma que solo aparezcan valores de 0 a 3 en estas líneas.

La utilidad que crees debe ir leyendo esas últimas líneas (las de los valores de los píxeles), por ejemplo con la función readLine de un BufferedReader en Java. Debes tomar las líneas de ocho en ocho y "empaquetarlas" en variables 16 bits (esto es lo que hay que hacer con cuidado para que quede bien xD), y luego usar alguna función (dechex, printf...) que imprima dichas variables en formato 0xABCD.

Seguramente haya formas más sencillas y rápidas pero es lo primero que se me ha ocurrido xD Aunque no quede claro del todo, ¿sabes al menos ya por dónde empezar?.

[Haohmaru]

Pues la verdad es que no lo tengo nada claro. Lo que comenta swapd0 sigo sin entender el sentido de para que usarlo.

La parte que me explicas para trabajar con la imagen pues, si no me queda otra que eso lo mirare con profundidad porque asi con unas líneas no es fácil de entender, aunque gracias.

He encontrado un conversor de tiles de GB a NGP, el conversor no me funciona no hace un carajo pero, trae consigo un fichero .c donde hay métodos y tal. He intentado comprender un poco lo que hace pero creo que faltan ficheros, ya que los include no están en el directorio

A ver si alguno tiene ganas y le hecha un ojete"

[Circunstante]

Los primeros son octillizos, los siguientes tienen pinta de ser gemelos de distintos padres, y hay uno que a mi me da que es un primo. Lo que esta claro es que son todos de origen persa con rasgos latinos.
Santo cielo, ¡qué pregunta!

[swapd0]

Te comento la primera funcion

// gameboy to neogeo pocket// fpi fichero de entrada
// fpo fichero de salida
// filesize ... pues el tamaño de entrada
void gb2ngp (FILE *fpi, FILE *fpo, int filesize)
{
   int i, j, c1, c2;
unsignedint val;
   int clr;


   for (i=0; i < filesize; i+=2)
   {
// handle 2 bytes at a time
      c1 = getc(fpi);	// byte alto de la palabra de 16bits
      c2 = getc(fpi);	// byte bajo
      val = 0;			// valor de salida


// parace que la gameboy tiene los colores entrelazados o por planos
// 8 pixels = 2 bytes
// byte alto byte bajo
// 01234567   01234567
// ||         ||
// |--------- |-- color del segundo pixel
// |          |
// -------------- color del primer pixel
	   for (j=0; j<8; j++)
	   {
// miro el bit mas alto de cada byte y lo convierto a un valor
// "empaquetado" con los bits contiguos
		   if (c1 & 0x80) clr=1; else clr=0;
		   if (c2 & 0x80) clr+=2;


// desplazo el valor de salida hacia la izquierda y le añado el
// valor del color "empaquetado"
// yo lo veo mas claro asi val = (val << 2) | clr;
		   val <<= 2;
		   val +=clr;


// desplazo los bytes de entrada un pixel/bit hacia la izquierda
		   c1 <<= 1;
		   c2 <<= 1;
      }


// guardo el valor generado
	   putc(val & 0xff, fpo);	// parte alta
      putc(val >> 8, fpo);		// parte baja


   }
}

-----Actualizado-----

Te comento la primera funcion

// gameboy to neogeo pocket// fpi fichero de entrada
// fpo fichero de salida
// filesize ... pues el tamaño de entrada
void gb2ngp (FILE *fpi, FILE *fpo, int filesize)
{
   int i, j, c1, c2;
unsignedint val;
   int clr;


   for (i=0; i < filesize; i+=2)
   {
// handle 2 bytes at a time
      c1 = getc(fpi);	// byte alto de la palabra de 16bits
      c2 = getc(fpi);	// byte bajo
      val = 0;			// valor de salida


// parace que la gameboy tiene los colores entrelazados o por planos
// 8 pixels = 2 bytes
// byte alto byte bajo
// 01234567   01234567
// ||         ||
// |--------- |-- color del segundo pixel
// |          |
// -------------- color del primer pixel
	   for (j=0; j<8; j++)
	   {
// miro el bit mas alto de cada byte y lo convierto a un valor
// "empaquetado" con los bits contiguos
		   if (c1 & 0x80) clr=1; else clr=0;
		   if (c2 & 0x80) clr+=2;


// desplazo el valor de salida hacia la izquierda y le añado el
// valor del color "empaquetado"
// yo lo veo mas claro asi val = (val << 2) | clr;
		   val <<= 2;
		   val +=clr;


// desplazo los bytes de entrada un pixel/bit hacia la izquierda
		   c1 <<= 1;
		   c2 <<= 1;
      }


// guardo el valor generado
	   putc(val & 0xff, fpo);	// parte alta
      putc(val >> 8, fpo);		// parte baja


   }
}

-----Actualizado-----

// neogeo pocket to gameboy
void ngp2gb (FILE *fpi,
             FILE *fpo,
             int filesize)
   {
   int i, j, c1, c2;
   unsigned int val = 0;
   int clr;
   int out1;
   int out2;


   for (i=0; i < filesize; i+=2)
   {
// leo 2 bytes y los uno en un entero de 16 bits (ok la variable es de 32 pero no importa)
      c1 = getc(fpi);
      c2 = getc(fpi);
      val = ((c2 & 0xff) <<8) + (c1 & 0xff);


// inicializo la salida a 0
	  out1 = 0;
      out2 = 0;


      for (j=0; j<8; j++)
      {
// me quedo con los 2 bits mas altos desplazandolos a la parte baja
// xx000000 00000000 -> 00000000 000000xx
         clr = val >> 14;


// desplazo los valores de entrada 2 bits hacia la izquierda para la siguente iteracion del bucle
		 val <<= 2;
// lo mismo pero con la salida, despues de esto el bit mas bajo de out1 y out2 estan a 0
         out1 <<= 1;
         out2 <<= 1;


// si el bit mas bajo esta a uno, pongo el bit mas bajo de out1 a uno
		 if (clr & 1) out1++;
// si el segundo bit mas bajo esta a uno, pongo el bit mas bajo de out2 a uno
         if (clr & 2) out2++;
// con esto he pasado he hecho lo siguiente, donde a y b representan un pixel con 4 posibles colores
// 00000000 000000ab -> 0000000b 0000000a
	  }


// vuelca los valores al fichero
	  putc(out1, fpo);
      putc(out2, fpo);
      }
   }

[juanvvc]

Otra opción es que hagas los gráficos en gimp (asegúrate que está en modo indexado y máximo 4 colores) y lo guardas como .h ó .c. Ahora haces un pequeño programita que transforme de los arrays de salida de Gimp al tipo que quiere la NGC. Este programita los gurús de C de aquí lo harán en medio minuto. Por ejemplo:

int main(int argc, char ** argv) {
  int i;
  int c=0;
  for(i=0; i<64; i++)  c += (i * 4 + header_data[i]);
  printf("0x%0x\n", c);
}

Y esto lo tienes que hacer para cada tile. Como ejemplo, con este programita este dibujo en Gimp



Dice que se codifica como 0x2011

(ahora toca saber exactamente qué bits son columnas y filas y colores, pero eso es solo retocar los números)

-----Actualizado-----

(Buf, me he liado mucho y no estoy nada seguro de lo que he dicho...)

[Haohmaru]

Te comento la primera funcion

// gameboy to neogeo pocket// fpi fichero de entrada
// fpo fichero de salida
// filesize ... pues el tamaño de entrada
void gb2ngp (FILE *fpi, FILE *fpo, int filesize)
{
   int i, j, c1, c2;
unsignedint val;
   int clr;


   for (i=0; i < filesize; i+=2)
   {
// handle 2 bytes at a time
      c1 = getc(fpi);	// byte alto de la palabra de 16bits
      c2 = getc(fpi);	// byte bajo
      val = 0;			// valor de salida


// parace que la gameboy tiene los colores entrelazados o por planos
// 8 pixels = 2 bytes
// byte alto byte bajo
// 01234567   01234567
// ||         ||
// |--------- |-- color del segundo pixel
// |          |
// -------------- color del primer pixel
	   for (j=0; j<8; j++)
	   {
// miro el bit mas alto de cada byte y lo convierto a un valor
// "empaquetado" con los bits contiguos
		   if (c1 & 0x80) clr=1; else clr=0;
		   if (c2 & 0x80) clr+=2;


// desplazo el valor de salida hacia la izquierda y le añado el
// valor del color "empaquetado"
// yo lo veo mas claro asi val = (val << 2) | clr;
		   val <<= 2;
		   val +=clr;


// desplazo los bytes de entrada un pixel/bit hacia la izquierda
		   c1 <<= 1;
		   c2 <<= 1;
      }


// guardo el valor generado
	   putc(val & 0xff, fpo);	// parte alta
      putc(val >> 8, fpo);		// parte baja


   }
}

-----Actualizado-----

Te comento la primera funcion

// gameboy to neogeo pocket// fpi fichero de entrada
// fpo fichero de salida
// filesize ... pues el tamaño de entrada
void gb2ngp (FILE *fpi, FILE *fpo, int filesize)
{
   int i, j, c1, c2;
unsignedint val;
   int clr;


   for (i=0; i < filesize; i+=2)
   {
// handle 2 bytes at a time
      c1 = getc(fpi);	// byte alto de la palabra de 16bits
      c2 = getc(fpi);	// byte bajo
      val = 0;			// valor de salida


// parace que la gameboy tiene los colores entrelazados o por planos
// 8 pixels = 2 bytes
// byte alto byte bajo
// 01234567   01234567
// ||         ||
// |--------- |-- color del segundo pixel
// |          |
// -------------- color del primer pixel
	   for (j=0; j<8; j++)
	   {
// miro el bit mas alto de cada byte y lo convierto a un valor
// "empaquetado" con los bits contiguos
		   if (c1 & 0x80) clr=1; else clr=0;
		   if (c2 & 0x80) clr+=2;


// desplazo el valor de salida hacia la izquierda y le añado el
// valor del color "empaquetado"
// yo lo veo mas claro asi val = (val << 2) | clr;
		   val <<= 2;
		   val +=clr;


// desplazo los bytes de entrada un pixel/bit hacia la izquierda
		   c1 <<= 1;
		   c2 <<= 1;
      }


// guardo el valor generado
	   putc(val & 0xff, fpo);	// parte alta
      putc(val >> 8, fpo);		// parte baja


   }
}

-----Actualizado-----

// neogeo pocket to gameboy
void ngp2gb (FILE *fpi,
             FILE *fpo,
             int filesize)
   {
   int i, j, c1, c2;
   unsigned int val = 0;
   int clr;
   int out1;
   int out2;


   for (i=0; i < filesize; i+=2)
   {
// leo 2 bytes y los uno en un entero de 16 bits (ok la variable es de 32 pero no importa)
      c1 = getc(fpi);
      c2 = getc(fpi);
      val = ((c2 & 0xff) <<8) + (c1 & 0xff);


// inicializo la salida a 0
	  out1 = 0;
      out2 = 0;


      for (j=0; j<8; j++)
      {
// me quedo con los 2 bits mas altos desplazandolos a la parte baja
// xx000000 00000000 -> 00000000 000000xx
         clr = val >> 14;


// desplazo los valores de entrada 2 bits hacia la izquierda para la siguente iteracion del bucle
		 val <<= 2;
// lo mismo pero con la salida, despues de esto el bit mas bajo de out1 y out2 estan a 0
         out1 <<= 1;
         out2 <<= 1;


// si el bit mas bajo esta a uno, pongo el bit mas bajo de out1 a uno
		 if (clr & 1) out1++;
// si el segundo bit mas bajo esta a uno, pongo el bit mas bajo de out2 a uno
         if (clr & 2) out2++;
// con esto he pasado he hecho lo siguiente, donde a y b representan un pixel con 4 posibles colores
// 00000000 000000ab -> 0000000b 0000000a
	  }


// vuelca los valores al fichero
	  putc(out1, fpo);
      putc(out2, fpo);
      }
   }

Voy a hecharle un ojo a lo que has comentado, gracias por el esfuerzo!

Los primeros son octillizos, los siguientes tienen pinta de ser gemelos de distintos padres, y hay uno que a mi me da que es un primo. Lo que esta claro es que son todos de origen persa con rasgos latinos.
Santo cielo, ¡qué pregunta!

Ni caso te hago.

Otra opción es que hagas los gráficos en gimp (asegúrate que está en modo indexado y máximo 4 colores) y lo guardas como .h ó .c. Ahora haces un pequeño programita que transforme de los arrays de salida de Gimp al tipo que quiere la NGC. Este programita los gurús de C de aquí lo harán en medio minuto. Por ejemplo:

int main(int argc, char ** argv) {
  int i;
  int c=0;
  for(i=0; i<64; i++)  c += (i * 4 + header_data[i]);
  printf("0x%0x\n", c);
}

Y esto lo tienes que hacer para cada tile. Como ejemplo, con este programita este dibujo en Gimp



Dice que se codifica como 0x2011

(ahora toca saber exactamente qué bits son columnas y filas y colores, pero eso es solo retocar los números)

-----Actualizado-----

(Buf, me he liado mucho y no estoy nada seguro de lo que he dicho...)

Voy a mirar si con el gimp como comentas puedo hacer algo posterio para transformarlo.

La verdad es que todo ésto se me complica un poco, principalmente porque nunca he trabajado con bytes directamente o con transformación y utilización de bitmaps anivel de código y se me escapa un pelín todo ésto. Lo que estoy haciendo es volver loca a la gente y al mismo tiempo a mí, porque no se ni por donde empezar

Gracias a todos pos vuestras respuestas aclaratorias y positivas.

[swapd0]

Si no lo ves claro coge un papel cuadriculado y dibujas ahí el esquema de los bytes y palabras de 16bits y como se modifican con cada operacion. Es facil, en los libros de ensamblador (cualquiera) puedes mirar como va el manejo de operaciones con bits, cuando te acostumbres lo harás de cabeza.

[Haohmaru]

Seguro que si, empezaré por ahí entonces.

Gracias swapd0