Primeros pasos con proyeccion isometrica

[vib]

HOla buenas de nuevo!
Estoy haciendo un proyecto de la universidad que trata sobre un juego con vista isometrica
La duda es que es la primera vez que me meto con vista isometrica y llevo 1 semana dandome cabezazos sin avanzar.

El juego no se va a imprimir tile por tile, si no que tenemos creada una imagen dibujada con todo el suelo, otra con las paredes y asi...
La duda es que como puedo identificar en que posicion de una matriz, esta el personaje...si la matriz la he de tratar de forma isometrica?

Viendo esta imagen:
http://subefotos.com/ver/?bdce191daefab20f98ec317c6254fbe3o.jpg

como identifico que voy a una casilla u otra?
Me esta volviendo loco...el tamaño de cada casilla sera multiple de 2...por ejemplo 120x 60y de tamaño..
Me he mirado varios tutoriales pero nose..no me aclaro.. mil gracias!

[Darago_malaga]

A ver si esta web t puede ayudar. Si no lo dices y te lo intento explicar yo.
http://clintbellanger.net/articles/isometric_math/

[vib]

a la perfección me ha ido..el problema me lo ha solventado..llevo rato haciendo pruebas sobre papel y lo he comprendido
gracias!
Aunque ahora me ha surgido una pequeña duda del mismo tema...
El problema es que a mi me pasaran una imagen, que sera el suelo por ejemplo...una imagen pongamos que 2,000x2,000
y de esa imagen voy a tener de crear la matriz para que luego pueda trabajar con ella de forma isometrica no?

El problema es como puedo hacerla?  La identifico como matriz normal? osea...la celda 0,0 es la parte de la imagen mas a la izquierda y arriba posible? y así quedándome una matriz normal..y con ella puedo usarla para la parte isometrica? o se hace diferente?

Porque claro..luego en forma isometrica la celda 0.0 queda rotada no? y todo se cambiaria?

No se si se entiende sino intentare ser mas gráfico con un dibujo..
Gracias

PD: http://coobird.net/img/tile-map.png
Seria esto lo que me refiero..pero..el dibujo previamente tiene unas dimensiones cuadradas o esta ya rotado como la imagen..

[Darago_malaga]

Por lo que entiendo te pasan un dibujo del suelo que evidentemente es rectangular, pero en du interior esta dibujada la forma del suelo que tendra forma de rombo (si el terreno es cuadrado). La posicion 0,0 corespondera a la esquina supetior de ese rombo. Y a partir de ese punto tendras que ir definiendo el resto de celdas de la matriz para definir por ejemplo, los obstaculos.

Basicamente como se miestra en ese segundo dibujo.

[vib]

si.. ya he hablado con el grafista y usaremos esa metologia..a ver como sale sino lo comento
gracias por tu atencion :D

[vib]

haciendo calculos..me surgieron una serie de dudas...
viendo la web que me pasaste...
la formula para determinar la posicion de pantalla sabiendo la celda de la matriz es:
screen.x = (map.x - map.y) * TILE_WIDTH_HALF;
screen.y = (map.x + map.y) * TILE_HEIGHT_HALF;

bien...si la celda "osea map.x -map.y" es 0-0 con esta formula....la posicion en pantalla tambien es 0-0 cuando
esa celda queda en el centro de la pantalla arriba...

Entonces...como lo hago para saber esa posicion? porque estaba haciendo el algoritmo..y me surgio esa duda :S
grcias!

[Hechelion]

El pixel (0,0) es la esquina superior izquierda del tile (0,0).
Para la representación usada en la página que te dieron (hay otras formas de hacerlo también, esa no es la única) vas a tener tile que estarán en posiciones negativas. Por ejemplo, el tile (0,1) tendrá coordenada (-64,32). Si usas esos mismos valores sobre la pantalla, significa que ese tile no se dibujara de forma completa, básicamente, por que la representación de diamente que estás usando posiciona el punto 0 del sistema de referencia a mitad del mapa y no en la esquina izquierda como ocurre con un mapa de tiles cuadrados.

Lo más fácil, es que agregues un offset para correr el sistema de referencia y poder centrar el mapa
screen.x = (map.x - map.y) * TILE_WIDTH_HALF + offset.x;
screen.y = (map.x + map.y) * TILE_HEIGHT_HALF + offset.y;

