array di sprite

[Paolo87]

Buona estate a tutti ragazzuoli !!!!!!!! Sto facendo un giochino semplice semplice con la libreria allegro e mi sono imbattuto in un problemino,che a prima vista è facile,ma vi assicuro che non lo è affatto.
Io ho creato questo gioco contenente delle funzioni nelle quali vadoa caricare,il buffer,lo sfondo il player il nemico e così via. La cosa che vorrei fare è creare molti nemici ma con poco codice e cosa meglio di un array per far questo ?! Così mi è sorto un mega dubbio, coem faccio a fare un array di immagini bitmap ?!
Secondo voi come lo dichiaro questo array ?!
Come setto le coordinate per far si che i nemici contenuti in questo array abbiamo coordinate diverse ?!

Rispondete in tanti ragazzi !!!!!!!!!!!

[Paolo87]

Dopo diverse prove e suggerimenti letti in giro ho trovato questo codice che devo dire non è malaccio,però devo cambiare una cosa. Le sprite si muovono dall'alto verso il basso e dio vorrei ceh si muovessero dal destra verso sinistra.
vi posto il codice :

Codice: Seleziona tutto

#include "allegro.h"

BITMAP *sprite, *buf,*nemico[25];
PALLETE co, image;
int x, y;                                       // coordinate giocatore //
int nx[25], ny[25], na[25], cattivovince, ritardogameover, vel;     // coordinate e variabili nemico in array fino a 25, incremento velocita' //
int fnr[25], fn[25], fnx[25], fny[25], fnstop;  // fnr[a]= numero casuale, fn[a]= permette lo sparo del proiettile, fnstop[a]= fa si che non vengano sparati altri proiettili, fny[a] e fny[a]= posizione proiettile //
int espx[25], espy[25];                         // coordinate in array per esplosione //
int a, b, c, e[25], f[25], g[25];               // variabili di array e posizione di partenza nemici //
int d=25, contapunti, meno, vite=3, ini;        // numero di nemici - dimensione max di array - variabile conta punti e contatore di esaurimento nemici, vite giocatore settato a 3, variabile di inizio //
int ritardo;                                    // variabile temporizzatrice //

// aggiornamento dello schermo in doppio buffering //
void vai()
{
 set_palette(co);           // setta la palette degli sprites //
 vsync();

 blit(buf, screen, 0, 0, 0, 0, 320, 200);
 clear(buf);
}
void inizio() {
if (ini==0) {         // variabile di inizio o di gioco: 0=inizio - 1=inizio //
        textout(buf, font, "PREMI ENTER PER INIZIARE", 65, 95, 215);
if (key[KEY_ENTER]) {
vite=3;
ini=1;
meno=0;

}
}
}
void partenzadazero() {
// valori delle variabili di partenza //
if (ini==1) {      // variabile di inizio o di gioco: 0=inizio - 1=gioco //
if (meno==0) {                                       // vengono assegnati i seguanti valori solo se meno e uguale a zero: cioe' all'inizio e quando vengono distrutti tutti i nemici, cosi si ricomincia a giocare //
meno=16;
d=15;
fx=x;
fy=y;
x=150;
y=180;
fok=0;
a=0, b=0, c=20;
for (a=0; a<=d; a++) {  //ciclo che crea un array di nuove variabili per la posizione di partenza di ogni nemico //
if (a>1) {
        b=b+40;
        }
if (b>=200) {
        b=0;
        c=c+40;
        }

na[a]=1;
ny[a]=c;
nx[a]=b;
e[a]=0; f[a]=0; g[a]=0;
espx[a]=0; espy[a]=0;
vel=1;
}
}
}
}
void cattivo()
{
if (ini==1) {              // variabile di inizio o di gioco: 0=inizio - 1=gioco //
        for (a=0; a<=d; a++) {                       //ciclo che crea un array di nuove variabili //
        if (e[a]==0) {                               // se e[a] e' diverso da 0 significa che il nemico e' stato colpito e quindi non viene visulizzato //
draw_sprite(buf, nemico[a], nx[a], ny[a]);   // disegna il nemico //
       
        if (na[a]==1) {                              // se na[a] e' ugale a 1 //
                nx[a]=nx[a]+vel;                       // nx[a] incrementa di 1 e il nemico avanza a dx //
                if (nx[a]>=300) {                    // se nx supera 300 ny[a] incrementa di 25 e il nemico scende di una riga.
                         ny[a]=ny[a]+20; na[a]=2; }  // na[a] diventa uguale a 2 //
                }
        if (na[a]==2) {                              // se na[a] e' uguale a 2 //
                nx[a]=nx[a]-vel;                       // allora nx[a] decrementa di 1 e il nemico avanza verso sinistra //
                if (nx[a]<=0) {                      // se nx[a] e minore o uguale a 0 //
                        ny[a]=ny[a]+20; na[a]=1; }   // allora ny[a] incrementa di 25 e quindi il nemico scende di una riga. Cosi' na[a] diventa uguale a 1 //
                }                                   
        if (ny[a]>=180) {                            // se ny[a] e' uguale maggiore o uguale a 175 //
                cattivovince=1;                      // IL NEMICO VINCE GAME OVER PERCHE IL CATTIVO TOCCA IL TERRENO QUINDI CATTIVO VINCE DIVENTA UGUALE A 1 //
                play_sample(gameov, 255,128,1000, FALSE);  // emette un suono //
      }
} } } }
int main()
{
allegro_init();
install_keyboard();
sprite = load_bmp("player.bmp",co);  // carica il giocatore //
for (a=0; a<=d; a++) {   //ciclo che crea un array di nuove variabili //
nemico[a] = load_bmp("nemico1.bmp",co); // carica l'immagine dei nemici //
}
buf = create_bitmap(320, 200);       // crea un una finestra di buffer 320 x 200 pixel //
clear(buf);                          // pulisce il buffer dello schermo //
set_gfx_mode(GFX_AUTODETECT_WINDOWED, 320, 200, 0, 0);  // inizializza il formato grafico  //
while (!key[KEY_ESC])  {
  partenzadazero();
  vai();
 cattivo();
 inizio();
  }
// vengono distrutti tutti i bitmap caricati prima della chiusura del programma //
destroy_bitmap(sprite);
for (a=0; a<=d; a++) {   //ciclo che crea un array di nuove variabili //
        destroy_bitmap(nemico[a]);
        }
        destroy_bitmap(buf);
return 0;
}
END_OF_MAIN ();


