[ferrass]

Allora il problema risiede nel fatto che se premo space lo sprite salta per se tengo premuto space il salto è infinito ovvero lo sprite vola

---

Non so se questa è la sezione giusta ... Comunque ecco il codice

Codice:

#include <allegro.h>
#define true 1
#define false 0

// massimo y 140 in basso  //massimo x 300 a destra  //massimo y alto =0
BITMAP*buf,*mario_right,*sfondo,*scorrimento,*cattivo1,*mattone,*mario_left,*mario_down,*mario_space,*mario_run_1,*mario_run_2; //variabili

PALETTE colori;
int x,y,xscorrimento,moltiplica,xcattivo1,ycattivo1,vx,vy,g,salto,change,tempo,contsalto;


void doppiobuffering() {
     vsync();
     blit(buf,screen,0,0,0,0,320,300) ;
     clear(buf);
     }
     void player() {
          
                      
          draw_sprite(buf,mario_right,x,y) ;
          
          }
          
          void movimento() {
               if(key[KEY_RIGHT]) x=x+1 ,vx=20  ;if(x>=300) x=300;vx=0;
               if(key[KEY_LEFT]) x=x-1,vx--,clear (buf),   blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200),draw_sprite(buf,mario_left,x,y); if ( x<=10) x=10;vx=0;    
              if(key[KEY_DOWN])clear(buf) , blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200),draw_sprite(buf,mario_down,x,y);
      if (key[KEY_SPACE] )
  

salto=true;


    if(y>=100 && salto==true )
    
  
{

blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
   draw_sprite(buf,mario_space,x,y);  

vy=1.8;
x +=vx;
y -= vy;
vy += g;
                      
}
   else {
      salto=false;

if(y<=140) {
     x +=vx;  
     y +=vy;
     vy +=g;      
  
      
                      
      
}

}
}

        
  

                
                                    
          
                            
                              
              
  
                                        
                      

            
            
            
            
            
            
            
            
            
               void paesaggio() {
                    
               if(x==300) {
                               xscorrimento++;
                               }
                        
                              
                    
                   blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
                   if(xscorrimento>319){
                                        xscorrimento=0;
                    
                    }
                    }
                    void cattivonumero1() {
                        
                         draw_sprite(buf,cattivo1,xcattivo1,ycattivo1);
                        
                         }
                  
                              

                                                                
        
     int main() {
         allegro_init();
         install_keyboard();
         set_color_depth(32);
set_palette(colori);
         set_gfx_mode(GFX_AUTODETECT, 320, 200, 0, 0);
        
         buf = create_bitmap(320, 200);
         clear(buf);
          mario_right=load_bmp("mario_right.bmp",colori);
          sfondo=load_bmp("paesaggio.bmp",colori);
          cattivo1=load_bmp("cattivo1.bmp",colori);
          
          mario_left=load_bmp("mario_left.bmp",colori);
          mario_down=load_bmp("mario_down.bmp",colori);
          mario_space=load_bmp("mario_space.bmp",colori);
          mario_run_2=load_bmp("frame2.bmp",colori);
          mario_run_1=load_bmp("frame1.bmp",colori);

        
              
          
         scorrimento = create_bitmap(640, 200);
         clear(scorrimento);
         for (moltiplica=0;moltiplica<=640;moltiplica=moltiplica+320) {
             blit(sfondo, scorrimento, 0, 0, moltiplica, 0, 320, 200);
}
          x=40;y=140;
          xcattivo1=250    ;   ycattivo1=149;
     vy=0;g=0.5;
      contsalto=0;
      
          tempo=0;
    
         while(!key[KEY_ESC]) {
                             doppiobuffering();
                             paesaggio();
                            player();
                            movimento();
                          
                            cattivonumero1();
                      
                      
                            
                  
                            
                            
                          
                            
                             }
                             destroy_bitmap(buf);
                             destroy_bitmap(mario_right);
                             destroy_bitmap(sfondo);
                             destroy_bitmap(scorrimento);
                             destroy_bitmap(cattivo1);
                             destroy_bitmap(mattone);
                             destroy_bitmap(mario_left);
                             destroy_bitmap(mario_down);
                             destroy_bitmap(mario_space);
                             destroy_bitmap(mario_run_2);
                             destroy_bitmap(mario_run_1);
                          
                            
                            
                             }
