Newsgroup: it.comp.java
Titolo: Un gioco piuttosto complicato (Java, grafica 2D)

Sto realizzando in Java un motore generico per videogiochi 2D (un maledetto
progetto
universitario), e proprio per il fatto di doverlo fare il più generico
possibile ho un brutto problema.
Dopo aver realizzato una serie di classi (caricamento e gestione dei dati
del gioco, lettura delle immagini degli sprite, caricamento di classi in
base al nome per rendere programmabile il comportamento degli oggetti del
gioco, ecc.), ora sono alle prese con il motore grafico vero e proprio.
Ecco una descrizione sommaria del programma:
- Nel gioco ci sono una serie di oggetti di tipo GameObject, ognuno dei
quali ha associato un'aspetto che può essere fisso oppure animato. Ogni
oggetto ha un metodo getImage() che ritorna il frame di animazione corrente,
e un metodo update() che aggiorna l'animazione. Per gli oggetti con aspetto
fisso, il metodo update() semplicemente non fa nulla.
- Ogni oggetto ha una dimensione e una posizione, ed è posizionato sulla
superficie di gioco.
- Ogni oggetto ha un metodo live() e nel costruttore riceve un oggetto che
implementi l'interfaccia Behaviour, che definisce il metodo live(). Quando
si chiama live() su un oggetto, questo non fa altro che chiamare live() sul
Behaviour a cui è associato.
- Il ciclo principale di gioco chiama live() e update() su tutti gli oggetti
e poi disegna la schermata del gioco su un Image. Il metodo paint() del
canvas del gioco prende l'immagine e la disegna a video (double buffering).
- La classe principale che gestisce il gioco è GameSurface, che definisce i
metodi
void placeobject(GameObject o);
void removeobject(GameObject o);
moveobject(GameObject o,int dir);
moveobject(GameObject o,int x,int y);
Image creategameimage();
I primi quattro metodi vengono utilizzati durante il movimento degli
oggetti, e alla fine del ciclo viene chiamato creategameimage() per produrre
l'immagine completa dello schermo.
Per velocizzare un po' le cose, internamente GameSurface utilizza un array
di interi per rappresentare i pixel dell'immagine, e opera su quelli; anche
le immagini degli oggetti sono rappresentate come array di int ottenuti con
un PixelGrabber a partire dalle bitmap fornite al programma; l'immagine
definitiva viene ottenuta con un MemoryImageSource.
Fin qui tutto chiaro (spero), ora iniziano i guai...
La gestione delle collisioni verrà implementata in modo totalmente
parametrico basato su classi da caricare dinamicamente, ma il problema
principale che ho è come gestire la sovrapposizione di oggetti: infatti devo
permettere che due o più oggetti possano sovrapporsi, se lo specifico gioco
realizzato lo consente; esempio: usando il programma per realizzare una
versione di PacMan, un fantasmino deve poter passare sopra una pillola senza
conseguenze, e la pillola dev'essere ancora lì quando il fantasmino se ne
va. Inoltre, se un PacMan tocca un pixel dove si trovano contemporaneamente
il fantasmino e la pillola, deve morire e non mangiare quest'ultima.
Per permettere tutto questo ho dato ad ogni oggetto un valore di priorità
che definisce cosa accade se due oggetti sono sovrapposti: l'oggetto che ha
priorità maggiore viene valutato per primo durante il controllo di
collisione, e viene invece disegnato per ultimo durante il refresh dello
schermo, in modo da essere effettivamente visualizzato.
I problemi principali sono due, strettamente legati fra di loro:
1) Quando un oggetto si sposta avviene il controllo di collisione. A questo
punto occorre risalire all'elenco di tutti gli oggetti che occupano quella
parte di schermo, e verificare l'esito della collisione con ciascuno di
questi in ordine di priorità decrescente.
2) Quando un oggetto si sposta occorre ridisegnare tutti gli oggetti
eventualmente presenti sull'area che la lasciato scoperta, e inoltre oggetti
che gli si sovrappongano ma abbiano priorità maggiore devono essergli
disegnati sopra.
Per risolvere il secondo problema sarebbe sufficiente ridisegnare tutti gli
oggetti ad ogni refresh, in ordine di priorità. Ma vorrei evitarlo, perché
buona parte degli oggetti non si muoveranno mai, essendo ostacoli fissi.
Potrei dare ad ogni oggetto un flag che stabilisce se dev'essere ridisegnato
al prossimo refresh, e quindi il problema si ricondurrebbe parzialmente al
primo: quando un oggetto si sovrappone ad un altro il flag verrebbe attivato
su entrambi; ma come rilevare quando la sorapposizione termina?
Per quanto riguarda il primo problema ho pensato ad alcune soluzioni, ma
tutte sono troppo pesanti e troppo lente.
Un ultimo dettaglio: non posso utilizzare una griglia per posizionare gli
oggetti, per due motivi: il movimento dev'essere libero da vincoli e gli
oggetti devono poter avere dimensioni variabili.
Credo di aver finito, a questo punto ogni consiglio è ben accetto :-)
Massimo

 wrote in message