[Dylan666]

Sparo la cavolata: non basta invertire...
ny[a]=c;
nx[a]=b;

...in...

ny[a]=b;
nx[a]=c;


...?
Anzi, per la precisione così dovrebbero muoversi da sinistra verso destra... vediamo se intanto ho trovato il punto incui operare

[infinito1971]

Ciao a tutti,
vorrei approfittare di questo topic per aprire una parentesi e lanciare un idea che, mi auguro, il webmaster o qualche moderatore legga e reputi interessante...
Spesso nel forum di programmazione di !pc-facile si trovano piccoli progetti, come ad esempio quello proposto da paolo, che per essere condivisi al meglio (magari perchè il progetto, essendo sviluppato per una determinata piattaforma è costituito da più files) sarebbe necessario, oltre al codice sorgente, che già viene presentato, allegare ulteriori files (icone, bitmaps, *.h, etc...).
Bene, mi chiedevo: non sarebbe possibile gestire una repository, per tutti i progetti open-source che ne necessitano, ed inviare i files accessori ai moderatori affinchè inseriscano, nella cartella del progetto il file inviato dall'autore?
Mi auguro di essere stato chiaro nell'esplicare quest'idea e mi auguro che riceva abbastanza consensi da poter essere accettata dal webmaster...

Un saluto,
infinito1971

[Paolo87]

Grazie per l'aiuto,lo provo subito a lavoro !!!! Comunque infinito,la tua idea non è male se si potesse gestire un repository metterei il mio progetto una volta finito e poi ogni utente potrebbe dire la sua per migliorarlo.

[Paolo87]

No aspetta Dylan l'effeto da destra verso sinistra funziona solo s elo schermo è piccolo ovvero se è un 320 x 200 se lo schemro è 1024 x 768 (la risoluzione finale del gioco), partono smepre da sinistra verso destra. che fare ?!
Comunque sto ancora lavorando a questo se ci riesco prima di te posto il codice

[Dylan666]

Ci riuscirai sicuramente prima di me dato che non so programmare nel linguaggio che stai utilizzando
Ma usando un po' di logica direi che devi mettere la risoluzione che vuoi usare qui:

blit(buf, screen, 0, 0, 0, 0, 320, 200);

E quindi diventa:

blit(buf, screen, 0, 0, 0, 0, 1024, 768);

In base alla nuova risoluzione e al fatto che abbiamo invertito prima "x" e "y" devi aggiustare pure questo:

if (nx[a]>=300) { // se nx supera 300 ny[a] incrementa di 25 e il nemico scende di una riga.

[Paolo87]

per lo schermo già fatto ora provo a mettere apposto ancora le cose perchè non mi convincono comunque grazie mille !!!!