Creare un gioco isometrico
markzn
come sviluppare l'aspetto grafico di profondità, cioè ad esempio, fare in
modo che un omino venga disegnato dietro un albero rispettandone il
contorno.
Più precisamente l'albero c'è già (fa parte dello sfondo) e l'omino che si
muove deve passargli dietro.
Sto programmando con Visual c++ 6.0 e directX 8.1
Grazie Matteo
XPress
capire
> come sviluppare l'aspetto grafico di profondità, cioè ad esempio, fare in
> modo che un omino venga disegnato dietro un albero rispettandone il
> contorno.
> Più precisamente l'albero c'è già (fa parte dello sfondo) e l'omino che si
> muove deve passargli dietro.
Putroppo questo è quel particolare che rende i giochi in isometrica più
difficili da programmare di quello che si pensa. Bisogna costruire un engine
proprio per rispettare l'aspetto di profondità di cui parlavi, in base alle
esigenze del gioco che hai in mente di fare. Se i tiles hanno una dimensione
fissa, allora puoi disegnarli dal più lontano al più vicino secondo
l'osservatore virtuale del tipo di isometrica che stai usando. Pensa
all'isometrica come ad un 3D senza prospettiva, dove XScreenTile =
(tile->posizione->x) - (tile->posizione->z) e YScreenTile =
(tile->posizione->x + tile->posizione->z) - tile->posizione->y. Disegna
inoltre i tiles secondo questo ordine, mostrato da seguente pseudo codice:
for (y = 0 to NYtiles)
for (z = 0 to NZtiles)
for (x = 0 to NXtiles)
DisegnaTile(Tiles[n])
n++
next x
next z
next y
Altri sistemi possono essere: controllare la priorità di disegno di ogni
tile rispetto a tutti gli altri che si trovano alle sue spalle, oppure fare
distinzione fra muri, pavimenti e personaggi per aumentare la precisione. Ci
sono parecchi sistemi e dei buoni tutorials al riguardo sparsi per internet.
> Sto programmando con Visual c++ 6.0 e directX 8.1
Usare il c++ non fa che avvantaggiarti, puoi anche costruire un'algoritmo
che inglobba i vari tiles in dei bounding box e fare lo z-buffer
dell'ambiente, così non avresti problemi di priorità. Scegli fra i vari
metodi che sono stati scoperti oppure scoprine altri tu, l'importante è
usare il sistema più adatto per le proprie esigenze.
Ciao!
Marco Tenca
Io ho risolto cosi:
Faccio lo scan dei tiles partendo dal piu lontano al piu vicino. I tile
hanno una proprieta "occupato" che indica il numero di sprite che occupa il
tile. Quindi quando controllo i tile se
tile[x, y].occupato > 0
allora faccio il blitting dello
sprite[tile[x,y].occupato].
In questo modo lo sprite piu vicino coprira quello piu lontano.
spero di essermi spiegato.
ciao
markzn
"Marco Tenca" <sa...@free.fr> ha scritto nel messaggio
> Io ho risolto cosi:
> Faccio lo scan dei tiles partendo dal piu lontano al piu vicino. I tile
> hanno una proprieta "occupato" che indica il numero di sprite che occupa
il
> tile. Quindi quando controllo i tile se
> tile[x, y].occupato > 0
> allora faccio il blitting dello
> sprite[tile[x,y].occupato].
> In questo modo lo sprite piu vicino coprira quello piu lontano.
> spero di essermi spiegato.
> ciao
>
Credo di aver capito.
Una volta disegnato lo sfondo con le tile, disegni sopra gli sprite di
animazione (modificando quindi la proprietà occupato) e per i tile occupati
ridisegni sopra gli sprite, in modo da dare il senso di profondità.
Grazie mi hai indicato una buona strada.
Ciao Matteo
markzn
"XPress" <n...@spam.it> ha scritto nel messaggio
news:E1Oc9.53059$pX1.1...@news2.tin.it...
> Usare il c++ non fa che avvantaggiarti, puoi anche costruire un'algoritmo
> che inglobba i vari tiles in dei bounding box e fare lo z-buffer
> dell'ambiente, così non avresti problemi di priorità. Scegli fra i vari
> metodi che sono stati scoperti oppure scoprine altri tu, l'importante è
> usare il sistema più adatto per le proprie esigenze.
> Ciao!
Ciao, il problema principale è che non avevo ben capito come lavorare con le
mappa. Disegnavo lo sfondo tutte le volte partendo dalla mappa 2D che
memorizza la posizione degli oggetti. Ma ho ora capito che una cosa è la
posizione degli oggetti, e un'altra cosa è la griglia di tile generata. Cioè
per me era molto difficile capire quale oggetto ricopriva (per via
dell'altezza) altri tile. Ora invece ho pensato di creare un'altra griglia
(ricavata da quella 2D) che indica i tile da disegnare rispetto allo
schermo, in modo da capire quando disegno lo sprite, se quella tile ha
precedenza sullo sprite. (Prima era qualcosa del tipo oggetto = tile)
Puoi darmi qualche dritta in più rispetto al z-buffer ? Ho cercato un pò su
internet ma non ho trovato un modo per implementarlo. Volevo capire se si
adatta al mio caso, dato che la mappa dovrebbe modificarsi durante il gioco
(una specie di gestionale).
Grazie Matteo
XPress
su
> internet ma non ho trovato un modo per implementarlo. Volevo capire se si
> adatta al mio caso, dato che la mappa dovrebbe modificarsi durante il
gioco
> (una specie di gestionale).
E' un sistema un pò complicato che implica l'utilizzo almeno di una scheda
grafica accelerata. Consiste nel considerare i Tiles come textures da
applicare ad un cubo o parallelepipedo, in modo da ottenere una naturale
sovrapposizione dei vari oggetti senza considerare strani valori di priorità
o cose del genere. E' molto importante inoltre che i cubi vengano disegnati
non in prospettiva, ma in 3D con una inclinazione equivalente a quella dei
tiles. Un'altro metodo valido è suddividere la mappa 2D di cui già disponi
in poligoni, per esempio l'albero di cui parlavi prima, per fare in modo che
i player, dei poligoni a loro volta, ci passino avanti o dietro, in base
alla loro posizione. Un sistema simile è stato usato su Zelda 64, per
disegnare correttamente oggetti trisimensionali all'interno di stanze
bidimensionali (pre-renderizzate). In ogni caso questi sono sistemi che
implicano una conoscenza di base di grafica tridimensionale e l'utilizzo di
validi driver per la grafica (opengl), se disponi di questi mezzi okey, se
no ti consiglio di rivolgerti al comune 2D, che ti permette di usare sistemi
molto più classici trattati da molti più tutorials.
Fai tu, ciao!
markzn
> In ogni caso questi sono sistemi che
> implicano una conoscenza di base di grafica tridimensionale e l'utilizzo
di
> validi driver per la grafica (opengl), se disponi di questi mezzi okey, se
> no ti consiglio di rivolgerti al comune 2D, che ti permette di usare
sistemi
> molto più classici trattati da molti più tutorials.
> Fai tu, ciao!
>
Per il gioco che stò sviluppando mi sembra infatti eccessivo, sopratutto
visto che una parte del motore grafico funziona già.(Dovrei rivoluzionare il
tutto)
Cmq. grazie alle tue spiegazioni penso di essere sulla strada giusta.
Ciao Matteo