news:9vj8k1$ch0$1...@newsreader1.mclink.it...


 
http://kazzuya.com/test/kazrace/
BELLISSIMO!!!! :-))
Aaaah, che bei tempi quando Out Run faceva spalancare le mascelle :-)
Ciao!
--
Alessandro Monopoli
----------------------------------------
Game Designer \ Lead Programmer dei Dreampainters
Membro dei Morningrise : 
www.morningrisegroup.com
--------------------------------------

 Massimo
ciao
Daniele

 sono accetti anche tuoi consigli...
Non era questo purtroppo il mio problema: a disegnare gli oggetti sullo
schermo ci arrivo :-) il problema è proprio nella gestione delle collisioni,
io voglio permettere che due o più oggetti possano essere sovrapposti (es.
il fantasmino sulla pillola), ma poi al momento di rilevare una collisione
devo scoprire *chi* occupa quella posizione... e non posso mica mettere un
Vector per ogni pixel che mi dica chi c'è lì sopra!
Massimo

 Aaaah, che bei tempi quando Out Run faceva spalancare le mascelle :-)
peccato che il Java non supporta MP3 o .mod (benche' ci siano librerie che
lo fanno).
Senza la musichella di Out Run non e' lo stesso..
baubau
Davide

Minchia che figata.
Non ho parole, sei un mito.
Ci sono dei siti dove studiare la teoria e la pratica relativa allo sviluppo
di piccoli giochio (2D) con particolare riguardo a Java?

 di piccoli giochio (2D) con particolare riguardo a Java?
Non ne so molto di tutorials ma non mi e' parso che il Java sia molto usato
per la grafica, benche' ci siano eccezioni come Anfy
(
http://www.anfyteam.com
) e altri democoders che hanno creato cose simili..
pero' non c'e' una vera e' propria comunita' pubblica di "java hackers"..
almeno non che io sappia.
AWT, la libreria grafica di base del Java, purtroppo diventa lenta come la
morte con gli sprites sia su IE che su Netscape.
Come al solito la Sun ha perso tempo creando la nuova API grafica per Java
2.0 che nessuno usera' mai. Avrebbe fatto prima a spiegare come usare il
Java a basso livello.
Direi che una volta che hai il tuo bel buffer grafico a 32bit colore puoi
fare quello che vuoi un po' come si faceva con la VGA. Quindi in questo caso
torna piu' utile conoscere concetti di base come il rendering e clipping di
uno sprite, dove si lavora fisicamente con i pixels.
Putroppo la mancanza di puntatori e il legame tra oggetti e strutture
complicano le cose.
baubau
Davide

 ha scritto nel messaggio
news:9vj8k1$ch0$1...@newsreader1.mclink.it...


> Sto realizzando in Java un motore generico per videogiochi 2D
Anch'io vorrei realizzare un motore grafico 2d ma non ne capisco proprio
niente.
potresti dirmi da dove iniziare
rispondimi via mail
ti ringrazio anticipatamente

 Davide
WofWof
TelespallacciaBob