END_OF_MAIN ();

[MickeyCrashRayman]

Io non sono un esperto di C++ applicato ai videogiochi, ma dovresti fare due cose:
1) o utilizzi delle librerie per la fisica (le più famose sono Physix o Newton);
2) oppure emuli la fisica inserendo un limite che permetta al personaggio di ricadere a terra non appena raggiunge un certo punto dell'ordinata.

Consiglio la prima.

[ferrass]

mmmm ok sentiro qualche altro parere e poi scegliero .. Mille grazie comunque per la risposta

[steve]

Prima di iniziare a fare un gioco devi avere una buona padronanza del linguaggio che usi:

• Non serve un define per true e false: a differenza del C, in C++ i valori booleani sono un tipo nativo.
  
• Una buona formattazione del codice rende tutto più comprensibile sia per te che per noi, ne è la prova la funzione movimento (sono sicuro che non fa quello che ti aspetti). Inoltre quando dai un nome a una funzione (ma anche a una variabile o a qualsiasi altra cosa) cerca di essere molto esplicativo; per esempio per funzione player ha più senso il nome drawPlayer, visto che serve solo per disegnarlo.
  
• L'OOP è molto utile, soprattutto per i giochi.
  
• Le variabili globali sono da evitare, ma vendendo il resto direi che per ora sono il problema minore.
  

Questo è il tuo codice indentato con un po' di senso (sperando che il forum non sputtani tutto), come vedi ci sono un mucchio di cose senza senso che ora saltano subito all'occhio:

Codice:

#include <allegro.h>

// massimo y 140 in basso  //massimo x 300 a destra  //massimo y alto =0
BITMAP    *buf,
        *mario_right,
        *sfondo,
        *scorrimento,
        *cattivo1,
        *mattone,
        *mario_left,
        *mario_down,
        *mario_space,
        *mario_run_1,
        *mario_run_2; //variabili

PALETTE colori;

int    x,
    y,
    xscorrimento,
    moltiplica,
    xcattivo1,
    ycattivo1,
    vx,
    vy,
    g,
    salto,
    change,
    tempo,
    contsalto;


void doppiobuffering()
{
    vsync();
    blit(buf,screen,0,0,0,0,320,300) ;
    clear(buf);
}


void player()
{        
    draw_sprite(buf,mario_right,x,y) ;
}


void movimento()
{
    if(key[KEY_RIGHT])
        x=x+1, vx=20;
    
    if(x>=300)
        x=300;
    
    vx=0;
    
    if(key[KEY_LEFT])
    {
        x=x-1;
        vx--;
        clear(buf);
        blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
        draw_sprite(buf,mario_left,x,y);
    }
    
    if(x<=10)
        x=10;
    
    vx=0;    
    
    if(key[KEY_DOWN])
    {
        clear(buf);
        blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
        draw_sprite(buf,mario_down,x,y);
    }
    
    if(key[KEY_SPACE])
        salto=true;

    if(y>=100 && salto==true )
    {
        blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
        draw_sprite(buf,mario_space,x,y);  
        vy = 1.8;
        x += vx;
        y -= vy;
        vy += g;              
    }
    else
    {
        salto=false;
        
        if(y<=140)
        {
            x += vx;  
            y += vy;
            vy += g;      
        }
    }
}


void paesaggio()
{
    if(x==300)
        xscorrimento++;

    blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
    
    if(xscorrimento>319)
    {
        xscorrimento=0;
    }
}


