Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - un altro problema con allegro!!
Forum - C/C++ - un altro problema con allegro!!

Pagine: [ 1 2 ] Precedente | Prossimo
Avatar
russoandrea96 (Normal User)
Newbie


Messaggi: 19
Iscritto: 20/08/2010

Segnala al moderatore
Postato alle 22:02
Domenica, 22/08/2010
Ciao a tutti,è il mio secondo post e ho un altro problema!!Finalmente il mio sprite salta così iniziamo il gioco...Immaginatevi la scena arriva il mio sprite tutto felice di saper saltare :D che cammina quanto di colpo incontra un ostacolo,così :idea: gli viene l'idea di saltare e cosa succede...CI PASSA ATTRAVERSO :rotfl: Cosa posso fare per renderlo "solido"?

PM Quote
Avatar
HeDo (Founder Member)
Guru^2


Messaggi: 2763
Iscritto: 21/09/2007

Segnala al moderatore
Postato alle 23:13
Domenica, 22/08/2010
devi implementare le collisioni, data la forma della sprite calcoli se si sovrappone alla sprite dell'ostacolo.

guarda questa libreria per allegro già implementata:

http://www.allegro.cc/forums/thread/550371


Ingegnere Informatico
https://ldlagency.it
PM Quote
Avatar
russoandrea96 (Normal User)
Newbie


Messaggi: 19
Iscritto: 20/08/2010

Segnala al moderatore
Postato alle 23:21
Domenica, 22/08/2010
ho trovato una guida in italiano che mi spiega come attivare la collisione,ma il problema è che una volta attivata come faccio a far in modo che il mio sprite sta sopra a che so ad un muretto tipo quelli di super mario? (infatti devo fare un gioco su quello)
Mi potresti fare un esempio?

ecco la guida trovata:

Gestione delle collisioni con la tecnica del bounding box.