De esa forma, si quieres que el mapa te quede en la mitad de la pantalla simplemente haces
offset.x = scree.weight/2

[Darago_malaga]

Bueno como yo tampoco entiendo esas operaciones muy bien vamos a hacer un poco de números.

Lo primero es determinar el tamaño de la pantalla, vamos a suponer que usamos la estándar 640x480.

Vamos a determinar el punto en la pantalla donde esta situada la celda [0,0] es ese punto que mencionas que esta en el centro de la pantalla arriba.

TILE_ZERO_POS_X=320;
TILE_ZERO_POS_Y=450; //a 30 pixeles del borde superior.

Tenemos definido el alto y ancho de los TILES, aunque esto no es necesario ya que en isometrico el ancho es el doble del alto. Son las constantes TILE_WIDTH_HALF y TILE_HEIGHT_HALF (en realidad para los calculos necesitamos la mitad) supongamos que son tiles de 128x64. Por lo tanto:
TILE_WIDTH_HALF=64;
TILE_HEIGHT_HALF=32;

Supongamos que como bien dices quieres averiguar la posicion en pantalla de la celda [0,0]

screen.x = TILE_ZERO_POS_X + (map.x - map.y) * TILE_WIDTH_HALF;
screen.y = TILE_ZERO_POS_Y - (map.x + map.y) * TILE_HEIGHT_HALF;

Sustituyendo:

screen.x = 320 + (0-0) * 64;
screen.y = 450 - (0+0) * 32;

Da como resultado

screen.x =320;
screen.y= 450;

Esto es la esquina superior central del Tile. Si queremos obtener el punto central de Tile a la posición "y" le restamos media altura del Tile, es decir 32. Ya q esta un poco mas bajo.

Vamos a obtener la posición en pantalla de la celda [0,2]

Si sustituimos en la formula:

screen.x = 320 + (0-2) * 64 = 320 - 128 = 192
screen.y = 450 - (0+2) * 32 = 450 - 64 = 386  // restar otros 32 si queremos el centro en vez de la esquina superior

Vamos a calcular otra mas [2,1]

screen.x = 320 + (2-1) * 64 = 320 + 64 = 384
screen.y = 450 - (2+1) * 32 = 450 - 96 = 354 // restar otros 32 si queremos el centro en vez de la esquina superior


Bueno....esto parece que va bien. Vamos a calcular el paso contrario. Dada una posicion en pantalla queremos averiguar que celda ocupamos. Muy util si queremos averiguar si colisionamos con algo.

Imaginemos que tenemos un personaje en las coordenadas de pantalla de pantalla [320,440] que casualmente sabemos que esta 10 pixeles por debajo del punto cero de la matriz.

Con las formulas:

map.x = ((screen.x - TILE_ZERO_POS_X) / TILE_WIDTH_HALF + (TILE_ZERO_POS_Y- screen.y) / TILE_HEIGHT_HALF) /2;
map.y = ((TILE_ZERO_POS_Y - screen.y ) / TILE_HEIGHT_HALF -((screen.x- TILE_ZERO_POS_X) / TILE_WIDTH_HALF)) /2;

Vamos a sustituir números:
map.x =((320 - 320) / 64 + ( 450 - 440) / 32) / 2 = ((0)/64 + (10)/32)/2 = 0,15625 // nos quedamos con la parte entera = 0
map.y =((450 - 440)/32-((320-320)/64))/2 = ((10)/32-((0)/64))/2 = 0,15625 = 0;

Correcto, dejamos solo la parte entera y nos dice que estamos en la celda [0,0]

Vamos a suponer que estamos en la posición de pantalla [ 380, 300]

map.x =((380 - 320) / 64 + ( 450 - 300) / 32) / 2 = 2.8125
map.y =((450 - 300)/32-((380-320)/64))/2 = 1.875

por lo que estamos en la posición [2,1]


Bueno pues esto es mas o menos todo....me he perdido La Que Se Avecina...pero estoy contento.

[vib]

Gracias a ambos!
Realmente no se me había ocurrido la idea de guardar las posiciones de pantalla respecto al punto 0,0 y luego jugar condicionado con eso.
Enserio mil gracias!
Lamento que te ayas perdido la que se avecina..pero siempre puedes ver el capitulo por internet y sin anuncios! jajaj

Bueno voy a ir haciendo pruebas a ver como va quedando..cualquier cosas lo dire!
repito mil gracias!