void cattivonumero1()
{
    draw_sprite(buf,cattivo1,xcattivo1,ycattivo1);
}

        
int main()
{
    allegro_init();
    install_keyboard();
    set_color_depth(32);
    set_palette(colori);
    set_gfx_mode(GFX_AUTODETECT, 320, 200, 0, 0);
    
    buf = create_bitmap(320, 200);
    clear(buf);
    mario_right=load_bmp("mario_right.bmp",colori);
    sfondo=load_bmp("paesaggio.bmp",colori);
    cattivo1=load_bmp("cattivo1.bmp",colori);
    
    mario_left=load_bmp("mario_left.bmp",colori);
    mario_down=load_bmp("mario_down.bmp",colori);
    mario_space=load_bmp("mario_space.bmp",colori);
    mario_run_2=load_bmp("frame2.bmp",colori);
    mario_run_1=load_bmp("frame1.bmp",colori);
      
    scorrimento = create_bitmap(640, 200);
    clear(scorrimento);
    for (moltiplica=0;moltiplica<=640;moltiplica=moltiplica+320)
    {
        blit(sfondo, scorrimento, 0, 0, moltiplica, 0, 320, 200);
    }
    x=40;            y=140;
    xcattivo1=250;    ycattivo1=149;
    vy=0;
    g=0.5;
    contsalto=0;
    tempo=0;
    
    while(!key[KEY_ESC])
    {
        doppiobuffering();
        paesaggio();
        player();
        movimento();
        
        cattivonumero1();
    }
    
    destroy_bitmap(buf);
    destroy_bitmap(mario_right);
    destroy_bitmap(sfondo);
    destroy_bitmap(scorrimento);
    destroy_bitmap(cattivo1);
    destroy_bitmap(mattone);
    destroy_bitmap(mario_left);
    destroy_bitmap(mario_down);
    destroy_bitmap(mario_space);
    destroy_bitmap(mario_run_2);
    destroy_bitmap(mario_run_1);
}
END_OF_MAIN ();

Sistema i no-sense e poi rivediamo come farlo saltare decentemente. Se il salto funziona bene e c'è solo il problema del volo basta cambiare questo:

Codice:

if(key[KEY_SPACE])
    salto=true;

in questo:

Codice:

if(key[KEY_SPACE] && salto==false)
    salto=true;

È abbastanza logica come cosa.

1) o utilizzi delle librerie per la fisica (le più famose sono Physix o Newton);

Assolutamente no! Aldilà del fatto che quelle che hai citato andrebbero bene per un gioco 3D, usare un engine fisico è solo una complicazione in più. Se devi solo gestire le collisioni, i salti e le cadute fai molto, ma molto prima a scrivertelo da solo.


PS. Benvenuto

[ferrass]

ti ringrazio per i consigli preziosi adesso faro qualche aggiustamento al codice ... Mi dite solo una cosa? xD il problema perchè se ripremo space in salto lo sprite risalta lo avete capito ? (non in senso offensivo ma almeno che qualcuno sappia come si risolva ) Comunque ringrazio tutti per la vostra immediata disponibilità..Un ultima cosa il post va bene in questa sezione ?

[ferrass]

Problema salto infinito risolto mille grazie a tutti posto il codice qua di sotto

Codice:

#include <allegro.h>


// massimo y 140 in basso  //massimo x 300 a destra  //massimo y alto =0
BITMAP    *buf,
        *mario_right,
        *sfondo,
        *scorrimento,
        *cattivo1,
        *mattone,
        *mario_left,
        *mario_down,
        *mario_space;

PALETTE colori;

int    x,
    y,
    xscorrimento,
    moltiplica,
    xcattivo1,
    ycattivo1,
    vx,
    vy,
    g,
    salto;
    

        


void doppiobuffering()
{
    vsync();
    blit(buf,screen,0,0,0,0,320,300) ;
    clear(buf);
}


void draw_player()
{        
    draw_sprite(buf,mario_right,x,y) ;
}


void movimento()
{
    if(key[KEY_RIGHT])
    {
        x=x+1, vx=20;
}
    if(x>=300) {
        x=300;
    
    vx=0;
}
    if(key[KEY_LEFT])
    {
        x=x-1;
        vx--;
        clear(buf);
        blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
        draw_sprite(buf,mario_left,x,y);
    }
    
    if(x<=10)
        x=10;
    
    vx=0;    
    
    if(key[KEY_DOWN])
    {
        clear(buf);
        blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
        draw_sprite(buf,mario_down,x,y);
    }



    
    
    if(key[KEY_SPACE] &&y==140 )
        salto=true;

    if(y>=100 && salto==true )
    {
        blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
        draw_sprite(buf,mario_space,x,y);  
        vy = 1.8;
        x += vx;
        y -= vy;
        vy += g;              
    }
    else
    {
        salto=false;
        
        if(y!=140)
        {
            x += vx;  
            y += vy;
            vy += g;      
        }
        
    }
}