Dunque in questo tutorial imparerete a gestire le collisioni con la tecnica del bounding box (d'ora in poi BB). Avete presente quando create un immagine? Questa viene racchiusa da un rettangolo (i bordi). La tecnica del BB consiste nel rilevare se un punto qualsiasi del perimetro di questo rettangolo tocca con il perimetro di un altro rettangolo. Semplice no? Ordunque per realizzare ciò di che cosa abbiamo bisogno? Delle cooordinate x ed y e della lunghezza e larghezza dell'oggetto.

immagine->w = dimensione width cioè larghezza
immagine->h = dimensione height cioè altezza

Questa è la sintassi usata dalle allegro per trovare questi due valori. Potremmo benissimo usare le dimensioni senza questa dicitura ma è mooolto conveniente. Infatti non serve che controlliamo ogni immagine.

Facciamo un piccolo esempio di codice:

if ((imagex+image->w>image2x) && (imagex<image2x+image2->w) && (imagey+image->h>image2y) && (imagey<image2y+image2->h))
{
}

Bene ora se ci ragionate troverete il sopra citato pezzo di codice moooolto semplice. Infatti prendete pure un pezzo di carta e una penna. Disegnate due quadrati o rettangoli che si "scontrano" in questo modo (scusate per il disegno a dir poco schifoso):

----- ####
| | # # Prima della collisione (1° stato)
| | # #
----- ####

----####
| # # Durante la collisione (2° stato)
| # #
----####

---####
| #| # Collisione finita (3° stato)
| #| #
---####

Bene nel 1° stato non c'è alcun tipo di collisione. Nel 2° stato invece c'è una collisione o meglio alcuni pixel di figura "-" tangono i pixel di figura "#". Bene al 3° stato NON dovete MAI arrivare in quanto verrebbe a crearsi un effetto veramente spiacevole. Voi dovete fare in modo che le due immagini non si sovrappongano mai. Però in alcuni casi può rivelarsi utile far passare un immagine sopra ad un altra. Ad esempio:

L'impavido eroe dopo aver saccagnato miriadi di mostri deve prendere la chiave.

e

L'impavido eroe dopo aver preso la chiave cade in una trappola rappresentata da un tile del terreno.

Nel primo caso si può arrivare fino al 2° stato infatti la chiave poi scomparirà (salvo diverso gameplay) e non si veranno a creare spiacevoli effetti "collaterali". Nel secondo caso invece visto che la collisione riguarda un tile del terreno (in giochi con visuale dall'alto) si può benissimo fare in modo che le due immagini si "sovrappongano" durante la collisione. Ufff quanta teoriaaa!!! Ora però passiamo ad analizzare ogni frammento del codice =P

if ((imagex+image->w>image2x)

ordunque qua si va a controllare se la somma della coordinata x e la larghezza dell'immagine (width = larghezza) è maggiore alla coordinata x dell'immagine numero 2. Poi però...

&& (imagex<image2x+image2->w)

si controlla anche se la coordinata x (imagex) dell'immagine 1 è minore alla somma fra la coordinata x di immagine 2 e la sua larghezza.

Stesso discorso per il resto della condizione =) Al posto che x però è y.

Ultima modifica effettuata da russoandrea96 il 22/08/2010 alle 23:35
PM Quote
Avatar
HeDo (Founder Member)
Guru^2


Messaggi: 2763
Iscritto: 21/09/2007

Segnala al moderatore
Postato alle 0:51
Lunedì, 23/08/2010

la guida mi sembra cristallina, se si sa programmare.

magari mi sbaglio ma il problema è decisamente più a monte.


Ingegnere Informatico
https://ldlagency.it
PM Quote
Avatar
russoandrea96 (Normal User)
Newbie


Messaggi: 19
Iscritto: 20/08/2010

Segnala al moderatore
Postato alle 1:29
Lunedì, 23/08/2010
mi potresti spiegare meglio il codice,visto che sei molto più bravo di me?

PM Quote
Avatar
HeDo (Founder Member)
Guru^2


Messaggi: 2763
Iscritto: 21/09/2007

Segnala al moderatore
Postato alle 1:56
Lunedì, 23/08/2010
Testo quotato

Postato originariamente da russoandrea96:

mi potresti spiegare meglio il codice,visto che sei molto più bravo di me?



anche se te lo spiegasssi con parole diverse non otterresti nulla, dovresti cmq scriverti il codice da solo :)

fidati di me, prima impara bene il linguaggio che stai usando, poi sviluppi dei giochi.
altrimenti finisci per chiedere e scopiazzare a destra e a manca pur di fare due cose in croce :) senza poi alla fine capire cosa stai facendo!

sviluppare giochi è solo l'ultima delle cose che si fa con un linguaggio che si impara, non la prima :)


Ingegnere Informatico
https://ldlagency.it
PM Quote
Avatar
russoandrea96 (Normal User)
Newbie


Messaggi: 19
Iscritto: 20/08/2010

Segnala al moderatore
Postato alle 13:01
Lunedì, 23/08/2010
Ma io lo conosco abbastanza bene il linguagguio che usa ma non centra niente perchè il mio problema c'è lo con allegro...

PM Quote
Avatar
HeDo (Founder Member)
Guru^2


Messaggi: 2763
Iscritto: 21/09/2007

Segnala al moderatore
Postato alle 16:02
Lunedì, 23/08/2010
Testo quotato

Postato originariamente da russoandrea96:

Ma io lo conosco abbastanza bene il linguagguio che usa ma non centra niente perchè il mio problema c'è lo con allegro...



anche con l'italiano a quanto vedo :)

il problema non è con allegro fidati!


Ingegnere Informatico
https://ldlagency.it
PM Quote
Avatar
russoandrea96 (Normal User)
Newbie


Messaggi: 19
Iscritto: 20/08/2010

Segnala al moderatore
Postato alle 16:26
Lunedì, 23/08/2010
Ok mi fido XD cmq. almeno mi puoi dare una mano con questo: ho fatto una giochino a scrolling orizzontale (è solo una cosa così) il problema è che il personaggio si vede male,cioè si vede e non si vede in maniera velocissima così si vede male... mi dai una mano,ecco il source:

Codice sorgente - presumibilmente C/C++

  1. #include <stdio.h>                                                                                         
  2. #include <string.h>                                                                                      
  3. #include <time.h>                                                                                          
  4. #include <allegro.h>
  5. #include <mario.h>                                                                           
  6.  
  7.  MIDI *musica;
  8.  BITMAP *immagine1, *immagine5, *buffer2, *sprite;                                                      
  9.  BITMAP *strato1, *strato5;                                      
  10.  PALETTE colori;
  11.  DATAFILE *dat;
  12.                                                                                  
  13.  int a,x,y,b,c, sposta, sposta1, sposta2, sposta3, sposta4, sposta5,movimento; 
  14. void scrolling(){
  15. if (key[KEY_LEFT]) {                                                                                       // ATTENDE LA PRESSIONE DEL TASTO CURSORE //
  16.                            sposta1=sposta1+5; sposta2=sposta2+4; sposta3=sposta3+3; sposta4=sposta4+2; sposta5=sposta5+1;      
  17.                                
  18.                                                                                    // SCROLLING DEI LIVELLI DI PARALLELASSE //
  19.                            }
  20.         if (key[KEY_RIGHT]) {                                                                                      // ATTENDE LA PRESSIONE DEL TASTO CURSORE //
  21.                           sposta1=sposta1-5; sposta2=sposta2-4; sposta3=sposta3-3; sposta4=sposta4-2;  sposta5=sposta5-1;      
  22.                                
  23.                                                                                    // SCROLLING DEI LIVELLI DI PARALLELASSE //  
  24.                           }
  25.                           // BLOCCA LO SPOSTAMENTO DELLO SCHERMO //
  26.  
  27.         if (sposta5>=0) {
  28.                           sposta1=sposta1-5; sposta2=sposta2-4; sposta3=sposta3-3; sposta4=sposta4-2; sposta5=sposta5-1;
  29.                           }
  30.         if (sposta5<=-640) {
  31.                            sposta1=sposta1+5; sposta2=sposta2+4; sposta3=sposta3+3; sposta4=sposta4+2; sposta5=sposta5+1;
  32.                            }
  33.                                  
  34.                                            
  35.  
  36.  
  37.        draw_sprite(buffer2, strato5, 0, 0);                                              
  38.        draw_sprite(buffer2, strato1, sposta1, 460);
  39. }
  40.    
  41.            
  42.  
  43. void doppiobuffering()                                                                                 
  44. {
  45.  vsync();                                                                                      
  46.  blit(buffer2, screen, 0, 0, 0, 0, 640, 480);                                                    
  47.  clear(buffer2);                                                                                 
  48. }
  49.  
  50. void movimentosprite(){
  51.    
  52.     draw_sprite(screen,sprite,x,y);
  53.     if(key[KEY_RIGHT]){
  54.       if(movimento>1) movimento=0;
  55.       draw_sprite(buffer2, strato5, 0, 0);  
  56.       draw_sprite(buffer2, strato1, sposta1, 460);
  57.       doppiobuffering();
  58.       draw_sprite(screen,dat[movimento].dat,x,y);
  59.       rest(55);
  60.       movimento=movimento+1;
  61.       sprite=(dat[mario].dat);
  62.       draw_sprite(screen,dat[movimento].dat,x,y);
  63.      
  64.     }
  65.     if(key[KEY_LEFT]){
  66.       if(movimento>1)movimento=0;
  67.       draw_sprite(buffer2, strato5, 0, 0);
  68.       draw_sprite(buffer2, strato1, sposta1, 460);
  69.       doppiobuffering();
  70.       draw_sprite_h_flip(screen,dat[movimento].dat,x,y);
  71.       sprite=load_bitmap("mariosinistra.bmp",colori);
  72.       rest(55);
  73.       movimento=movimento+1;  
  74.       draw_sprite_h_flip(screen,dat[movimento].dat,x,y);
  75.      
  76.     }  
  77.    if (key[KEY_UP]){
  78.       for(b=0;b<17;b++){
  79.         y=y-5;
  80.         if(key[KEY_LEFT]){
  81.            
  82.            sposta1=sposta1+5; sposta2=sposta2+4; sposta3=sposta3+3; sposta4=sposta4+2; sposta5=sposta5+1;
  83.            draw_sprite_h_flip(screen,dat[salto].dat,x,y);
  84.         }  
  85.         if(key[KEY_RIGHT]){
  86.          
  87.           sposta1=sposta1-5; sposta2=sposta2-4; sposta3=sposta3-3; sposta4=sposta4-2;  sposta5=sposta5-1;
  88.           draw_sprite(screen,dat[salto].dat,x,y);
  89.         }  
  90.         draw_sprite(buffer2, strato5, 0, 0);
  91.         draw_sprite(buffer2, strato1, sposta1, 460);
  92.         doppiobuffering();
  93.         draw_sprite(screen,dat[salto].dat,x,y);    
  94.         draw_sprite(buffer2, strato5, 0, 0);
  95.         draw_sprite(buffer2, strato1, sposta1, 460);
  96.       }
  97.      
  98.       for(c=0;c<17;c++){
  99.        
  100.         y=y+5;
  101.         if(key[KEY_LEFT]){
  102.            sposta1=sposta1+5; sposta2=sposta2+4; sposta3=sposta3+3; sposta4=sposta4+2; sposta5=sposta5+1;
  103.            draw_sprite_h_flip(screen,dat[salto].dat,x,y);
  104.            
  105.         }  
  106.         if(key[KEY_RIGHT]){
  107.           sposta1=sposta1-5; sposta2=sposta2-4; sposta3=sposta3-3; sposta4=sposta4-2;  sposta5=sposta5-1;  
  108.           draw_sprite(screen,dat[salto].dat,x,y);
  109.          
  110.         }
  111.        
  112.         draw_sprite(buffer2, strato5, 0, 0);  
  113.         draw_sprite(buffer2, strato1, sposta1, 460);
  114.         doppiobuffering();
  115.         draw_sprite(screen,dat[salto].dat,x,y);
  116.       }
  117.     }  
  118.      
  119. }
  120.  
  121.  
  122.  
  123. int main()                                                                                     
  124. {
  125.  
  126.          allegro_init();                                                                     
  127.          install_keyboard();                                                                   
  128.  
  129.          set_color_depth(32);                                                                
  130.          set_gfx_mode(GFX_GDI, 640, 480, 0, 0);
  131.          install_sound(DIGI_AUTODETECT,MIDI_AUTODETECT,0);
  132.          dat=load_datafile("mario.dat");
  133.          sprite=(dat[mario].dat);
  134.          musica=load_midi("supermario.mid");
  135.          set_volume(255,255);
  136.          play_midi(musica,TRUE);
  137.          immagine1=load_bitmap("parallelasse1.bmp", colori);                           
  138.          immagine5=load_bitmap("parallelasse5.bmp", colori);
  139.          x=196;                                  
  140.          y=432;
  141.          movimento=0;
  142.          b=0;
  143.          c=0;
  144.                
  145.          buffer2 = create_bitmap(640, 480);                                                    
  146.          clear(buffer2);                                                                                         
  147.          strato5 = create_bitmap(640, 480);                                                  
  148.          clear(strato5);                                                                                         
  149.          strato1 = create_bitmap(3840, 480);                                                 
  150.          clear(strato1);                                                                                           
  151.                                
  152.          blit(immagine5, strato5, 0, 0, 0, 0, 640, 480);
  153.      
  154.  
  155.          for (a=0;a<=3840;a=a+640) {                                                                       
  156.                 blit(immagine1, strato1, 0, 0, a, 0, 640, 480);
  157.          }      
  158.          
  159.  while (!key[KEY_ESC]) {
  160.        movimentosprite();
  161.        scrolling();
  162.        doppiobuffering();
  163.                                                                                  
  164.         }        
  165.        destroy_midi(musica);  
  166.        destroy_bitmap(immagine1);                                                                                                  
  167.        destroy_bitmap(immagine5);                                                            
  168.        
  169.        allegro_exit();                                                                                                                
  170. }
  171. END_OF_MAIN ();


Ultima modifica effettuata da russoandrea96 il 24/08/2010 alle 0:30
PM Quote
Pagine: [ 1 2 ] Precedente | Prossimo