void paesaggio()
{
    if(x==300)
        xscorrimento++;

    blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
    
    if(xscorrimento>319)
    {
        xscorrimento=0;
    }
}


void cattivonumero1()
{
    draw_sprite(buf,cattivo1,xcattivo1,ycattivo1);
}

        
int main()
{
    allegro_init();
    install_keyboard();
    set_color_depth(32);
    set_palette(colori);
    set_gfx_mode(GFX_AUTODETECT, 320, 200, 0, 0);
    
    buf = create_bitmap(320, 200);
    clear(buf);
    mario_right=load_bmp("mario_right.bmp",colori);
    sfondo=load_bmp("paesaggio.bmp",colori);
    cattivo1=load_bmp("cattivo1.bmp",colori);
    
    mario_left=load_bmp("mario_left.bmp",colori);
    mario_down=load_bmp("mario_down.bmp",colori);
    mario_space=load_bmp("mario_space.bmp",colori);

      
    scorrimento = create_bitmap(640, 200);
    clear(scorrimento);
    for (moltiplica=0;moltiplica<=640;moltiplica=moltiplica+320)
    {
        blit(sfondo, scorrimento, 0, 0, moltiplica, 0, 320, 200);
    }
    x=40;            y=140;
    xcattivo1=250;    ycattivo1=149;
    vy=0;
    g=0.5;


    
    while(!key[KEY_ESC])
    {
        doppiobuffering();
        paesaggio();
        draw_player();
        movimento();
        
        cattivonumero1();

    }
    
    destroy_bitmap(buf);
    destroy_bitmap(mario_right);
    destroy_bitmap(sfondo);
    destroy_bitmap(scorrimento);
    destroy_bitmap(cattivo1);
    destroy_bitmap(mattone);
    destroy_bitmap(mario_left);
    destroy_bitmap(mario_down);
    destroy_bitmap(mario_space);
    
}
END_OF_MAIN ();
[code]

[MickeyCrashRayman]

Prima di iniziare a fare un gioco devi avere una buona padronanza del linguaggio che usi:

• Non serve un define per true e false: a differenza del C, in C++ i valori booleani sono un tipo nativo.
  
• Una buona formattazione del codice rende tutto più comprensibile sia per te che per noi, ne è la prova la funzione movimento (sono sicuro che non fa quello che ti aspetti). Inoltre quando dai un nome a una funzione (ma anche a una variabile o a qualsiasi altra cosa) cerca di essere molto esplicativo; per esempio per funzione player ha più senso il nome drawPlayer, visto che serve solo per disegnarlo.
  
• L'OOP è molto utile, soprattutto per i giochi.
  
• Le variabili globali sono da evitare, ma vendendo il resto direi che per ora sono il problema minore.
  

Questo è il tuo codice indentato con un po' di senso (sperando che il forum non sputtani tutto), come vedi ci sono un mucchio di cose senza senso che ora saltano subito all'occhio:

Codice:

#include <allegro.h>

// massimo y 140 in basso  //massimo x 300 a destra  //massimo y alto =0
BITMAP    *buf,
        *mario_right,
        *sfondo,
        *scorrimento,
        *cattivo1,
        *mattone,
        *mario_left,
        *mario_down,
        *mario_space,
        *mario_run_1,
        *mario_run_2; //variabili

PALETTE colori;

int    x,
    y,
    xscorrimento,
    moltiplica,
    xcattivo1,
    ycattivo1,
    vx,
    vy,
    g,
    salto,
    change,
    tempo,
    contsalto;


void doppiobuffering()
{
    vsync();
    blit(buf,screen,0,0,0,0,320,300) ;
    clear(buf);
}


void player()
{        
    draw_sprite(buf,mario_right,x,y) ;
}


void movimento()
{
    if(key[KEY_RIGHT])
        x=x+1, vx=20;
    
    if(x>=300)
        x=300;
    
    vx=0;
    
    if(key[KEY_LEFT])
    {
        x=x-1;
        vx--;
        clear(buf);
        blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
        draw_sprite(buf,mario_left,x,y);
    }
    
    if(x<=10)
        x=10;
    
    vx=0;    
    
    if(key[KEY_DOWN])
    {
        clear(buf);
        blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
        draw_sprite(buf,mario_down,x,y);
    }
    
    if(key[KEY_SPACE])
        salto=true;

    if(y>=100 && salto==true )
    {
        blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
        draw_sprite(buf,mario_space,x,y);  
        vy = 1.8;
        x += vx;
        y -= vy;
        vy += g;              
    }
    else
    {
        salto=false;
        
        if(y<=140)
        {
            x += vx;  
            y += vy;
            vy += g;      
        }
    }
}


void paesaggio()
{
    if(x==300)
        xscorrimento++;

    blit(scorrimento, buf, xscorrimento, 0, 0, 0, 320, 200);
    
    if(xscorrimento>319)
    {
        xscorrimento=0;
    }
}


void cattivonumero1()
{
    draw_sprite(buf,cattivo1,xcattivo1,ycattivo1);
}

        
int main()
{
    allegro_init();
    install_keyboard();
    set_color_depth(32);
    set_palette(colori);
    set_gfx_mode(GFX_AUTODETECT, 320, 200, 0, 0);
    
    buf = create_bitmap(320, 200);
    clear(buf);
    mario_right=load_bmp("mario_right.bmp",colori);
    sfondo=load_bmp("paesaggio.bmp",colori);
    cattivo1=load_bmp("cattivo1.bmp",colori);
    
    mario_left=load_bmp("mario_left.bmp",colori);
    mario_down=load_bmp("mario_down.bmp",colori);
    mario_space=load_bmp("mario_space.bmp",colori);
    mario_run_2=load_bmp("frame2.bmp",colori);
    mario_run_1=load_bmp("frame1.bmp",colori);
      
    scorrimento = create_bitmap(640, 200);
    clear(scorrimento);
    for (moltiplica=0;moltiplica<=640;moltiplica=moltiplica+320)
    {
        blit(sfondo, scorrimento, 0, 0, moltiplica, 0, 320, 200);
    }
    x=40;            y=140;
    xcattivo1=250;    ycattivo1=149;
    vy=0;
    g=0.5;
    contsalto=0;
    tempo=0;
    
    while(!key[KEY_ESC])
    {
        doppiobuffering();
        paesaggio();
        player();
        movimento();
        
        cattivonumero1();
    }
    
    destroy_bitmap(buf);
    destroy_bitmap(mario_right);
    destroy_bitmap(sfondo);
    destroy_bitmap(scorrimento);
    destroy_bitmap(cattivo1);
    destroy_bitmap(mattone);
    destroy_bitmap(mario_left);
    destroy_bitmap(mario_down);
    destroy_bitmap(mario_space);
    destroy_bitmap(mario_run_2);
    destroy_bitmap(mario_run_1);
}
END_OF_MAIN ();

Sistema i no-sense e poi rivediamo come farlo saltare decentemente. Se il salto funziona bene e c'è solo il problema del volo basta cambiare questo:

Codice:

if(key[KEY_SPACE])
    salto=true;

in questo:

Codice:

if(key[KEY_SPACE] && salto==false)
    salto=true;

È abbastanza logica come cosa.

1) o utilizzi delle librerie per la fisica (le più famose sono Physix o Newton);

Assolutamente no! Aldilà del fatto che quelle che hai citato andrebbero bene per un gioco 3D, usare un engine fisico è solo una complicazione in più. Se devi solo gestire le collisioni, i salti e le cadute fai molto, ma molto prima a scrivertelo da solo.


PS. Benvenuto

Meno male che sei intervenuto, tu sei al pari di Yoda. asd